blob: 9538c4ee607017cff56edad7439370e2e094adc3 [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
2// Copyright (C) 2014 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//
Alex Deymo0d11c602014-04-23 20:12:20 -070016
Alex Deymo63784a52014-05-28 10:46:14 -070017#include "update_engine/update_manager/chromeos_policy.h"
Alex Deymo0d11c602014-04-23 20:12:20 -070018
Amin Hassani186ff6a2018-02-27 11:06:03 -080019#include <memory>
Gilad Arnold0adbc942014-05-12 10:35:43 -070020#include <set>
Alex Deymo0d11c602014-04-23 20:12:20 -070021
Amin Hassani186ff6a2018-02-27 11:06:03 -080022#include "update_engine/update_manager/next_update_check_policy_impl.h"
23#include "update_engine/update_manager/policy_test_utils.h"
Alex Deymo0d11c602014-04-23 20:12:20 -070024
25using base::Time;
26using base::TimeDelta;
Sen Jiang255e22b2016-05-20 16:15:29 -070027using chromeos_update_engine::ConnectionTethering;
28using chromeos_update_engine::ConnectionType;
Gilad Arnoldb3b05442014-05-30 14:25:05 -070029using chromeos_update_engine::ErrorCode;
Gilad Arnold0adbc942014-05-12 10:35:43 -070030using std::set;
Alex Deymo0d11c602014-04-23 20:12:20 -070031using std::string;
32
Alex Deymo63784a52014-05-28 10:46:14 -070033namespace chromeos_update_manager {
Alex Deymo0d11c602014-04-23 20:12:20 -070034
Amin Hassani186ff6a2018-02-27 11:06:03 -080035class UmChromeOSPolicyTest : public UmPolicyTestBase {
Alex Deymo0d11c602014-04-23 20:12:20 -070036 protected:
Amin Hassani186ff6a2018-02-27 11:06:03 -080037 UmChromeOSPolicyTest() : UmPolicyTestBase() {
38 policy_ = std::make_unique<ChromeOSPolicy>();
39 }
40
Alex Deymo610277e2014-11-11 21:18:11 -080041 void SetUp() override {
Amin Hassani186ff6a2018-02-27 11:06:03 -080042 UmPolicyTestBase::SetUp();
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070043 SetUpDefaultDevicePolicy();
Alex Deymo0d11c602014-04-23 20:12:20 -070044 }
45
Amin Hassani186ff6a2018-02-27 11:06:03 -080046 void SetUpDefaultState() override {
47 UmPolicyTestBase::SetUpDefaultState();
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070048
Gilad Arnolda1eabcd2014-07-09 15:42:40 -070049 // OOBE is enabled by default.
50 fake_state_.config_provider()->var_is_oobe_enabled()->reset(
51 new bool(true));
52
Gilad Arnold76a11f62014-05-20 09:02:12 -070053 // For the purpose of the tests, this is an official build and OOBE was
54 // completed.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070055 fake_state_.system_provider()->var_is_official_build()->reset(
56 new bool(true));
Gilad Arnold76a11f62014-05-20 09:02:12 -070057 fake_state_.system_provider()->var_is_oobe_complete()->reset(
58 new bool(true));
Aaron Woodc73fdc12017-12-06 11:09:15 -080059 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -070060 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(2));
Gilad Arnold0adbc942014-05-12 10:35:43 -070061
62 // Connection is wifi, untethered.
63 fake_state_.shill_provider()->var_conn_type()->
64 reset(new ConnectionType(ConnectionType::kWifi));
65 fake_state_.shill_provider()->var_conn_tethering()->
66 reset(new ConnectionTethering(ConnectionTethering::kNotDetected));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070067 }
68
Gilad Arnoldb3b05442014-05-30 14:25:05 -070069 // Sets up a default device policy that does not impose any restrictions
70 // (HTTP) nor enables any features (P2P).
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070071 void SetUpDefaultDevicePolicy() {
72 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
73 new bool(true));
74 fake_state_.device_policy_provider()->var_update_disabled()->reset(
75 new bool(false));
76 fake_state_.device_policy_provider()->
77 var_allowed_connection_types_for_update()->reset(nullptr);
78 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
79 new TimeDelta());
80 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
Gilad Arnoldb3b05442014-05-30 14:25:05 -070081 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070082 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
83 new bool(false));
84 fake_state_.device_policy_provider()->var_release_channel_delegated()->
85 reset(new bool(true));
86 }
87
Amin Hassani186ff6a2018-02-27 11:06:03 -080088 // Configures the policy to return a desired value from UpdateCheckAllowed by
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070089 // faking the current wall clock time as needed. Restores the default state.
90 // This is used when testing policies that depend on this one.
Amin Hassani186ff6a2018-02-27 11:06:03 -080091 //
92 // Note that the default implementation relies on NextUpdateCheckPolicyImpl to
93 // set the FakeClock to the appropriate time.
94 virtual void SetUpdateCheckAllowed(bool allow_check) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070095 Time next_update_check;
Amin Hassani186ff6a2018-02-27 11:06:03 -080096 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
97 &next_update_check,
98 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070099 SetUpDefaultState();
100 SetUpDefaultDevicePolicy();
101 Time curr_time = next_update_check;
102 if (allow_check)
103 curr_time += TimeDelta::FromSeconds(1);
104 else
105 curr_time -= TimeDelta::FromSeconds(1);
106 fake_clock_.SetWallclockTime(curr_time);
107 }
Alex Deymo0d11c602014-04-23 20:12:20 -0700108};
109
Alex Deymo63784a52014-05-28 10:46:14 -0700110TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForTheTimeout) {
Alex Deymo0d11c602014-04-23 20:12:20 -0700111 // We get the next update_check timestamp from the policy's private method
112 // and then we check the public method respects that value on the normal
113 // case.
114 Time next_update_check;
115 Time last_checked_time =
116 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
117
Alex Deymo0d11c602014-04-23 20:12:20 -0700118 fake_state_.updater_provider()->var_last_checked_time()->reset(
119 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800120 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
121 &next_update_check,
122 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Alex Deymo0d11c602014-04-23 20:12:20 -0700123
124 UpdateCheckParams result;
125
126 // Check that the policy blocks until the next_update_check is reached.
127 SetUpDefaultClock();
128 SetUpDefaultState();
129 fake_state_.updater_provider()->var_last_checked_time()->reset(
130 new Time(last_checked_time));
131 fake_clock_.SetWallclockTime(next_update_check - TimeDelta::FromSeconds(1));
132 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
133 &Policy::UpdateCheckAllowed, &result);
134
135 SetUpDefaultClock();
136 SetUpDefaultState();
137 fake_state_.updater_provider()->var_last_checked_time()->reset(
138 new Time(last_checked_time));
139 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
140 ExpectPolicyStatus(EvalStatus::kSucceeded,
141 &Policy::UpdateCheckAllowed, &result);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700142 EXPECT_TRUE(result.updates_enabled);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700143 EXPECT_FALSE(result.is_interactive);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700144}
145
146TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForOOBE) {
Alex Vakulenko072359c2014-07-18 11:41:07 -0700147 // Update checks are deferred until OOBE is completed.
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700148
149 // Ensure that update is not allowed even if wait period is satisfied.
150 Time next_update_check;
151 Time last_checked_time =
152 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
153
154 fake_state_.updater_provider()->var_last_checked_time()->reset(
155 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800156 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
157 &next_update_check,
158 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700159
160 SetUpDefaultClock();
161 SetUpDefaultState();
162 fake_state_.updater_provider()->var_last_checked_time()->reset(
163 new Time(last_checked_time));
164 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
165 fake_state_.system_provider()->var_is_oobe_complete()->reset(
166 new bool(false));
167
168 UpdateCheckParams result;
169 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
170 &Policy::UpdateCheckAllowed, &result);
171
172 // Now check that it is allowed if OOBE is completed.
173 SetUpDefaultClock();
174 SetUpDefaultState();
175 fake_state_.updater_provider()->var_last_checked_time()->reset(
176 new Time(last_checked_time));
177 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
178 ExpectPolicyStatus(EvalStatus::kSucceeded,
179 &Policy::UpdateCheckAllowed, &result);
180 EXPECT_TRUE(result.updates_enabled);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700181 EXPECT_FALSE(result.is_interactive);
Alex Deymo0d11c602014-04-23 20:12:20 -0700182}
183
Gilad Arnold42f253b2014-06-25 12:39:17 -0700184TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWithAttributes) {
Alex Vakulenko072359c2014-07-18 11:41:07 -0700185 // Update check is allowed, response includes attributes for use in the
Gilad Arnold42f253b2014-06-25 12:39:17 -0700186 // request.
187 SetUpdateCheckAllowed(true);
188
189 // Override specific device policy attributes.
Gilad Arnoldd4b30322014-07-21 15:35:27 -0700190 fake_state_.device_policy_provider()->var_target_version_prefix()->
191 reset(new string("1.2"));
Marton Hunyady0e0e3542018-02-21 18:51:39 +0100192 fake_state_.device_policy_provider()->var_rollback_to_target_version()->reset(
193 new RollbackToTargetVersion(
194 RollbackToTargetVersion::kRollbackWithFullPowerwash));
195 fake_state_.device_policy_provider()
196 ->var_rollback_allowed_milestones()
197 ->reset(new int(5));
198 fake_state_.device_policy_provider()->var_release_channel_delegated()->reset(
199 new bool(false));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700200 fake_state_.device_policy_provider()->var_release_channel()->
201 reset(new string("foo-channel"));
202
203 UpdateCheckParams result;
204 ExpectPolicyStatus(EvalStatus::kSucceeded,
205 &Policy::UpdateCheckAllowed, &result);
206 EXPECT_TRUE(result.updates_enabled);
Gilad Arnoldd4b30322014-07-21 15:35:27 -0700207 EXPECT_EQ("1.2", result.target_version_prefix);
Marton Hunyady0e0e3542018-02-21 18:51:39 +0100208 EXPECT_EQ(RollbackToTargetVersion::kRollbackWithFullPowerwash,
209 result.rollback_to_target_version);
210 EXPECT_EQ(5, result.rollback_allowed_milestones);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700211 EXPECT_EQ("foo-channel", result.target_channel);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700212 EXPECT_FALSE(result.is_interactive);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700213}
214
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700215TEST_F(UmChromeOSPolicyTest,
216 UpdateCheckAllowedUpdatesDisabledForUnofficialBuilds) {
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700217 // UpdateCheckAllowed should return kAskMeAgainLater if this is an unofficial
218 // build; we don't want periodic update checks on developer images.
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700219
220 fake_state_.system_provider()->var_is_official_build()->reset(
221 new bool(false));
222
223 UpdateCheckParams result;
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700224 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700225 &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700226}
227
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700228TEST_F(UmChromeOSPolicyTest,
Aaron Wood56d8ab32017-09-22 15:56:18 -0700229 UpdateCheckAllowedUpdatesDisabledWhenNotEnoughSlotsAbUpdates) {
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700230 // UpdateCheckAllowed should return false (kSucceeded) if the image booted
Aaron Wood56d8ab32017-09-22 15:56:18 -0700231 // without enough slots to do A/B updates.
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700232
Aaron Woodc73fdc12017-12-06 11:09:15 -0800233 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -0700234 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(1));
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700235
236 UpdateCheckParams result;
237 ExpectPolicyStatus(EvalStatus::kSucceeded,
238 &Policy::UpdateCheckAllowed, &result);
239 EXPECT_FALSE(result.updates_enabled);
240}
241
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700242TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedUpdatesDisabledByPolicy) {
Gilad Arnold42f253b2014-06-25 12:39:17 -0700243 // UpdateCheckAllowed should return kAskMeAgainLater because a device policy
244 // is loaded and prohibits updates.
245
246 SetUpdateCheckAllowed(false);
247 fake_state_.device_policy_provider()->var_update_disabled()->reset(
248 new bool(true));
249
Gilad Arnold42f253b2014-06-25 12:39:17 -0700250 UpdateCheckParams result;
251 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
252 &Policy::UpdateCheckAllowed, &result);
253}
254
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700255TEST_F(UmChromeOSPolicyTest,
256 UpdateCheckAllowedForcedUpdateRequestedInteractive) {
257 // UpdateCheckAllowed should return true because a forced update request was
258 // signaled for an interactive update.
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700259
260 SetUpdateCheckAllowed(true);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700261 fake_state_.updater_provider()->var_forced_update_requested()->reset(
262 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700263
264 UpdateCheckParams result;
265 ExpectPolicyStatus(EvalStatus::kSucceeded,
266 &Policy::UpdateCheckAllowed, &result);
267 EXPECT_TRUE(result.updates_enabled);
268 EXPECT_TRUE(result.is_interactive);
269}
270
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700271TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedForcedUpdateRequestedPeriodic) {
272 // UpdateCheckAllowed should return true because a forced update request was
273 // signaled for a periodic check.
274
275 SetUpdateCheckAllowed(true);
276 fake_state_.updater_provider()->var_forced_update_requested()->reset(
277 new UpdateRequestStatus(UpdateRequestStatus::kPeriodic));
278
279 UpdateCheckParams result;
280 ExpectPolicyStatus(EvalStatus::kSucceeded,
281 &Policy::UpdateCheckAllowed, &result);
282 EXPECT_TRUE(result.updates_enabled);
283 EXPECT_FALSE(result.is_interactive);
284}
285
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800286TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPin) {
287 // Update check is allowed.
288 SetUpdateCheckAllowed(true);
289
290 // A typical setup for kiosk pin policy: AU disabled, allow kiosk to pin
291 // and there is a kiosk required platform version.
292 fake_state_.device_policy_provider()->var_update_disabled()->reset(
293 new bool(true));
294 fake_state_.device_policy_provider()
295 ->var_allow_kiosk_app_control_chrome_version()
296 ->reset(new bool(true));
297 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
298 new string("1234.0.0"));
299
300 UpdateCheckParams result;
301 ExpectPolicyStatus(EvalStatus::kSucceeded,
302 &Policy::UpdateCheckAllowed, &result);
303 EXPECT_TRUE(result.updates_enabled);
304 EXPECT_EQ("1234.0.0", result.target_version_prefix);
305 EXPECT_FALSE(result.is_interactive);
306}
307
308TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedDisabledWhenNoKioskPin) {
309 // Update check is allowed.
310 SetUpdateCheckAllowed(true);
311
312 // Disable AU policy is set but kiosk pin policy is set to false. Update is
313 // disabled in such case.
314 fake_state_.device_policy_provider()->var_update_disabled()->reset(
315 new bool(true));
316 fake_state_.device_policy_provider()
317 ->var_allow_kiosk_app_control_chrome_version()
318 ->reset(new bool(false));
319
320 UpdateCheckParams result;
321 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
322 &Policy::UpdateCheckAllowed, &result);
323}
324
325TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPinWithNoRequiredVersion) {
326 // Update check is allowed.
327 SetUpdateCheckAllowed(true);
328
329 // AU disabled, allow kiosk to pin but there is no kiosk required platform
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700330 // version (i.e. app does not provide the info). Update to latest in such
331 // case.
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800332 fake_state_.device_policy_provider()->var_update_disabled()->reset(
333 new bool(true));
334 fake_state_.device_policy_provider()
335 ->var_allow_kiosk_app_control_chrome_version()
336 ->reset(new bool(true));
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700337 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
338 new string());
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800339
340 UpdateCheckParams result;
341 ExpectPolicyStatus(EvalStatus::kSucceeded,
342 &Policy::UpdateCheckAllowed, &result);
343 EXPECT_TRUE(result.updates_enabled);
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700344 EXPECT_TRUE(result.target_version_prefix.empty());
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800345 EXPECT_FALSE(result.is_interactive);
346}
347
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700348TEST_F(UmChromeOSPolicyTest,
349 UpdateCheckAllowedKioskPinWithFailedGetRequiredVersionCall) {
350 // AU disabled, allow kiosk to pin but D-Bus call to get required platform
351 // version failed. Defer update check in this case.
352 fake_state_.device_policy_provider()->var_update_disabled()->reset(
353 new bool(true));
354 fake_state_.device_policy_provider()
355 ->var_allow_kiosk_app_control_chrome_version()
356 ->reset(new bool(true));
357 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
358 nullptr);
359
360 UpdateCheckParams result;
361 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
362 &Policy::UpdateCheckAllowed, &result);
363}
364
Alex Deymo63784a52014-05-28 10:46:14 -0700365TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsCheckAllowedError) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700366 // The UpdateCanStart policy fails, not being able to query
367 // UpdateCheckAllowed.
368
369 // Configure the UpdateCheckAllowed policy to fail.
370 fake_state_.updater_provider()->var_updater_started_time()->reset(nullptr);
371
372 // Check that the UpdateCanStart fails.
373 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700374 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700375 ExpectPolicyStatus(EvalStatus::kFailed,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700376 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700377}
378
Alex Deymo63784a52014-05-28 10:46:14 -0700379TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedCheckDue) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700380 // The UpdateCanStart policy returns false because we are due for another
Gilad Arnold14a9e702014-10-08 08:09:09 -0700381 // update check. Ensure that download related values are still returned.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700382
383 SetUpdateCheckAllowed(true);
384
385 // Check that the UpdateCanStart returns false.
386 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700387 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700388 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700389 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700390 EXPECT_FALSE(result.update_can_start);
391 EXPECT_EQ(UpdateCannotStartReason::kCheckDue, result.cannot_start_reason);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700392 EXPECT_EQ(0, result.download_url_idx);
393 EXPECT_EQ(0, result.download_url_num_errors);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700394}
395
Alex Deymo63784a52014-05-28 10:46:14 -0700396TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoDevicePolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700397 // The UpdateCanStart policy returns true; no device policy is loaded.
398
399 SetUpdateCheckAllowed(false);
400 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
401 new bool(false));
402
403 // Check that the UpdateCanStart returns true with no further attributes.
404 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700405 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700406 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700407 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700408 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700409 EXPECT_FALSE(result.p2p_downloading_allowed);
410 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700411 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700412 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700413 EXPECT_EQ(0, result.download_url_num_errors);
414 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700415}
416
Alex Deymo63784a52014-05-28 10:46:14 -0700417TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBlankPolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700418 // The UpdateCanStart policy returns true; device policy is loaded but imposes
419 // no restrictions on updating.
420
421 SetUpdateCheckAllowed(false);
422
423 // Check that the UpdateCanStart returns true.
424 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700425 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700426 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700427 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700428 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700429 EXPECT_FALSE(result.p2p_downloading_allowed);
430 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700431 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700432 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700433 EXPECT_EQ(0, result.download_url_num_errors);
434 EXPECT_FALSE(result.do_increment_failures);
435}
436
437TEST_F(UmChromeOSPolicyTest,
438 UpdateCanStartNotAllowedBackoffNewWaitPeriodApplies) {
439 // The UpdateCanStart policy returns false; failures are reported and a new
440 // backoff period is enacted.
441
442 SetUpdateCheckAllowed(false);
443
444 const Time curr_time = fake_clock_.GetWallclockTime();
445 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
446 update_state.download_errors_max = 1;
447 update_state.download_errors.emplace_back(
448 0, ErrorCode::kDownloadTransferError,
449 curr_time - TimeDelta::FromSeconds(8));
450 update_state.download_errors.emplace_back(
451 0, ErrorCode::kDownloadTransferError,
452 curr_time - TimeDelta::FromSeconds(2));
453
454 // Check that UpdateCanStart returns false and a new backoff expiry is
455 // generated.
456 UpdateDownloadParams result;
457 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
458 update_state);
459 EXPECT_FALSE(result.update_can_start);
460 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
461 EXPECT_TRUE(result.do_increment_failures);
462 EXPECT_LT(curr_time, result.backoff_expiry);
463}
464
465TEST_F(UmChromeOSPolicyTest,
466 UpdateCanStartNotAllowedBackoffPrevWaitPeriodStillApplies) {
467 // The UpdateCanStart policy returns false; a previously enacted backoff
468 // period still applies.
469
470 SetUpdateCheckAllowed(false);
471
472 const Time curr_time = fake_clock_.GetWallclockTime();
473 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
474 update_state.download_errors_max = 1;
475 update_state.download_errors.emplace_back(
476 0, ErrorCode::kDownloadTransferError,
477 curr_time - TimeDelta::FromSeconds(8));
478 update_state.download_errors.emplace_back(
479 0, ErrorCode::kDownloadTransferError,
480 curr_time - TimeDelta::FromSeconds(2));
481 update_state.failures_last_updated = curr_time;
482 update_state.backoff_expiry = curr_time + TimeDelta::FromMinutes(3);
483
484 // Check that UpdateCanStart returns false and a new backoff expiry is
485 // generated.
486 UpdateDownloadParams result;
487 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::UpdateCanStart,
488 &result, update_state);
489 EXPECT_FALSE(result.update_can_start);
490 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
491 EXPECT_FALSE(result.do_increment_failures);
492 EXPECT_LT(curr_time, result.backoff_expiry);
493}
494
495TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffSatisfied) {
496 // The UpdateCanStart policy returns true; a previously enacted backoff period
497 // has elapsed, we're good to go.
498
499 SetUpdateCheckAllowed(false);
500
501 const Time curr_time = fake_clock_.GetWallclockTime();
502 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
503 update_state.download_errors_max = 1;
504 update_state.download_errors.emplace_back(
505 0, ErrorCode::kDownloadTransferError,
506 curr_time - TimeDelta::FromSeconds(8));
507 update_state.download_errors.emplace_back(
508 0, ErrorCode::kDownloadTransferError,
509 curr_time - TimeDelta::FromSeconds(2));
510 update_state.failures_last_updated = curr_time - TimeDelta::FromSeconds(1);
511 update_state.backoff_expiry = curr_time - TimeDelta::FromSeconds(1);
512
513 // Check that UpdateCanStart returns false and a new backoff expiry is
514 // generated.
515 UpdateDownloadParams result;
516 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart,
517 &result, update_state);
518 EXPECT_TRUE(result.update_can_start);
519 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
520 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700521 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700522 EXPECT_EQ(0, result.download_url_num_errors);
523 EXPECT_FALSE(result.do_increment_failures);
524 EXPECT_EQ(Time(), result.backoff_expiry);
525}
526
527TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffDisabled) {
528 // The UpdateCanStart policy returns false; failures are reported but backoff
529 // is disabled.
530
531 SetUpdateCheckAllowed(false);
532
533 const Time curr_time = fake_clock_.GetWallclockTime();
534 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
535 update_state.download_errors_max = 1;
536 update_state.download_errors.emplace_back(
537 0, ErrorCode::kDownloadTransferError,
538 curr_time - TimeDelta::FromSeconds(8));
539 update_state.download_errors.emplace_back(
540 0, ErrorCode::kDownloadTransferError,
541 curr_time - TimeDelta::FromSeconds(2));
542 update_state.is_backoff_disabled = true;
543
544 // Check that UpdateCanStart returns false and a new backoff expiry is
545 // generated.
546 UpdateDownloadParams result;
547 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
548 update_state);
549 EXPECT_TRUE(result.update_can_start);
550 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
551 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700552 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700553 EXPECT_EQ(0, result.download_url_num_errors);
554 EXPECT_TRUE(result.do_increment_failures);
555 EXPECT_EQ(Time(), result.backoff_expiry);
556}
557
558TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffInteractive) {
559 // The UpdateCanStart policy returns false; failures are reported but this is
560 // an interactive update check.
561
562 SetUpdateCheckAllowed(false);
563
564 const Time curr_time = fake_clock_.GetWallclockTime();
565 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
566 update_state.download_errors_max = 1;
567 update_state.download_errors.emplace_back(
568 0, ErrorCode::kDownloadTransferError,
569 curr_time - TimeDelta::FromSeconds(8));
570 update_state.download_errors.emplace_back(
571 0, ErrorCode::kDownloadTransferError,
572 curr_time - TimeDelta::FromSeconds(2));
573 update_state.is_interactive = true;
574
575 // Check that UpdateCanStart returns false and a new backoff expiry is
576 // generated.
577 UpdateDownloadParams result;
578 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
579 update_state);
580 EXPECT_TRUE(result.update_can_start);
581 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
582 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700583 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700584 EXPECT_EQ(0, result.download_url_num_errors);
585 EXPECT_TRUE(result.do_increment_failures);
586 EXPECT_EQ(Time(), result.backoff_expiry);
587}
588
589TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffDelta) {
590 // The UpdateCanStart policy returns false; failures are reported but this is
591 // a delta payload.
592
593 SetUpdateCheckAllowed(false);
594
595 const Time curr_time = fake_clock_.GetWallclockTime();
596 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
597 update_state.download_errors_max = 1;
598 update_state.download_errors.emplace_back(
599 0, ErrorCode::kDownloadTransferError,
600 curr_time - TimeDelta::FromSeconds(8));
601 update_state.download_errors.emplace_back(
602 0, ErrorCode::kDownloadTransferError,
603 curr_time - TimeDelta::FromSeconds(2));
604 update_state.is_delta_payload = true;
605
606 // Check that UpdateCanStart returns false and a new backoff expiry is
607 // generated.
608 UpdateDownloadParams result;
609 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
610 update_state);
611 EXPECT_TRUE(result.update_can_start);
612 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
613 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700614 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700615 EXPECT_EQ(0, result.download_url_num_errors);
616 EXPECT_TRUE(result.do_increment_failures);
617 EXPECT_EQ(Time(), result.backoff_expiry);
618}
619
620TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffUnofficialBuild) {
621 // The UpdateCanStart policy returns false; failures are reported but this is
622 // an unofficial build.
623
624 SetUpdateCheckAllowed(false);
625
626 const Time curr_time = fake_clock_.GetWallclockTime();
627 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
628 update_state.download_errors_max = 1;
629 update_state.download_errors.emplace_back(
630 0, ErrorCode::kDownloadTransferError,
631 curr_time - TimeDelta::FromSeconds(8));
632 update_state.download_errors.emplace_back(
633 0, ErrorCode::kDownloadTransferError,
634 curr_time - TimeDelta::FromSeconds(2));
635
636 fake_state_.system_provider()->var_is_official_build()->
637 reset(new bool(false));
638
639 // Check that UpdateCanStart returns false and a new backoff expiry is
640 // generated.
641 UpdateDownloadParams result;
642 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
643 update_state);
644 EXPECT_TRUE(result.update_can_start);
645 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
646 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700647 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700648 EXPECT_EQ(0, result.download_url_num_errors);
649 EXPECT_TRUE(result.do_increment_failures);
650 EXPECT_EQ(Time(), result.backoff_expiry);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700651}
652
Alex Deymo63784a52014-05-28 10:46:14 -0700653TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsScatteringFailed) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700654 // The UpdateCanStart policy fails because the UpdateScattering policy it
655 // depends on fails (unset variable).
656
657 SetUpdateCheckAllowed(false);
658
659 // Override the default seed variable with a null value so that the policy
660 // request would fail.
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700661 // TODO(garnold) This failure may or may not fail a number
662 // sub-policies/decisions, like scattering and backoff. We'll need a more
663 // deliberate setup to ensure that we're failing what we want to be failing.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700664 fake_state_.random_provider()->var_seed()->reset(nullptr);
665
666 // Check that the UpdateCanStart fails.
667 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700668 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700669 ExpectPolicyStatus(EvalStatus::kFailed,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700670 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700671}
672
Alex Deymo63784a52014-05-28 10:46:14 -0700673TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700674 UpdateCanStartNotAllowedScatteringNewWaitPeriodApplies) {
675 // The UpdateCanStart policy returns false; device policy is loaded and
676 // scattering applies due to an unsatisfied wait period, which was newly
677 // generated.
678
679 SetUpdateCheckAllowed(false);
680 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
681 new TimeDelta(TimeDelta::FromMinutes(2)));
682
683
684 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
685
686 // Check that the UpdateCanStart returns false and a new wait period
687 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700688 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700689 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700690 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700691 EXPECT_FALSE(result.update_can_start);
692 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
693 EXPECT_LT(TimeDelta(), result.scatter_wait_period);
694 EXPECT_EQ(0, result.scatter_check_threshold);
695}
696
Alex Deymo63784a52014-05-28 10:46:14 -0700697TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700698 UpdateCanStartNotAllowedScatteringPrevWaitPeriodStillApplies) {
699 // The UpdateCanStart policy returns false w/ kAskMeAgainLater; device policy
700 // is loaded and a previously generated scattering period still applies, none
701 // of the scattering values has changed.
702
703 SetUpdateCheckAllowed(false);
704 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
705 new TimeDelta(TimeDelta::FromMinutes(2)));
706
707 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
708 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
709
710 // Check that the UpdateCanStart returns false and a new wait period
711 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700712 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700713 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::UpdateCanStart,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700714 &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700715 EXPECT_FALSE(result.update_can_start);
716 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
717 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
718 EXPECT_EQ(0, result.scatter_check_threshold);
719}
720
Alex Deymo63784a52014-05-28 10:46:14 -0700721TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700722 UpdateCanStartNotAllowedScatteringNewCountThresholdApplies) {
723 // The UpdateCanStart policy returns false; device policy is loaded and
724 // scattering applies due to an unsatisfied update check count threshold.
725 //
726 // This ensures a non-zero check threshold, which may or may not be combined
727 // with a non-zero wait period (for which we cannot reliably control).
728
729 SetUpdateCheckAllowed(false);
730 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
731 new TimeDelta(TimeDelta::FromSeconds(1)));
732
733 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
734 update_state.scatter_check_threshold_min = 2;
735 update_state.scatter_check_threshold_max = 5;
736
737 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700738 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700739 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700740 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700741 EXPECT_FALSE(result.update_can_start);
742 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
743 EXPECT_LE(2, result.scatter_check_threshold);
744 EXPECT_GE(5, result.scatter_check_threshold);
745}
746
Alex Deymo63784a52014-05-28 10:46:14 -0700747TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700748 UpdateCanStartNotAllowedScatteringPrevCountThresholdStillApplies) {
749 // The UpdateCanStart policy returns false; device policy is loaded and
750 // scattering due to a previously generated count threshold still applies.
751
752 SetUpdateCheckAllowed(false);
753 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
754 new TimeDelta(TimeDelta::FromSeconds(1)));
755
756 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
757 update_state.scatter_check_threshold = 3;
758 update_state.scatter_check_threshold_min = 2;
759 update_state.scatter_check_threshold_max = 5;
760
761 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700762 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700763 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700764 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700765 EXPECT_FALSE(result.update_can_start);
766 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
767 EXPECT_EQ(3, result.scatter_check_threshold);
768}
769
Alex Deymo63784a52014-05-28 10:46:14 -0700770TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSatisfied) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700771 // The UpdateCanStart policy returns true; device policy is loaded and
772 // scattering is enabled, but both wait period and check threshold are
773 // satisfied.
774
775 SetUpdateCheckAllowed(false);
776 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
777 new TimeDelta(TimeDelta::FromSeconds(120)));
778
779 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(75));
780 update_state.num_checks = 4;
781 update_state.scatter_wait_period = TimeDelta::FromSeconds(60);
782 update_state.scatter_check_threshold = 3;
783 update_state.scatter_check_threshold_min = 2;
784 update_state.scatter_check_threshold_max = 5;
785
786 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700787 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700788 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700789 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700790 EXPECT_TRUE(result.update_can_start);
791 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
792 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700793 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700794 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700795 EXPECT_EQ(0, result.download_url_num_errors);
796 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700797}
798
Alex Deymo63784a52014-05-28 10:46:14 -0700799TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700800 UpdateCanStartAllowedInteractivePreventsScattering) {
801 // The UpdateCanStart policy returns true; device policy is loaded and
802 // scattering would have applied, except that the update check is interactive
803 // and so it is suppressed.
804
805 SetUpdateCheckAllowed(false);
806 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
807 new TimeDelta(TimeDelta::FromSeconds(1)));
808
809 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700810 update_state.is_interactive = true;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700811 update_state.scatter_check_threshold = 0;
812 update_state.scatter_check_threshold_min = 2;
813 update_state.scatter_check_threshold_max = 5;
814
815 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700816 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700817 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700818 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700819 EXPECT_TRUE(result.update_can_start);
820 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
821 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700822 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700823 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700824 EXPECT_EQ(0, result.download_url_num_errors);
825 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700826}
827
Alex Deymo63784a52014-05-28 10:46:14 -0700828TEST_F(UmChromeOSPolicyTest,
Gilad Arnold76a11f62014-05-20 09:02:12 -0700829 UpdateCanStartAllowedOobePreventsScattering) {
830 // The UpdateCanStart policy returns true; device policy is loaded and
831 // scattering would have applied, except that OOBE was not completed and so it
832 // is suppressed.
833
834 SetUpdateCheckAllowed(false);
835 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
836 new TimeDelta(TimeDelta::FromSeconds(1)));
837 fake_state_.system_provider()->var_is_oobe_complete()->reset(new bool(false));
838
839 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700840 update_state.is_interactive = true;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700841 update_state.scatter_check_threshold = 0;
842 update_state.scatter_check_threshold_min = 2;
843 update_state.scatter_check_threshold_max = 5;
844
845 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700846 UpdateDownloadParams result;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700847 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700848 update_state);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700849 EXPECT_TRUE(result.update_can_start);
850 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
851 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700852 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700853 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700854 EXPECT_EQ(0, result.download_url_num_errors);
855 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700856}
857
Alex Deymo63784a52014-05-28 10:46:14 -0700858TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithAttributes) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700859 // The UpdateCanStart policy returns true; device policy permits both HTTP and
860 // P2P updates, as well as a non-empty target channel string.
861
862 SetUpdateCheckAllowed(false);
863
864 // Override specific device policy attributes.
865 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
866 new bool(true));
867 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
868 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700869
870 // Check that the UpdateCanStart returns true.
871 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700872 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700873 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700874 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700875 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700876 EXPECT_TRUE(result.p2p_downloading_allowed);
877 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700878 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700879 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700880 EXPECT_EQ(0, result.download_url_num_errors);
881 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700882}
883
Alex Deymo63784a52014-05-28 10:46:14 -0700884TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithP2PFromUpdater) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700885 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
886 // P2P updates, but the updater is configured to allow P2P and overrules the
887 // setting.
888
889 SetUpdateCheckAllowed(false);
890
891 // Override specific device policy attributes.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700892 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
893
894 // Check that the UpdateCanStart returns true.
895 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700896 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700897 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700898 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700899 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700900 EXPECT_TRUE(result.p2p_downloading_allowed);
901 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700902 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700903 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700904 EXPECT_EQ(0, result.download_url_num_errors);
905 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700906}
907
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700908TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -0700909 UpdateCanStartAllowedP2PDownloadingBlockedDueToOmaha) {
910 // The UpdateCanStart policy returns true; device policy permits HTTP, but
911 // policy blocks P2P downloading because Omaha forbids it. P2P sharing is
912 // still permitted.
913
914 SetUpdateCheckAllowed(false);
915
916 // Override specific device policy attributes.
917 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
918 new bool(true));
919 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
920 new bool(true));
921
922 // Check that the UpdateCanStart returns true.
923 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
924 update_state.p2p_downloading_disabled = true;
925 UpdateDownloadParams result;
926 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
927 update_state);
928 EXPECT_TRUE(result.update_can_start);
929 EXPECT_FALSE(result.p2p_downloading_allowed);
930 EXPECT_TRUE(result.p2p_sharing_allowed);
931}
932
933TEST_F(UmChromeOSPolicyTest,
934 UpdateCanStartAllowedP2PSharingBlockedDueToOmaha) {
935 // The UpdateCanStart policy returns true; device policy permits HTTP, but
936 // policy blocks P2P sharing because Omaha forbids it. P2P downloading is
937 // still permitted.
938
939 SetUpdateCheckAllowed(false);
940
941 // Override specific device policy attributes.
942 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
943 new bool(true));
944 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
945 new bool(true));
946
947 // Check that the UpdateCanStart returns true.
948 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
949 update_state.p2p_sharing_disabled = true;
950 UpdateDownloadParams result;
951 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
952 update_state);
953 EXPECT_TRUE(result.update_can_start);
954 EXPECT_TRUE(result.p2p_downloading_allowed);
955 EXPECT_FALSE(result.p2p_sharing_allowed);
956}
957
958TEST_F(UmChromeOSPolicyTest,
959 UpdateCanStartAllowedP2PDownloadingBlockedDueToNumAttempts) {
Gilad Arnold349ac832014-10-06 14:20:28 -0700960 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700961 // blocks P2P download, because the max number of P2P downloads have been
962 // attempted. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -0700963
964 SetUpdateCheckAllowed(false);
965
966 // Override specific device policy attributes.
967 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
968 new bool(true));
969 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
970 new bool(true));
971
972 // Check that the UpdateCanStart returns true.
973 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
974 update_state.p2p_num_attempts = ChromeOSPolicy::kMaxP2PAttempts;
975 UpdateDownloadParams result;
976 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
977 update_state);
978 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700979 EXPECT_FALSE(result.p2p_downloading_allowed);
980 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -0700981}
982
983TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -0700984 UpdateCanStartAllowedP2PDownloadingBlockedDueToAttemptsPeriod) {
Gilad Arnold349ac832014-10-06 14:20:28 -0700985 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700986 // blocks P2P download, because the max period for attempt to download via P2P
987 // has elapsed. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -0700988
989 SetUpdateCheckAllowed(false);
990
991 // Override specific device policy attributes.
992 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
993 new bool(true));
994 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
995 new bool(true));
996
997 // Check that the UpdateCanStart returns true.
998 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
999 update_state.p2p_num_attempts = 1;
1000 update_state.p2p_first_attempted =
1001 fake_clock_.GetWallclockTime() -
Alex Deymof329b932014-10-30 01:37:48 -07001002 TimeDelta::FromSeconds(
1003 ChromeOSPolicy::kMaxP2PAttemptsPeriodInSeconds + 1);
Gilad Arnold349ac832014-10-06 14:20:28 -07001004 UpdateDownloadParams result;
1005 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1006 update_state);
1007 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001008 EXPECT_FALSE(result.p2p_downloading_allowed);
1009 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001010}
1011
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001012TEST_F(UmChromeOSPolicyTest,
1013 UpdateCanStartAllowedWithHttpUrlForUnofficialBuild) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001014 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1015 // P2P updates, but marking this an unofficial build overrules the HTTP
1016 // setting.
1017
1018 SetUpdateCheckAllowed(false);
1019
1020 // Override specific device policy attributes.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001021 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1022 new bool(false));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001023 fake_state_.system_provider()->var_is_official_build()->
1024 reset(new bool(false));
1025
1026 // Check that the UpdateCanStart returns true.
1027 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001028 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001029 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001030 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001031 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001032 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001033 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001034 EXPECT_EQ(0, result.download_url_num_errors);
1035 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001036}
1037
1038TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithHttpsUrl) {
1039 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1040 // P2P updates, but an HTTPS URL is provided and selected for download.
1041
1042 SetUpdateCheckAllowed(false);
1043
1044 // Override specific device policy attributes.
1045 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1046 new bool(false));
1047
1048 // Add an HTTPS URL.
1049 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001050 update_state.download_urls.emplace_back("https://secure/url/");
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001051
1052 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001053 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001054 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001055 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001056 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001057 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001058 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001059 EXPECT_EQ(0, result.download_url_num_errors);
1060 EXPECT_FALSE(result.do_increment_failures);
1061}
1062
1063TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedMaxErrorsNotExceeded) {
1064 // The UpdateCanStart policy returns true; the first URL has download errors
1065 // but does not exceed the maximum allowed number of failures, so it is stilli
1066 // usable.
1067
1068 SetUpdateCheckAllowed(false);
1069
1070 // Add a second URL; update with this URL attempted and failed enough times to
1071 // disqualify the current (first) URL.
1072 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1073 update_state.num_checks = 5;
1074 update_state.download_urls.emplace_back("http://another/fake/url/");
1075 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1076 for (int i = 0; i < 5; i++) {
1077 update_state.download_errors.emplace_back(
1078 0, ErrorCode::kDownloadTransferError, t);
1079 t += TimeDelta::FromSeconds(1);
1080 }
1081
1082 // Check that the UpdateCanStart returns true.
1083 UpdateDownloadParams result;
1084 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1085 update_state);
1086 EXPECT_TRUE(result.update_can_start);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001087 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001088 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001089 EXPECT_EQ(5, result.download_url_num_errors);
1090 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001091}
1092
1093TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlMaxExceeded) {
1094 // The UpdateCanStart policy returns true; the first URL exceeded the maximum
1095 // allowed number of failures, but a second URL is available.
1096
1097 SetUpdateCheckAllowed(false);
1098
1099 // Add a second URL; update with this URL attempted and failed enough times to
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001100 // disqualify the current (first) URL.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001101 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1102 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001103 update_state.download_urls.emplace_back("http://another/fake/url/");
1104 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1105 for (int i = 0; i < 11; i++) {
1106 update_state.download_errors.emplace_back(
1107 0, ErrorCode::kDownloadTransferError, t);
1108 t += TimeDelta::FromSeconds(1);
1109 }
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001110
1111 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001112 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001113 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001114 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001115 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001116 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001117 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001118 EXPECT_EQ(0, result.download_url_num_errors);
1119 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001120}
1121
1122TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlHardError) {
1123 // The UpdateCanStart policy returns true; the first URL fails with a hard
1124 // error, but a second URL is available.
1125
1126 SetUpdateCheckAllowed(false);
1127
1128 // Add a second URL; update with this URL attempted and failed in a way that
1129 // causes it to switch directly to the next URL.
1130 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1131 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001132 update_state.download_urls.emplace_back("http://another/fake/url/");
1133 update_state.download_errors.emplace_back(
1134 0, ErrorCode::kPayloadHashMismatchError,
1135 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001136
1137 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001138 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001139 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001140 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001141 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001142 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001143 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001144 EXPECT_EQ(0, result.download_url_num_errors);
1145 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001146}
1147
1148TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedUrlWrapsAround) {
1149 // The UpdateCanStart policy returns true; URL search properly wraps around
1150 // the last one on the list.
1151
1152 SetUpdateCheckAllowed(false);
1153
1154 // Add a second URL; update with this URL attempted and failed in a way that
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001155 // causes it to switch directly to the next URL. We must disable backoff in
1156 // order for it not to interfere.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001157 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001158 update_state.num_checks = 1;
1159 update_state.is_backoff_disabled = true;
1160 update_state.download_urls.emplace_back("http://another/fake/url/");
1161 update_state.download_errors.emplace_back(
1162 1, ErrorCode::kPayloadHashMismatchError,
1163 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001164
1165 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001166 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001167 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001168 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001169 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001170 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001171 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001172 EXPECT_EQ(0, result.download_url_num_errors);
1173 EXPECT_TRUE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001174}
1175
1176TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedNoUsableUrls) {
1177 // The UpdateCanStart policy returns false; there's a single HTTP URL but its
1178 // use is forbidden by policy.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001179 //
1180 // Note: In the case where no usable URLs are found, the policy should not
1181 // increment the number of failed attempts! Doing so would result in a
1182 // non-idempotent semantics, and does not fall within the intended purpose of
1183 // the backoff mechanism anyway.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001184
1185 SetUpdateCheckAllowed(false);
1186
1187 // Override specific device policy attributes.
1188 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1189 new bool(false));
1190
1191 // Check that the UpdateCanStart returns false.
1192 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001193 UpdateDownloadParams result;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001194 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1195 update_state);
1196 EXPECT_FALSE(result.update_can_start);
1197 EXPECT_EQ(UpdateCannotStartReason::kCannotDownload,
1198 result.cannot_start_reason);
1199 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001200}
1201
1202TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoUsableUrlsButP2PEnabled) {
1203 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1204 // use is forbidden by policy, however P2P is enabled. The result indicates
1205 // that no URL can be used.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001206 //
1207 // Note: The number of failed attempts should not increase in this case (see
1208 // above test).
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001209
1210 SetUpdateCheckAllowed(false);
1211
1212 // Override specific device policy attributes.
1213 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1214 new bool(true));
1215 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1216 new bool(false));
1217
1218 // Check that the UpdateCanStart returns true.
1219 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001220 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001221 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001222 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001223 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001224 EXPECT_TRUE(result.p2p_downloading_allowed);
1225 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001226 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001227 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001228 EXPECT_EQ(0, result.download_url_num_errors);
1229 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001230}
1231
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001232TEST_F(UmChromeOSPolicyTest,
1233 UpdateCanStartAllowedNoUsableUrlsButEnterpriseEnrolled) {
1234 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1235 // use is forbidden by policy, and P2P is unset on the policy, however the
1236 // device is enterprise-enrolled so P2P is allowed. The result indicates that
1237 // no URL can be used.
1238 //
1239 // Note: The number of failed attempts should not increase in this case (see
1240 // above test).
1241
1242 SetUpdateCheckAllowed(false);
1243
1244 // Override specific device policy attributes.
1245 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
1246 fake_state_.device_policy_provider()->var_owner()->reset(nullptr);
1247 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1248 new bool(false));
1249
1250 // Check that the UpdateCanStart returns true.
1251 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1252 UpdateDownloadParams result;
1253 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1254 update_state);
1255 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001256 EXPECT_TRUE(result.p2p_downloading_allowed);
1257 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001258 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001259 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001260 EXPECT_EQ(0, result.download_url_num_errors);
1261 EXPECT_FALSE(result.do_increment_failures);
1262}
1263
Gilad Arnold684219d2014-07-07 14:54:57 -07001264TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedEthernetDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001265 // Ethernet is always allowed.
1266
1267 fake_state_.shill_provider()->var_conn_type()->
1268 reset(new ConnectionType(ConnectionType::kEthernet));
1269
1270 bool result;
1271 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001272 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001273 EXPECT_TRUE(result);
1274}
1275
Gilad Arnold684219d2014-07-07 14:54:57 -07001276TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWifiDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001277 // Wifi is allowed if not tethered.
1278
1279 fake_state_.shill_provider()->var_conn_type()->
1280 reset(new ConnectionType(ConnectionType::kWifi));
1281
1282 bool result;
1283 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001284 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001285 EXPECT_TRUE(result);
1286}
1287
Alex Deymo63784a52014-05-28 10:46:14 -07001288TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001289 UpdateCurrentConnectionNotAllowedWifiTetheredDefault) {
1290 // Tethered wifi is not allowed by default.
1291
1292 fake_state_.shill_provider()->var_conn_type()->
1293 reset(new ConnectionType(ConnectionType::kWifi));
1294 fake_state_.shill_provider()->var_conn_tethering()->
1295 reset(new ConnectionTethering(ConnectionTethering::kConfirmed));
1296
1297 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001298 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001299 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001300}
1301
Alex Deymo63784a52014-05-28 10:46:14 -07001302TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001303 UpdateDownloadAllowedWifiTetheredPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001304 // Tethered wifi can be allowed by policy.
1305
1306 fake_state_.shill_provider()->var_conn_type()->
1307 reset(new ConnectionType(ConnectionType::kWifi));
1308 fake_state_.shill_provider()->var_conn_tethering()->
1309 reset(new ConnectionTethering(ConnectionTethering::kConfirmed));
1310 set<ConnectionType> allowed_connections;
1311 allowed_connections.insert(ConnectionType::kCellular);
1312 fake_state_.device_policy_provider()->
1313 var_allowed_connection_types_for_update()->
1314 reset(new set<ConnectionType>(allowed_connections));
1315
1316 bool result;
1317 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001318 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001319 EXPECT_TRUE(result);
1320}
1321
Gilad Arnold684219d2014-07-07 14:54:57 -07001322TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWimaxDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001323 // Wimax is always allowed.
1324
1325 fake_state_.shill_provider()->var_conn_type()->
1326 reset(new ConnectionType(ConnectionType::kWifi));
1327
1328 bool result;
1329 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001330 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001331 EXPECT_TRUE(result);
1332}
1333
Alex Deymo63784a52014-05-28 10:46:14 -07001334TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001335 UpdateCurrentConnectionNotAllowedBluetoothDefault) {
1336 // Bluetooth is never allowed.
1337
1338 fake_state_.shill_provider()->var_conn_type()->
1339 reset(new ConnectionType(ConnectionType::kBluetooth));
1340
1341 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001342 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001343 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001344}
1345
Alex Deymo63784a52014-05-28 10:46:14 -07001346TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001347 UpdateCurrentConnectionNotAllowedBluetoothPolicyCannotOverride) {
1348 // Bluetooth cannot be allowed even by policy.
1349
1350 fake_state_.shill_provider()->var_conn_type()->
1351 reset(new ConnectionType(ConnectionType::kBluetooth));
1352 set<ConnectionType> allowed_connections;
1353 allowed_connections.insert(ConnectionType::kBluetooth);
1354 fake_state_.device_policy_provider()->
1355 var_allowed_connection_types_for_update()->
1356 reset(new set<ConnectionType>(allowed_connections));
1357
1358 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001359 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001360 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001361}
1362
Alex Deymo63784a52014-05-28 10:46:14 -07001363TEST_F(UmChromeOSPolicyTest, UpdateCurrentConnectionNotAllowedCellularDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001364 // Cellular is not allowed by default.
1365
1366 fake_state_.shill_provider()->var_conn_type()->
1367 reset(new ConnectionType(ConnectionType::kCellular));
1368
1369 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001370 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001371 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001372}
1373
Alex Deymo63784a52014-05-28 10:46:14 -07001374TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001375 UpdateDownloadAllowedCellularPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001376 // Update over cellular can be enabled by policy.
1377
1378 fake_state_.shill_provider()->var_conn_type()->
1379 reset(new ConnectionType(ConnectionType::kCellular));
1380 set<ConnectionType> allowed_connections;
1381 allowed_connections.insert(ConnectionType::kCellular);
1382 fake_state_.device_policy_provider()->
1383 var_allowed_connection_types_for_update()->
1384 reset(new set<ConnectionType>(allowed_connections));
1385
1386 bool result;
1387 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001388 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001389 EXPECT_TRUE(result);
1390}
1391
Alex Deymo63784a52014-05-28 10:46:14 -07001392TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001393 UpdateDownloadAllowedCellularUserOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001394 // Update over cellular can be enabled by user settings, but only if policy
1395 // is present and does not determine allowed connections.
1396
1397 fake_state_.shill_provider()->var_conn_type()->
1398 reset(new ConnectionType(ConnectionType::kCellular));
1399 set<ConnectionType> allowed_connections;
1400 allowed_connections.insert(ConnectionType::kCellular);
1401 fake_state_.updater_provider()->var_cellular_enabled()->
1402 reset(new bool(true));
1403
1404 bool result;
1405 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001406 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001407 EXPECT_TRUE(result);
1408}
1409
Gilad Arnold14a9e702014-10-08 08:09:09 -07001410TEST_F(UmChromeOSPolicyTest,
1411 UpdateCanStartAllowedScatteringSupressedDueToP2P) {
1412 // The UpdateCanStart policy returns true; scattering should have applied, but
1413 // P2P download is allowed. Scattering values are nonetheless returned, and so
1414 // are download URL values, albeit the latter are not allowed to be used.
1415
1416 SetUpdateCheckAllowed(false);
1417 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
1418 new TimeDelta(TimeDelta::FromMinutes(2)));
1419 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1420
1421 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
1422 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
1423
1424 UpdateDownloadParams result;
1425 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart,
1426 &result, update_state);
1427 EXPECT_TRUE(result.update_can_start);
1428 EXPECT_EQ(0, result.download_url_idx);
1429 EXPECT_FALSE(result.download_url_allowed);
1430 EXPECT_EQ(0, result.download_url_num_errors);
1431 EXPECT_TRUE(result.p2p_downloading_allowed);
1432 EXPECT_TRUE(result.p2p_sharing_allowed);
1433 EXPECT_FALSE(result.do_increment_failures);
1434 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
1435 EXPECT_EQ(0, result.scatter_check_threshold);
1436}
1437
1438TEST_F(UmChromeOSPolicyTest,
1439 UpdateCanStartAllowedBackoffSupressedDueToP2P) {
1440 // The UpdateCanStart policy returns true; backoff should have applied, but
1441 // P2P download is allowed. Backoff values are nonetheless returned, and so
1442 // are download URL values, albeit the latter are not allowed to be used.
1443
1444 SetUpdateCheckAllowed(false);
1445
1446 const Time curr_time = fake_clock_.GetWallclockTime();
1447 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
1448 update_state.download_errors_max = 1;
1449 update_state.download_errors.emplace_back(
1450 0, ErrorCode::kDownloadTransferError,
1451 curr_time - TimeDelta::FromSeconds(8));
1452 update_state.download_errors.emplace_back(
1453 0, ErrorCode::kDownloadTransferError,
1454 curr_time - TimeDelta::FromSeconds(2));
1455 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1456
1457 UpdateDownloadParams result;
1458 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1459 update_state);
1460 EXPECT_TRUE(result.update_can_start);
1461 EXPECT_EQ(0, result.download_url_idx);
1462 EXPECT_FALSE(result.download_url_allowed);
1463 EXPECT_EQ(0, result.download_url_num_errors);
1464 EXPECT_TRUE(result.p2p_downloading_allowed);
1465 EXPECT_TRUE(result.p2p_sharing_allowed);
1466 EXPECT_TRUE(result.do_increment_failures);
1467 EXPECT_LT(curr_time, result.backoff_expiry);
1468}
1469
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001470TEST_F(UmChromeOSPolicyTest, P2PEnabledNotAllowed) {
1471 bool result;
1472 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1473 EXPECT_FALSE(result);
1474}
1475
1476TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByDevicePolicy) {
1477 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1478 new bool(true));
1479
1480 bool result;
1481 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1482 EXPECT_TRUE(result);
1483}
1484
1485TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByUpdater) {
1486 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1487
1488 bool result;
1489 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1490 EXPECT_TRUE(result);
1491}
1492
1493TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedDeviceEnterpriseEnrolled) {
1494 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
1495 fake_state_.device_policy_provider()->var_owner()->reset(nullptr);
1496
1497 bool result;
1498 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1499 EXPECT_TRUE(result);
1500}
1501
1502TEST_F(UmChromeOSPolicyTest, P2PEnabledChangedBlocks) {
1503 bool result;
1504 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::P2PEnabledChanged,
1505 &result, false);
1506}
1507
Alex Deymo63784a52014-05-28 10:46:14 -07001508} // namespace chromeos_update_manager