Home | History | Annotate | Download | only in update_engine 
      1 //
      2 // Copyright (C) 2012 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #include "update_engine/update_attempter.h"
     18 
     19 #include <stdint.h>
     20 
     21 #include <memory>
     22 
     23 #include <base/files/file_util.h>
     24 #include <base/message_loop/message_loop.h>
     25 #include <brillo/bind_lambda.h>
     26 #include <brillo/make_unique_ptr.h>
     27 #include <brillo/message_loops/base_message_loop.h>
     28 #include <brillo/message_loops/message_loop.h>
     29 #include <brillo/message_loops/message_loop_utils.h>
     30 #include <debugd/dbus-constants.h>
     31 #include <debugd/dbus-proxies.h>
     32 #include <debugd/dbus-proxy-mocks.h>
     33 #include <gtest/gtest.h>
     34 #include <policy/libpolicy.h>
     35 #include <policy/mock_device_policy.h>
     36 
     37 #include "libcros/dbus-proxies.h"
     38 #include "libcros/dbus-proxy-mocks.h"
     39 #include "update_engine/common/fake_clock.h"
     40 #include "update_engine/common/fake_prefs.h"
     41 #include "update_engine/common/mock_action.h"
     42 #include "update_engine/common/mock_action_processor.h"
     43 #include "update_engine/common/mock_http_fetcher.h"
     44 #include "update_engine/common/mock_prefs.h"
     45 #include "update_engine/common/platform_constants.h"
     46 #include "update_engine/common/prefs.h"
     47 #include "update_engine/common/test_utils.h"
     48 #include "update_engine/common/utils.h"
     49 #include "update_engine/fake_system_state.h"
     50 #include "update_engine/mock_p2p_manager.h"
     51 #include "update_engine/mock_payload_state.h"
     52 #include "update_engine/payload_consumer/filesystem_verifier_action.h"
     53 #include "update_engine/payload_consumer/install_plan.h"
     54 #include "update_engine/payload_consumer/payload_constants.h"
     55 #include "update_engine/payload_consumer/postinstall_runner_action.h"
     56 
     57 using base::Time;
     58 using base::TimeDelta;
     59 using org::chromium::LibCrosServiceInterfaceProxyMock;
     60 using org::chromium::UpdateEngineLibcrosProxyResolvedInterfaceProxyMock;
     61 using std::string;
     62 using std::unique_ptr;
     63 using testing::DoAll;
     64 using testing::InSequence;
     65 using testing::Ne;
     66 using testing::NiceMock;
     67 using testing::Property;
     68 using testing::Return;
     69 using testing::ReturnPointee;
     70 using testing::SaveArg;
     71 using testing::SetArgumentPointee;
     72 using testing::_;
     73 using update_engine::UpdateStatus;
     74 
     75 namespace chromeos_update_engine {
     76 
     77 // Test a subclass rather than the main class directly so that we can mock out
     78 // methods within the class. There're explicit unit tests for the mocked out
     79 // methods.
     80 class UpdateAttempterUnderTest : public UpdateAttempter {
     81  public:
     82   UpdateAttempterUnderTest(SystemState* system_state,
     83                            LibCrosProxy* libcros_proxy,
     84                            org::chromium::debugdProxyInterface* debugd_proxy)
     85       : UpdateAttempter(system_state, nullptr, libcros_proxy, debugd_proxy) {}
     86 
     87   // Wrap the update scheduling method, allowing us to opt out of scheduled
     88   // updates for testing purposes.
     89   void ScheduleUpdates() override {
     90     schedule_updates_called_ = true;
     91     if (do_schedule_updates_) {
     92       UpdateAttempter::ScheduleUpdates();
     93     } else {
     94       LOG(INFO) << "[TEST] Update scheduling disabled.";
     95     }
     96   }
     97   void EnableScheduleUpdates() { do_schedule_updates_ = true; }
     98   void DisableScheduleUpdates() { do_schedule_updates_ = false; }
     99 
    100   // Indicates whether ScheduleUpdates() was called.
    101   bool schedule_updates_called() const { return schedule_updates_called_; }
    102 
    103   // Need to expose forced_omaha_url_ so we can test it.
    104   const string& forced_omaha_url() const { return forced_omaha_url_; }
    105 
    106  private:
    107   bool schedule_updates_called_ = false;
    108   bool do_schedule_updates_ = true;
    109 };
    110 
    111 class UpdateAttempterTest : public ::testing::Test {
    112  protected:
    113   UpdateAttempterTest()
    114       : service_interface_mock_(new LibCrosServiceInterfaceProxyMock()),
    115         ue_proxy_resolved_interface_mock_(
    116             new NiceMock<UpdateEngineLibcrosProxyResolvedInterfaceProxyMock>()),
    117         libcros_proxy_(
    118             brillo::make_unique_ptr(service_interface_mock_),
    119             brillo::make_unique_ptr(ue_proxy_resolved_interface_mock_)),
    120         certificate_checker_(fake_system_state_.mock_prefs(),
    121                              &openssl_wrapper_) {
    122     // Override system state members.
    123     fake_system_state_.set_connection_manager(&mock_connection_manager);
    124     fake_system_state_.set_update_attempter(&attempter_);
    125     loop_.SetAsCurrent();
    126 
    127     certificate_checker_.Init();
    128 
    129     // Finish initializing the attempter.
    130     attempter_.Init();
    131   }
    132 
    133   void SetUp() override {
    134     CHECK(utils::MakeTempDirectory("UpdateAttempterTest-XXXXXX", &test_dir_));
    135 
    136     EXPECT_NE(nullptr, attempter_.system_state_);
    137     EXPECT_EQ(0, attempter_.http_response_code_);
    138     EXPECT_EQ(UpdateStatus::IDLE, attempter_.status_);
    139     EXPECT_EQ(0.0, attempter_.download_progress_);
    140     EXPECT_EQ(0, attempter_.last_checked_time_);
    141     EXPECT_EQ("0.0.0.0", attempter_.new_version_);
    142     EXPECT_EQ(0, attempter_.new_payload_size_);
    143     processor_ = new NiceMock<MockActionProcessor>();
    144     attempter_.processor_.reset(processor_);  // Transfers ownership.
    145     prefs_ = fake_system_state_.mock_prefs();
    146 
    147     // Set up store/load semantics of P2P properties via the mock PayloadState.
    148     actual_using_p2p_for_downloading_ = false;
    149     EXPECT_CALL(*fake_system_state_.mock_payload_state(),
    150                 SetUsingP2PForDownloading(_))
    151         .WillRepeatedly(SaveArg<0>(&actual_using_p2p_for_downloading_));
    152     EXPECT_CALL(*fake_system_state_.mock_payload_state(),
    153                 GetUsingP2PForDownloading())
    154         .WillRepeatedly(ReturnPointee(&actual_using_p2p_for_downloading_));
    155     actual_using_p2p_for_sharing_ = false;
    156     EXPECT_CALL(*fake_system_state_.mock_payload_state(),
    157                 SetUsingP2PForSharing(_))
    158         .WillRepeatedly(SaveArg<0>(&actual_using_p2p_for_sharing_));
    159     EXPECT_CALL(*fake_system_state_.mock_payload_state(),
    160                 GetUsingP2PForDownloading())
    161         .WillRepeatedly(ReturnPointee(&actual_using_p2p_for_sharing_));
    162   }
    163 
    164   void TearDown() override {
    165     base::DeleteFile(base::FilePath(test_dir_), true);
    166   }
    167 
    168  public:
    169   void ScheduleQuitMainLoop();
    170 
    171   // Callbacks to run the different tests from the main loop.
    172   void UpdateTestStart();
    173   void UpdateTestVerify();
    174   void RollbackTestStart(bool enterprise_rollback, bool valid_slot);
    175   void RollbackTestVerify();
    176   void PingOmahaTestStart();
    177   void ReadScatterFactorFromPolicyTestStart();
    178   void DecrementUpdateCheckCountTestStart();
    179   void NoScatteringDoneDuringManualUpdateTestStart();
    180   void P2PNotEnabledStart();
    181   void P2PEnabledStart();
    182   void P2PEnabledInteractiveStart();
    183   void P2PEnabledStartingFailsStart();
    184   void P2PEnabledHousekeepingFailsStart();
    185 
    186   bool actual_using_p2p_for_downloading() {
    187     return actual_using_p2p_for_downloading_;
    188   }
    189   bool actual_using_p2p_for_sharing() {
    190     return actual_using_p2p_for_sharing_;
    191   }
    192 
    193   base::MessageLoopForIO base_loop_;
    194   brillo::BaseMessageLoop loop_{&base_loop_};
    195 
    196   FakeSystemState fake_system_state_;
    197   org::chromium::debugdProxyMock debugd_proxy_mock_;
    198   LibCrosServiceInterfaceProxyMock* service_interface_mock_;
    199   UpdateEngineLibcrosProxyResolvedInterfaceProxyMock*
    200       ue_proxy_resolved_interface_mock_;
    201   LibCrosProxy libcros_proxy_;
    202   OpenSSLWrapper openssl_wrapper_;
    203   CertificateChecker certificate_checker_;
    204   UpdateAttempterUnderTest attempter_{&fake_system_state_,
    205                                       &libcros_proxy_,
    206                                       &debugd_proxy_mock_};
    207 
    208   NiceMock<MockActionProcessor>* processor_;
    209   NiceMock<MockPrefs>* prefs_;  // Shortcut to fake_system_state_->mock_prefs().
    210   NiceMock<MockConnectionManager> mock_connection_manager;
    211 
    212   string test_dir_;
    213 
    214   bool actual_using_p2p_for_downloading_;
    215   bool actual_using_p2p_for_sharing_;
    216 };
    217 
    218 void UpdateAttempterTest::ScheduleQuitMainLoop() {
    219   loop_.PostTask(FROM_HERE, base::Bind([this] { this->loop_.BreakLoop(); }));
    220 }
    221 
    222 TEST_F(UpdateAttempterTest, ActionCompletedDownloadTest) {
    223   unique_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, nullptr));
    224   fetcher->FailTransfer(503);  // Sets the HTTP response code.
    225   DownloadAction action(prefs_, nullptr, nullptr, nullptr, fetcher.release());
    226   EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0);
    227   attempter_.ActionCompleted(nullptr, &action, ErrorCode::kSuccess);
    228   EXPECT_EQ(503, attempter_.http_response_code());
    229   EXPECT_EQ(UpdateStatus::FINALIZING, attempter_.status());
    230   ASSERT_EQ(nullptr, attempter_.error_event_.get());
    231 }
    232 
    233 TEST_F(UpdateAttempterTest, ActionCompletedErrorTest) {
    234   MockAction action;
    235   EXPECT_CALL(action, Type()).WillRepeatedly(Return("MockAction"));
    236   attempter_.status_ = UpdateStatus::DOWNLOADING;
    237   EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
    238       .WillOnce(Return(false));
    239   attempter_.ActionCompleted(nullptr, &action, ErrorCode::kError);
    240   ASSERT_NE(nullptr, attempter_.error_event_.get());
    241 }
    242 
    243 TEST_F(UpdateAttempterTest, ActionCompletedOmahaRequestTest) {
    244   unique_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, nullptr));
    245   fetcher->FailTransfer(500);  // Sets the HTTP response code.
    246   OmahaRequestAction action(&fake_system_state_, nullptr,
    247                             std::move(fetcher), false);
    248   ObjectCollectorAction<OmahaResponse> collector_action;
    249   BondActions(&action, &collector_action);
    250   OmahaResponse response;
    251   response.poll_interval = 234;
    252   action.SetOutputObject(response);
    253   EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0);
    254   attempter_.ActionCompleted(nullptr, &action, ErrorCode::kSuccess);
    255   EXPECT_EQ(500, attempter_.http_response_code());
    256   EXPECT_EQ(UpdateStatus::IDLE, attempter_.status());
    257   EXPECT_EQ(234U, attempter_.server_dictated_poll_interval_);
    258   ASSERT_TRUE(attempter_.error_event_.get() == nullptr);
    259 }
    260 
    261 TEST_F(UpdateAttempterTest, ConstructWithUpdatedMarkerTest) {
    262   FakePrefs fake_prefs;
    263   string boot_id;
    264   EXPECT_TRUE(utils::GetBootId(&boot_id));
    265   fake_prefs.SetString(kPrefsUpdateCompletedOnBootId, boot_id);
    266   fake_system_state_.set_prefs(&fake_prefs);
    267   UpdateAttempterUnderTest attempter(&fake_system_state_, &libcros_proxy_,
    268                                      &debugd_proxy_mock_);
    269   attempter.Init();
    270   EXPECT_EQ(UpdateStatus::UPDATED_NEED_REBOOT, attempter.status());
    271 }
    272 
    273 TEST_F(UpdateAttempterTest, GetErrorCodeForActionTest) {
    274   extern ErrorCode GetErrorCodeForAction(AbstractAction* action,
    275                                               ErrorCode code);
    276   EXPECT_EQ(ErrorCode::kSuccess,
    277             GetErrorCodeForAction(nullptr, ErrorCode::kSuccess));
    278 
    279   FakeSystemState fake_system_state;
    280   OmahaRequestAction omaha_request_action(&fake_system_state, nullptr,
    281                                           nullptr, false);
    282   EXPECT_EQ(ErrorCode::kOmahaRequestError,
    283             GetErrorCodeForAction(&omaha_request_action, ErrorCode::kError));
    284   OmahaResponseHandlerAction omaha_response_handler_action(&fake_system_state_);
    285   EXPECT_EQ(ErrorCode::kOmahaResponseHandlerError,
    286             GetErrorCodeForAction(&omaha_response_handler_action,
    287                                   ErrorCode::kError));
    288   FilesystemVerifierAction filesystem_verifier_action(
    289       fake_system_state_.boot_control(), VerifierMode::kVerifyTargetHash);
    290   EXPECT_EQ(ErrorCode::kFilesystemVerifierError,
    291             GetErrorCodeForAction(&filesystem_verifier_action,
    292                                   ErrorCode::kError));
    293   PostinstallRunnerAction postinstall_runner_action(
    294       fake_system_state.fake_boot_control(), fake_system_state.fake_hardware());
    295   EXPECT_EQ(ErrorCode::kPostinstallRunnerError,
    296             GetErrorCodeForAction(&postinstall_runner_action,
    297                                   ErrorCode::kError));
    298   MockAction action_mock;
    299   EXPECT_CALL(action_mock, Type()).WillOnce(Return("MockAction"));
    300   EXPECT_EQ(ErrorCode::kError,
    301             GetErrorCodeForAction(&action_mock, ErrorCode::kError));
    302 }
    303 
    304 TEST_F(UpdateAttempterTest, DisableDeltaUpdateIfNeededTest) {
    305   attempter_.omaha_request_params_->set_delta_okay(true);
    306   EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
    307       .WillOnce(Return(false));
    308   attempter_.DisableDeltaUpdateIfNeeded();
    309   EXPECT_TRUE(attempter_.omaha_request_params_->delta_okay());
    310   EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
    311       .WillOnce(DoAll(
    312           SetArgumentPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures - 1),
    313           Return(true)));
    314   attempter_.DisableDeltaUpdateIfNeeded();
    315   EXPECT_TRUE(attempter_.omaha_request_params_->delta_okay());
    316   EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
    317       .WillOnce(DoAll(
    318           SetArgumentPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures),
    319           Return(true)));
    320   attempter_.DisableDeltaUpdateIfNeeded();
    321   EXPECT_FALSE(attempter_.omaha_request_params_->delta_okay());
    322   EXPECT_CALL(*prefs_, GetInt64(_, _)).Times(0);
    323   attempter_.DisableDeltaUpdateIfNeeded();
    324   EXPECT_FALSE(attempter_.omaha_request_params_->delta_okay());
    325 }
    326 
    327 TEST_F(UpdateAttempterTest, MarkDeltaUpdateFailureTest) {
    328   EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
    329       .WillOnce(Return(false))
    330       .WillOnce(DoAll(SetArgumentPointee<1>(-1), Return(true)))
    331       .WillOnce(DoAll(SetArgumentPointee<1>(1), Return(true)))
    332       .WillOnce(DoAll(
    333           SetArgumentPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures),
    334           Return(true)));
    335   EXPECT_CALL(*prefs_, SetInt64(Ne(kPrefsDeltaUpdateFailures), _))
    336       .WillRepeatedly(Return(true));
    337   EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures, 1)).Times(2);
    338   EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures, 2));
    339   EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures,
    340                                UpdateAttempter::kMaxDeltaUpdateFailures + 1));
    341   for (int i = 0; i < 4; i ++)
    342     attempter_.MarkDeltaUpdateFailure();
    343 }
    344 
    345 TEST_F(UpdateAttempterTest, ScheduleErrorEventActionNoEventTest) {
    346   EXPECT_CALL(*processor_, EnqueueAction(_)).Times(0);
    347   EXPECT_CALL(*processor_, StartProcessing()).Times(0);
    348   EXPECT_CALL(*fake_system_state_.mock_payload_state(), UpdateFailed(_))
    349       .Times(0);
    350   OmahaResponse response;
    351   string url1 = "http://url1";
    352   response.payload_urls.push_back(url1);
    353   response.payload_urls.push_back("https://url");
    354   EXPECT_CALL(*(fake_system_state_.mock_payload_state()), GetCurrentUrl())
    355       .WillRepeatedly(Return(url1));
    356   fake_system_state_.mock_payload_state()->SetResponse(response);
    357   attempter_.ScheduleErrorEventAction();
    358   EXPECT_EQ(url1, fake_system_state_.mock_payload_state()->GetCurrentUrl());
    359 }
    360 
    361 TEST_F(UpdateAttempterTest, ScheduleErrorEventActionTest) {
    362   EXPECT_CALL(*processor_,
    363               EnqueueAction(Property(&AbstractAction::Type,
    364                                      OmahaRequestAction::StaticType())));
    365   EXPECT_CALL(*processor_, StartProcessing());
    366   ErrorCode err = ErrorCode::kError;
    367   EXPECT_CALL(*fake_system_state_.mock_payload_state(), UpdateFailed(err));
    368   attempter_.error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
    369                                                OmahaEvent::kResultError,
    370                                                err));
    371   attempter_.ScheduleErrorEventAction();
    372   EXPECT_EQ(UpdateStatus::REPORTING_ERROR_EVENT, attempter_.status());
    373 }
    374 
    375 namespace {
    376 // Actions that will be built as part of an update check.
    377 const string kUpdateActionTypes[] = {  // NOLINT(runtime/string)
    378   OmahaRequestAction::StaticType(),
    379   OmahaResponseHandlerAction::StaticType(),
    380   FilesystemVerifierAction::StaticType(),
    381   OmahaRequestAction::StaticType(),
    382   DownloadAction::StaticType(),
    383   OmahaRequestAction::StaticType(),
    384   FilesystemVerifierAction::StaticType(),
    385   PostinstallRunnerAction::StaticType(),
    386   OmahaRequestAction::StaticType()
    387 };
    388 
    389 // Actions that will be built as part of a user-initiated rollback.
    390 const string kRollbackActionTypes[] = {  // NOLINT(runtime/string)
    391   InstallPlanAction::StaticType(),
    392   PostinstallRunnerAction::StaticType(),
    393 };
    394 
    395 }  // namespace
    396 
    397 void UpdateAttempterTest::UpdateTestStart() {
    398   attempter_.set_http_response_code(200);
    399 
    400   // Expect that the device policy is loaded by the UpdateAttempter at some
    401   // point by calling RefreshDevicePolicy.
    402   policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy();
    403   attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy));
    404   EXPECT_CALL(*device_policy, LoadPolicy())
    405       .Times(testing::AtLeast(1)).WillRepeatedly(Return(true));
    406 
    407   {
    408     InSequence s;
    409     for (size_t i = 0; i < arraysize(kUpdateActionTypes); ++i) {
    410       EXPECT_CALL(*processor_,
    411                   EnqueueAction(Property(&AbstractAction::Type,
    412                                          kUpdateActionTypes[i])));
    413     }
    414     EXPECT_CALL(*processor_, StartProcessing());
    415   }
    416 
    417   attempter_.Update("", "", "", "", false, false);
    418   loop_.PostTask(FROM_HERE,
    419                  base::Bind(&UpdateAttempterTest::UpdateTestVerify,
    420                             base::Unretained(this)));
    421 }
    422 
    423 void UpdateAttempterTest::UpdateTestVerify() {
    424   EXPECT_EQ(0, attempter_.http_response_code());
    425   EXPECT_EQ(&attempter_, processor_->delegate());
    426   EXPECT_EQ(arraysize(kUpdateActionTypes), attempter_.actions_.size());
    427   for (size_t i = 0; i < arraysize(kUpdateActionTypes); ++i) {
    428     EXPECT_EQ(kUpdateActionTypes[i], attempter_.actions_[i]->Type());
    429   }
    430   EXPECT_EQ(attempter_.response_handler_action_.get(),
    431             attempter_.actions_[1].get());
    432   AbstractAction* action_4 = attempter_.actions_[4].get();
    433   ASSERT_NE(nullptr, action_4);
    434   ASSERT_EQ(DownloadAction::StaticType(), action_4->Type());
    435   DownloadAction* download_action = static_cast<DownloadAction*>(action_4);
    436   EXPECT_EQ(&attempter_, download_action->delegate());
    437   EXPECT_EQ(UpdateStatus::CHECKING_FOR_UPDATE, attempter_.status());
    438   loop_.BreakLoop();
    439 }
    440 
    441 void UpdateAttempterTest::RollbackTestStart(
    442     bool enterprise_rollback, bool valid_slot) {
    443   // Create a device policy so that we can change settings.
    444   policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy();
    445   attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy));
    446 
    447   EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
    448   fake_system_state_.set_device_policy(device_policy);
    449 
    450   if (valid_slot) {
    451     BootControlInterface::Slot rollback_slot = 1;
    452     LOG(INFO) << "Test Mark Bootable: "
    453               << BootControlInterface::SlotName(rollback_slot);
    454     fake_system_state_.fake_boot_control()->SetSlotBootable(rollback_slot,
    455                                                             true);
    456   }
    457 
    458   bool is_rollback_allowed = false;
    459 
    460   // We only allow rollback on devices that are not enterprise enrolled and
    461   // which have a valid slot to rollback to.
    462   if (!enterprise_rollback && valid_slot) {
    463      is_rollback_allowed = true;
    464   }
    465 
    466   if (enterprise_rollback) {
    467     // We return an empty owner as this is an enterprise.
    468     EXPECT_CALL(*device_policy, GetOwner(_)).WillRepeatedly(
    469         DoAll(SetArgumentPointee<0>(string("")),
    470         Return(true)));
    471   } else {
    472     // We return a fake owner as this is an owned consumer device.
    473     EXPECT_CALL(*device_policy, GetOwner(_)).WillRepeatedly(
    474         DoAll(SetArgumentPointee<0>(string("fake.mail (at) fake.com")),
    475         Return(true)));
    476   }
    477 
    478   if (is_rollback_allowed) {
    479     InSequence s;
    480     for (size_t i = 0; i < arraysize(kRollbackActionTypes); ++i) {
    481       EXPECT_CALL(*processor_,
    482                   EnqueueAction(Property(&AbstractAction::Type,
    483                                          kRollbackActionTypes[i])));
    484     }
    485     EXPECT_CALL(*processor_, StartProcessing());
    486 
    487     EXPECT_TRUE(attempter_.Rollback(true));
    488     loop_.PostTask(FROM_HERE,
    489                    base::Bind(&UpdateAttempterTest::RollbackTestVerify,
    490                               base::Unretained(this)));
    491   } else {
    492     EXPECT_FALSE(attempter_.Rollback(true));
    493     loop_.BreakLoop();
    494   }
    495 }
    496 
    497 void UpdateAttempterTest::RollbackTestVerify() {
    498   // Verifies the actions that were enqueued.
    499   EXPECT_EQ(&attempter_, processor_->delegate());
    500   EXPECT_EQ(arraysize(kRollbackActionTypes), attempter_.actions_.size());
    501   for (size_t i = 0; i < arraysize(kRollbackActionTypes); ++i) {
    502     EXPECT_EQ(kRollbackActionTypes[i], attempter_.actions_[i]->Type());
    503   }
    504   EXPECT_EQ(UpdateStatus::ATTEMPTING_ROLLBACK, attempter_.status());
    505   AbstractAction* action_0 = attempter_.actions_[0].get();
    506   ASSERT_NE(nullptr, action_0);
    507   ASSERT_EQ(InstallPlanAction::StaticType(), action_0->Type());
    508   InstallPlanAction* install_plan_action =
    509       static_cast<InstallPlanAction*>(action_0);
    510   InstallPlan* install_plan = install_plan_action->install_plan();
    511   EXPECT_EQ(0U, install_plan->partitions.size());
    512   EXPECT_EQ(install_plan->powerwash_required, true);
    513   loop_.BreakLoop();
    514 }
    515 
    516 TEST_F(UpdateAttempterTest, UpdateTest) {
    517   UpdateTestStart();
    518   loop_.Run();
    519 }
    520 
    521 TEST_F(UpdateAttempterTest, RollbackTest) {
    522   loop_.PostTask(FROM_HERE,
    523                  base::Bind(&UpdateAttempterTest::RollbackTestStart,
    524                             base::Unretained(this),
    525                             false, true));
    526   loop_.Run();
    527 }
    528 
    529 TEST_F(UpdateAttempterTest, InvalidSlotRollbackTest) {
    530   loop_.PostTask(FROM_HERE,
    531                  base::Bind(&UpdateAttempterTest::RollbackTestStart,
    532                             base::Unretained(this),
    533                             false, false));
    534   loop_.Run();
    535 }
    536 
    537 TEST_F(UpdateAttempterTest, EnterpriseRollbackTest) {
    538   loop_.PostTask(FROM_HERE,
    539                  base::Bind(&UpdateAttempterTest::RollbackTestStart,
    540                             base::Unretained(this),
    541                             true, true));
    542   loop_.Run();
    543 }
    544 
    545 void UpdateAttempterTest::PingOmahaTestStart() {
    546   EXPECT_CALL(*processor_,
    547               EnqueueAction(Property(&AbstractAction::Type,
    548                                      OmahaRequestAction::StaticType())));
    549   EXPECT_CALL(*processor_, StartProcessing());
    550   attempter_.PingOmaha();
    551   ScheduleQuitMainLoop();
    552 }
    553 
    554 TEST_F(UpdateAttempterTest, PingOmahaTest) {
    555   EXPECT_FALSE(attempter_.waiting_for_scheduled_check_);
    556   EXPECT_FALSE(attempter_.schedule_updates_called());
    557   // Disable scheduling of subsequnet checks; we're using the DefaultPolicy in
    558   // testing, which is more permissive than we want to handle here.
    559   attempter_.DisableScheduleUpdates();
    560   loop_.PostTask(FROM_HERE,
    561                  base::Bind(&UpdateAttempterTest::PingOmahaTestStart,
    562                             base::Unretained(this)));
    563   brillo::MessageLoopRunMaxIterations(&loop_, 100);
    564   EXPECT_EQ(UpdateStatus::UPDATED_NEED_REBOOT, attempter_.status());
    565   EXPECT_TRUE(attempter_.schedule_updates_called());
    566 }
    567 
    568 TEST_F(UpdateAttempterTest, CreatePendingErrorEventTest) {
    569   MockAction action;
    570   const ErrorCode kCode = ErrorCode::kDownloadTransferError;
    571   attempter_.CreatePendingErrorEvent(&action, kCode);
    572   ASSERT_NE(nullptr, attempter_.error_event_.get());
    573   EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type);
    574   EXPECT_EQ(OmahaEvent::kResultError, attempter_.error_event_->result);
    575   EXPECT_EQ(
    576       static_cast<ErrorCode>(static_cast<int>(kCode) |
    577                              static_cast<int>(ErrorCode::kTestOmahaUrlFlag)),
    578       attempter_.error_event_->error_code);
    579 }
    580 
    581 TEST_F(UpdateAttempterTest, CreatePendingErrorEventResumedTest) {
    582   OmahaResponseHandlerAction *response_action =
    583       new OmahaResponseHandlerAction(&fake_system_state_);
    584   response_action->install_plan_.is_resume = true;
    585   attempter_.response_handler_action_.reset(response_action);
    586   MockAction action;
    587   const ErrorCode kCode = ErrorCode::kInstallDeviceOpenError;
    588   attempter_.CreatePendingErrorEvent(&action, kCode);
    589   ASSERT_NE(nullptr, attempter_.error_event_.get());
    590   EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type);
    591   EXPECT_EQ(OmahaEvent::kResultError, attempter_.error_event_->result);
    592   EXPECT_EQ(
    593       static_cast<ErrorCode>(
    594           static_cast<int>(kCode) |
    595           static_cast<int>(ErrorCode::kResumedFlag) |
    596           static_cast<int>(ErrorCode::kTestOmahaUrlFlag)),
    597       attempter_.error_event_->error_code);
    598 }
    599 
    600 TEST_F(UpdateAttempterTest, P2PNotStartedAtStartupWhenNotEnabled) {
    601   MockP2PManager mock_p2p_manager;
    602   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    603   mock_p2p_manager.fake().SetP2PEnabled(false);
    604   EXPECT_CALL(mock_p2p_manager, EnsureP2PRunning()).Times(0);
    605   attempter_.UpdateEngineStarted();
    606 }
    607 
    608 TEST_F(UpdateAttempterTest, P2PNotStartedAtStartupWhenEnabledButNotSharing) {
    609   MockP2PManager mock_p2p_manager;
    610   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    611   mock_p2p_manager.fake().SetP2PEnabled(true);
    612   EXPECT_CALL(mock_p2p_manager, EnsureP2PRunning()).Times(0);
    613   attempter_.UpdateEngineStarted();
    614 }
    615 
    616 TEST_F(UpdateAttempterTest, P2PStartedAtStartupWhenEnabledAndSharing) {
    617   MockP2PManager mock_p2p_manager;
    618   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    619   mock_p2p_manager.fake().SetP2PEnabled(true);
    620   mock_p2p_manager.fake().SetCountSharedFilesResult(1);
    621   EXPECT_CALL(mock_p2p_manager, EnsureP2PRunning());
    622   attempter_.UpdateEngineStarted();
    623 }
    624 
    625 TEST_F(UpdateAttempterTest, P2PNotEnabled) {
    626   loop_.PostTask(FROM_HERE,
    627                  base::Bind(&UpdateAttempterTest::P2PNotEnabledStart,
    628                             base::Unretained(this)));
    629   loop_.Run();
    630 }
    631 
    632 void UpdateAttempterTest::P2PNotEnabledStart() {
    633   // If P2P is not enabled, check that we do not attempt housekeeping
    634   // and do not convey that p2p is to be used.
    635   MockP2PManager mock_p2p_manager;
    636   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    637   mock_p2p_manager.fake().SetP2PEnabled(false);
    638   EXPECT_CALL(mock_p2p_manager, PerformHousekeeping()).Times(0);
    639   attempter_.Update("", "", "", "", false, false);
    640   EXPECT_FALSE(actual_using_p2p_for_downloading_);
    641   EXPECT_FALSE(actual_using_p2p_for_sharing());
    642   ScheduleQuitMainLoop();
    643 }
    644 
    645 TEST_F(UpdateAttempterTest, P2PEnabledStartingFails) {
    646   loop_.PostTask(FROM_HERE,
    647                  base::Bind(&UpdateAttempterTest::P2PEnabledStartingFailsStart,
    648                             base::Unretained(this)));
    649   loop_.Run();
    650 }
    651 
    652 void UpdateAttempterTest::P2PEnabledStartingFailsStart() {
    653   // If p2p is enabled, but starting it fails ensure we don't do
    654   // any housekeeping and do not convey that p2p should be used.
    655   MockP2PManager mock_p2p_manager;
    656   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    657   mock_p2p_manager.fake().SetP2PEnabled(true);
    658   mock_p2p_manager.fake().SetEnsureP2PRunningResult(false);
    659   mock_p2p_manager.fake().SetPerformHousekeepingResult(false);
    660   EXPECT_CALL(mock_p2p_manager, PerformHousekeeping()).Times(0);
    661   attempter_.Update("", "", "", "", false, false);
    662   EXPECT_FALSE(actual_using_p2p_for_downloading());
    663   EXPECT_FALSE(actual_using_p2p_for_sharing());
    664   ScheduleQuitMainLoop();
    665 }
    666 
    667 TEST_F(UpdateAttempterTest, P2PEnabledHousekeepingFails) {
    668   loop_.PostTask(
    669       FROM_HERE,
    670       base::Bind(&UpdateAttempterTest::P2PEnabledHousekeepingFailsStart,
    671                  base::Unretained(this)));
    672   loop_.Run();
    673 }
    674 
    675 void UpdateAttempterTest::P2PEnabledHousekeepingFailsStart() {
    676   // If p2p is enabled, starting it works but housekeeping fails, ensure
    677   // we do not convey p2p is to be used.
    678   MockP2PManager mock_p2p_manager;
    679   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    680   mock_p2p_manager.fake().SetP2PEnabled(true);
    681   mock_p2p_manager.fake().SetEnsureP2PRunningResult(true);
    682   mock_p2p_manager.fake().SetPerformHousekeepingResult(false);
    683   EXPECT_CALL(mock_p2p_manager, PerformHousekeeping());
    684   attempter_.Update("", "", "", "", false, false);
    685   EXPECT_FALSE(actual_using_p2p_for_downloading());
    686   EXPECT_FALSE(actual_using_p2p_for_sharing());
    687   ScheduleQuitMainLoop();
    688 }
    689 
    690 TEST_F(UpdateAttempterTest, P2PEnabled) {
    691   loop_.PostTask(FROM_HERE,
    692                  base::Bind(&UpdateAttempterTest::P2PEnabledStart,
    693                             base::Unretained(this)));
    694   loop_.Run();
    695 }
    696 
    697 void UpdateAttempterTest::P2PEnabledStart() {
    698   MockP2PManager mock_p2p_manager;
    699   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    700   // If P2P is enabled and starting it works, check that we performed
    701   // housekeeping and that we convey p2p should be used.
    702   mock_p2p_manager.fake().SetP2PEnabled(true);
    703   mock_p2p_manager.fake().SetEnsureP2PRunningResult(true);
    704   mock_p2p_manager.fake().SetPerformHousekeepingResult(true);
    705   EXPECT_CALL(mock_p2p_manager, PerformHousekeeping());
    706   attempter_.Update("", "", "", "", false, false);
    707   EXPECT_TRUE(actual_using_p2p_for_downloading());
    708   EXPECT_TRUE(actual_using_p2p_for_sharing());
    709   ScheduleQuitMainLoop();
    710 }
    711 
    712 TEST_F(UpdateAttempterTest, P2PEnabledInteractive) {
    713   loop_.PostTask(FROM_HERE,
    714                  base::Bind(&UpdateAttempterTest::P2PEnabledInteractiveStart,
    715                             base::Unretained(this)));
    716   loop_.Run();
    717 }
    718 
    719 void UpdateAttempterTest::P2PEnabledInteractiveStart() {
    720   MockP2PManager mock_p2p_manager;
    721   fake_system_state_.set_p2p_manager(&mock_p2p_manager);
    722   // For an interactive check, if P2P is enabled and starting it
    723   // works, check that we performed housekeeping and that we convey
    724   // p2p should be used for sharing but NOT for downloading.
    725   mock_p2p_manager.fake().SetP2PEnabled(true);
    726   mock_p2p_manager.fake().SetEnsureP2PRunningResult(true);
    727   mock_p2p_manager.fake().SetPerformHousekeepingResult(true);
    728   EXPECT_CALL(mock_p2p_manager, PerformHousekeeping());
    729   attempter_.Update("", "", "", "", false, true /* interactive */);
    730   EXPECT_FALSE(actual_using_p2p_for_downloading());
    731   EXPECT_TRUE(actual_using_p2p_for_sharing());
    732   ScheduleQuitMainLoop();
    733 }
    734 
    735 TEST_F(UpdateAttempterTest, ReadScatterFactorFromPolicy) {
    736   loop_.PostTask(
    737       FROM_HERE,
    738       base::Bind(&UpdateAttempterTest::ReadScatterFactorFromPolicyTestStart,
    739                  base::Unretained(this)));
    740   loop_.Run();
    741 }
    742 
    743 // Tests that the scatter_factor_in_seconds value is properly fetched
    744 // from the device policy.
    745 void UpdateAttempterTest::ReadScatterFactorFromPolicyTestStart() {
    746   int64_t scatter_factor_in_seconds = 36000;
    747 
    748   policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy();
    749   attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy));
    750 
    751   EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
    752   fake_system_state_.set_device_policy(device_policy);
    753 
    754   EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_))
    755       .WillRepeatedly(DoAll(
    756           SetArgumentPointee<0>(scatter_factor_in_seconds),
    757           Return(true)));
    758 
    759   attempter_.Update("", "", "", "", false, false);
    760   EXPECT_EQ(scatter_factor_in_seconds, attempter_.scatter_factor_.InSeconds());
    761 
    762   ScheduleQuitMainLoop();
    763 }
    764 
    765 TEST_F(UpdateAttempterTest, DecrementUpdateCheckCountTest) {
    766   loop_.PostTask(
    767       FROM_HERE,
    768       base::Bind(&UpdateAttempterTest::DecrementUpdateCheckCountTestStart,
    769                  base::Unretained(this)));
    770   loop_.Run();
    771 }
    772 
    773 void UpdateAttempterTest::DecrementUpdateCheckCountTestStart() {
    774   // Tests that the scatter_factor_in_seconds value is properly fetched
    775   // from the device policy and is decremented if value > 0.
    776   int64_t initial_value = 5;
    777   FakePrefs fake_prefs;
    778   attempter_.prefs_ = &fake_prefs;
    779 
    780   fake_system_state_.fake_hardware()->SetIsOOBEComplete(Time::UnixEpoch());
    781 
    782   EXPECT_TRUE(fake_prefs.SetInt64(kPrefsUpdateCheckCount, initial_value));
    783 
    784   int64_t scatter_factor_in_seconds = 10;
    785 
    786   policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy();
    787   attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy));
    788 
    789   EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
    790   fake_system_state_.set_device_policy(device_policy);
    791 
    792   EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_))
    793       .WillRepeatedly(DoAll(
    794           SetArgumentPointee<0>(scatter_factor_in_seconds),
    795           Return(true)));
    796 
    797   attempter_.Update("", "", "", "", false, false);
    798   EXPECT_EQ(scatter_factor_in_seconds, attempter_.scatter_factor_.InSeconds());
    799 
    800   // Make sure the file still exists.
    801   EXPECT_TRUE(fake_prefs.Exists(kPrefsUpdateCheckCount));
    802 
    803   int64_t new_value;
    804   EXPECT_TRUE(fake_prefs.GetInt64(kPrefsUpdateCheckCount, &new_value));
    805   EXPECT_EQ(initial_value - 1, new_value);
    806 
    807   EXPECT_TRUE(
    808       attempter_.omaha_request_params_->update_check_count_wait_enabled());
    809 
    810   // However, if the count is already 0, it's not decremented. Test that.
    811   initial_value = 0;
    812   EXPECT_TRUE(fake_prefs.SetInt64(kPrefsUpdateCheckCount, initial_value));
    813   attempter_.Update("", "", "", "", false, false);
    814   EXPECT_TRUE(fake_prefs.Exists(kPrefsUpdateCheckCount));
    815   EXPECT_TRUE(fake_prefs.GetInt64(kPrefsUpdateCheckCount, &new_value));
    816   EXPECT_EQ(initial_value, new_value);
    817 
    818   ScheduleQuitMainLoop();
    819 }
    820 
    821 TEST_F(UpdateAttempterTest, NoScatteringDoneDuringManualUpdateTestStart) {
    822   loop_.PostTask(FROM_HERE, base::Bind(
    823       &UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart,
    824       base::Unretained(this)));
    825   loop_.Run();
    826 }
    827 
    828 void UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart() {
    829   // Tests that no scattering logic is enabled if the update check
    830   // is manually done (as opposed to a scheduled update check)
    831   int64_t initial_value = 8;
    832   FakePrefs fake_prefs;
    833   attempter_.prefs_ = &fake_prefs;
    834 
    835   fake_system_state_.fake_hardware()->SetIsOOBEComplete(Time::UnixEpoch());
    836   fake_system_state_.set_prefs(&fake_prefs);
    837 
    838   EXPECT_TRUE(fake_prefs.SetInt64(kPrefsWallClockWaitPeriod, initial_value));
    839   EXPECT_TRUE(fake_prefs.SetInt64(kPrefsUpdateCheckCount, initial_value));
    840 
    841   // make sure scatter_factor is non-zero as scattering is disabled
    842   // otherwise.
    843   int64_t scatter_factor_in_seconds = 50;
    844 
    845   policy::MockDevicePolicy* device_policy = new policy::MockDevicePolicy();
    846   attempter_.policy_provider_.reset(new policy::PolicyProvider(device_policy));
    847 
    848   EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
    849   fake_system_state_.set_device_policy(device_policy);
    850 
    851   EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_))
    852       .WillRepeatedly(DoAll(
    853           SetArgumentPointee<0>(scatter_factor_in_seconds),
    854           Return(true)));
    855 
    856   // Trigger an interactive check so we can test that scattering is disabled.
    857   attempter_.Update("", "", "", "", false, true);
    858   EXPECT_EQ(scatter_factor_in_seconds, attempter_.scatter_factor_.InSeconds());
    859 
    860   // Make sure scattering is disabled for manual (i.e. user initiated) update
    861   // checks and all artifacts are removed.
    862   EXPECT_FALSE(
    863       attempter_.omaha_request_params_->wall_clock_based_wait_enabled());
    864   EXPECT_FALSE(fake_prefs.Exists(kPrefsWallClockWaitPeriod));
    865   EXPECT_EQ(0, attempter_.omaha_request_params_->waiting_period().InSeconds());
    866   EXPECT_FALSE(
    867       attempter_.omaha_request_params_->update_check_count_wait_enabled());
    868   EXPECT_FALSE(fake_prefs.Exists(kPrefsUpdateCheckCount));
    869 
    870   ScheduleQuitMainLoop();
    871 }
    872 
    873 // Checks that we only report daily metrics at most every 24 hours.
    874 TEST_F(UpdateAttempterTest, ReportDailyMetrics) {
    875   FakeClock fake_clock;
    876   FakePrefs fake_prefs;
    877 
    878   fake_system_state_.set_clock(&fake_clock);
    879   fake_system_state_.set_prefs(&fake_prefs);
    880 
    881   Time epoch = Time::FromInternalValue(0);
    882   fake_clock.SetWallclockTime(epoch);
    883 
    884   // If there is no kPrefsDailyMetricsLastReportedAt state variable,
    885   // we should report.
    886   EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
    887   // We should not report again if no time has passed.
    888   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    889 
    890   // We should not report if only 10 hours has passed.
    891   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(10));
    892   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    893 
    894   // We should not report if only 24 hours - 1 sec has passed.
    895   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(24) -
    896                               TimeDelta::FromSeconds(1));
    897   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    898 
    899   // We should report if 24 hours has passed.
    900   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(24));
    901   EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
    902 
    903   // But then we should not report again..
    904   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    905 
    906   // .. until another 24 hours has passed
    907   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(47));
    908   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    909   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(48));
    910   EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
    911   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    912 
    913   // .. and another 24 hours
    914   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(71));
    915   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    916   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(72));
    917   EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
    918   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    919 
    920   // If the span between time of reporting and present time is
    921   // negative, we report. This is in order to reset the timestamp and
    922   // avoid an edge condition whereby a distant point in the future is
    923   // in the state variable resulting in us never ever reporting again.
    924   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(71));
    925   EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
    926   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    927 
    928   // In this case we should not update until the clock reads 71 + 24 = 95.
    929   // Check that.
    930   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(94));
    931   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    932   fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(95));
    933   EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
    934   EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
    935 }
    936 
    937 TEST_F(UpdateAttempterTest, BootTimeInUpdateMarkerFile) {
    938   UpdateAttempterUnderTest attempter{&fake_system_state_,
    939                                      &libcros_proxy_,
    940                                      &debugd_proxy_mock_};
    941   FakeClock fake_clock;
    942   fake_clock.SetBootTime(Time::FromTimeT(42));
    943   fake_system_state_.set_clock(&fake_clock);
    944   FakePrefs fake_prefs;
    945   fake_system_state_.set_prefs(&fake_prefs);
    946   attempter.Init();
    947 
    948   Time boot_time;
    949   EXPECT_FALSE(attempter.GetBootTimeAtUpdate(&boot_time));
    950 
    951   attempter.WriteUpdateCompletedMarker();
    952 
    953   EXPECT_TRUE(attempter.GetBootTimeAtUpdate(&boot_time));
    954   EXPECT_EQ(boot_time.ToTimeT(), 42);
    955 }
    956 
    957 TEST_F(UpdateAttempterTest, AnyUpdateSourceAllowedUnofficial) {
    958   fake_system_state_.fake_hardware()->SetIsOfficialBuild(false);
    959   EXPECT_TRUE(attempter_.IsAnyUpdateSourceAllowed());
    960 }
    961 
    962 TEST_F(UpdateAttempterTest, AnyUpdateSourceAllowedOfficialDevmode) {
    963   fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
    964   fake_system_state_.fake_hardware()->SetIsNormalBootMode(false);
    965   EXPECT_CALL(debugd_proxy_mock_, QueryDevFeatures(_, _, _))
    966       .WillRepeatedly(DoAll(SetArgumentPointee<0>(0), Return(true)));
    967   EXPECT_TRUE(attempter_.IsAnyUpdateSourceAllowed());
    968 }
    969 
    970 TEST_F(UpdateAttempterTest, AnyUpdateSourceDisallowedOfficialNormal) {
    971   fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
    972   fake_system_state_.fake_hardware()->SetIsNormalBootMode(true);
    973   // debugd should not be queried in this case.
    974   EXPECT_CALL(debugd_proxy_mock_, QueryDevFeatures(_, _, _)).Times(0);
    975   EXPECT_FALSE(attempter_.IsAnyUpdateSourceAllowed());
    976 }
    977 
    978 TEST_F(UpdateAttempterTest, AnyUpdateSourceDisallowedDebugdDisabled) {
    979   using debugd::DEV_FEATURES_DISABLED;
    980   fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
    981   fake_system_state_.fake_hardware()->SetIsNormalBootMode(false);
    982   EXPECT_CALL(debugd_proxy_mock_, QueryDevFeatures(_, _, _))
    983       .WillRepeatedly(
    984           DoAll(SetArgumentPointee<0>(DEV_FEATURES_DISABLED), Return(true)));
    985   EXPECT_FALSE(attempter_.IsAnyUpdateSourceAllowed());
    986 }
    987 
    988 TEST_F(UpdateAttempterTest, AnyUpdateSourceDisallowedDebugdFailure) {
    989   fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
    990   fake_system_state_.fake_hardware()->SetIsNormalBootMode(false);
    991   EXPECT_CALL(debugd_proxy_mock_, QueryDevFeatures(_, _, _))
    992       .WillRepeatedly(Return(false));
    993   EXPECT_FALSE(attempter_.IsAnyUpdateSourceAllowed());
    994 }
    995 
    996 TEST_F(UpdateAttempterTest, CheckForUpdateAUTest) {
    997   fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
    998   fake_system_state_.fake_hardware()->SetIsNormalBootMode(true);
    999   attempter_.CheckForUpdate("", "autest", true);
   1000   EXPECT_EQ(constants::kOmahaDefaultAUTestURL, attempter_.forced_omaha_url());
   1001 }
   1002 
   1003 TEST_F(UpdateAttempterTest, CheckForUpdateScheduledAUTest) {
   1004   fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
   1005   fake_system_state_.fake_hardware()->SetIsNormalBootMode(true);
   1006   attempter_.CheckForUpdate("", "autest-scheduled", true);
   1007   EXPECT_EQ(constants::kOmahaDefaultAUTestURL, attempter_.forced_omaha_url());
   1008 }
   1009 
   1010 }  // namespace chromeos_update_engine
   1011