AU: Use NiceMock<PrefsMock to suppress uninteresting call warnings.

omaha_request_action_unittest.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include <glib.h>
 
 #include "base/string_util.h"
 #include "base/time.h"
 #include "gtest/gtest.h"
 #include "update_engine/action_pipe.h"
 #include "update_engine/mock_http_fetcher.h"
 #include "update_engine/omaha_hash_calculator.h"
 #include "update_engine/omaha_request_action.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/prefs_mock.h"
 #include "update_engine/test_utils.h"
 
 using base::Time;
 using base::TimeDelta;
 using std::string;
 using std::vector;
 using testing::_;
 using testing::AllOf;
 using testing::Ge;
 using testing::Le;
+using testing::NiceMock;
 using testing::Return;
 using testing::SetArgumentPointee;
 
 namespace chromeos_update_engine {
 
 class OmahaRequestActionTest : public ::testing::Test { };
 
 namespace {
 const OmahaRequestParams kDefaultTestParams(
     OmahaRequestParams::kOsPlatform,
@@ skipping 117 matching lines @@
                      int fail_http_response_code,
                      ActionExitCode expected_code,
                      OmahaResponse* out_response,
                      vector<char>* out_post_data) {
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   MockHttpFetcher* fetcher = new MockHttpFetcher(http_response.data(),
                                                  http_response.size());
   if (fail_http_response_code >= 0) {
     fetcher->FailTransfer(fail_http_response_code);
   }
-  PrefsMock local_prefs;
+  NiceMock<PrefsMock> local_prefs;
   OmahaRequestAction action(prefs ? prefs : &local_prefs,
                             params,
                             NULL,
                             fetcher);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   delegate.expected_code_ = expected_code;
 
   ActionProcessor processor;
   processor.set_delegate(&delegate);
@@ skipping 16 matching lines @@
 // Tests Event requests -- they should always succeed. |out_post_data|
 // may be null; if non-null, the post-data received by the mock
 // HttpFetcher is returned.
 void TestEvent(const OmahaRequestParams& params,
                OmahaEvent* event,
                const string& http_response,
                vector<char>* out_post_data) {
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   MockHttpFetcher* fetcher = new MockHttpFetcher(http_response.data(),
                                                  http_response.size());
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   OmahaRequestAction action(&prefs, params, event, fetcher);
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
@@ skipping 42 matching lines @@
   EXPECT_FALSE(response.needs_admin);
   EXPECT_TRUE(response.prompt);
   EXPECT_EQ("20101020", response.deadline);
 }
 
 TEST(OmahaRequestActionTest, NoOutputPipeTest) {
   const string http_response(GetNoUpdateResponse(OmahaRequestParams::kAppId));
 
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   OmahaRequestAction action(&prefs, kDefaultTestParams, NULL,
                             new MockHttpFetcher(http_response.data(),
                                                 http_response.size()));
   OmahaRequestActionTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   g_timeout_add(0, &StartProcessorInRunLoop, &processor);
@@ skipping 126 matching lines @@
   CHECK(processor->IsRunning());
   processor->StopProcessing();
   return FALSE;
 }
 }  // namespace {}
 
 TEST(OmahaRequestActionTest, TerminateTransferTest) {
   string http_response("doesn't matter");
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   OmahaRequestAction action(&prefs, kDefaultTestParams, NULL,
                             new MockHttpFetcher(http_response.data(),
                                                 http_response.size()));
   TerminateEarlyTestProcessorDelegate delegate;
   delegate.loop_ = loop;
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&action);
 
   g_timeout_add(0, &TerminateTransferTestStarter, &processor);
@@ skipping 161 matching lines @@
       "errorcode=\"%d\"></o:event>\n",
       OmahaEvent::kTypeDownloadComplete,
       OmahaEvent::kResultError,
       kActionCodeError);
   EXPECT_NE(post_str.find(expected_event), string::npos);
   EXPECT_EQ(post_str.find("o:updatecheck"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, IsEventTest) {
   string http_response("doesn't matter");
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   OmahaRequestAction update_check_action(
       &prefs,
       kDefaultTestParams,
       NULL,
       new MockHttpFetcher(http_response.data(),
                           http_response.size()));
   EXPECT_FALSE(update_check_action.IsEvent());
 
   OmahaRequestAction event_action(
       &prefs,
@@ skipping 48 matching lines @@
 
   OmahaEvent error_event(OmahaEvent::kTypeUpdateDownloadFinished,
                          OmahaEvent::kResultError,
                          kActionCodeError);
   EXPECT_EQ(OmahaEvent::kTypeUpdateDownloadFinished, error_event.type);
   EXPECT_EQ(OmahaEvent::kResultError, error_event.result);
   EXPECT_EQ(kActionCodeError, error_event.error_code);
 }
 
 TEST(OmahaRequestActionTest, PingTest) {
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   // Add a few hours to the day difference to test no rounding, etc.
   int64_t five_days_ago =
       (Time::Now() - TimeDelta::FromHours(5 * 24 + 13)).ToInternalValue();
   int64_t six_days_ago =
       (Time::Now() - TimeDelta::FromHours(6 * 24 + 11)).ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(six_days_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(five_days_ago), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("<o:ping a=\"6\" r=\"5\"></o:ping>"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, ActivePingTest) {
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   int64_t three_days_ago =
       (Time::Now() - TimeDelta::FromHours(3 * 24 + 12)).ToInternalValue();
   int64_t now = Time::Now().ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(three_days_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("<o:ping a=\"3\"></o:ping>"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, RollCallPingTest) {
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   int64_t four_days_ago =
       (Time::Now() - TimeDelta::FromHours(4 * 24)).ToInternalValue();
   int64_t now = Time::Now().ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(now), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(four_days_ago), Return(true)));
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_NE(post_str.find("<o:ping r=\"4\"></o:ping>\n"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, NoPingTest) {
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   int64_t one_hour_ago =
       (Time::Now() - TimeDelta::FromHours(1)).ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(one_hour_ago), Return(true)));
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
   vector<char> post_data;
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       GetNoUpdateResponse(OmahaRequestParams::kAppId),
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       &post_data));
   string post_str(&post_data[0], post_data.size());
   EXPECT_EQ(post_str.find("o:ping"), string::npos);
 }
 
 TEST(OmahaRequestActionTest, BackInTimePingTest) {
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   int64_t future =
       (Time::Now() + TimeDelta::FromHours(3 * 24 + 4)).ToInternalValue();
   EXPECT_CALL(prefs, GetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(future), Return(true)));
   EXPECT_CALL(prefs, GetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(future), Return(true)));
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _))
       .WillOnce(Return(true));
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _))
       .WillOnce(Return(true));
