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