blob: f97d4ed7be57e3df23bdfbc9dbac604d0b76558a [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"
Adolfo Victoria94ffe132018-06-28 16:14:56 -070024#include "update_engine/update_manager/weekly_time.h"
Alex Deymo0d11c602014-04-23 20:12:20 -070025
26using base::Time;
27using base::TimeDelta;
Sen Jiang255e22b2016-05-20 16:15:29 -070028using chromeos_update_engine::ConnectionTethering;
29using chromeos_update_engine::ConnectionType;
Gilad Arnoldb3b05442014-05-30 14:25:05 -070030using chromeos_update_engine::ErrorCode;
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -070031using chromeos_update_engine::InstallPlan;
Gilad Arnold0adbc942014-05-12 10:35:43 -070032using std::set;
Alex Deymo0d11c602014-04-23 20:12:20 -070033using std::string;
34
Alex Deymo63784a52014-05-28 10:46:14 -070035namespace chromeos_update_manager {
Alex Deymo0d11c602014-04-23 20:12:20 -070036
Amin Hassani186ff6a2018-02-27 11:06:03 -080037class UmChromeOSPolicyTest : public UmPolicyTestBase {
Alex Deymo0d11c602014-04-23 20:12:20 -070038 protected:
Amin Hassani186ff6a2018-02-27 11:06:03 -080039 UmChromeOSPolicyTest() : UmPolicyTestBase() {
40 policy_ = std::make_unique<ChromeOSPolicy>();
41 }
42
Alex Deymo610277e2014-11-11 21:18:11 -080043 void SetUp() override {
Amin Hassani186ff6a2018-02-27 11:06:03 -080044 UmPolicyTestBase::SetUp();
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070045 SetUpDefaultDevicePolicy();
Alex Deymo0d11c602014-04-23 20:12:20 -070046 }
47
Amin Hassani186ff6a2018-02-27 11:06:03 -080048 void SetUpDefaultState() override {
49 UmPolicyTestBase::SetUpDefaultState();
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070050
Gilad Arnolda1eabcd2014-07-09 15:42:40 -070051 // OOBE is enabled by default.
52 fake_state_.config_provider()->var_is_oobe_enabled()->reset(
53 new bool(true));
54
Gilad Arnold76a11f62014-05-20 09:02:12 -070055 // For the purpose of the tests, this is an official build and OOBE was
56 // completed.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070057 fake_state_.system_provider()->var_is_official_build()->reset(
58 new bool(true));
Gilad Arnold76a11f62014-05-20 09:02:12 -070059 fake_state_.system_provider()->var_is_oobe_complete()->reset(
60 new bool(true));
Aaron Woodc73fdc12017-12-06 11:09:15 -080061 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -070062 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(2));
Gilad Arnold0adbc942014-05-12 10:35:43 -070063
64 // Connection is wifi, untethered.
65 fake_state_.shill_provider()->var_conn_type()->
66 reset(new ConnectionType(ConnectionType::kWifi));
67 fake_state_.shill_provider()->var_conn_tethering()->
68 reset(new ConnectionTethering(ConnectionTethering::kNotDetected));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070069 }
70
Gilad Arnoldb3b05442014-05-30 14:25:05 -070071 // Sets up a default device policy that does not impose any restrictions
72 // (HTTP) nor enables any features (P2P).
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070073 void SetUpDefaultDevicePolicy() {
74 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
75 new bool(true));
76 fake_state_.device_policy_provider()->var_update_disabled()->reset(
77 new bool(false));
78 fake_state_.device_policy_provider()->
79 var_allowed_connection_types_for_update()->reset(nullptr);
80 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
81 new TimeDelta());
82 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
Gilad Arnoldb3b05442014-05-30 14:25:05 -070083 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070084 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
85 new bool(false));
86 fake_state_.device_policy_provider()->var_release_channel_delegated()->
87 reset(new bool(true));
Adolfo Victoria94ffe132018-06-28 16:14:56 -070088 fake_state_.device_policy_provider()
89 ->var_disallowed_time_intervals()
90 ->reset(new WeeklyTimeIntervalVector());
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070091 }
92
Amin Hassani186ff6a2018-02-27 11:06:03 -080093 // Configures the policy to return a desired value from UpdateCheckAllowed by
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070094 // faking the current wall clock time as needed. Restores the default state.
95 // This is used when testing policies that depend on this one.
Amin Hassani186ff6a2018-02-27 11:06:03 -080096 //
97 // Note that the default implementation relies on NextUpdateCheckPolicyImpl to
98 // set the FakeClock to the appropriate time.
99 virtual void SetUpdateCheckAllowed(bool allow_check) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700100 Time next_update_check;
Amin Hassani186ff6a2018-02-27 11:06:03 -0800101 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
102 &next_update_check,
103 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700104 SetUpDefaultState();
105 SetUpDefaultDevicePolicy();
106 Time curr_time = next_update_check;
107 if (allow_check)
108 curr_time += TimeDelta::FromSeconds(1);
109 else
110 curr_time -= TimeDelta::FromSeconds(1);
111 fake_clock_.SetWallclockTime(curr_time);
112 }
Marton Hunyady8b936f22018-06-15 16:44:37 +0200113
114 // Sets the policies required for a kiosk app to control Chrome OS version:
115 // - AllowKioskAppControlChromeVersion = True
116 // - UpdateDisabled = True
117 // In the kiosk app manifest:
118 // - RequiredPlatformVersion = 1234.
119 void SetKioskAppControlsChromeOsVersion() {
120 fake_state_.device_policy_provider()
121 ->var_allow_kiosk_app_control_chrome_version()
122 ->reset(new bool(true));
123 fake_state_.device_policy_provider()->var_update_disabled()->reset(
124 new bool(true));
125 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
126 new string("1234."));
127 }
128
129 // Sets up a test with the value of RollbackToTargetVersion policy (and
130 // whether it's set), and returns the value of
131 // UpdateCheckParams.rollback_allowed.
132 bool TestRollbackAllowed(bool set_policy,
133 RollbackToTargetVersion rollback_to_target_version) {
134 // Update check is allowed, response includes attributes for use in the
135 // request.
136 SetUpdateCheckAllowed(true);
137
138 if (set_policy) {
139 // Override RollbackToTargetVersion device policy attribute.
140 fake_state_.device_policy_provider()
141 ->var_rollback_to_target_version()
142 ->reset(new RollbackToTargetVersion(rollback_to_target_version));
143 }
144
145 UpdateCheckParams result;
146 ExpectPolicyStatus(
147 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
148 return result.rollback_allowed;
149 }
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700150
151 // Sets up a test with the given intervals and the current fake wallclock
152 // time.
153 void TestDisallowedTimeIntervals(const WeeklyTimeIntervalVector& intervals,
Adolfo Victoria7a7a0822018-07-27 13:35:24 -0700154 const ErrorCode& expected_error_code,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -0700155 bool kiosk) {
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700156 SetUpDefaultTimeProvider();
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -0700157 if (kiosk)
158 fake_state_.device_policy_provider()
159 ->var_auto_launched_kiosk_app_id()
160 ->reset(new string("myapp"));
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700161 fake_state_.device_policy_provider()
162 ->var_disallowed_time_intervals()
163 ->reset(new WeeklyTimeIntervalVector(intervals));
164
165 // Check that |expected_status| matches the value of UpdateCheckAllowed
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -0700166 ErrorCode result;
167 InstallPlan install_plan;
Adolfo Victoria7a7a0822018-07-27 13:35:24 -0700168 ExpectPolicyStatus(EvalStatus::kSucceeded,
169 &Policy::UpdateCanBeApplied,
170 &result,
171 &install_plan);
172 EXPECT_EQ(result, expected_error_code);
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700173 }
Alex Deymo0d11c602014-04-23 20:12:20 -0700174};
175
Alex Deymo63784a52014-05-28 10:46:14 -0700176TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForTheTimeout) {
Alex Deymo0d11c602014-04-23 20:12:20 -0700177 // We get the next update_check timestamp from the policy's private method
178 // and then we check the public method respects that value on the normal
179 // case.
180 Time next_update_check;
181 Time last_checked_time =
182 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
183
Alex Deymo0d11c602014-04-23 20:12:20 -0700184 fake_state_.updater_provider()->var_last_checked_time()->reset(
185 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800186 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
187 &next_update_check,
188 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Alex Deymo0d11c602014-04-23 20:12:20 -0700189
190 UpdateCheckParams result;
191
192 // Check that the policy blocks until the next_update_check is reached.
193 SetUpDefaultClock();
194 SetUpDefaultState();
195 fake_state_.updater_provider()->var_last_checked_time()->reset(
196 new Time(last_checked_time));
197 fake_clock_.SetWallclockTime(next_update_check - TimeDelta::FromSeconds(1));
198 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
199 &Policy::UpdateCheckAllowed, &result);
200
201 SetUpDefaultClock();
202 SetUpDefaultState();
203 fake_state_.updater_provider()->var_last_checked_time()->reset(
204 new Time(last_checked_time));
205 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
206 ExpectPolicyStatus(EvalStatus::kSucceeded,
207 &Policy::UpdateCheckAllowed, &result);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700208 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700209 EXPECT_FALSE(result.interactive);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700210}
211
212TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForOOBE) {
Alex Vakulenko072359c2014-07-18 11:41:07 -0700213 // Update checks are deferred until OOBE is completed.
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700214
215 // Ensure that update is not allowed even if wait period is satisfied.
216 Time next_update_check;
217 Time last_checked_time =
218 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
219
220 fake_state_.updater_provider()->var_last_checked_time()->reset(
221 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800222 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
223 &next_update_check,
224 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700225
226 SetUpDefaultClock();
227 SetUpDefaultState();
228 fake_state_.updater_provider()->var_last_checked_time()->reset(
229 new Time(last_checked_time));
230 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
231 fake_state_.system_provider()->var_is_oobe_complete()->reset(
232 new bool(false));
233
234 UpdateCheckParams result;
235 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
236 &Policy::UpdateCheckAllowed, &result);
237
238 // Now check that it is allowed if OOBE is completed.
239 SetUpDefaultClock();
240 SetUpDefaultState();
241 fake_state_.updater_provider()->var_last_checked_time()->reset(
242 new Time(last_checked_time));
243 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
244 ExpectPolicyStatus(EvalStatus::kSucceeded,
245 &Policy::UpdateCheckAllowed, &result);
246 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700247 EXPECT_FALSE(result.interactive);
Alex Deymo0d11c602014-04-23 20:12:20 -0700248}
249
Gilad Arnold42f253b2014-06-25 12:39:17 -0700250TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWithAttributes) {
Alex Vakulenko072359c2014-07-18 11:41:07 -0700251 // Update check is allowed, response includes attributes for use in the
Gilad Arnold42f253b2014-06-25 12:39:17 -0700252 // request.
253 SetUpdateCheckAllowed(true);
254
255 // Override specific device policy attributes.
Gilad Arnoldd4b30322014-07-21 15:35:27 -0700256 fake_state_.device_policy_provider()->var_target_version_prefix()->
257 reset(new string("1.2"));
Marton Hunyady0e0e3542018-02-21 18:51:39 +0100258 fake_state_.device_policy_provider()
259 ->var_rollback_allowed_milestones()
260 ->reset(new int(5));
261 fake_state_.device_policy_provider()->var_release_channel_delegated()->reset(
262 new bool(false));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700263 fake_state_.device_policy_provider()->var_release_channel()->
264 reset(new string("foo-channel"));
265
266 UpdateCheckParams result;
267 ExpectPolicyStatus(EvalStatus::kSucceeded,
268 &Policy::UpdateCheckAllowed, &result);
269 EXPECT_TRUE(result.updates_enabled);
Gilad Arnoldd4b30322014-07-21 15:35:27 -0700270 EXPECT_EQ("1.2", result.target_version_prefix);
Marton Hunyady0e0e3542018-02-21 18:51:39 +0100271 EXPECT_EQ(5, result.rollback_allowed_milestones);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700272 EXPECT_EQ("foo-channel", result.target_channel);
Amin Hassanied37d682018-04-06 13:22:00 -0700273 EXPECT_FALSE(result.interactive);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700274}
275
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200276TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackAllowed) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200277 EXPECT_TRUE(TestRollbackAllowed(
278 true, RollbackToTargetVersion::kRollbackWithFullPowerwash));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200279}
280
Marton Hunyady31aefb92018-08-29 16:17:03 +0200281TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackAndRestoreIfPossible) {
282 // We're doing rollback even if we don't support data save and restore.
283 EXPECT_TRUE(TestRollbackAllowed(
284 true, RollbackToTargetVersion::kRollbackAndRestoreIfPossible));
285}
286
287TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackWithRestoreOnly) {
288 // We're not allowed to do rollback until we support data save and restore.
289 EXPECT_FALSE(TestRollbackAllowed(
290 true, RollbackToTargetVersion::kRollbackWithRestoreOnly));
291}
292
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200293TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackDisabled) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200294 EXPECT_FALSE(TestRollbackAllowed(true, RollbackToTargetVersion::kDisabled));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200295}
296
297TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackUnspecified) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200298 EXPECT_FALSE(
299 TestRollbackAllowed(true, RollbackToTargetVersion::kUnspecified));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200300}
301
302TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackNotSet) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200303 EXPECT_FALSE(
304 TestRollbackAllowed(false, RollbackToTargetVersion::kUnspecified));
305}
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200306
Marton Hunyady8b936f22018-06-15 16:44:37 +0200307TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackAllowed) {
308 SetKioskAppControlsChromeOsVersion();
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200309
Marton Hunyady8b936f22018-06-15 16:44:37 +0200310 EXPECT_TRUE(TestRollbackAllowed(
311 true, RollbackToTargetVersion::kRollbackWithFullPowerwash));
312}
313
314TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackDisabled) {
315 SetKioskAppControlsChromeOsVersion();
316
317 EXPECT_FALSE(TestRollbackAllowed(true, RollbackToTargetVersion::kDisabled));
318}
319
320TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackUnspecified) {
321 SetKioskAppControlsChromeOsVersion();
322
323 EXPECT_FALSE(
324 TestRollbackAllowed(true, RollbackToTargetVersion::kUnspecified));
325}
326
327TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackNotSet) {
328 SetKioskAppControlsChromeOsVersion();
329
330 EXPECT_FALSE(
331 TestRollbackAllowed(false, RollbackToTargetVersion::kUnspecified));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200332}
333
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700334TEST_F(UmChromeOSPolicyTest,
335 UpdateCheckAllowedUpdatesDisabledForUnofficialBuilds) {
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700336 // UpdateCheckAllowed should return kAskMeAgainLater if this is an unofficial
337 // build; we don't want periodic update checks on developer images.
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700338
339 fake_state_.system_provider()->var_is_official_build()->reset(
340 new bool(false));
341
342 UpdateCheckParams result;
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700343 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700344 &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700345}
346
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700347TEST_F(UmChromeOSPolicyTest,
Aaron Wood56d8ab32017-09-22 15:56:18 -0700348 UpdateCheckAllowedUpdatesDisabledWhenNotEnoughSlotsAbUpdates) {
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700349 // UpdateCheckAllowed should return false (kSucceeded) if the image booted
Aaron Wood56d8ab32017-09-22 15:56:18 -0700350 // without enough slots to do A/B updates.
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700351
Aaron Woodc73fdc12017-12-06 11:09:15 -0800352 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -0700353 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(1));
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700354
355 UpdateCheckParams result;
356 ExpectPolicyStatus(EvalStatus::kSucceeded,
357 &Policy::UpdateCheckAllowed, &result);
358 EXPECT_FALSE(result.updates_enabled);
359}
360
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700361TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedUpdatesDisabledByPolicy) {
Gilad Arnold42f253b2014-06-25 12:39:17 -0700362 // UpdateCheckAllowed should return kAskMeAgainLater because a device policy
363 // is loaded and prohibits updates.
364
365 SetUpdateCheckAllowed(false);
366 fake_state_.device_policy_provider()->var_update_disabled()->reset(
367 new bool(true));
368
Gilad Arnold42f253b2014-06-25 12:39:17 -0700369 UpdateCheckParams result;
370 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
371 &Policy::UpdateCheckAllowed, &result);
372}
373
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700374TEST_F(UmChromeOSPolicyTest,
375 UpdateCheckAllowedForcedUpdateRequestedInteractive) {
376 // UpdateCheckAllowed should return true because a forced update request was
377 // signaled for an interactive update.
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700378
379 SetUpdateCheckAllowed(true);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700380 fake_state_.updater_provider()->var_forced_update_requested()->reset(
381 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700382
383 UpdateCheckParams result;
384 ExpectPolicyStatus(EvalStatus::kSucceeded,
385 &Policy::UpdateCheckAllowed, &result);
386 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700387 EXPECT_TRUE(result.interactive);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700388}
389
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700390TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedForcedUpdateRequestedPeriodic) {
391 // UpdateCheckAllowed should return true because a forced update request was
392 // signaled for a periodic check.
393
394 SetUpdateCheckAllowed(true);
395 fake_state_.updater_provider()->var_forced_update_requested()->reset(
396 new UpdateRequestStatus(UpdateRequestStatus::kPeriodic));
397
398 UpdateCheckParams result;
399 ExpectPolicyStatus(EvalStatus::kSucceeded,
400 &Policy::UpdateCheckAllowed, &result);
401 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700402 EXPECT_FALSE(result.interactive);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700403}
404
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800405TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPin) {
406 // Update check is allowed.
407 SetUpdateCheckAllowed(true);
408
Marton Hunyady8b936f22018-06-15 16:44:37 +0200409 SetKioskAppControlsChromeOsVersion();
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800410
411 UpdateCheckParams result;
412 ExpectPolicyStatus(EvalStatus::kSucceeded,
413 &Policy::UpdateCheckAllowed, &result);
414 EXPECT_TRUE(result.updates_enabled);
Marton Hunyady8b936f22018-06-15 16:44:37 +0200415 EXPECT_EQ("1234.", result.target_version_prefix);
Amin Hassanied37d682018-04-06 13:22:00 -0700416 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800417}
418
419TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedDisabledWhenNoKioskPin) {
420 // Update check is allowed.
421 SetUpdateCheckAllowed(true);
422
423 // Disable AU policy is set but kiosk pin policy is set to false. Update is
424 // disabled in such case.
425 fake_state_.device_policy_provider()->var_update_disabled()->reset(
426 new bool(true));
427 fake_state_.device_policy_provider()
428 ->var_allow_kiosk_app_control_chrome_version()
429 ->reset(new bool(false));
430
431 UpdateCheckParams result;
432 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
433 &Policy::UpdateCheckAllowed, &result);
434}
435
436TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPinWithNoRequiredVersion) {
437 // Update check is allowed.
438 SetUpdateCheckAllowed(true);
439
440 // AU disabled, allow kiosk to pin but there is no kiosk required platform
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700441 // version (i.e. app does not provide the info). Update to latest in such
442 // case.
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800443 fake_state_.device_policy_provider()->var_update_disabled()->reset(
444 new bool(true));
445 fake_state_.device_policy_provider()
446 ->var_allow_kiosk_app_control_chrome_version()
447 ->reset(new bool(true));
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700448 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
449 new string());
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800450
451 UpdateCheckParams result;
452 ExpectPolicyStatus(EvalStatus::kSucceeded,
453 &Policy::UpdateCheckAllowed, &result);
454 EXPECT_TRUE(result.updates_enabled);
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700455 EXPECT_TRUE(result.target_version_prefix.empty());
Amin Hassanied37d682018-04-06 13:22:00 -0700456 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800457}
458
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700459TEST_F(UmChromeOSPolicyTest,
460 UpdateCheckAllowedKioskPinWithFailedGetRequiredVersionCall) {
461 // AU disabled, allow kiosk to pin but D-Bus call to get required platform
462 // version failed. Defer update check in this case.
463 fake_state_.device_policy_provider()->var_update_disabled()->reset(
464 new bool(true));
465 fake_state_.device_policy_provider()
466 ->var_allow_kiosk_app_control_chrome_version()
467 ->reset(new bool(true));
468 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
469 nullptr);
470
471 UpdateCheckParams result;
472 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
473 &Policy::UpdateCheckAllowed, &result);
474}
475
Alex Deymo63784a52014-05-28 10:46:14 -0700476TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsCheckAllowedError) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700477 // The UpdateCanStart policy fails, not being able to query
478 // UpdateCheckAllowed.
479
480 // Configure the UpdateCheckAllowed policy to fail.
481 fake_state_.updater_provider()->var_updater_started_time()->reset(nullptr);
482
483 // Check that the UpdateCanStart fails.
484 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700485 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700486 ExpectPolicyStatus(EvalStatus::kFailed,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700487 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700488}
489
Alex Deymo63784a52014-05-28 10:46:14 -0700490TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedCheckDue) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700491 // The UpdateCanStart policy returns false because we are due for another
Gilad Arnold14a9e702014-10-08 08:09:09 -0700492 // update check. Ensure that download related values are still returned.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700493
494 SetUpdateCheckAllowed(true);
495
496 // Check that the UpdateCanStart returns false.
497 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700498 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700499 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700500 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700501 EXPECT_FALSE(result.update_can_start);
502 EXPECT_EQ(UpdateCannotStartReason::kCheckDue, result.cannot_start_reason);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700503 EXPECT_EQ(0, result.download_url_idx);
504 EXPECT_EQ(0, result.download_url_num_errors);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700505}
506
Alex Deymo63784a52014-05-28 10:46:14 -0700507TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoDevicePolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700508 // The UpdateCanStart policy returns true; no device policy is loaded.
509
510 SetUpdateCheckAllowed(false);
511 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
512 new bool(false));
513
514 // Check that the UpdateCanStart returns true with no further attributes.
515 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700516 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700517 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700518 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700519 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700520 EXPECT_FALSE(result.p2p_downloading_allowed);
521 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700522 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700523 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700524 EXPECT_EQ(0, result.download_url_num_errors);
525 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700526}
527
Alex Deymo63784a52014-05-28 10:46:14 -0700528TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBlankPolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700529 // The UpdateCanStart policy returns true; device policy is loaded but imposes
530 // no restrictions on updating.
531
532 SetUpdateCheckAllowed(false);
533
534 // Check that the UpdateCanStart returns true.
535 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700536 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700537 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700538 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700539 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700540 EXPECT_FALSE(result.p2p_downloading_allowed);
541 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700542 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700543 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700544 EXPECT_EQ(0, result.download_url_num_errors);
545 EXPECT_FALSE(result.do_increment_failures);
546}
547
548TEST_F(UmChromeOSPolicyTest,
549 UpdateCanStartNotAllowedBackoffNewWaitPeriodApplies) {
550 // The UpdateCanStart policy returns false; failures are reported and a new
551 // backoff period is enacted.
552
553 SetUpdateCheckAllowed(false);
554
555 const Time curr_time = fake_clock_.GetWallclockTime();
556 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
557 update_state.download_errors_max = 1;
558 update_state.download_errors.emplace_back(
559 0, ErrorCode::kDownloadTransferError,
560 curr_time - TimeDelta::FromSeconds(8));
561 update_state.download_errors.emplace_back(
562 0, ErrorCode::kDownloadTransferError,
563 curr_time - TimeDelta::FromSeconds(2));
564
565 // Check that UpdateCanStart returns false and a new backoff expiry is
566 // generated.
567 UpdateDownloadParams result;
568 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
569 update_state);
570 EXPECT_FALSE(result.update_can_start);
571 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
572 EXPECT_TRUE(result.do_increment_failures);
573 EXPECT_LT(curr_time, result.backoff_expiry);
574}
575
576TEST_F(UmChromeOSPolicyTest,
577 UpdateCanStartNotAllowedBackoffPrevWaitPeriodStillApplies) {
578 // The UpdateCanStart policy returns false; a previously enacted backoff
579 // period still applies.
580
581 SetUpdateCheckAllowed(false);
582
583 const Time curr_time = fake_clock_.GetWallclockTime();
584 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
585 update_state.download_errors_max = 1;
586 update_state.download_errors.emplace_back(
587 0, ErrorCode::kDownloadTransferError,
588 curr_time - TimeDelta::FromSeconds(8));
589 update_state.download_errors.emplace_back(
590 0, ErrorCode::kDownloadTransferError,
591 curr_time - TimeDelta::FromSeconds(2));
592 update_state.failures_last_updated = curr_time;
593 update_state.backoff_expiry = curr_time + TimeDelta::FromMinutes(3);
594
595 // Check that UpdateCanStart returns false and a new backoff expiry is
596 // generated.
597 UpdateDownloadParams result;
598 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::UpdateCanStart,
599 &result, update_state);
600 EXPECT_FALSE(result.update_can_start);
601 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
602 EXPECT_FALSE(result.do_increment_failures);
603 EXPECT_LT(curr_time, result.backoff_expiry);
604}
605
606TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffSatisfied) {
607 // The UpdateCanStart policy returns true; a previously enacted backoff period
608 // has elapsed, we're good to go.
609
610 SetUpdateCheckAllowed(false);
611
612 const Time curr_time = fake_clock_.GetWallclockTime();
613 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
614 update_state.download_errors_max = 1;
615 update_state.download_errors.emplace_back(
616 0, ErrorCode::kDownloadTransferError,
617 curr_time - TimeDelta::FromSeconds(8));
618 update_state.download_errors.emplace_back(
619 0, ErrorCode::kDownloadTransferError,
620 curr_time - TimeDelta::FromSeconds(2));
621 update_state.failures_last_updated = curr_time - TimeDelta::FromSeconds(1);
622 update_state.backoff_expiry = curr_time - TimeDelta::FromSeconds(1);
623
624 // Check that UpdateCanStart returns false and a new backoff expiry is
625 // generated.
626 UpdateDownloadParams result;
627 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart,
628 &result, update_state);
629 EXPECT_TRUE(result.update_can_start);
630 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
631 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700632 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700633 EXPECT_EQ(0, result.download_url_num_errors);
634 EXPECT_FALSE(result.do_increment_failures);
635 EXPECT_EQ(Time(), result.backoff_expiry);
636}
637
638TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffDisabled) {
639 // The UpdateCanStart policy returns false; failures are reported but backoff
640 // is disabled.
641
642 SetUpdateCheckAllowed(false);
643
644 const Time curr_time = fake_clock_.GetWallclockTime();
645 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
646 update_state.download_errors_max = 1;
647 update_state.download_errors.emplace_back(
648 0, ErrorCode::kDownloadTransferError,
649 curr_time - TimeDelta::FromSeconds(8));
650 update_state.download_errors.emplace_back(
651 0, ErrorCode::kDownloadTransferError,
652 curr_time - TimeDelta::FromSeconds(2));
653 update_state.is_backoff_disabled = true;
654
655 // Check that UpdateCanStart returns false and a new backoff expiry is
656 // generated.
657 UpdateDownloadParams result;
658 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
659 update_state);
660 EXPECT_TRUE(result.update_can_start);
661 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
662 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700663 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700664 EXPECT_EQ(0, result.download_url_num_errors);
665 EXPECT_TRUE(result.do_increment_failures);
666 EXPECT_EQ(Time(), result.backoff_expiry);
667}
668
669TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffInteractive) {
670 // The UpdateCanStart policy returns false; failures are reported but this is
671 // an interactive update check.
672
673 SetUpdateCheckAllowed(false);
674
675 const Time curr_time = fake_clock_.GetWallclockTime();
676 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
677 update_state.download_errors_max = 1;
678 update_state.download_errors.emplace_back(
679 0, ErrorCode::kDownloadTransferError,
680 curr_time - TimeDelta::FromSeconds(8));
681 update_state.download_errors.emplace_back(
682 0, ErrorCode::kDownloadTransferError,
683 curr_time - TimeDelta::FromSeconds(2));
Amin Hassanied37d682018-04-06 13:22:00 -0700684 update_state.interactive = true;
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700685
686 // Check that UpdateCanStart returns false and a new backoff expiry is
687 // generated.
688 UpdateDownloadParams result;
689 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
690 update_state);
691 EXPECT_TRUE(result.update_can_start);
692 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
693 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700694 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700695 EXPECT_EQ(0, result.download_url_num_errors);
696 EXPECT_TRUE(result.do_increment_failures);
697 EXPECT_EQ(Time(), result.backoff_expiry);
698}
699
700TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffDelta) {
701 // The UpdateCanStart policy returns false; failures are reported but this is
702 // a delta payload.
703
704 SetUpdateCheckAllowed(false);
705
706 const Time curr_time = fake_clock_.GetWallclockTime();
707 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
708 update_state.download_errors_max = 1;
709 update_state.download_errors.emplace_back(
710 0, ErrorCode::kDownloadTransferError,
711 curr_time - TimeDelta::FromSeconds(8));
712 update_state.download_errors.emplace_back(
713 0, ErrorCode::kDownloadTransferError,
714 curr_time - TimeDelta::FromSeconds(2));
715 update_state.is_delta_payload = true;
716
717 // Check that UpdateCanStart returns false and a new backoff expiry is
718 // generated.
719 UpdateDownloadParams result;
720 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
721 update_state);
722 EXPECT_TRUE(result.update_can_start);
723 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
724 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700725 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700726 EXPECT_EQ(0, result.download_url_num_errors);
727 EXPECT_TRUE(result.do_increment_failures);
728 EXPECT_EQ(Time(), result.backoff_expiry);
729}
730
731TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffUnofficialBuild) {
732 // The UpdateCanStart policy returns false; failures are reported but this is
733 // an unofficial build.
734
735 SetUpdateCheckAllowed(false);
736
737 const Time curr_time = fake_clock_.GetWallclockTime();
738 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
739 update_state.download_errors_max = 1;
740 update_state.download_errors.emplace_back(
741 0, ErrorCode::kDownloadTransferError,
742 curr_time - TimeDelta::FromSeconds(8));
743 update_state.download_errors.emplace_back(
744 0, ErrorCode::kDownloadTransferError,
745 curr_time - TimeDelta::FromSeconds(2));
746
747 fake_state_.system_provider()->var_is_official_build()->
748 reset(new bool(false));
749
750 // Check that UpdateCanStart returns false and a new backoff expiry is
751 // generated.
752 UpdateDownloadParams result;
753 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
754 update_state);
755 EXPECT_TRUE(result.update_can_start);
756 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
757 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700758 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700759 EXPECT_EQ(0, result.download_url_num_errors);
760 EXPECT_TRUE(result.do_increment_failures);
761 EXPECT_EQ(Time(), result.backoff_expiry);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700762}
763
Alex Deymo63784a52014-05-28 10:46:14 -0700764TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsScatteringFailed) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700765 // The UpdateCanStart policy fails because the UpdateScattering policy it
766 // depends on fails (unset variable).
767
768 SetUpdateCheckAllowed(false);
769
770 // Override the default seed variable with a null value so that the policy
771 // request would fail.
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700772 // TODO(garnold) This failure may or may not fail a number
773 // sub-policies/decisions, like scattering and backoff. We'll need a more
774 // deliberate setup to ensure that we're failing what we want to be failing.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700775 fake_state_.random_provider()->var_seed()->reset(nullptr);
776
777 // Check that the UpdateCanStart fails.
778 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700779 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700780 ExpectPolicyStatus(EvalStatus::kFailed,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700781 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700782}
783
Alex Deymo63784a52014-05-28 10:46:14 -0700784TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700785 UpdateCanStartNotAllowedScatteringNewWaitPeriodApplies) {
786 // The UpdateCanStart policy returns false; device policy is loaded and
787 // scattering applies due to an unsatisfied wait period, which was newly
788 // generated.
789
790 SetUpdateCheckAllowed(false);
791 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
792 new TimeDelta(TimeDelta::FromMinutes(2)));
793
794
795 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
796
797 // Check that the UpdateCanStart returns false and a new wait period
798 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700799 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700800 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700801 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700802 EXPECT_FALSE(result.update_can_start);
803 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
804 EXPECT_LT(TimeDelta(), result.scatter_wait_period);
805 EXPECT_EQ(0, result.scatter_check_threshold);
806}
807
Alex Deymo63784a52014-05-28 10:46:14 -0700808TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700809 UpdateCanStartNotAllowedScatteringPrevWaitPeriodStillApplies) {
810 // The UpdateCanStart policy returns false w/ kAskMeAgainLater; device policy
811 // is loaded and a previously generated scattering period still applies, none
812 // of the scattering values has changed.
813
814 SetUpdateCheckAllowed(false);
815 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
816 new TimeDelta(TimeDelta::FromMinutes(2)));
817
818 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
819 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
820
821 // Check that the UpdateCanStart returns false and a new wait period
822 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700823 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700824 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::UpdateCanStart,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700825 &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700826 EXPECT_FALSE(result.update_can_start);
827 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
828 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
829 EXPECT_EQ(0, result.scatter_check_threshold);
830}
831
Alex Deymo63784a52014-05-28 10:46:14 -0700832TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700833 UpdateCanStartNotAllowedScatteringNewCountThresholdApplies) {
834 // The UpdateCanStart policy returns false; device policy is loaded and
835 // scattering applies due to an unsatisfied update check count threshold.
836 //
837 // This ensures a non-zero check threshold, which may or may not be combined
838 // with a non-zero wait period (for which we cannot reliably control).
839
840 SetUpdateCheckAllowed(false);
841 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
842 new TimeDelta(TimeDelta::FromSeconds(1)));
843
844 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
845 update_state.scatter_check_threshold_min = 2;
846 update_state.scatter_check_threshold_max = 5;
847
848 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700849 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700850 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700851 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700852 EXPECT_FALSE(result.update_can_start);
853 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
854 EXPECT_LE(2, result.scatter_check_threshold);
855 EXPECT_GE(5, result.scatter_check_threshold);
856}
857
Alex Deymo63784a52014-05-28 10:46:14 -0700858TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700859 UpdateCanStartNotAllowedScatteringPrevCountThresholdStillApplies) {
860 // The UpdateCanStart policy returns false; device policy is loaded and
861 // scattering due to a previously generated count threshold still applies.
862
863 SetUpdateCheckAllowed(false);
864 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
865 new TimeDelta(TimeDelta::FromSeconds(1)));
866
867 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
868 update_state.scatter_check_threshold = 3;
869 update_state.scatter_check_threshold_min = 2;
870 update_state.scatter_check_threshold_max = 5;
871
872 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700873 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700874 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700875 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700876 EXPECT_FALSE(result.update_can_start);
877 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
878 EXPECT_EQ(3, result.scatter_check_threshold);
879}
880
Alex Deymo63784a52014-05-28 10:46:14 -0700881TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSatisfied) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700882 // The UpdateCanStart policy returns true; device policy is loaded and
883 // scattering is enabled, but both wait period and check threshold are
884 // satisfied.
885
886 SetUpdateCheckAllowed(false);
887 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
888 new TimeDelta(TimeDelta::FromSeconds(120)));
889
890 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(75));
891 update_state.num_checks = 4;
892 update_state.scatter_wait_period = TimeDelta::FromSeconds(60);
893 update_state.scatter_check_threshold = 3;
894 update_state.scatter_check_threshold_min = 2;
895 update_state.scatter_check_threshold_max = 5;
896
897 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700898 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700899 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700900 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700901 EXPECT_TRUE(result.update_can_start);
902 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
903 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700904 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700905 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700906 EXPECT_EQ(0, result.download_url_num_errors);
907 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700908}
909
Alex Deymo63784a52014-05-28 10:46:14 -0700910TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700911 UpdateCanStartAllowedInteractivePreventsScattering) {
912 // The UpdateCanStart policy returns true; device policy is loaded and
913 // scattering would have applied, except that the update check is interactive
914 // and so it is suppressed.
915
916 SetUpdateCheckAllowed(false);
917 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
918 new TimeDelta(TimeDelta::FromSeconds(1)));
919
920 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700921 update_state.interactive = true;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700922 update_state.scatter_check_threshold = 0;
923 update_state.scatter_check_threshold_min = 2;
924 update_state.scatter_check_threshold_max = 5;
925
926 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700927 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700928 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700929 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700930 EXPECT_TRUE(result.update_can_start);
931 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
932 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700933 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700934 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700935 EXPECT_EQ(0, result.download_url_num_errors);
936 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700937}
938
Alex Deymo63784a52014-05-28 10:46:14 -0700939TEST_F(UmChromeOSPolicyTest,
Gilad Arnold76a11f62014-05-20 09:02:12 -0700940 UpdateCanStartAllowedOobePreventsScattering) {
941 // The UpdateCanStart policy returns true; device policy is loaded and
942 // scattering would have applied, except that OOBE was not completed and so it
943 // is suppressed.
944
945 SetUpdateCheckAllowed(false);
946 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
947 new TimeDelta(TimeDelta::FromSeconds(1)));
948 fake_state_.system_provider()->var_is_oobe_complete()->reset(new bool(false));
949
950 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700951 update_state.interactive = true;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700952 update_state.scatter_check_threshold = 0;
953 update_state.scatter_check_threshold_min = 2;
954 update_state.scatter_check_threshold_max = 5;
955
956 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700957 UpdateDownloadParams result;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700958 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700959 update_state);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700960 EXPECT_TRUE(result.update_can_start);
961 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
962 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700963 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700964 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700965 EXPECT_EQ(0, result.download_url_num_errors);
966 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700967}
968
Alex Deymo63784a52014-05-28 10:46:14 -0700969TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithAttributes) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700970 // The UpdateCanStart policy returns true; device policy permits both HTTP and
971 // P2P updates, as well as a non-empty target channel string.
972
973 SetUpdateCheckAllowed(false);
974
975 // Override specific device policy attributes.
976 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
977 new bool(true));
978 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
979 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700980
981 // Check that the UpdateCanStart returns true.
982 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700983 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700984 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700985 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700986 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700987 EXPECT_TRUE(result.p2p_downloading_allowed);
988 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700989 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700990 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700991 EXPECT_EQ(0, result.download_url_num_errors);
992 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700993}
994
Alex Deymo63784a52014-05-28 10:46:14 -0700995TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithP2PFromUpdater) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700996 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
997 // P2P updates, but the updater is configured to allow P2P and overrules the
998 // setting.
999
1000 SetUpdateCheckAllowed(false);
1001
1002 // Override specific device policy attributes.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001003 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1004
1005 // Check that the UpdateCanStart returns true.
1006 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001007 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001008 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001009 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001010 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001011 EXPECT_TRUE(result.p2p_downloading_allowed);
1012 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001013 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001014 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001015 EXPECT_EQ(0, result.download_url_num_errors);
1016 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001017}
1018
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001019TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001020 UpdateCanStartAllowedP2PDownloadingBlockedDueToOmaha) {
1021 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1022 // policy blocks P2P downloading because Omaha forbids it. P2P sharing is
1023 // still permitted.
1024
1025 SetUpdateCheckAllowed(false);
1026
1027 // Override specific device policy attributes.
1028 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1029 new bool(true));
1030 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1031 new bool(true));
1032
1033 // Check that the UpdateCanStart returns true.
1034 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1035 update_state.p2p_downloading_disabled = true;
1036 UpdateDownloadParams result;
1037 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1038 update_state);
1039 EXPECT_TRUE(result.update_can_start);
1040 EXPECT_FALSE(result.p2p_downloading_allowed);
1041 EXPECT_TRUE(result.p2p_sharing_allowed);
1042}
1043
1044TEST_F(UmChromeOSPolicyTest,
1045 UpdateCanStartAllowedP2PSharingBlockedDueToOmaha) {
1046 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1047 // policy blocks P2P sharing because Omaha forbids it. P2P downloading is
1048 // still permitted.
1049
1050 SetUpdateCheckAllowed(false);
1051
1052 // Override specific device policy attributes.
1053 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1054 new bool(true));
1055 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1056 new bool(true));
1057
1058 // Check that the UpdateCanStart returns true.
1059 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1060 update_state.p2p_sharing_disabled = true;
1061 UpdateDownloadParams result;
1062 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1063 update_state);
1064 EXPECT_TRUE(result.update_can_start);
1065 EXPECT_TRUE(result.p2p_downloading_allowed);
1066 EXPECT_FALSE(result.p2p_sharing_allowed);
1067}
1068
1069TEST_F(UmChromeOSPolicyTest,
1070 UpdateCanStartAllowedP2PDownloadingBlockedDueToNumAttempts) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001071 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001072 // blocks P2P download, because the max number of P2P downloads have been
1073 // attempted. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001074
1075 SetUpdateCheckAllowed(false);
1076
1077 // Override specific device policy attributes.
1078 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1079 new bool(true));
1080 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1081 new bool(true));
1082
1083 // Check that the UpdateCanStart returns true.
1084 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1085 update_state.p2p_num_attempts = ChromeOSPolicy::kMaxP2PAttempts;
1086 UpdateDownloadParams result;
1087 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1088 update_state);
1089 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001090 EXPECT_FALSE(result.p2p_downloading_allowed);
1091 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001092}
1093
1094TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001095 UpdateCanStartAllowedP2PDownloadingBlockedDueToAttemptsPeriod) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001096 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001097 // blocks P2P download, because the max period for attempt to download via P2P
1098 // has elapsed. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001099
1100 SetUpdateCheckAllowed(false);
1101
1102 // Override specific device policy attributes.
1103 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1104 new bool(true));
1105 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1106 new bool(true));
1107
1108 // Check that the UpdateCanStart returns true.
1109 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1110 update_state.p2p_num_attempts = 1;
1111 update_state.p2p_first_attempted =
1112 fake_clock_.GetWallclockTime() -
Alex Deymof329b932014-10-30 01:37:48 -07001113 TimeDelta::FromSeconds(
1114 ChromeOSPolicy::kMaxP2PAttemptsPeriodInSeconds + 1);
Gilad Arnold349ac832014-10-06 14:20:28 -07001115 UpdateDownloadParams result;
1116 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1117 update_state);
1118 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001119 EXPECT_FALSE(result.p2p_downloading_allowed);
1120 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001121}
1122
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001123TEST_F(UmChromeOSPolicyTest,
1124 UpdateCanStartAllowedWithHttpUrlForUnofficialBuild) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001125 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1126 // P2P updates, but marking this an unofficial build overrules the HTTP
1127 // setting.
1128
1129 SetUpdateCheckAllowed(false);
1130
1131 // Override specific device policy attributes.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001132 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1133 new bool(false));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001134 fake_state_.system_provider()->var_is_official_build()->
1135 reset(new bool(false));
1136
1137 // Check that the UpdateCanStart returns true.
1138 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001139 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001140 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001141 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001142 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001143 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001144 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001145 EXPECT_EQ(0, result.download_url_num_errors);
1146 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001147}
1148
1149TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithHttpsUrl) {
1150 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1151 // P2P updates, but an HTTPS URL is provided and selected for download.
1152
1153 SetUpdateCheckAllowed(false);
1154
1155 // Override specific device policy attributes.
1156 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1157 new bool(false));
1158
1159 // Add an HTTPS URL.
1160 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001161 update_state.download_urls.emplace_back("https://secure/url/");
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001162
1163 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001164 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001165 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001166 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001167 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001168 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001169 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001170 EXPECT_EQ(0, result.download_url_num_errors);
1171 EXPECT_FALSE(result.do_increment_failures);
1172}
1173
1174TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedMaxErrorsNotExceeded) {
1175 // The UpdateCanStart policy returns true; the first URL has download errors
1176 // but does not exceed the maximum allowed number of failures, so it is stilli
1177 // usable.
1178
1179 SetUpdateCheckAllowed(false);
1180
1181 // Add a second URL; update with this URL attempted and failed enough times to
1182 // disqualify the current (first) URL.
1183 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1184 update_state.num_checks = 5;
1185 update_state.download_urls.emplace_back("http://another/fake/url/");
1186 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1187 for (int i = 0; i < 5; i++) {
1188 update_state.download_errors.emplace_back(
1189 0, ErrorCode::kDownloadTransferError, t);
1190 t += TimeDelta::FromSeconds(1);
1191 }
1192
1193 // Check that the UpdateCanStart returns true.
1194 UpdateDownloadParams result;
1195 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1196 update_state);
1197 EXPECT_TRUE(result.update_can_start);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001198 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001199 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001200 EXPECT_EQ(5, result.download_url_num_errors);
1201 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001202}
1203
1204TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlMaxExceeded) {
1205 // The UpdateCanStart policy returns true; the first URL exceeded the maximum
1206 // allowed number of failures, but a second URL is available.
1207
1208 SetUpdateCheckAllowed(false);
1209
1210 // Add a second URL; update with this URL attempted and failed enough times to
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001211 // disqualify the current (first) URL.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001212 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1213 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001214 update_state.download_urls.emplace_back("http://another/fake/url/");
1215 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1216 for (int i = 0; i < 11; i++) {
1217 update_state.download_errors.emplace_back(
1218 0, ErrorCode::kDownloadTransferError, t);
1219 t += TimeDelta::FromSeconds(1);
1220 }
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001221
1222 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001223 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001224 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001225 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001226 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001227 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001228 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001229 EXPECT_EQ(0, result.download_url_num_errors);
1230 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001231}
1232
1233TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlHardError) {
1234 // The UpdateCanStart policy returns true; the first URL fails with a hard
1235 // error, but a second URL is available.
1236
1237 SetUpdateCheckAllowed(false);
1238
1239 // Add a second URL; update with this URL attempted and failed in a way that
1240 // causes it to switch directly to the next URL.
1241 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1242 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001243 update_state.download_urls.emplace_back("http://another/fake/url/");
1244 update_state.download_errors.emplace_back(
1245 0, ErrorCode::kPayloadHashMismatchError,
1246 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001247
1248 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001249 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001250 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001251 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001252 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001253 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001254 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001255 EXPECT_EQ(0, result.download_url_num_errors);
1256 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001257}
1258
1259TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedUrlWrapsAround) {
1260 // The UpdateCanStart policy returns true; URL search properly wraps around
1261 // the last one on the list.
1262
1263 SetUpdateCheckAllowed(false);
1264
1265 // Add a second URL; update with this URL attempted and failed in a way that
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001266 // causes it to switch directly to the next URL. We must disable backoff in
1267 // order for it not to interfere.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001268 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001269 update_state.num_checks = 1;
1270 update_state.is_backoff_disabled = true;
1271 update_state.download_urls.emplace_back("http://another/fake/url/");
1272 update_state.download_errors.emplace_back(
1273 1, ErrorCode::kPayloadHashMismatchError,
1274 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001275
1276 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001277 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001278 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001279 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001280 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001281 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001282 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001283 EXPECT_EQ(0, result.download_url_num_errors);
1284 EXPECT_TRUE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001285}
1286
1287TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedNoUsableUrls) {
1288 // The UpdateCanStart policy returns false; there's a single HTTP URL but its
1289 // use is forbidden by policy.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001290 //
1291 // Note: In the case where no usable URLs are found, the policy should not
1292 // increment the number of failed attempts! Doing so would result in a
1293 // non-idempotent semantics, and does not fall within the intended purpose of
1294 // the backoff mechanism anyway.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001295
1296 SetUpdateCheckAllowed(false);
1297
1298 // Override specific device policy attributes.
1299 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1300 new bool(false));
1301
1302 // Check that the UpdateCanStart returns false.
1303 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001304 UpdateDownloadParams result;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001305 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1306 update_state);
1307 EXPECT_FALSE(result.update_can_start);
1308 EXPECT_EQ(UpdateCannotStartReason::kCannotDownload,
1309 result.cannot_start_reason);
1310 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001311}
1312
1313TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoUsableUrlsButP2PEnabled) {
1314 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1315 // use is forbidden by policy, however P2P is enabled. The result indicates
1316 // that no URL can be used.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001317 //
1318 // Note: The number of failed attempts should not increase in this case (see
1319 // above test).
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001320
1321 SetUpdateCheckAllowed(false);
1322
1323 // Override specific device policy attributes.
1324 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1325 new bool(true));
1326 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1327 new bool(false));
1328
1329 // Check that the UpdateCanStart returns true.
1330 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001331 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001332 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001333 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001334 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001335 EXPECT_TRUE(result.p2p_downloading_allowed);
1336 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001337 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001338 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001339 EXPECT_EQ(0, result.download_url_num_errors);
1340 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001341}
1342
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001343TEST_F(UmChromeOSPolicyTest,
1344 UpdateCanStartAllowedNoUsableUrlsButEnterpriseEnrolled) {
1345 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1346 // use is forbidden by policy, and P2P is unset on the policy, however the
1347 // device is enterprise-enrolled so P2P is allowed. The result indicates that
1348 // no URL can be used.
1349 //
1350 // Note: The number of failed attempts should not increase in this case (see
1351 // above test).
1352
1353 SetUpdateCheckAllowed(false);
1354
1355 // Override specific device policy attributes.
1356 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
1357 fake_state_.device_policy_provider()->var_owner()->reset(nullptr);
1358 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1359 new bool(false));
1360
1361 // Check that the UpdateCanStart returns true.
1362 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1363 UpdateDownloadParams result;
1364 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1365 update_state);
1366 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001367 EXPECT_TRUE(result.p2p_downloading_allowed);
1368 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001369 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001370 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001371 EXPECT_EQ(0, result.download_url_num_errors);
1372 EXPECT_FALSE(result.do_increment_failures);
1373}
1374
Gilad Arnold684219d2014-07-07 14:54:57 -07001375TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedEthernetDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001376 // Ethernet is always allowed.
1377
1378 fake_state_.shill_provider()->var_conn_type()->
1379 reset(new ConnectionType(ConnectionType::kEthernet));
1380
1381 bool result;
1382 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001383 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001384 EXPECT_TRUE(result);
1385}
1386
Gilad Arnold684219d2014-07-07 14:54:57 -07001387TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWifiDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001388 // Wifi is allowed if not tethered.
1389
1390 fake_state_.shill_provider()->var_conn_type()->
1391 reset(new ConnectionType(ConnectionType::kWifi));
1392
1393 bool result;
1394 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001395 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001396 EXPECT_TRUE(result);
1397}
1398
Alex Deymo63784a52014-05-28 10:46:14 -07001399TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001400 UpdateCurrentConnectionNotAllowedWifiTetheredDefault) {
1401 // Tethered wifi is not allowed by default.
1402
1403 fake_state_.shill_provider()->var_conn_type()->
1404 reset(new ConnectionType(ConnectionType::kWifi));
1405 fake_state_.shill_provider()->var_conn_tethering()->
1406 reset(new ConnectionTethering(ConnectionTethering::kConfirmed));
1407
1408 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001409 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001410 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001411}
1412
Alex Deymo63784a52014-05-28 10:46:14 -07001413TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001414 UpdateDownloadAllowedWifiTetheredPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001415 // Tethered wifi can be allowed by policy.
1416
1417 fake_state_.shill_provider()->var_conn_type()->
1418 reset(new ConnectionType(ConnectionType::kWifi));
1419 fake_state_.shill_provider()->var_conn_tethering()->
1420 reset(new ConnectionTethering(ConnectionTethering::kConfirmed));
1421 set<ConnectionType> allowed_connections;
1422 allowed_connections.insert(ConnectionType::kCellular);
1423 fake_state_.device_policy_provider()->
1424 var_allowed_connection_types_for_update()->
1425 reset(new set<ConnectionType>(allowed_connections));
1426
1427 bool result;
1428 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001429 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001430 EXPECT_TRUE(result);
1431}
1432
Gilad Arnold684219d2014-07-07 14:54:57 -07001433TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWimaxDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001434 // Wimax is always allowed.
1435
1436 fake_state_.shill_provider()->var_conn_type()->
1437 reset(new ConnectionType(ConnectionType::kWifi));
1438
1439 bool result;
1440 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001441 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001442 EXPECT_TRUE(result);
1443}
1444
Alex Deymo63784a52014-05-28 10:46:14 -07001445TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001446 UpdateCurrentConnectionNotAllowedBluetoothDefault) {
1447 // Bluetooth is never allowed.
1448
1449 fake_state_.shill_provider()->var_conn_type()->
1450 reset(new ConnectionType(ConnectionType::kBluetooth));
1451
1452 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001453 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001454 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001455}
1456
Alex Deymo63784a52014-05-28 10:46:14 -07001457TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001458 UpdateCurrentConnectionNotAllowedBluetoothPolicyCannotOverride) {
1459 // Bluetooth cannot be allowed even by policy.
1460
1461 fake_state_.shill_provider()->var_conn_type()->
1462 reset(new ConnectionType(ConnectionType::kBluetooth));
1463 set<ConnectionType> allowed_connections;
1464 allowed_connections.insert(ConnectionType::kBluetooth);
1465 fake_state_.device_policy_provider()->
1466 var_allowed_connection_types_for_update()->
1467 reset(new set<ConnectionType>(allowed_connections));
1468
1469 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001470 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001471 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001472}
1473
Alex Deymo63784a52014-05-28 10:46:14 -07001474TEST_F(UmChromeOSPolicyTest, UpdateCurrentConnectionNotAllowedCellularDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001475 // Cellular is not allowed by default.
1476
1477 fake_state_.shill_provider()->var_conn_type()->
1478 reset(new ConnectionType(ConnectionType::kCellular));
1479
1480 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001481 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001482 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001483}
1484
Alex Deymo63784a52014-05-28 10:46:14 -07001485TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001486 UpdateDownloadAllowedCellularPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001487 // Update over cellular can be enabled by policy.
1488
1489 fake_state_.shill_provider()->var_conn_type()->
1490 reset(new ConnectionType(ConnectionType::kCellular));
1491 set<ConnectionType> allowed_connections;
1492 allowed_connections.insert(ConnectionType::kCellular);
1493 fake_state_.device_policy_provider()->
1494 var_allowed_connection_types_for_update()->
1495 reset(new set<ConnectionType>(allowed_connections));
1496
1497 bool result;
1498 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001499 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001500 EXPECT_TRUE(result);
1501}
1502
Alex Deymo63784a52014-05-28 10:46:14 -07001503TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001504 UpdateDownloadAllowedCellularUserOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001505 // Update over cellular can be enabled by user settings, but only if policy
1506 // is present and does not determine allowed connections.
1507
1508 fake_state_.shill_provider()->var_conn_type()->
1509 reset(new ConnectionType(ConnectionType::kCellular));
1510 set<ConnectionType> allowed_connections;
1511 allowed_connections.insert(ConnectionType::kCellular);
1512 fake_state_.updater_provider()->var_cellular_enabled()->
1513 reset(new bool(true));
1514
1515 bool result;
1516 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001517 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001518 EXPECT_TRUE(result);
1519}
1520
Gilad Arnold14a9e702014-10-08 08:09:09 -07001521TEST_F(UmChromeOSPolicyTest,
1522 UpdateCanStartAllowedScatteringSupressedDueToP2P) {
1523 // The UpdateCanStart policy returns true; scattering should have applied, but
1524 // P2P download is allowed. Scattering values are nonetheless returned, and so
1525 // are download URL values, albeit the latter are not allowed to be used.
1526
1527 SetUpdateCheckAllowed(false);
1528 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
1529 new TimeDelta(TimeDelta::FromMinutes(2)));
1530 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1531
1532 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
1533 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
1534
1535 UpdateDownloadParams result;
1536 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart,
1537 &result, update_state);
1538 EXPECT_TRUE(result.update_can_start);
1539 EXPECT_EQ(0, result.download_url_idx);
1540 EXPECT_FALSE(result.download_url_allowed);
1541 EXPECT_EQ(0, result.download_url_num_errors);
1542 EXPECT_TRUE(result.p2p_downloading_allowed);
1543 EXPECT_TRUE(result.p2p_sharing_allowed);
1544 EXPECT_FALSE(result.do_increment_failures);
1545 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
1546 EXPECT_EQ(0, result.scatter_check_threshold);
1547}
1548
1549TEST_F(UmChromeOSPolicyTest,
1550 UpdateCanStartAllowedBackoffSupressedDueToP2P) {
1551 // The UpdateCanStart policy returns true; backoff should have applied, but
1552 // P2P download is allowed. Backoff values are nonetheless returned, and so
1553 // are download URL values, albeit the latter are not allowed to be used.
1554
1555 SetUpdateCheckAllowed(false);
1556
1557 const Time curr_time = fake_clock_.GetWallclockTime();
1558 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
1559 update_state.download_errors_max = 1;
1560 update_state.download_errors.emplace_back(
1561 0, ErrorCode::kDownloadTransferError,
1562 curr_time - TimeDelta::FromSeconds(8));
1563 update_state.download_errors.emplace_back(
1564 0, ErrorCode::kDownloadTransferError,
1565 curr_time - TimeDelta::FromSeconds(2));
1566 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1567
1568 UpdateDownloadParams result;
1569 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1570 update_state);
1571 EXPECT_TRUE(result.update_can_start);
1572 EXPECT_EQ(0, result.download_url_idx);
1573 EXPECT_FALSE(result.download_url_allowed);
1574 EXPECT_EQ(0, result.download_url_num_errors);
1575 EXPECT_TRUE(result.p2p_downloading_allowed);
1576 EXPECT_TRUE(result.p2p_sharing_allowed);
1577 EXPECT_TRUE(result.do_increment_failures);
1578 EXPECT_LT(curr_time, result.backoff_expiry);
1579}
1580
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001581TEST_F(UmChromeOSPolicyTest, P2PEnabledNotAllowed) {
1582 bool result;
1583 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1584 EXPECT_FALSE(result);
1585}
1586
1587TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByDevicePolicy) {
1588 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1589 new bool(true));
1590
1591 bool result;
1592 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1593 EXPECT_TRUE(result);
1594}
1595
1596TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByUpdater) {
1597 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1598
1599 bool result;
1600 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1601 EXPECT_TRUE(result);
1602}
1603
1604TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedDeviceEnterpriseEnrolled) {
1605 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
1606 fake_state_.device_policy_provider()->var_owner()->reset(nullptr);
1607
1608 bool result;
1609 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1610 EXPECT_TRUE(result);
1611}
1612
1613TEST_F(UmChromeOSPolicyTest, P2PEnabledChangedBlocks) {
1614 bool result;
1615 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::P2PEnabledChanged,
1616 &result, false);
1617}
1618
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001619TEST_F(UmChromeOSPolicyTest,
1620 UpdateCanBeAppliedForcedUpdatesDisablesTimeRestrictions) {
1621 Time curr_time = fake_clock_.GetWallclockTime();
1622 fake_state_.updater_provider()->var_forced_update_requested()->reset(
1623 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
1624 // Should return kAskMeAgainLater when updated are not forced.
1625 TestDisallowedTimeIntervals(
1626 {WeeklyTimeInterval(
1627 WeeklyTime::FromTime(curr_time),
1628 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001629 ErrorCode::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001630 /* kiosk = */ true);
1631}
1632
1633TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedFailsInDisallowedTime) {
1634 Time curr_time = fake_clock_.GetWallclockTime();
1635 TestDisallowedTimeIntervals(
1636 {WeeklyTimeInterval(
1637 WeeklyTime::FromTime(curr_time),
1638 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001639 ErrorCode::kOmahaUpdateDeferredPerPolicy,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001640 /* kiosk = */ true);
1641}
1642
1643TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedOutsideDisallowedTime) {
1644 Time curr_time = fake_clock_.GetWallclockTime();
1645 TestDisallowedTimeIntervals(
1646 {WeeklyTimeInterval(
1647 WeeklyTime::FromTime(curr_time - TimeDelta::FromHours(3)),
1648 WeeklyTime::FromTime(curr_time))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001649 ErrorCode::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001650 /* kiosk = */ true);
1651}
1652
1653TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedPassesOnNonKiosk) {
1654 Time curr_time = fake_clock_.GetWallclockTime();
1655 TestDisallowedTimeIntervals(
1656 {WeeklyTimeInterval(
1657 WeeklyTime::FromTime(curr_time),
1658 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001659 ErrorCode::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001660 /* kiosk = */ false);
1661}
1662
Alex Deymo63784a52014-05-28 10:46:14 -07001663} // namespace chromeos_update_manager