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:
UpdateAttempterUnderTest(SystemState * system_state,LibCrosProxy * libcros_proxy,org::chromium::debugdProxyInterface * debugd_proxy)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.
ScheduleUpdates()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   }
EnableScheduleUpdates()97   void EnableScheduleUpdates() { do_schedule_updates_ = true; }
DisableScheduleUpdates()98   void DisableScheduleUpdates() { do_schedule_updates_ = false; }
99 
100   // Indicates whether ScheduleUpdates() was called.
schedule_updates_called() const101   bool schedule_updates_called() const { return schedule_updates_called_; }
102 
103   // Need to expose forced_omaha_url_ so we can test it.
forced_omaha_url() const104   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:
UpdateAttempterTest()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 
SetUp()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 
TearDown()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 
actual_using_p2p_for_downloading()186   bool actual_using_p2p_for_downloading() {
187     return actual_using_p2p_for_downloading_;
188   }
actual_using_p2p_for_sharing()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 
ScheduleQuitMainLoop()218 void UpdateAttempterTest::ScheduleQuitMainLoop() {
219   loop_.PostTask(FROM_HERE, base::Bind([this] { this->loop_.BreakLoop(); }));
220 }
221 
TEST_F(UpdateAttempterTest,ActionCompletedDownloadTest)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 
TEST_F(UpdateAttempterTest,ActionCompletedErrorTest)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 
TEST_F(UpdateAttempterTest,ActionCompletedOmahaRequestTest)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 
TEST_F(UpdateAttempterTest,ConstructWithUpdatedMarkerTest)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 
TEST_F(UpdateAttempterTest,GetErrorCodeForActionTest)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());
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 
TEST_F(UpdateAttempterTest,DisableDeltaUpdateIfNeededTest)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 
TEST_F(UpdateAttempterTest,MarkDeltaUpdateFailureTest)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 
TEST_F(UpdateAttempterTest,ScheduleErrorEventActionNoEventTest)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 
TEST_F(UpdateAttempterTest,ScheduleErrorEventActionTest)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 
UpdateTestStart()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 
UpdateTestVerify()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 
RollbackTestStart(bool enterprise_rollback,bool valid_slot)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@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 
RollbackTestVerify()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 
TEST_F(UpdateAttempterTest,UpdateTest)516 TEST_F(UpdateAttempterTest, UpdateTest) {
517   UpdateTestStart();
518   loop_.Run();
519 }
520 
TEST_F(UpdateAttempterTest,RollbackTest)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 
TEST_F(UpdateAttempterTest,InvalidSlotRollbackTest)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 
TEST_F(UpdateAttempterTest,EnterpriseRollbackTest)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 
PingOmahaTestStart()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 
TEST_F(UpdateAttempterTest,PingOmahaTest)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 
TEST_F(UpdateAttempterTest,CreatePendingErrorEventTest)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 
TEST_F(UpdateAttempterTest,CreatePendingErrorEventResumedTest)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 
TEST_F(UpdateAttempterTest,P2PNotStartedAtStartupWhenNotEnabled)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 
TEST_F(UpdateAttempterTest,P2PNotStartedAtStartupWhenEnabledButNotSharing)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 
TEST_F(UpdateAttempterTest,P2PStartedAtStartupWhenEnabledAndSharing)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 
TEST_F(UpdateAttempterTest,P2PNotEnabled)625 TEST_F(UpdateAttempterTest, P2PNotEnabled) {
626   loop_.PostTask(FROM_HERE,
627                  base::Bind(&UpdateAttempterTest::P2PNotEnabledStart,
628                             base::Unretained(this)));
629   loop_.Run();
630 }
631 
P2PNotEnabledStart()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 
TEST_F(UpdateAttempterTest,P2PEnabledStartingFails)645 TEST_F(UpdateAttempterTest, P2PEnabledStartingFails) {
646   loop_.PostTask(FROM_HERE,
647                  base::Bind(&UpdateAttempterTest::P2PEnabledStartingFailsStart,
648                             base::Unretained(this)));
649   loop_.Run();
650 }
651 
P2PEnabledStartingFailsStart()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 
TEST_F(UpdateAttempterTest,P2PEnabledHousekeepingFails)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 
P2PEnabledHousekeepingFailsStart()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 
TEST_F(UpdateAttempterTest,P2PEnabled)690 TEST_F(UpdateAttempterTest, P2PEnabled) {
691   loop_.PostTask(FROM_HERE,
692                  base::Bind(&UpdateAttempterTest::P2PEnabledStart,
693                             base::Unretained(this)));
694   loop_.Run();
695 }
696 
P2PEnabledStart()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 
TEST_F(UpdateAttempterTest,P2PEnabledInteractive)712 TEST_F(UpdateAttempterTest, P2PEnabledInteractive) {
713   loop_.PostTask(FROM_HERE,
714                  base::Bind(&UpdateAttempterTest::P2PEnabledInteractiveStart,
715                             base::Unretained(this)));
716   loop_.Run();
717 }
718 
P2PEnabledInteractiveStart()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 
TEST_F(UpdateAttempterTest,ReadScatterFactorFromPolicy)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.
ReadScatterFactorFromPolicyTestStart()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 
TEST_F(UpdateAttempterTest,DecrementUpdateCheckCountTest)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 
DecrementUpdateCheckCountTestStart()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 
TEST_F(UpdateAttempterTest,NoScatteringDoneDuringManualUpdateTestStart)821 TEST_F(UpdateAttempterTest, NoScatteringDoneDuringManualUpdateTestStart) {
822   loop_.PostTask(FROM_HERE, base::Bind(
823       &UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart,
824       base::Unretained(this)));
825   loop_.Run();
826 }
827 
NoScatteringDoneDuringManualUpdateTestStart()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.
TEST_F(UpdateAttempterTest,ReportDailyMetrics)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 
TEST_F(UpdateAttempterTest,BootTimeInUpdateMarkerFile)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 
TEST_F(UpdateAttempterTest,AnyUpdateSourceAllowedUnofficial)957 TEST_F(UpdateAttempterTest, AnyUpdateSourceAllowedUnofficial) {
958   fake_system_state_.fake_hardware()->SetIsOfficialBuild(false);
959   EXPECT_TRUE(attempter_.IsAnyUpdateSourceAllowed());
960 }
961 
TEST_F(UpdateAttempterTest,AnyUpdateSourceAllowedOfficialDevmode)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 
TEST_F(UpdateAttempterTest,AnyUpdateSourceDisallowedOfficialNormal)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 
TEST_F(UpdateAttempterTest,AnyUpdateSourceDisallowedDebugdDisabled)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 
TEST_F(UpdateAttempterTest,AnyUpdateSourceDisallowedDebugdFailure)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 
TEST_F(UpdateAttempterTest,CheckForUpdateAUTest)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 
TEST_F(UpdateAttempterTest,CheckForUpdateScheduledAUTest)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