@@ skipping 16 matching lines @@
 
 TEST(OmahaRequestActionTest, LastPingDayUpdateTest) {
   // This test checks that the action updates the last ping day to now
   // minus 200 seconds with a slack of 5 seconds. Therefore, the test
   // may fail if it runs for longer than 5 seconds. It shouldn't run
   // that long though.
   int64_t midnight =
       (Time::Now() - TimeDelta::FromSeconds(200)).ToInternalValue();
   int64_t midnight_slack =
       (Time::Now() - TimeDelta::FromSeconds(195)).ToInternalValue();
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay,
                               AllOf(Ge(midnight), Le(midnight_slack))))
       .WillOnce(Return(true));
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay,
                               AllOf(Ge(midnight), Le(midnight_slack))))
       .WillOnce(Return(true));
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
                       "xmlns=\"http://www.google.com/update2/response\" "
                       "protocol=\"2.0\"><daystart elapsed_seconds=\"200\"/>"
                       "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
                       "<updatecheck status=\"noupdate\"/></app></gupdate>",
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       NULL));
 }
 
 TEST(OmahaRequestActionTest, NoElapsedSecondsTest) {
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
                       "xmlns=\"http://www.google.com/update2/response\" "
                       "protocol=\"2.0\"><daystart blah=\"200\"/>"
                       "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
                       "<updatecheck status=\"noupdate\"/></app></gupdate>",
                       -1,
                       kActionCodeSuccess,
                       NULL,
                       NULL));
 }
 
 TEST(OmahaRequestActionTest, BadElapsedSecondsTest) {
-  PrefsMock prefs;
+  NiceMock<PrefsMock> prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsLastActivePingDay, _)).Times(0);
   EXPECT_CALL(prefs, SetInt64(kPrefsLastRollCallPingDay, _)).Times(0);
   ASSERT_TRUE(
       TestUpdateCheck(&prefs,
                       kDefaultTestParams,
                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?><gupdate "
                       "xmlns=\"http://www.google.com/update2/response\" "
                       "protocol=\"2.0\"><daystart elapsed_seconds=\"x\"/>"
                       "<app appid=\"foo\" status=\"ok\"><ping status=\"ok\"/>"
                       "<updatecheck status=\"noupdate\"/></app></gupdate>",
@@ skipping 40 matching lines @@
                       "",
                       1500,
                       static_cast<ActionExitCode>(
                           kActionCodeOmahaRequestHTTPResponseBase + 999),
                       &response,
                       NULL));
   EXPECT_FALSE(response.update_exists);
 }
 
 }  // namespace chromeos_update_engine