blob: 4677d317c8e6ed2183d2887881de26e7fad671f2 [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
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//
Darin Petkovf42cc1c2010-09-01 09:03:02 -070016
Alex Deymo2c0db7b2014-11-04 12:23:39 -080017#include "update_engine/update_attempter.h"
18
Ben Chan9abb7632014-08-07 00:10:53 -070019#include <stdint.h>
20
Ben Chan02f7c1d2014-10-18 15:18:02 -070021#include <memory>
22
Ben Chan06c76a42014-09-05 08:21:06 -070023#include <base/files/file_util.h>
Alex Deymo0b3db6b2015-08-10 15:19:37 -070024#include <base/message_loop/message_loop.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070025#include <brillo/message_loops/base_message_loop.h>
26#include <brillo/message_loops/message_loop.h>
27#include <brillo/message_loops/message_loop_utils.h>
Darin Petkovf42cc1c2010-09-01 09:03:02 -070028#include <gtest/gtest.h>
Patrick Dubroy7fbbe8a2011-08-01 17:28:22 +020029#include <policy/libpolicy.h>
30#include <policy/mock_device_policy.h>
Darin Petkovf42cc1c2010-09-01 09:03:02 -070031
Alex Deymo39910dc2015-11-09 17:04:30 -080032#include "update_engine/common/fake_clock.h"
33#include "update_engine/common/fake_prefs.h"
Alex Deymo14fd1ec2016-02-24 22:03:57 -080034#include "update_engine/common/mock_action.h"
35#include "update_engine/common/mock_action_processor.h"
Alex Deymo39910dc2015-11-09 17:04:30 -080036#include "update_engine/common/mock_http_fetcher.h"
37#include "update_engine/common/mock_prefs.h"
38#include "update_engine/common/platform_constants.h"
39#include "update_engine/common/prefs.h"
40#include "update_engine/common/test_utils.h"
41#include "update_engine/common/utils.h"
Gilad Arnold5bb4c902014-04-10 12:32:13 -070042#include "update_engine/fake_system_state.h"
David Zeuthen8f191b22013-08-06 12:27:50 -070043#include "update_engine/mock_p2p_manager.h"
Jay Srinivasan6f6ea002012-12-14 11:26:28 -080044#include "update_engine/mock_payload_state.h"
Aaron Wood9321f502017-09-07 11:18:54 -070045#include "update_engine/mock_service_observer.h"
Alex Deymo39910dc2015-11-09 17:04:30 -080046#include "update_engine/payload_consumer/filesystem_verifier_action.h"
47#include "update_engine/payload_consumer/install_plan.h"
48#include "update_engine/payload_consumer/payload_constants.h"
49#include "update_engine/payload_consumer/postinstall_runner_action.h"
Darin Petkovf42cc1c2010-09-01 09:03:02 -070050
David Zeuthen985b1122013-10-09 12:13:15 -070051using base::Time;
52using base::TimeDelta;
Aaron Woodbf5a2522017-10-04 10:58:36 -070053using chromeos_update_manager::EvalStatus;
54using chromeos_update_manager::UpdateCheckParams;
Darin Petkovf42cc1c2010-09-01 09:03:02 -070055using std::string;
Ben Chan02f7c1d2014-10-18 15:18:02 -070056using std::unique_ptr;
Aaron Woodbf5a2522017-10-04 10:58:36 -070057using testing::_;
Darin Petkov36275772010-10-01 11:40:57 -070058using testing::DoAll;
Aaron Wood7f92e2b2017-08-28 14:51:21 -070059using testing::Field;
Darin Petkovf42cc1c2010-09-01 09:03:02 -070060using testing::InSequence;
Darin Petkov2dd01092010-10-08 15:43:05 -070061using testing::Ne;
Darin Petkov9c096d62010-11-17 14:49:04 -080062using testing::NiceMock;
Darin Petkovf42cc1c2010-09-01 09:03:02 -070063using testing::Property;
64using testing::Return;
Gilad Arnold74b5f552014-10-07 08:17:16 -070065using testing::ReturnPointee;
Alex Deymo2c0db7b2014-11-04 12:23:39 -080066using testing::SaveArg;
Ben Chan672c1f52017-10-23 15:41:39 -070067using testing::SetArgPointee;
Aaron Woodbf5a2522017-10-04 10:58:36 -070068using update_engine::UpdateAttemptFlags;
Aaron Wood7f92e2b2017-08-28 14:51:21 -070069using update_engine::UpdateEngineStatus;
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -070070using update_engine::UpdateStatus;
Darin Petkovf42cc1c2010-09-01 09:03:02 -070071
72namespace chromeos_update_engine {
73
74// Test a subclass rather than the main class directly so that we can mock out
Darin Petkovcd1666f2010-09-23 09:53:44 -070075// methods within the class. There're explicit unit tests for the mocked out
Darin Petkovf42cc1c2010-09-01 09:03:02 -070076// methods.
77class UpdateAttempterUnderTest : public UpdateAttempter {
78 public:
Jeffrey Kardatzkecf5f1f12017-10-02 16:08:44 -070079 explicit UpdateAttempterUnderTest(SystemState* system_state)
80 : UpdateAttempter(system_state, nullptr) {}
Gilad Arnoldec7f9162014-07-15 13:24:46 -070081
82 // Wrap the update scheduling method, allowing us to opt out of scheduled
83 // updates for testing purposes.
84 void ScheduleUpdates() override {
85 schedule_updates_called_ = true;
86 if (do_schedule_updates_) {
87 UpdateAttempter::ScheduleUpdates();
88 } else {
89 LOG(INFO) << "[TEST] Update scheduling disabled.";
90 }
91 }
92 void EnableScheduleUpdates() { do_schedule_updates_ = true; }
93 void DisableScheduleUpdates() { do_schedule_updates_ = false; }
94
95 // Indicates whether ScheduleUpdates() was called.
96 bool schedule_updates_called() const { return schedule_updates_called_; }
97
David Pursell02c18642014-11-06 11:26:11 -080098 // Need to expose forced_omaha_url_ so we can test it.
Alex Deymo60ca1a72015-06-18 18:19:15 -070099 const string& forced_omaha_url() const { return forced_omaha_url_; }
David Pursell02c18642014-11-06 11:26:11 -0800100
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700101 private:
102 bool schedule_updates_called_ = false;
103 bool do_schedule_updates_ = true;
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700104};
105
106class UpdateAttempterTest : public ::testing::Test {
107 protected:
Jay Srinivasan43488792012-06-19 00:25:31 -0700108 UpdateAttempterTest()
Daniel Erate5f6f252017-04-20 12:09:58 -0600109 : certificate_checker_(fake_system_state_.mock_prefs(),
Alex Deymo33e91e72015-12-01 18:26:08 -0300110 &openssl_wrapper_) {
Gilad Arnold1f847232014-04-07 12:07:49 -0700111 // Override system state members.
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700112 fake_system_state_.set_connection_manager(&mock_connection_manager);
113 fake_system_state_.set_update_attempter(&attempter_);
Alex Deymo60ca1a72015-06-18 18:19:15 -0700114 loop_.SetAsCurrent();
Gilad Arnold1f847232014-04-07 12:07:49 -0700115
Alex Deymo33e91e72015-12-01 18:26:08 -0300116 certificate_checker_.Init();
117
Sen Jiange67bb5b2016-06-20 15:53:56 -0700118 // Finish initializing the attempter.
Gilad Arnold1f847232014-04-07 12:07:49 -0700119 attempter_.Init();
Jay Srinivasan43488792012-06-19 00:25:31 -0700120 }
Gilad Arnoldeff87cc2013-07-22 18:32:09 -0700121
Alex Deymo610277e2014-11-11 21:18:11 -0800122 void SetUp() override {
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700123 EXPECT_NE(nullptr, attempter_.system_state_);
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700124 EXPECT_EQ(0, attempter_.http_response_code_);
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700125 EXPECT_EQ(UpdateStatus::IDLE, attempter_.status_);
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700126 EXPECT_EQ(0.0, attempter_.download_progress_);
127 EXPECT_EQ(0, attempter_.last_checked_time_);
128 EXPECT_EQ("0.0.0.0", attempter_.new_version_);
Aaron Wood7f92e2b2017-08-28 14:51:21 -0700129 EXPECT_EQ(0ULL, attempter_.new_payload_size_);
Alex Deymo8427b4a2014-11-05 14:00:32 -0800130 processor_ = new NiceMock<MockActionProcessor>();
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700131 attempter_.processor_.reset(processor_); // Transfers ownership.
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700132 prefs_ = fake_system_state_.mock_prefs();
Gilad Arnold74b5f552014-10-07 08:17:16 -0700133
134 // Set up store/load semantics of P2P properties via the mock PayloadState.
135 actual_using_p2p_for_downloading_ = false;
136 EXPECT_CALL(*fake_system_state_.mock_payload_state(),
137 SetUsingP2PForDownloading(_))
138 .WillRepeatedly(SaveArg<0>(&actual_using_p2p_for_downloading_));
139 EXPECT_CALL(*fake_system_state_.mock_payload_state(),
140 GetUsingP2PForDownloading())
141 .WillRepeatedly(ReturnPointee(&actual_using_p2p_for_downloading_));
142 actual_using_p2p_for_sharing_ = false;
143 EXPECT_CALL(*fake_system_state_.mock_payload_state(),
144 SetUsingP2PForSharing(_))
145 .WillRepeatedly(SaveArg<0>(&actual_using_p2p_for_sharing_));
146 EXPECT_CALL(*fake_system_state_.mock_payload_state(),
147 GetUsingP2PForDownloading())
148 .WillRepeatedly(ReturnPointee(&actual_using_p2p_for_sharing_));
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700149 }
150
Alex Deymo60ca1a72015-06-18 18:19:15 -0700151 public:
152 void ScheduleQuitMainLoop();
Patrick Dubroy7fbbe8a2011-08-01 17:28:22 +0200153
Alex Deymo60ca1a72015-06-18 18:19:15 -0700154 // Callbacks to run the different tests from the main loop.
Darin Petkove6ef2f82011-03-07 17:31:11 -0800155 void UpdateTestStart();
156 void UpdateTestVerify();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700157 void RollbackTestStart(bool enterprise_rollback, bool valid_slot);
Chris Sosa76a29ae2013-07-11 17:59:24 -0700158 void RollbackTestVerify();
Thieu Le116fda32011-04-19 11:01:54 -0700159 void PingOmahaTestStart();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700160 void ReadScatterFactorFromPolicyTestStart();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700161 void DecrementUpdateCheckCountTestStart();
Jay Srinivasan08fce042012-06-07 16:31:01 -0700162 void NoScatteringDoneDuringManualUpdateTestStart();
David Zeuthen8f191b22013-08-06 12:27:50 -0700163 void P2PNotEnabledStart();
David Zeuthen8f191b22013-08-06 12:27:50 -0700164 void P2PEnabledStart();
David Zeuthen8f191b22013-08-06 12:27:50 -0700165 void P2PEnabledInteractiveStart();
David Zeuthen8f191b22013-08-06 12:27:50 -0700166 void P2PEnabledStartingFailsStart();
David Zeuthen8f191b22013-08-06 12:27:50 -0700167 void P2PEnabledHousekeepingFailsStart();
David Zeuthen8f191b22013-08-06 12:27:50 -0700168
Gilad Arnold74b5f552014-10-07 08:17:16 -0700169 bool actual_using_p2p_for_downloading() {
170 return actual_using_p2p_for_downloading_;
171 }
172 bool actual_using_p2p_for_sharing() {
173 return actual_using_p2p_for_sharing_;
174 }
175
Alex Deymo0b3db6b2015-08-10 15:19:37 -0700176 base::MessageLoopForIO base_loop_;
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700177 brillo::BaseMessageLoop loop_{&base_loop_};
Alex Deymo60ca1a72015-06-18 18:19:15 -0700178
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700179 FakeSystemState fake_system_state_;
Jeffrey Kardatzkecf5f1f12017-10-02 16:08:44 -0700180 UpdateAttempterUnderTest attempter_{&fake_system_state_};
Alex Deymo33e91e72015-12-01 18:26:08 -0300181 OpenSSLWrapper openssl_wrapper_;
182 CertificateChecker certificate_checker_;
Alex Deymo30534502015-07-20 15:06:33 -0700183
Alex Deymo8427b4a2014-11-05 14:00:32 -0800184 NiceMock<MockActionProcessor>* processor_;
185 NiceMock<MockPrefs>* prefs_; // Shortcut to fake_system_state_->mock_prefs().
Jay Srinivasan55f50c22013-01-10 19:24:35 -0800186 NiceMock<MockConnectionManager> mock_connection_manager;
Gilad Arnoldeff87cc2013-07-22 18:32:09 -0700187
Gilad Arnold74b5f552014-10-07 08:17:16 -0700188 bool actual_using_p2p_for_downloading_;
189 bool actual_using_p2p_for_sharing_;
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700190};
191
Alex Deymo60ca1a72015-06-18 18:19:15 -0700192void UpdateAttempterTest::ScheduleQuitMainLoop() {
Luis Hector Chavezf1cf3482016-07-19 14:29:19 -0700193 loop_.PostTask(
194 FROM_HERE,
195 base::Bind([](brillo::BaseMessageLoop* loop) { loop->BreakLoop(); },
196 base::Unretained(&loop_)));
Alex Deymo60ca1a72015-06-18 18:19:15 -0700197}
198
Darin Petkov1b003102010-11-30 10:18:36 -0800199TEST_F(UpdateAttempterTest, ActionCompletedDownloadTest) {
Ben Chan02f7c1d2014-10-18 15:18:02 -0700200 unique_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, nullptr));
Darin Petkov1b003102010-11-30 10:18:36 -0800201 fetcher->FailTransfer(503); // Sets the HTTP response code.
Amin Hassani7ecda262017-07-11 17:10:50 -0700202 DownloadAction action(prefs_,
203 nullptr,
204 nullptr,
205 nullptr,
206 fetcher.release(),
Amin Hassanied37d682018-04-06 13:22:00 -0700207 false /* interactive */);
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800208 EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0);
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700209 attempter_.ActionCompleted(nullptr, &action, ErrorCode::kSuccess);
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700210 EXPECT_EQ(UpdateStatus::FINALIZING, attempter_.status());
Aaron Wood9321f502017-09-07 11:18:54 -0700211 EXPECT_EQ(0.0, attempter_.download_progress_);
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700212 ASSERT_EQ(nullptr, attempter_.error_event_.get());
Darin Petkov1b003102010-11-30 10:18:36 -0800213}
214
215TEST_F(UpdateAttempterTest, ActionCompletedErrorTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -0800216 MockAction action;
217 EXPECT_CALL(action, Type()).WillRepeatedly(Return("MockAction"));
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700218 attempter_.status_ = UpdateStatus::DOWNLOADING;
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800219 EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
Darin Petkov1b003102010-11-30 10:18:36 -0800220 .WillOnce(Return(false));
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700221 attempter_.ActionCompleted(nullptr, &action, ErrorCode::kError);
222 ASSERT_NE(nullptr, attempter_.error_event_.get());
Darin Petkov1b003102010-11-30 10:18:36 -0800223}
224
Aaron Wood9321f502017-09-07 11:18:54 -0700225TEST_F(UpdateAttempterTest, DownloadProgressAccumulationTest) {
226 // Simple test case, where all the values match (nothing was skipped)
227 uint64_t bytes_progressed_1 = 1024 * 1024; // 1MB
228 uint64_t bytes_progressed_2 = 1024 * 1024; // 1MB
229 uint64_t bytes_received_1 = bytes_progressed_1;
230 uint64_t bytes_received_2 = bytes_received_1 + bytes_progressed_2;
231 uint64_t bytes_total = 20 * 1024 * 1024; // 20MB
232
233 double progress_1 =
234 static_cast<double>(bytes_received_1) / static_cast<double>(bytes_total);
235 double progress_2 =
236 static_cast<double>(bytes_received_2) / static_cast<double>(bytes_total);
237
238 EXPECT_EQ(0.0, attempter_.download_progress_);
239 // This is set via inspecting the InstallPlan payloads when the
240 // OmahaResponseAction is completed
241 attempter_.new_payload_size_ = bytes_total;
242 NiceMock<MockServiceObserver> observer;
243 EXPECT_CALL(observer,
Aaron Wood7f92e2b2017-08-28 14:51:21 -0700244 SendStatusUpdate(AllOf(
245 Field(&UpdateEngineStatus::progress, progress_1),
246 Field(&UpdateEngineStatus::status, UpdateStatus::DOWNLOADING),
247 Field(&UpdateEngineStatus::new_size_bytes, bytes_total))));
Aaron Wood9321f502017-09-07 11:18:54 -0700248 EXPECT_CALL(observer,
Aaron Wood7f92e2b2017-08-28 14:51:21 -0700249 SendStatusUpdate(AllOf(
250 Field(&UpdateEngineStatus::progress, progress_2),
251 Field(&UpdateEngineStatus::status, UpdateStatus::DOWNLOADING),
252 Field(&UpdateEngineStatus::new_size_bytes, bytes_total))));
Aaron Wood9321f502017-09-07 11:18:54 -0700253 attempter_.AddObserver(&observer);
254 attempter_.BytesReceived(bytes_progressed_1, bytes_received_1, bytes_total);
255 EXPECT_EQ(progress_1, attempter_.download_progress_);
256 // This iteration validates that a later set of updates to the variables are
257 // properly handled (so that |getStatus()| will return the same progress info
258 // as the callback is receiving.
259 attempter_.BytesReceived(bytes_progressed_2, bytes_received_2, bytes_total);
260 EXPECT_EQ(progress_2, attempter_.download_progress_);
261}
262
263TEST_F(UpdateAttempterTest, ChangeToDownloadingOnReceivedBytesTest) {
264 // The transition into UpdateStatus::DOWNLOADING happens when the
265 // first bytes are received.
266 uint64_t bytes_progressed = 1024 * 1024; // 1MB
267 uint64_t bytes_received = 2 * 1024 * 1024; // 2MB
268 uint64_t bytes_total = 20 * 1024 * 1024; // 300MB
269 attempter_.status_ = UpdateStatus::CHECKING_FOR_UPDATE;
270 // This is set via inspecting the InstallPlan payloads when the
271 // OmahaResponseAction is completed
272 attempter_.new_payload_size_ = bytes_total;
273 EXPECT_EQ(0.0, attempter_.download_progress_);
274 NiceMock<MockServiceObserver> observer;
Aaron Wood7f92e2b2017-08-28 14:51:21 -0700275 EXPECT_CALL(observer,
276 SendStatusUpdate(AllOf(
277 Field(&UpdateEngineStatus::status, UpdateStatus::DOWNLOADING),
278 Field(&UpdateEngineStatus::new_size_bytes, bytes_total))));
Aaron Wood9321f502017-09-07 11:18:54 -0700279 attempter_.AddObserver(&observer);
280 attempter_.BytesReceived(bytes_progressed, bytes_received, bytes_total);
281 EXPECT_EQ(UpdateStatus::DOWNLOADING, attempter_.status_);
282}
283
284TEST_F(UpdateAttempterTest, BroadcastCompleteDownloadTest) {
285 // There is a special case to ensure that at 100% downloaded,
286 // download_progress_ is updated and that value broadcast. This test confirms
287 // that.
288 uint64_t bytes_progressed = 0; // ignored
289 uint64_t bytes_received = 5 * 1024 * 1024; // ignored
290 uint64_t bytes_total = 5 * 1024 * 1024; // 300MB
291 attempter_.status_ = UpdateStatus::DOWNLOADING;
292 attempter_.new_payload_size_ = bytes_total;
293 EXPECT_EQ(0.0, attempter_.download_progress_);
294 NiceMock<MockServiceObserver> observer;
Aaron Wood7f92e2b2017-08-28 14:51:21 -0700295 EXPECT_CALL(observer,
296 SendStatusUpdate(AllOf(
297 Field(&UpdateEngineStatus::progress, 1.0),
298 Field(&UpdateEngineStatus::status, UpdateStatus::DOWNLOADING),
299 Field(&UpdateEngineStatus::new_size_bytes, bytes_total))));
Aaron Wood9321f502017-09-07 11:18:54 -0700300 attempter_.AddObserver(&observer);
301 attempter_.BytesReceived(bytes_progressed, bytes_received, bytes_total);
302 EXPECT_EQ(1.0, attempter_.download_progress_);
303}
304
Darin Petkov1b003102010-11-30 10:18:36 -0800305TEST_F(UpdateAttempterTest, ActionCompletedOmahaRequestTest) {
Ben Chan02f7c1d2014-10-18 15:18:02 -0700306 unique_ptr<MockHttpFetcher> fetcher(new MockHttpFetcher("", 0, nullptr));
Darin Petkov1b003102010-11-30 10:18:36 -0800307 fetcher->FailTransfer(500); // Sets the HTTP response code.
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700308 OmahaRequestAction action(&fake_system_state_, nullptr,
Alex Deymoc1c17b42015-11-23 03:53:15 -0300309 std::move(fetcher), false);
Darin Petkov1b003102010-11-30 10:18:36 -0800310 ObjectCollectorAction<OmahaResponse> collector_action;
311 BondActions(&action, &collector_action);
312 OmahaResponse response;
313 response.poll_interval = 234;
314 action.SetOutputObject(response);
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800315 EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _)).Times(0);
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700316 attempter_.ActionCompleted(nullptr, &action, ErrorCode::kSuccess);
Darin Petkov1b003102010-11-30 10:18:36 -0800317 EXPECT_EQ(500, attempter_.http_response_code());
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700318 EXPECT_EQ(UpdateStatus::IDLE, attempter_.status());
Alex Deymo80f70ff2016-02-10 16:08:11 -0800319 EXPECT_EQ(234U, attempter_.server_dictated_poll_interval_);
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700320 ASSERT_TRUE(attempter_.error_event_.get() == nullptr);
Darin Petkov1b003102010-11-30 10:18:36 -0800321}
322
Alex Deymo30534502015-07-20 15:06:33 -0700323TEST_F(UpdateAttempterTest, ConstructWithUpdatedMarkerTest) {
Alex Deymo906191f2015-10-12 12:22:44 -0700324 FakePrefs fake_prefs;
325 string boot_id;
326 EXPECT_TRUE(utils::GetBootId(&boot_id));
327 fake_prefs.SetString(kPrefsUpdateCompletedOnBootId, boot_id);
328 fake_system_state_.set_prefs(&fake_prefs);
Sen Jiangaeeb2e02016-06-09 15:00:16 -0700329 attempter_.Init();
330 EXPECT_EQ(UpdateStatus::UPDATED_NEED_REBOOT, attempter_.status());
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700331}
332
333TEST_F(UpdateAttempterTest, GetErrorCodeForActionTest) {
David Zeuthena99981f2013-04-29 13:42:47 -0700334 extern ErrorCode GetErrorCodeForAction(AbstractAction* action,
335 ErrorCode code);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700336 EXPECT_EQ(ErrorCode::kSuccess,
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700337 GetErrorCodeForAction(nullptr, ErrorCode::kSuccess));
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700338
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700339 FakeSystemState fake_system_state;
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700340 OmahaRequestAction omaha_request_action(&fake_system_state, nullptr,
341 nullptr, false);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700342 EXPECT_EQ(ErrorCode::kOmahaRequestError,
343 GetErrorCodeForAction(&omaha_request_action, ErrorCode::kError));
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700344 OmahaResponseHandlerAction omaha_response_handler_action(&fake_system_state_);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700345 EXPECT_EQ(ErrorCode::kOmahaResponseHandlerError,
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700346 GetErrorCodeForAction(&omaha_response_handler_action,
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700347 ErrorCode::kError));
Sen Jiange6e4bb92016-04-05 14:59:12 -0700348 FilesystemVerifierAction filesystem_verifier_action;
Allie Woodeb9e6d82015-04-17 13:55:30 -0700349 EXPECT_EQ(ErrorCode::kFilesystemVerifierError,
350 GetErrorCodeForAction(&filesystem_verifier_action,
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700351 ErrorCode::kError));
Alex Deymob15a0b82015-11-25 20:30:40 -0300352 PostinstallRunnerAction postinstall_runner_action(
Alex Deymofb905d92016-06-03 19:26:58 -0700353 fake_system_state.fake_boot_control(), fake_system_state.fake_hardware());
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700354 EXPECT_EQ(ErrorCode::kPostinstallRunnerError,
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700355 GetErrorCodeForAction(&postinstall_runner_action,
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700356 ErrorCode::kError));
Alex Deymo8427b4a2014-11-05 14:00:32 -0800357 MockAction action_mock;
358 EXPECT_CALL(action_mock, Type()).WillOnce(Return("MockAction"));
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700359 EXPECT_EQ(ErrorCode::kError,
360 GetErrorCodeForAction(&action_mock, ErrorCode::kError));
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700361}
362
Darin Petkov36275772010-10-01 11:40:57 -0700363TEST_F(UpdateAttempterTest, DisableDeltaUpdateIfNeededTest) {
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700364 attempter_.omaha_request_params_->set_delta_okay(true);
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800365 EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
Darin Petkov36275772010-10-01 11:40:57 -0700366 .WillOnce(Return(false));
367 attempter_.DisableDeltaUpdateIfNeeded();
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700368 EXPECT_TRUE(attempter_.omaha_request_params_->delta_okay());
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800369 EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
Darin Petkov36275772010-10-01 11:40:57 -0700370 .WillOnce(DoAll(
Ben Chan672c1f52017-10-23 15:41:39 -0700371 SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures - 1),
Darin Petkov36275772010-10-01 11:40:57 -0700372 Return(true)));
373 attempter_.DisableDeltaUpdateIfNeeded();
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700374 EXPECT_TRUE(attempter_.omaha_request_params_->delta_okay());
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800375 EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
Darin Petkov36275772010-10-01 11:40:57 -0700376 .WillOnce(DoAll(
Ben Chan672c1f52017-10-23 15:41:39 -0700377 SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures),
Darin Petkov36275772010-10-01 11:40:57 -0700378 Return(true)));
379 attempter_.DisableDeltaUpdateIfNeeded();
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700380 EXPECT_FALSE(attempter_.omaha_request_params_->delta_okay());
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800381 EXPECT_CALL(*prefs_, GetInt64(_, _)).Times(0);
Darin Petkov36275772010-10-01 11:40:57 -0700382 attempter_.DisableDeltaUpdateIfNeeded();
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700383 EXPECT_FALSE(attempter_.omaha_request_params_->delta_okay());
Darin Petkov36275772010-10-01 11:40:57 -0700384}
385
386TEST_F(UpdateAttempterTest, MarkDeltaUpdateFailureTest) {
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800387 EXPECT_CALL(*prefs_, GetInt64(kPrefsDeltaUpdateFailures, _))
Darin Petkov36275772010-10-01 11:40:57 -0700388 .WillOnce(Return(false))
Ben Chan672c1f52017-10-23 15:41:39 -0700389 .WillOnce(DoAll(SetArgPointee<1>(-1), Return(true)))
390 .WillOnce(DoAll(SetArgPointee<1>(1), Return(true)))
Darin Petkov36275772010-10-01 11:40:57 -0700391 .WillOnce(DoAll(
Ben Chan672c1f52017-10-23 15:41:39 -0700392 SetArgPointee<1>(UpdateAttempter::kMaxDeltaUpdateFailures),
Darin Petkov36275772010-10-01 11:40:57 -0700393 Return(true)));
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800394 EXPECT_CALL(*prefs_, SetInt64(Ne(kPrefsDeltaUpdateFailures), _))
Darin Petkov2dd01092010-10-08 15:43:05 -0700395 .WillRepeatedly(Return(true));
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800396 EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures, 1)).Times(2);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700397 EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures, 2));
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800398 EXPECT_CALL(*prefs_, SetInt64(kPrefsDeltaUpdateFailures,
Gilad Arnold74b5f552014-10-07 08:17:16 -0700399 UpdateAttempter::kMaxDeltaUpdateFailures + 1));
Darin Petkov36275772010-10-01 11:40:57 -0700400 for (int i = 0; i < 4; i ++)
401 attempter_.MarkDeltaUpdateFailure();
402}
403
Darin Petkov1b003102010-11-30 10:18:36 -0800404TEST_F(UpdateAttempterTest, ScheduleErrorEventActionNoEventTest) {
405 EXPECT_CALL(*processor_, EnqueueAction(_)).Times(0);
406 EXPECT_CALL(*processor_, StartProcessing()).Times(0);
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700407 EXPECT_CALL(*fake_system_state_.mock_payload_state(), UpdateFailed(_))
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800408 .Times(0);
409 OmahaResponse response;
Jay Srinivasan53173b92013-05-17 17:13:01 -0700410 string url1 = "http://url1";
Sen Jiang0affc2c2017-02-10 15:55:05 -0800411 response.packages.push_back({.payload_urls = {url1, "https://url"}});
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700412 EXPECT_CALL(*(fake_system_state_.mock_payload_state()), GetCurrentUrl())
Jay Srinivasan53173b92013-05-17 17:13:01 -0700413 .WillRepeatedly(Return(url1));
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700414 fake_system_state_.mock_payload_state()->SetResponse(response);
Darin Petkov1b003102010-11-30 10:18:36 -0800415 attempter_.ScheduleErrorEventAction();
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700416 EXPECT_EQ(url1, fake_system_state_.mock_payload_state()->GetCurrentUrl());
Darin Petkov1b003102010-11-30 10:18:36 -0800417}
418
419TEST_F(UpdateAttempterTest, ScheduleErrorEventActionTest) {
420 EXPECT_CALL(*processor_,
421 EnqueueAction(Property(&AbstractAction::Type,
Gilad Arnold74b5f552014-10-07 08:17:16 -0700422 OmahaRequestAction::StaticType())));
423 EXPECT_CALL(*processor_, StartProcessing());
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700424 ErrorCode err = ErrorCode::kError;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700425 EXPECT_CALL(*fake_system_state_.mock_payload_state(), UpdateFailed(err));
Darin Petkov1b003102010-11-30 10:18:36 -0800426 attempter_.error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
427 OmahaEvent::kResultError,
Jay Srinivasan6f6ea002012-12-14 11:26:28 -0800428 err));
Darin Petkov1b003102010-11-30 10:18:36 -0800429 attempter_.ScheduleErrorEventAction();
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700430 EXPECT_EQ(UpdateStatus::REPORTING_ERROR_EVENT, attempter_.status());
Darin Petkov1b003102010-11-30 10:18:36 -0800431}
432
Darin Petkove6ef2f82011-03-07 17:31:11 -0800433namespace {
Chris Sosa76a29ae2013-07-11 17:59:24 -0700434// Actions that will be built as part of an update check.
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700435const string kUpdateActionTypes[] = { // NOLINT(runtime/string)
Darin Petkove6ef2f82011-03-07 17:31:11 -0800436 OmahaRequestAction::StaticType(),
437 OmahaResponseHandlerAction::StaticType(),
Darin Petkove6ef2f82011-03-07 17:31:11 -0800438 OmahaRequestAction::StaticType(),
439 DownloadAction::StaticType(),
440 OmahaRequestAction::StaticType(),
Allie Woodeb9e6d82015-04-17 13:55:30 -0700441 FilesystemVerifierAction::StaticType(),
Darin Petkove6ef2f82011-03-07 17:31:11 -0800442 PostinstallRunnerAction::StaticType(),
443 OmahaRequestAction::StaticType()
444};
Chris Sosa76a29ae2013-07-11 17:59:24 -0700445
446// Actions that will be built as part of a user-initiated rollback.
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700447const string kRollbackActionTypes[] = { // NOLINT(runtime/string)
Chris Sosa76a29ae2013-07-11 17:59:24 -0700448 InstallPlanAction::StaticType(),
449 PostinstallRunnerAction::StaticType(),
450};
451
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700452} // namespace
Darin Petkove6ef2f82011-03-07 17:31:11 -0800453
454void UpdateAttempterTest::UpdateTestStart() {
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700455 attempter_.set_http_response_code(200);
Alex Deymo749ecf12014-10-21 20:06:57 -0700456
457 // Expect that the device policy is loaded by the UpdateAttempter at some
458 // point by calling RefreshDevicePolicy.
Igor9fd76b62017-12-11 15:24:18 +0100459 auto device_policy = std::make_unique<policy::MockDevicePolicy>();
Alex Deymo749ecf12014-10-21 20:06:57 -0700460 EXPECT_CALL(*device_policy, LoadPolicy())
461 .Times(testing::AtLeast(1)).WillRepeatedly(Return(true));
Igor9fd76b62017-12-11 15:24:18 +0100462 attempter_.policy_provider_.reset(
463 new policy::PolicyProvider(std::move(device_policy)));
Alex Deymo749ecf12014-10-21 20:06:57 -0700464
465 {
466 InSequence s;
467 for (size_t i = 0; i < arraysize(kUpdateActionTypes); ++i) {
468 EXPECT_CALL(*processor_,
469 EnqueueAction(Property(&AbstractAction::Type,
Gilad Arnold74b5f552014-10-07 08:17:16 -0700470 kUpdateActionTypes[i])));
Alex Deymo749ecf12014-10-21 20:06:57 -0700471 }
Gilad Arnold74b5f552014-10-07 08:17:16 -0700472 EXPECT_CALL(*processor_, StartProcessing());
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700473 }
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700474
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700475 attempter_.Update("", "", "", "", false, false);
Alex Deymo60ca1a72015-06-18 18:19:15 -0700476 loop_.PostTask(FROM_HERE,
477 base::Bind(&UpdateAttempterTest::UpdateTestVerify,
478 base::Unretained(this)));
Darin Petkove6ef2f82011-03-07 17:31:11 -0800479}
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700480
Darin Petkove6ef2f82011-03-07 17:31:11 -0800481void UpdateAttempterTest::UpdateTestVerify() {
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700482 EXPECT_EQ(0, attempter_.http_response_code());
483 EXPECT_EQ(&attempter_, processor_->delegate());
Chris Sosa76a29ae2013-07-11 17:59:24 -0700484 EXPECT_EQ(arraysize(kUpdateActionTypes), attempter_.actions_.size());
485 for (size_t i = 0; i < arraysize(kUpdateActionTypes); ++i) {
486 EXPECT_EQ(kUpdateActionTypes[i], attempter_.actions_[i]->Type());
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700487 }
488 EXPECT_EQ(attempter_.response_handler_action_.get(),
489 attempter_.actions_[1].get());
Sen Jiangfef85fd2016-03-25 15:32:49 -0700490 AbstractAction* action_3 = attempter_.actions_[3].get();
491 ASSERT_NE(nullptr, action_3);
492 ASSERT_EQ(DownloadAction::StaticType(), action_3->Type());
493 DownloadAction* download_action = static_cast<DownloadAction*>(action_3);
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700494 EXPECT_EQ(&attempter_, download_action->delegate());
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700495 EXPECT_EQ(UpdateStatus::CHECKING_FOR_UPDATE, attempter_.status());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700496 loop_.BreakLoop();
Darin Petkove6ef2f82011-03-07 17:31:11 -0800497}
498
Chris Sosa28e479c2013-07-12 11:39:53 -0700499void UpdateAttempterTest::RollbackTestStart(
Chris Sosa44b9b7e2014-04-02 13:53:46 -0700500 bool enterprise_rollback, bool valid_slot) {
Chris Sosa76a29ae2013-07-11 17:59:24 -0700501 // Create a device policy so that we can change settings.
Igor9fd76b62017-12-11 15:24:18 +0100502 auto device_policy = std::make_unique<policy::MockDevicePolicy>();
Chris Sosa76a29ae2013-07-11 17:59:24 -0700503 EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
Igor9fd76b62017-12-11 15:24:18 +0100504 fake_system_state_.set_device_policy(device_policy.get());
505 if (enterprise_rollback) {
506 // We return an empty owner as this is an enterprise.
507 EXPECT_CALL(*device_policy, GetOwner(_)).WillRepeatedly(
508 DoAll(SetArgPointee<0>(string("")),
509 Return(true)));
510 } else {
511 // We return a fake owner as this is an owned consumer device.
512 EXPECT_CALL(*device_policy, GetOwner(_)).WillRepeatedly(
513 DoAll(SetArgPointee<0>(string("fake.mail@fake.com")),
514 Return(true)));
515 }
516
517 attempter_.policy_provider_.reset(
518 new policy::PolicyProvider(std::move(device_policy)));
Chris Sosa76a29ae2013-07-11 17:59:24 -0700519
Alex Deymo763e7db2015-08-27 21:08:08 -0700520 if (valid_slot) {
521 BootControlInterface::Slot rollback_slot = 1;
522 LOG(INFO) << "Test Mark Bootable: "
523 << BootControlInterface::SlotName(rollback_slot);
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700524 fake_system_state_.fake_boot_control()->SetSlotBootable(rollback_slot,
525 true);
Don Garrett6646b442013-11-13 15:29:11 -0800526 }
527
Chris Sosa28e479c2013-07-12 11:39:53 -0700528 bool is_rollback_allowed = false;
Chris Sosa76a29ae2013-07-11 17:59:24 -0700529
Chris Sosad38b1132014-03-25 10:43:59 -0700530 // We only allow rollback on devices that are not enterprise enrolled and
531 // which have a valid slot to rollback to.
532 if (!enterprise_rollback && valid_slot) {
Chris Sosa28e479c2013-07-12 11:39:53 -0700533 is_rollback_allowed = true;
534 }
535
Chris Sosa28e479c2013-07-12 11:39:53 -0700536 if (is_rollback_allowed) {
Chris Sosa76a29ae2013-07-11 17:59:24 -0700537 InSequence s;
538 for (size_t i = 0; i < arraysize(kRollbackActionTypes); ++i) {
539 EXPECT_CALL(*processor_,
540 EnqueueAction(Property(&AbstractAction::Type,
Gilad Arnold74b5f552014-10-07 08:17:16 -0700541 kRollbackActionTypes[i])));
Chris Sosa76a29ae2013-07-11 17:59:24 -0700542 }
Gilad Arnold74b5f552014-10-07 08:17:16 -0700543 EXPECT_CALL(*processor_, StartProcessing());
Chris Sosa76a29ae2013-07-11 17:59:24 -0700544
Chris Sosa44b9b7e2014-04-02 13:53:46 -0700545 EXPECT_TRUE(attempter_.Rollback(true));
Alex Deymo60ca1a72015-06-18 18:19:15 -0700546 loop_.PostTask(FROM_HERE,
547 base::Bind(&UpdateAttempterTest::RollbackTestVerify,
548 base::Unretained(this)));
Chris Sosa76a29ae2013-07-11 17:59:24 -0700549 } else {
Chris Sosa44b9b7e2014-04-02 13:53:46 -0700550 EXPECT_FALSE(attempter_.Rollback(true));
Alex Deymo60ca1a72015-06-18 18:19:15 -0700551 loop_.BreakLoop();
Chris Sosa76a29ae2013-07-11 17:59:24 -0700552 }
553}
554
555void UpdateAttempterTest::RollbackTestVerify() {
556 // Verifies the actions that were enqueued.
557 EXPECT_EQ(&attempter_, processor_->delegate());
558 EXPECT_EQ(arraysize(kRollbackActionTypes), attempter_.actions_.size());
559 for (size_t i = 0; i < arraysize(kRollbackActionTypes); ++i) {
560 EXPECT_EQ(kRollbackActionTypes[i], attempter_.actions_[i]->Type());
561 }
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700562 EXPECT_EQ(UpdateStatus::ATTEMPTING_ROLLBACK, attempter_.status());
Alex Deymo80f70ff2016-02-10 16:08:11 -0800563 AbstractAction* action_0 = attempter_.actions_[0].get();
564 ASSERT_NE(nullptr, action_0);
565 ASSERT_EQ(InstallPlanAction::StaticType(), action_0->Type());
Chris Sosa76a29ae2013-07-11 17:59:24 -0700566 InstallPlanAction* install_plan_action =
Alex Deymo80f70ff2016-02-10 16:08:11 -0800567 static_cast<InstallPlanAction*>(action_0);
Chris Sosa76a29ae2013-07-11 17:59:24 -0700568 InstallPlan* install_plan = install_plan_action->install_plan();
Alex Deymo80f70ff2016-02-10 16:08:11 -0800569 EXPECT_EQ(0U, install_plan->partitions.size());
Chris Sosa76a29ae2013-07-11 17:59:24 -0700570 EXPECT_EQ(install_plan->powerwash_required, true);
Alex Deymo60ca1a72015-06-18 18:19:15 -0700571 loop_.BreakLoop();
Chris Sosa76a29ae2013-07-11 17:59:24 -0700572}
573
Darin Petkove6ef2f82011-03-07 17:31:11 -0800574TEST_F(UpdateAttempterTest, UpdateTest) {
Alex Deymo461b2592015-07-24 20:10:52 -0700575 UpdateTestStart();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700576 loop_.Run();
Darin Petkovf42cc1c2010-09-01 09:03:02 -0700577}
578
Chris Sosa76a29ae2013-07-11 17:59:24 -0700579TEST_F(UpdateAttempterTest, RollbackTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700580 loop_.PostTask(FROM_HERE,
581 base::Bind(&UpdateAttempterTest::RollbackTestStart,
582 base::Unretained(this),
583 false, true));
584 loop_.Run();
Chris Sosa76a29ae2013-07-11 17:59:24 -0700585}
586
Don Garrett6646b442013-11-13 15:29:11 -0800587TEST_F(UpdateAttempterTest, InvalidSlotRollbackTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700588 loop_.PostTask(FROM_HERE,
589 base::Bind(&UpdateAttempterTest::RollbackTestStart,
590 base::Unretained(this),
591 false, false));
592 loop_.Run();
Don Garrett6646b442013-11-13 15:29:11 -0800593}
594
Chris Sosa76a29ae2013-07-11 17:59:24 -0700595TEST_F(UpdateAttempterTest, EnterpriseRollbackTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700596 loop_.PostTask(FROM_HERE,
597 base::Bind(&UpdateAttempterTest::RollbackTestStart,
598 base::Unretained(this),
599 true, true));
600 loop_.Run();
Chris Sosa76a29ae2013-07-11 17:59:24 -0700601}
602
Thieu Le116fda32011-04-19 11:01:54 -0700603void UpdateAttempterTest::PingOmahaTestStart() {
604 EXPECT_CALL(*processor_,
605 EnqueueAction(Property(&AbstractAction::Type,
Gilad Arnold74b5f552014-10-07 08:17:16 -0700606 OmahaRequestAction::StaticType())));
607 EXPECT_CALL(*processor_, StartProcessing());
Thieu Le116fda32011-04-19 11:01:54 -0700608 attempter_.PingOmaha();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700609 ScheduleQuitMainLoop();
Thieu Le116fda32011-04-19 11:01:54 -0700610}
611
612TEST_F(UpdateAttempterTest, PingOmahaTest) {
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700613 EXPECT_FALSE(attempter_.waiting_for_scheduled_check_);
614 EXPECT_FALSE(attempter_.schedule_updates_called());
615 // Disable scheduling of subsequnet checks; we're using the DefaultPolicy in
616 // testing, which is more permissive than we want to handle here.
617 attempter_.DisableScheduleUpdates();
Alex Deymo60ca1a72015-06-18 18:19:15 -0700618 loop_.PostTask(FROM_HERE,
619 base::Bind(&UpdateAttempterTest::PingOmahaTestStart,
620 base::Unretained(this)));
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700621 brillo::MessageLoopRunMaxIterations(&loop_, 100);
Christopher Wiley6b6cc1b2015-10-05 17:50:07 -0700622 EXPECT_EQ(UpdateStatus::UPDATED_NEED_REBOOT, attempter_.status());
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700623 EXPECT_TRUE(attempter_.schedule_updates_called());
Thieu Le116fda32011-04-19 11:01:54 -0700624}
625
Darin Petkov18c7bce2011-06-16 14:07:00 -0700626TEST_F(UpdateAttempterTest, CreatePendingErrorEventTest) {
Alex Deymo8427b4a2014-11-05 14:00:32 -0800627 MockAction action;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700628 const ErrorCode kCode = ErrorCode::kDownloadTransferError;
Darin Petkov18c7bce2011-06-16 14:07:00 -0700629 attempter_.CreatePendingErrorEvent(&action, kCode);
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700630 ASSERT_NE(nullptr, attempter_.error_event_.get());
Darin Petkov18c7bce2011-06-16 14:07:00 -0700631 EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type);
632 EXPECT_EQ(OmahaEvent::kResultError, attempter_.error_event_->result);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700633 EXPECT_EQ(
634 static_cast<ErrorCode>(static_cast<int>(kCode) |
635 static_cast<int>(ErrorCode::kTestOmahaUrlFlag)),
636 attempter_.error_event_->error_code);
Darin Petkov18c7bce2011-06-16 14:07:00 -0700637}
638
639TEST_F(UpdateAttempterTest, CreatePendingErrorEventResumedTest) {
640 OmahaResponseHandlerAction *response_action =
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700641 new OmahaResponseHandlerAction(&fake_system_state_);
Darin Petkov18c7bce2011-06-16 14:07:00 -0700642 response_action->install_plan_.is_resume = true;
643 attempter_.response_handler_action_.reset(response_action);
Alex Deymo8427b4a2014-11-05 14:00:32 -0800644 MockAction action;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700645 const ErrorCode kCode = ErrorCode::kInstallDeviceOpenError;
Darin Petkov18c7bce2011-06-16 14:07:00 -0700646 attempter_.CreatePendingErrorEvent(&action, kCode);
Alex Vakulenko88b591f2014-08-28 16:48:57 -0700647 ASSERT_NE(nullptr, attempter_.error_event_.get());
Darin Petkov18c7bce2011-06-16 14:07:00 -0700648 EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type);
649 EXPECT_EQ(OmahaEvent::kResultError, attempter_.error_event_->result);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700650 EXPECT_EQ(
651 static_cast<ErrorCode>(
652 static_cast<int>(kCode) |
653 static_cast<int>(ErrorCode::kResumedFlag) |
654 static_cast<int>(ErrorCode::kTestOmahaUrlFlag)),
655 attempter_.error_event_->error_code);
Darin Petkov18c7bce2011-06-16 14:07:00 -0700656}
657
David Zeuthen8f191b22013-08-06 12:27:50 -0700658TEST_F(UpdateAttempterTest, P2PNotStartedAtStartupWhenNotEnabled) {
659 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700660 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700661 mock_p2p_manager.fake().SetP2PEnabled(false);
662 EXPECT_CALL(mock_p2p_manager, EnsureP2PRunning()).Times(0);
663 attempter_.UpdateEngineStarted();
664}
665
666TEST_F(UpdateAttempterTest, P2PNotStartedAtStartupWhenEnabledButNotSharing) {
667 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700668 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700669 mock_p2p_manager.fake().SetP2PEnabled(true);
670 EXPECT_CALL(mock_p2p_manager, EnsureP2PRunning()).Times(0);
671 attempter_.UpdateEngineStarted();
672}
673
674TEST_F(UpdateAttempterTest, P2PStartedAtStartupWhenEnabledAndSharing) {
675 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700676 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700677 mock_p2p_manager.fake().SetP2PEnabled(true);
678 mock_p2p_manager.fake().SetCountSharedFilesResult(1);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700679 EXPECT_CALL(mock_p2p_manager, EnsureP2PRunning());
David Zeuthen8f191b22013-08-06 12:27:50 -0700680 attempter_.UpdateEngineStarted();
681}
682
683TEST_F(UpdateAttempterTest, P2PNotEnabled) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700684 loop_.PostTask(FROM_HERE,
685 base::Bind(&UpdateAttempterTest::P2PNotEnabledStart,
686 base::Unretained(this)));
687 loop_.Run();
David Zeuthen8f191b22013-08-06 12:27:50 -0700688}
Alex Deymo60ca1a72015-06-18 18:19:15 -0700689
David Zeuthen8f191b22013-08-06 12:27:50 -0700690void UpdateAttempterTest::P2PNotEnabledStart() {
691 // If P2P is not enabled, check that we do not attempt housekeeping
692 // and do not convey that p2p is to be used.
693 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700694 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700695 mock_p2p_manager.fake().SetP2PEnabled(false);
696 EXPECT_CALL(mock_p2p_manager, PerformHousekeeping()).Times(0);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700697 attempter_.Update("", "", "", "", false, false);
Alex Deymo60ca1a72015-06-18 18:19:15 -0700698 EXPECT_FALSE(actual_using_p2p_for_downloading_);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700699 EXPECT_FALSE(actual_using_p2p_for_sharing());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700700 ScheduleQuitMainLoop();
David Zeuthen8f191b22013-08-06 12:27:50 -0700701}
702
703TEST_F(UpdateAttempterTest, P2PEnabledStartingFails) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700704 loop_.PostTask(FROM_HERE,
705 base::Bind(&UpdateAttempterTest::P2PEnabledStartingFailsStart,
706 base::Unretained(this)));
707 loop_.Run();
David Zeuthen8f191b22013-08-06 12:27:50 -0700708}
Alex Deymo60ca1a72015-06-18 18:19:15 -0700709
David Zeuthen8f191b22013-08-06 12:27:50 -0700710void UpdateAttempterTest::P2PEnabledStartingFailsStart() {
711 // If p2p is enabled, but starting it fails ensure we don't do
712 // any housekeeping and do not convey that p2p should be used.
713 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700714 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700715 mock_p2p_manager.fake().SetP2PEnabled(true);
716 mock_p2p_manager.fake().SetEnsureP2PRunningResult(false);
717 mock_p2p_manager.fake().SetPerformHousekeepingResult(false);
718 EXPECT_CALL(mock_p2p_manager, PerformHousekeeping()).Times(0);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700719 attempter_.Update("", "", "", "", false, false);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700720 EXPECT_FALSE(actual_using_p2p_for_downloading());
721 EXPECT_FALSE(actual_using_p2p_for_sharing());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700722 ScheduleQuitMainLoop();
David Zeuthen8f191b22013-08-06 12:27:50 -0700723}
724
725TEST_F(UpdateAttempterTest, P2PEnabledHousekeepingFails) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700726 loop_.PostTask(
727 FROM_HERE,
728 base::Bind(&UpdateAttempterTest::P2PEnabledHousekeepingFailsStart,
729 base::Unretained(this)));
730 loop_.Run();
David Zeuthen8f191b22013-08-06 12:27:50 -0700731}
Alex Deymo60ca1a72015-06-18 18:19:15 -0700732
David Zeuthen8f191b22013-08-06 12:27:50 -0700733void UpdateAttempterTest::P2PEnabledHousekeepingFailsStart() {
734 // If p2p is enabled, starting it works but housekeeping fails, ensure
735 // we do not convey p2p is to be used.
736 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700737 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700738 mock_p2p_manager.fake().SetP2PEnabled(true);
739 mock_p2p_manager.fake().SetEnsureP2PRunningResult(true);
740 mock_p2p_manager.fake().SetPerformHousekeepingResult(false);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700741 EXPECT_CALL(mock_p2p_manager, PerformHousekeeping());
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700742 attempter_.Update("", "", "", "", false, false);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700743 EXPECT_FALSE(actual_using_p2p_for_downloading());
744 EXPECT_FALSE(actual_using_p2p_for_sharing());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700745 ScheduleQuitMainLoop();
David Zeuthen8f191b22013-08-06 12:27:50 -0700746}
747
748TEST_F(UpdateAttempterTest, P2PEnabled) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700749 loop_.PostTask(FROM_HERE,
750 base::Bind(&UpdateAttempterTest::P2PEnabledStart,
751 base::Unretained(this)));
752 loop_.Run();
David Zeuthen8f191b22013-08-06 12:27:50 -0700753}
Alex Deymo60ca1a72015-06-18 18:19:15 -0700754
David Zeuthen8f191b22013-08-06 12:27:50 -0700755void UpdateAttempterTest::P2PEnabledStart() {
756 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700757 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700758 // If P2P is enabled and starting it works, check that we performed
759 // housekeeping and that we convey p2p should be used.
760 mock_p2p_manager.fake().SetP2PEnabled(true);
761 mock_p2p_manager.fake().SetEnsureP2PRunningResult(true);
762 mock_p2p_manager.fake().SetPerformHousekeepingResult(true);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700763 EXPECT_CALL(mock_p2p_manager, PerformHousekeeping());
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700764 attempter_.Update("", "", "", "", false, false);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700765 EXPECT_TRUE(actual_using_p2p_for_downloading());
766 EXPECT_TRUE(actual_using_p2p_for_sharing());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700767 ScheduleQuitMainLoop();
David Zeuthen8f191b22013-08-06 12:27:50 -0700768}
769
770TEST_F(UpdateAttempterTest, P2PEnabledInteractive) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700771 loop_.PostTask(FROM_HERE,
772 base::Bind(&UpdateAttempterTest::P2PEnabledInteractiveStart,
773 base::Unretained(this)));
774 loop_.Run();
David Zeuthen8f191b22013-08-06 12:27:50 -0700775}
Alex Deymo60ca1a72015-06-18 18:19:15 -0700776
David Zeuthen8f191b22013-08-06 12:27:50 -0700777void UpdateAttempterTest::P2PEnabledInteractiveStart() {
778 MockP2PManager mock_p2p_manager;
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700779 fake_system_state_.set_p2p_manager(&mock_p2p_manager);
David Zeuthen8f191b22013-08-06 12:27:50 -0700780 // For an interactive check, if P2P is enabled and starting it
781 // works, check that we performed housekeeping and that we convey
782 // p2p should be used for sharing but NOT for downloading.
783 mock_p2p_manager.fake().SetP2PEnabled(true);
784 mock_p2p_manager.fake().SetEnsureP2PRunningResult(true);
785 mock_p2p_manager.fake().SetPerformHousekeepingResult(true);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700786 EXPECT_CALL(mock_p2p_manager, PerformHousekeeping());
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700787 attempter_.Update("", "", "", "", false, true /* interactive */);
Gilad Arnold74b5f552014-10-07 08:17:16 -0700788 EXPECT_FALSE(actual_using_p2p_for_downloading());
789 EXPECT_TRUE(actual_using_p2p_for_sharing());
Alex Deymo60ca1a72015-06-18 18:19:15 -0700790 ScheduleQuitMainLoop();
David Zeuthen8f191b22013-08-06 12:27:50 -0700791}
792
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700793TEST_F(UpdateAttempterTest, ReadScatterFactorFromPolicy) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700794 loop_.PostTask(
795 FROM_HERE,
796 base::Bind(&UpdateAttempterTest::ReadScatterFactorFromPolicyTestStart,
797 base::Unretained(this)));
798 loop_.Run();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700799}
800
801// Tests that the scatter_factor_in_seconds value is properly fetched
802// from the device policy.
803void UpdateAttempterTest::ReadScatterFactorFromPolicyTestStart() {
Ben Chan9abb7632014-08-07 00:10:53 -0700804 int64_t scatter_factor_in_seconds = 36000;
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700805
Igor9fd76b62017-12-11 15:24:18 +0100806 auto device_policy = std::make_unique<policy::MockDevicePolicy>();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700807 EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
Igor9fd76b62017-12-11 15:24:18 +0100808 fake_system_state_.set_device_policy(device_policy.get());
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700809
810 EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_))
811 .WillRepeatedly(DoAll(
Ben Chan672c1f52017-10-23 15:41:39 -0700812 SetArgPointee<0>(scatter_factor_in_seconds),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700813 Return(true)));
814
Igor9fd76b62017-12-11 15:24:18 +0100815 attempter_.policy_provider_.reset(
816 new policy::PolicyProvider(std::move(device_policy)));
817
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700818 attempter_.Update("", "", "", "", false, false);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700819 EXPECT_EQ(scatter_factor_in_seconds, attempter_.scatter_factor_.InSeconds());
820
Alex Deymo60ca1a72015-06-18 18:19:15 -0700821 ScheduleQuitMainLoop();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700822}
823
824TEST_F(UpdateAttempterTest, DecrementUpdateCheckCountTest) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700825 loop_.PostTask(
826 FROM_HERE,
827 base::Bind(&UpdateAttempterTest::DecrementUpdateCheckCountTestStart,
828 base::Unretained(this)));
829 loop_.Run();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700830}
831
832void UpdateAttempterTest::DecrementUpdateCheckCountTestStart() {
833 // Tests that the scatter_factor_in_seconds value is properly fetched
834 // from the device policy and is decremented if value > 0.
Ben Chan9abb7632014-08-07 00:10:53 -0700835 int64_t initial_value = 5;
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800836 FakePrefs fake_prefs;
837 attempter_.prefs_ = &fake_prefs;
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700838
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700839 fake_system_state_.fake_hardware()->SetIsOOBEComplete(Time::UnixEpoch());
Jay Srinivasan08fce042012-06-07 16:31:01 -0700840
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800841 EXPECT_TRUE(fake_prefs.SetInt64(kPrefsUpdateCheckCount, initial_value));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700842
Ben Chan9abb7632014-08-07 00:10:53 -0700843 int64_t scatter_factor_in_seconds = 10;
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700844
Igor9fd76b62017-12-11 15:24:18 +0100845 auto device_policy = std::make_unique<policy::MockDevicePolicy>();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700846 EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
Igor9fd76b62017-12-11 15:24:18 +0100847 fake_system_state_.set_device_policy(device_policy.get());
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700848
849 EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_))
850 .WillRepeatedly(DoAll(
Ben Chan672c1f52017-10-23 15:41:39 -0700851 SetArgPointee<0>(scatter_factor_in_seconds),
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700852 Return(true)));
853
Igor9fd76b62017-12-11 15:24:18 +0100854 attempter_.policy_provider_.reset(
855 new policy::PolicyProvider(std::move(device_policy)));
856
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700857 attempter_.Update("", "", "", "", false, false);
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700858 EXPECT_EQ(scatter_factor_in_seconds, attempter_.scatter_factor_.InSeconds());
859
860 // Make sure the file still exists.
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800861 EXPECT_TRUE(fake_prefs.Exists(kPrefsUpdateCheckCount));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700862
Ben Chan9abb7632014-08-07 00:10:53 -0700863 int64_t new_value;
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800864 EXPECT_TRUE(fake_prefs.GetInt64(kPrefsUpdateCheckCount, &new_value));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700865 EXPECT_EQ(initial_value - 1, new_value);
866
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700867 EXPECT_TRUE(
868 attempter_.omaha_request_params_->update_check_count_wait_enabled());
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700869
870 // However, if the count is already 0, it's not decremented. Test that.
871 initial_value = 0;
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800872 EXPECT_TRUE(fake_prefs.SetInt64(kPrefsUpdateCheckCount, initial_value));
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700873 attempter_.Update("", "", "", "", false, false);
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800874 EXPECT_TRUE(fake_prefs.Exists(kPrefsUpdateCheckCount));
875 EXPECT_TRUE(fake_prefs.GetInt64(kPrefsUpdateCheckCount, &new_value));
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700876 EXPECT_EQ(initial_value, new_value);
877
Alex Deymo60ca1a72015-06-18 18:19:15 -0700878 ScheduleQuitMainLoop();
Jay Srinivasan480ddfa2012-06-01 19:15:26 -0700879}
880
Jay Srinivasan08fce042012-06-07 16:31:01 -0700881TEST_F(UpdateAttempterTest, NoScatteringDoneDuringManualUpdateTestStart) {
Alex Deymo60ca1a72015-06-18 18:19:15 -0700882 loop_.PostTask(FROM_HERE, base::Bind(
883 &UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart,
884 base::Unretained(this)));
885 loop_.Run();
Jay Srinivasan08fce042012-06-07 16:31:01 -0700886}
887
888void UpdateAttempterTest::NoScatteringDoneDuringManualUpdateTestStart() {
889 // Tests that no scattering logic is enabled if the update check
890 // is manually done (as opposed to a scheduled update check)
Ben Chan9abb7632014-08-07 00:10:53 -0700891 int64_t initial_value = 8;
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800892 FakePrefs fake_prefs;
893 attempter_.prefs_ = &fake_prefs;
Jay Srinivasan08fce042012-06-07 16:31:01 -0700894
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700895 fake_system_state_.fake_hardware()->SetIsOOBEComplete(Time::UnixEpoch());
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800896 fake_system_state_.set_prefs(&fake_prefs);
Jay Srinivasan08fce042012-06-07 16:31:01 -0700897
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800898 EXPECT_TRUE(fake_prefs.SetInt64(kPrefsWallClockWaitPeriod, initial_value));
899 EXPECT_TRUE(fake_prefs.SetInt64(kPrefsUpdateCheckCount, initial_value));
Jay Srinivasan08fce042012-06-07 16:31:01 -0700900
901 // make sure scatter_factor is non-zero as scattering is disabled
902 // otherwise.
Ben Chan9abb7632014-08-07 00:10:53 -0700903 int64_t scatter_factor_in_seconds = 50;
Jay Srinivasan08fce042012-06-07 16:31:01 -0700904
Igor9fd76b62017-12-11 15:24:18 +0100905 auto device_policy = std::make_unique<policy::MockDevicePolicy>();
Jay Srinivasan08fce042012-06-07 16:31:01 -0700906 EXPECT_CALL(*device_policy, LoadPolicy()).WillRepeatedly(Return(true));
Igor9fd76b62017-12-11 15:24:18 +0100907 fake_system_state_.set_device_policy(device_policy.get());
Jay Srinivasan08fce042012-06-07 16:31:01 -0700908
909 EXPECT_CALL(*device_policy, GetScatterFactorInSeconds(_))
910 .WillRepeatedly(DoAll(
Ben Chan672c1f52017-10-23 15:41:39 -0700911 SetArgPointee<0>(scatter_factor_in_seconds),
Jay Srinivasan08fce042012-06-07 16:31:01 -0700912 Return(true)));
913
Igor9fd76b62017-12-11 15:24:18 +0100914 attempter_.policy_provider_.reset(
915 new policy::PolicyProvider(std::move(device_policy)));
916
Gilad Arnoldb92f0df2013-01-10 16:32:45 -0800917 // Trigger an interactive check so we can test that scattering is disabled.
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700918 attempter_.Update("", "", "", "", false, true);
Jay Srinivasan08fce042012-06-07 16:31:01 -0700919 EXPECT_EQ(scatter_factor_in_seconds, attempter_.scatter_factor_.InSeconds());
920
921 // Make sure scattering is disabled for manual (i.e. user initiated) update
Jay Srinivasan21be0752012-07-25 15:44:56 -0700922 // checks and all artifacts are removed.
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700923 EXPECT_FALSE(
924 attempter_.omaha_request_params_->wall_clock_based_wait_enabled());
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800925 EXPECT_FALSE(fake_prefs.Exists(kPrefsWallClockWaitPeriod));
Jay Srinivasanae4697c2013-03-18 17:08:08 -0700926 EXPECT_EQ(0, attempter_.omaha_request_params_->waiting_period().InSeconds());
927 EXPECT_FALSE(
928 attempter_.omaha_request_params_->update_check_count_wait_enabled());
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800929 EXPECT_FALSE(fake_prefs.Exists(kPrefsUpdateCheckCount));
Jay Srinivasan08fce042012-06-07 16:31:01 -0700930
Alex Deymo60ca1a72015-06-18 18:19:15 -0700931 ScheduleQuitMainLoop();
Jay Srinivasan08fce042012-06-07 16:31:01 -0700932}
933
David Zeuthen985b1122013-10-09 12:13:15 -0700934// Checks that we only report daily metrics at most every 24 hours.
935TEST_F(UpdateAttempterTest, ReportDailyMetrics) {
936 FakeClock fake_clock;
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800937 FakePrefs fake_prefs;
David Zeuthen985b1122013-10-09 12:13:15 -0700938
Gilad Arnold5bb4c902014-04-10 12:32:13 -0700939 fake_system_state_.set_clock(&fake_clock);
Alex Deymo2c0db7b2014-11-04 12:23:39 -0800940 fake_system_state_.set_prefs(&fake_prefs);
David Zeuthen985b1122013-10-09 12:13:15 -0700941
942 Time epoch = Time::FromInternalValue(0);
943 fake_clock.SetWallclockTime(epoch);
944
945 // If there is no kPrefsDailyMetricsLastReportedAt state variable,
946 // we should report.
947 EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
948 // We should not report again if no time has passed.
949 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
950
951 // We should not report if only 10 hours has passed.
952 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(10));
953 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
954
955 // We should not report if only 24 hours - 1 sec has passed.
956 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(24) -
957 TimeDelta::FromSeconds(1));
958 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
959
960 // We should report if 24 hours has passed.
961 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(24));
962 EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
963
964 // But then we should not report again..
965 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
966
967 // .. until another 24 hours has passed
968 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(47));
969 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
970 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(48));
971 EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
972 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
973
974 // .. and another 24 hours
975 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(71));
976 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
977 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(72));
978 EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
979 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
980
981 // If the span between time of reporting and present time is
982 // negative, we report. This is in order to reset the timestamp and
983 // avoid an edge condition whereby a distant point in the future is
984 // in the state variable resulting in us never ever reporting again.
985 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(71));
986 EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
987 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
988
989 // In this case we should not update until the clock reads 71 + 24 = 95.
990 // Check that.
991 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(94));
992 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
993 fake_clock.SetWallclockTime(epoch + TimeDelta::FromHours(95));
994 EXPECT_TRUE(attempter_.CheckAndReportDailyMetrics());
995 EXPECT_FALSE(attempter_.CheckAndReportDailyMetrics());
David Zeuthen985b1122013-10-09 12:13:15 -0700996}
997
David Zeuthen3c55abd2013-10-14 12:48:03 -0700998TEST_F(UpdateAttempterTest, BootTimeInUpdateMarkerFile) {
David Zeuthen3c55abd2013-10-14 12:48:03 -0700999 FakeClock fake_clock;
1000 fake_clock.SetBootTime(Time::FromTimeT(42));
Gilad Arnold5bb4c902014-04-10 12:32:13 -07001001 fake_system_state_.set_clock(&fake_clock);
Alex Deymo906191f2015-10-12 12:22:44 -07001002 FakePrefs fake_prefs;
1003 fake_system_state_.set_prefs(&fake_prefs);
Sen Jiangaeeb2e02016-06-09 15:00:16 -07001004 attempter_.Init();
David Zeuthen3c55abd2013-10-14 12:48:03 -07001005
1006 Time boot_time;
Sen Jiangaeeb2e02016-06-09 15:00:16 -07001007 EXPECT_FALSE(attempter_.GetBootTimeAtUpdate(&boot_time));
David Zeuthen3c55abd2013-10-14 12:48:03 -07001008
Sen Jiangaeeb2e02016-06-09 15:00:16 -07001009 attempter_.WriteUpdateCompletedMarker();
David Zeuthen3c55abd2013-10-14 12:48:03 -07001010
Sen Jiangaeeb2e02016-06-09 15:00:16 -07001011 EXPECT_TRUE(attempter_.GetBootTimeAtUpdate(&boot_time));
David Zeuthen3c55abd2013-10-14 12:48:03 -07001012 EXPECT_EQ(boot_time.ToTimeT(), 42);
1013}
1014
David Pursell02c18642014-11-06 11:26:11 -08001015TEST_F(UpdateAttempterTest, AnyUpdateSourceAllowedUnofficial) {
1016 fake_system_state_.fake_hardware()->SetIsOfficialBuild(false);
1017 EXPECT_TRUE(attempter_.IsAnyUpdateSourceAllowed());
1018}
1019
1020TEST_F(UpdateAttempterTest, AnyUpdateSourceAllowedOfficialDevmode) {
1021 fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
Sen Jiange67bb5b2016-06-20 15:53:56 -07001022 fake_system_state_.fake_hardware()->SetAreDevFeaturesEnabled(true);
David Pursell02c18642014-11-06 11:26:11 -08001023 EXPECT_TRUE(attempter_.IsAnyUpdateSourceAllowed());
1024}
1025
1026TEST_F(UpdateAttempterTest, AnyUpdateSourceDisallowedOfficialNormal) {
1027 fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
Sen Jiange67bb5b2016-06-20 15:53:56 -07001028 fake_system_state_.fake_hardware()->SetAreDevFeaturesEnabled(false);
David Pursell02c18642014-11-06 11:26:11 -08001029 EXPECT_FALSE(attempter_.IsAnyUpdateSourceAllowed());
1030}
1031
1032TEST_F(UpdateAttempterTest, CheckForUpdateAUTest) {
1033 fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
Sen Jiange67bb5b2016-06-20 15:53:56 -07001034 fake_system_state_.fake_hardware()->SetAreDevFeaturesEnabled(false);
Aaron Wood081c0232017-10-19 17:14:58 -07001035 attempter_.CheckForUpdate("", "autest", UpdateAttemptFlags::kNone);
Alex Deymoac41a822015-09-15 20:52:53 -07001036 EXPECT_EQ(constants::kOmahaDefaultAUTestURL, attempter_.forced_omaha_url());
David Pursell02c18642014-11-06 11:26:11 -08001037}
1038
1039TEST_F(UpdateAttempterTest, CheckForUpdateScheduledAUTest) {
1040 fake_system_state_.fake_hardware()->SetIsOfficialBuild(true);
Sen Jiange67bb5b2016-06-20 15:53:56 -07001041 fake_system_state_.fake_hardware()->SetAreDevFeaturesEnabled(false);
Aaron Wood081c0232017-10-19 17:14:58 -07001042 attempter_.CheckForUpdate("", "autest-scheduled", UpdateAttemptFlags::kNone);
Alex Deymoac41a822015-09-15 20:52:53 -07001043 EXPECT_EQ(constants::kOmahaDefaultAUTestURL, attempter_.forced_omaha_url());
David Pursell02c18642014-11-06 11:26:11 -08001044}
1045
Xiyuan Xiac0e8f9a2017-02-22 13:19:35 -08001046TEST_F(UpdateAttempterTest, TargetVersionPrefixSetAndReset) {
1047 attempter_.CalculateUpdateParams("", "", "", "1234", false, false);
1048 EXPECT_EQ("1234",
1049 fake_system_state_.request_params()->target_version_prefix());
1050
1051 attempter_.CalculateUpdateParams("", "", "", "", false, false);
1052 EXPECT_TRUE(
1053 fake_system_state_.request_params()->target_version_prefix().empty());
1054}
1055
Aaron Wood23bd3392017-10-06 14:48:25 -07001056TEST_F(UpdateAttempterTest, UpdateDeferredByPolicyTest) {
1057 // Construct an OmahaResponseHandlerAction that has processed an InstallPlan,
1058 // but the update is being deferred by the Policy.
1059 OmahaResponseHandlerAction* response_action =
1060 new OmahaResponseHandlerAction(&fake_system_state_);
1061 response_action->install_plan_.version = "a.b.c.d";
1062 response_action->install_plan_.system_version = "b.c.d.e";
1063 response_action->install_plan_.payloads.push_back(
1064 {.size = 1234ULL, .type = InstallPayloadType::kFull});
1065 attempter_.response_handler_action_.reset(response_action);
1066 // Inform the UpdateAttempter that the OmahaResponseHandlerAction has
1067 // completed, with the deferred-update error code.
1068 attempter_.ActionCompleted(
1069 nullptr, response_action, ErrorCode::kOmahaUpdateDeferredPerPolicy);
1070 {
1071 UpdateEngineStatus status;
1072 attempter_.GetStatus(&status);
1073 EXPECT_EQ(UpdateStatus::UPDATE_AVAILABLE, status.status);
1074 EXPECT_EQ(response_action->install_plan_.version, status.new_version);
1075 EXPECT_EQ(response_action->install_plan_.system_version,
1076 status.new_system_version);
1077 EXPECT_EQ(response_action->install_plan_.payloads[0].size,
1078 status.new_size_bytes);
1079 }
1080 // An "error" event should have been created to tell Omaha that the update is
1081 // being deferred.
1082 EXPECT_TRUE(nullptr != attempter_.error_event_);
1083 EXPECT_EQ(OmahaEvent::kTypeUpdateComplete, attempter_.error_event_->type);
1084 EXPECT_EQ(OmahaEvent::kResultUpdateDeferred, attempter_.error_event_->result);
1085 ErrorCode expected_code = static_cast<ErrorCode>(
1086 static_cast<int>(ErrorCode::kOmahaUpdateDeferredPerPolicy) |
1087 static_cast<int>(ErrorCode::kTestOmahaUrlFlag));
1088 EXPECT_EQ(expected_code, attempter_.error_event_->error_code);
1089 // End the processing
1090 attempter_.ProcessingDone(nullptr, ErrorCode::kOmahaUpdateDeferredPerPolicy);
1091 // Validate the state of the attempter.
1092 {
1093 UpdateEngineStatus status;
1094 attempter_.GetStatus(&status);
1095 EXPECT_EQ(UpdateStatus::REPORTING_ERROR_EVENT, status.status);
1096 EXPECT_EQ(response_action->install_plan_.version, status.new_version);
1097 EXPECT_EQ(response_action->install_plan_.system_version,
1098 status.new_system_version);
1099 EXPECT_EQ(response_action->install_plan_.payloads[0].size,
1100 status.new_size_bytes);
1101 }
1102}
1103
1104TEST_F(UpdateAttempterTest, UpdateIsNotRunningWhenUpdateAvailable) {
1105 EXPECT_FALSE(attempter_.IsUpdateRunningOrScheduled());
1106 // Verify in-progress update with UPDATE_AVAILABLE is running
1107 attempter_.status_ = UpdateStatus::UPDATE_AVAILABLE;
1108 EXPECT_TRUE(attempter_.IsUpdateRunningOrScheduled());
1109}
1110
Aaron Woodbf5a2522017-10-04 10:58:36 -07001111TEST_F(UpdateAttempterTest, UpdateAttemptFlagsCachedAtUpdateStart) {
1112 attempter_.SetUpdateAttemptFlags(UpdateAttemptFlags::kFlagRestrictDownload);
1113
1114 UpdateCheckParams params = {.updates_enabled = true};
1115 attempter_.OnUpdateScheduled(EvalStatus::kSucceeded, params);
1116
1117 EXPECT_EQ(UpdateAttemptFlags::kFlagRestrictDownload,
1118 attempter_.GetCurrentUpdateAttemptFlags());
1119}
1120
Aaron Wood081c0232017-10-19 17:14:58 -07001121TEST_F(UpdateAttempterTest, InteractiveUpdateUsesPassedRestrictions) {
1122 attempter_.SetUpdateAttemptFlags(UpdateAttemptFlags::kFlagRestrictDownload);
1123
1124 attempter_.CheckForUpdate("", "", UpdateAttemptFlags::kNone);
1125 EXPECT_EQ(UpdateAttemptFlags::kNone,
1126 attempter_.GetCurrentUpdateAttemptFlags());
1127}
1128
1129TEST_F(UpdateAttempterTest, NonInteractiveUpdateUsesSetRestrictions) {
1130 attempter_.SetUpdateAttemptFlags(UpdateAttemptFlags::kNone);
1131
1132 // This tests that when CheckForUpdate() is called with the non-interactive
1133 // flag set, that it doesn't change the current UpdateAttemptFlags.
1134 attempter_.CheckForUpdate("",
1135 "",
1136 UpdateAttemptFlags::kFlagNonInteractive |
1137 UpdateAttemptFlags::kFlagRestrictDownload);
1138 EXPECT_EQ(UpdateAttemptFlags::kNone,
1139 attempter_.GetCurrentUpdateAttemptFlags());
1140}
1141
Darin Petkovf42cc1c2010-09-01 09:03:02 -07001142} // namespace chromeos_update_engine