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