blob: 184c2414409ad0e2f88eeb8ba65e1d71bc2e29ae [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;
Gilad Arnold0adbc942014-05-12 10:35:43 -070031using std::set;
Alex Deymo0d11c602014-04-23 20:12:20 -070032using std::string;
33
Alex Deymo63784a52014-05-28 10:46:14 -070034namespace chromeos_update_manager {
Alex Deymo0d11c602014-04-23 20:12:20 -070035
Amin Hassani186ff6a2018-02-27 11:06:03 -080036class UmChromeOSPolicyTest : public UmPolicyTestBase {
Alex Deymo0d11c602014-04-23 20:12:20 -070037 protected:
Amin Hassani186ff6a2018-02-27 11:06:03 -080038 UmChromeOSPolicyTest() : UmPolicyTestBase() {
39 policy_ = std::make_unique<ChromeOSPolicy>();
40 }
41
Alex Deymo610277e2014-11-11 21:18:11 -080042 void SetUp() override {
Amin Hassani186ff6a2018-02-27 11:06:03 -080043 UmPolicyTestBase::SetUp();
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070044 SetUpDefaultDevicePolicy();
Alex Deymo0d11c602014-04-23 20:12:20 -070045 }
46
Amin Hassani186ff6a2018-02-27 11:06:03 -080047 void SetUpDefaultState() override {
48 UmPolicyTestBase::SetUpDefaultState();
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070049
Gilad Arnolda1eabcd2014-07-09 15:42:40 -070050 // OOBE is enabled by default.
51 fake_state_.config_provider()->var_is_oobe_enabled()->reset(
52 new bool(true));
53
Gilad Arnold76a11f62014-05-20 09:02:12 -070054 // For the purpose of the tests, this is an official build and OOBE was
55 // completed.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070056 fake_state_.system_provider()->var_is_official_build()->reset(
57 new bool(true));
Gilad Arnold76a11f62014-05-20 09:02:12 -070058 fake_state_.system_provider()->var_is_oobe_complete()->reset(
59 new bool(true));
Aaron Woodc73fdc12017-12-06 11:09:15 -080060 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -070061 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(2));
Gilad Arnold0adbc942014-05-12 10:35:43 -070062
63 // Connection is wifi, untethered.
64 fake_state_.shill_provider()->var_conn_type()->
65 reset(new ConnectionType(ConnectionType::kWifi));
66 fake_state_.shill_provider()->var_conn_tethering()->
67 reset(new ConnectionTethering(ConnectionTethering::kNotDetected));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070068 }
69
Gilad Arnoldb3b05442014-05-30 14:25:05 -070070 // Sets up a default device policy that does not impose any restrictions
71 // (HTTP) nor enables any features (P2P).
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070072 void SetUpDefaultDevicePolicy() {
73 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
74 new bool(true));
75 fake_state_.device_policy_provider()->var_update_disabled()->reset(
76 new bool(false));
77 fake_state_.device_policy_provider()->
78 var_allowed_connection_types_for_update()->reset(nullptr);
79 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
80 new TimeDelta());
81 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
Gilad Arnoldb3b05442014-05-30 14:25:05 -070082 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070083 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
84 new bool(false));
85 fake_state_.device_policy_provider()->var_release_channel_delegated()->
86 reset(new bool(true));
Adolfo Victoria94ffe132018-06-28 16:14:56 -070087 fake_state_.device_policy_provider()
88 ->var_disallowed_time_intervals()
89 ->reset(new WeeklyTimeIntervalVector());
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070090 }
91
Amin Hassani186ff6a2018-02-27 11:06:03 -080092 // Configures the policy to return a desired value from UpdateCheckAllowed by
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070093 // faking the current wall clock time as needed. Restores the default state.
94 // This is used when testing policies that depend on this one.
Amin Hassani186ff6a2018-02-27 11:06:03 -080095 //
96 // Note that the default implementation relies on NextUpdateCheckPolicyImpl to
97 // set the FakeClock to the appropriate time.
98 virtual void SetUpdateCheckAllowed(bool allow_check) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070099 Time next_update_check;
Amin Hassani186ff6a2018-02-27 11:06:03 -0800100 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
101 &next_update_check,
102 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700103 SetUpDefaultState();
104 SetUpDefaultDevicePolicy();
105 Time curr_time = next_update_check;
106 if (allow_check)
107 curr_time += TimeDelta::FromSeconds(1);
108 else
109 curr_time -= TimeDelta::FromSeconds(1);
110 fake_clock_.SetWallclockTime(curr_time);
111 }
Marton Hunyady8b936f22018-06-15 16:44:37 +0200112
113 // Sets the policies required for a kiosk app to control Chrome OS version:
114 // - AllowKioskAppControlChromeVersion = True
115 // - UpdateDisabled = True
116 // In the kiosk app manifest:
117 // - RequiredPlatformVersion = 1234.
118 void SetKioskAppControlsChromeOsVersion() {
119 fake_state_.device_policy_provider()
120 ->var_allow_kiosk_app_control_chrome_version()
121 ->reset(new bool(true));
122 fake_state_.device_policy_provider()->var_update_disabled()->reset(
123 new bool(true));
124 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
125 new string("1234."));
126 }
127
128 // Sets up a test with the value of RollbackToTargetVersion policy (and
129 // whether it's set), and returns the value of
130 // UpdateCheckParams.rollback_allowed.
131 bool TestRollbackAllowed(bool set_policy,
132 RollbackToTargetVersion rollback_to_target_version) {
133 // Update check is allowed, response includes attributes for use in the
134 // request.
135 SetUpdateCheckAllowed(true);
136
137 if (set_policy) {
138 // Override RollbackToTargetVersion device policy attribute.
139 fake_state_.device_policy_provider()
140 ->var_rollback_to_target_version()
141 ->reset(new RollbackToTargetVersion(rollback_to_target_version));
142 }
143
144 UpdateCheckParams result;
145 ExpectPolicyStatus(
146 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
147 return result.rollback_allowed;
148 }
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700149
150 // Sets up a test with the given intervals and the current fake wallclock
151 // time.
152 void TestDisallowedTimeIntervals(const WeeklyTimeIntervalVector& intervals,
153 const EvalStatus& expected_status,
154 bool is_forced_update) {
155 SetUpDefaultTimeProvider();
156 SetUpdateCheckAllowed(true);
157
158 if (is_forced_update)
159 fake_state_.updater_provider()->var_forced_update_requested()->reset(
160 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
161 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
166 UpdateCheckParams result;
167 ExpectPolicyStatus(expected_status, &Policy::UpdateCheckAllowed, &result);
168 }
Alex Deymo0d11c602014-04-23 20:12:20 -0700169};
170
Alex Deymo63784a52014-05-28 10:46:14 -0700171TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForTheTimeout) {
Alex Deymo0d11c602014-04-23 20:12:20 -0700172 // We get the next update_check timestamp from the policy's private method
173 // and then we check the public method respects that value on the normal
174 // case.
175 Time next_update_check;
176 Time last_checked_time =
177 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
178
Alex Deymo0d11c602014-04-23 20:12:20 -0700179 fake_state_.updater_provider()->var_last_checked_time()->reset(
180 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800181 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
182 &next_update_check,
183 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Alex Deymo0d11c602014-04-23 20:12:20 -0700184
185 UpdateCheckParams result;
186
187 // Check that the policy blocks until the next_update_check is reached.
188 SetUpDefaultClock();
189 SetUpDefaultState();
190 fake_state_.updater_provider()->var_last_checked_time()->reset(
191 new Time(last_checked_time));
192 fake_clock_.SetWallclockTime(next_update_check - TimeDelta::FromSeconds(1));
193 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
194 &Policy::UpdateCheckAllowed, &result);
195
196 SetUpDefaultClock();
197 SetUpDefaultState();
198 fake_state_.updater_provider()->var_last_checked_time()->reset(
199 new Time(last_checked_time));
200 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
201 ExpectPolicyStatus(EvalStatus::kSucceeded,
202 &Policy::UpdateCheckAllowed, &result);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700203 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700204 EXPECT_FALSE(result.interactive);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700205}
206
207TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForOOBE) {
Alex Vakulenko072359c2014-07-18 11:41:07 -0700208 // Update checks are deferred until OOBE is completed.
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700209
210 // Ensure that update is not allowed even if wait period is satisfied.
211 Time next_update_check;
212 Time last_checked_time =
213 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
214
215 fake_state_.updater_provider()->var_last_checked_time()->reset(
216 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800217 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
218 &next_update_check,
219 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700220
221 SetUpDefaultClock();
222 SetUpDefaultState();
223 fake_state_.updater_provider()->var_last_checked_time()->reset(
224 new Time(last_checked_time));
225 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
226 fake_state_.system_provider()->var_is_oobe_complete()->reset(
227 new bool(false));
228
229 UpdateCheckParams result;
230 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
231 &Policy::UpdateCheckAllowed, &result);
232
233 // Now check that it is allowed if OOBE is completed.
234 SetUpDefaultClock();
235 SetUpDefaultState();
236 fake_state_.updater_provider()->var_last_checked_time()->reset(
237 new Time(last_checked_time));
238 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
239 ExpectPolicyStatus(EvalStatus::kSucceeded,
240 &Policy::UpdateCheckAllowed, &result);
241 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700242 EXPECT_FALSE(result.interactive);
Alex Deymo0d11c602014-04-23 20:12:20 -0700243}
244
Gilad Arnold42f253b2014-06-25 12:39:17 -0700245TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWithAttributes) {
Alex Vakulenko072359c2014-07-18 11:41:07 -0700246 // Update check is allowed, response includes attributes for use in the
Gilad Arnold42f253b2014-06-25 12:39:17 -0700247 // request.
248 SetUpdateCheckAllowed(true);
249
250 // Override specific device policy attributes.
Gilad Arnoldd4b30322014-07-21 15:35:27 -0700251 fake_state_.device_policy_provider()->var_target_version_prefix()->
252 reset(new string("1.2"));
Marton Hunyady0e0e3542018-02-21 18:51:39 +0100253 fake_state_.device_policy_provider()
254 ->var_rollback_allowed_milestones()
255 ->reset(new int(5));
256 fake_state_.device_policy_provider()->var_release_channel_delegated()->reset(
257 new bool(false));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700258 fake_state_.device_policy_provider()->var_release_channel()->
259 reset(new string("foo-channel"));
260
261 UpdateCheckParams result;
262 ExpectPolicyStatus(EvalStatus::kSucceeded,
263 &Policy::UpdateCheckAllowed, &result);
264 EXPECT_TRUE(result.updates_enabled);
Gilad Arnoldd4b30322014-07-21 15:35:27 -0700265 EXPECT_EQ("1.2", result.target_version_prefix);
Marton Hunyady0e0e3542018-02-21 18:51:39 +0100266 EXPECT_EQ(5, result.rollback_allowed_milestones);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700267 EXPECT_EQ("foo-channel", result.target_channel);
Amin Hassanied37d682018-04-06 13:22:00 -0700268 EXPECT_FALSE(result.interactive);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700269}
270
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200271TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackAllowed) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200272 EXPECT_TRUE(TestRollbackAllowed(
273 true, RollbackToTargetVersion::kRollbackWithFullPowerwash));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200274}
275
276TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackDisabled) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200277 EXPECT_FALSE(TestRollbackAllowed(true, RollbackToTargetVersion::kDisabled));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200278}
279
280TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackUnspecified) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200281 EXPECT_FALSE(
282 TestRollbackAllowed(true, RollbackToTargetVersion::kUnspecified));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200283}
284
285TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackNotSet) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200286 EXPECT_FALSE(
287 TestRollbackAllowed(false, RollbackToTargetVersion::kUnspecified));
288}
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200289
Marton Hunyady8b936f22018-06-15 16:44:37 +0200290TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackAllowed) {
291 SetKioskAppControlsChromeOsVersion();
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200292
Marton Hunyady8b936f22018-06-15 16:44:37 +0200293 EXPECT_TRUE(TestRollbackAllowed(
294 true, RollbackToTargetVersion::kRollbackWithFullPowerwash));
295}
296
297TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackDisabled) {
298 SetKioskAppControlsChromeOsVersion();
299
300 EXPECT_FALSE(TestRollbackAllowed(true, RollbackToTargetVersion::kDisabled));
301}
302
303TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackUnspecified) {
304 SetKioskAppControlsChromeOsVersion();
305
306 EXPECT_FALSE(
307 TestRollbackAllowed(true, RollbackToTargetVersion::kUnspecified));
308}
309
310TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackNotSet) {
311 SetKioskAppControlsChromeOsVersion();
312
313 EXPECT_FALSE(
314 TestRollbackAllowed(false, RollbackToTargetVersion::kUnspecified));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200315}
316
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700317TEST_F(UmChromeOSPolicyTest,
318 UpdateCheckAllowedUpdatesDisabledForUnofficialBuilds) {
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700319 // UpdateCheckAllowed should return kAskMeAgainLater if this is an unofficial
320 // build; we don't want periodic update checks on developer images.
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700321
322 fake_state_.system_provider()->var_is_official_build()->reset(
323 new bool(false));
324
325 UpdateCheckParams result;
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700326 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700327 &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700328}
329
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700330TEST_F(UmChromeOSPolicyTest,
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700331 UpdateCheckAllowedWaitsForEndOfDisallowedInterval) {
332 // Check that the policy blocks during the disallowed checking intervals.
333 Time curr_time = fake_clock_.GetWallclockTime();
334 TestDisallowedTimeIntervals(
335 {WeeklyTimeInterval(
336 WeeklyTime::FromTime(curr_time),
337 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
338 EvalStatus::kAskMeAgainLater,
339 false);
340}
341
342TEST_F(UmChromeOSPolicyTest,
343 UpdateCheckAllowedNoBlockOutsideDisallowedInterval) {
344 // Check that updates are allowed outside interval.
345 Time curr_time = fake_clock_.GetWallclockTime();
346 TestDisallowedTimeIntervals(
347 {WeeklyTimeInterval(
348 WeeklyTime::FromTime(curr_time - TimeDelta::FromMinutes(2)),
349 WeeklyTime::FromTime(curr_time - TimeDelta::FromMinutes(1)))},
350 EvalStatus::kSucceeded,
351 false);
352}
353
354TEST_F(UmChromeOSPolicyTest,
355 UpdateCheckAllowedDisallowedIntervalNoBlockWhenForced) {
356 // Check that updates are not blocked by this policy when an update is forced.
357 Time curr_time = fake_clock_.GetWallclockTime();
358 // Really big interval so that current time definitely falls in it.
359 TestDisallowedTimeIntervals(
360 {WeeklyTimeInterval(
361 WeeklyTime::FromTime(curr_time - TimeDelta::FromMinutes(1234)),
362 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1234)))},
363 EvalStatus::kSucceeded,
364 true);
365}
366
367TEST_F(UmChromeOSPolicyTest,
Aaron Wood56d8ab32017-09-22 15:56:18 -0700368 UpdateCheckAllowedUpdatesDisabledWhenNotEnoughSlotsAbUpdates) {
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700369 // UpdateCheckAllowed should return false (kSucceeded) if the image booted
Aaron Wood56d8ab32017-09-22 15:56:18 -0700370 // without enough slots to do A/B updates.
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700371
Aaron Woodc73fdc12017-12-06 11:09:15 -0800372 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -0700373 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(1));
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700374
375 UpdateCheckParams result;
376 ExpectPolicyStatus(EvalStatus::kSucceeded,
377 &Policy::UpdateCheckAllowed, &result);
378 EXPECT_FALSE(result.updates_enabled);
379}
380
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700381TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedUpdatesDisabledByPolicy) {
Gilad Arnold42f253b2014-06-25 12:39:17 -0700382 // UpdateCheckAllowed should return kAskMeAgainLater because a device policy
383 // is loaded and prohibits updates.
384
385 SetUpdateCheckAllowed(false);
386 fake_state_.device_policy_provider()->var_update_disabled()->reset(
387 new bool(true));
388
Gilad Arnold42f253b2014-06-25 12:39:17 -0700389 UpdateCheckParams result;
390 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
391 &Policy::UpdateCheckAllowed, &result);
392}
393
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700394TEST_F(UmChromeOSPolicyTest,
395 UpdateCheckAllowedForcedUpdateRequestedInteractive) {
396 // UpdateCheckAllowed should return true because a forced update request was
397 // signaled for an interactive update.
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700398
399 SetUpdateCheckAllowed(true);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700400 fake_state_.updater_provider()->var_forced_update_requested()->reset(
401 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700402
403 UpdateCheckParams result;
404 ExpectPolicyStatus(EvalStatus::kSucceeded,
405 &Policy::UpdateCheckAllowed, &result);
406 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700407 EXPECT_TRUE(result.interactive);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700408}
409
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700410TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedForcedUpdateRequestedPeriodic) {
411 // UpdateCheckAllowed should return true because a forced update request was
412 // signaled for a periodic check.
413
414 SetUpdateCheckAllowed(true);
415 fake_state_.updater_provider()->var_forced_update_requested()->reset(
416 new UpdateRequestStatus(UpdateRequestStatus::kPeriodic));
417
418 UpdateCheckParams result;
419 ExpectPolicyStatus(EvalStatus::kSucceeded,
420 &Policy::UpdateCheckAllowed, &result);
421 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700422 EXPECT_FALSE(result.interactive);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700423}
424
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800425TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPin) {
426 // Update check is allowed.
427 SetUpdateCheckAllowed(true);
428
Marton Hunyady8b936f22018-06-15 16:44:37 +0200429 SetKioskAppControlsChromeOsVersion();
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800430
431 UpdateCheckParams result;
432 ExpectPolicyStatus(EvalStatus::kSucceeded,
433 &Policy::UpdateCheckAllowed, &result);
434 EXPECT_TRUE(result.updates_enabled);
Marton Hunyady8b936f22018-06-15 16:44:37 +0200435 EXPECT_EQ("1234.", result.target_version_prefix);
Amin Hassanied37d682018-04-06 13:22:00 -0700436 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800437}
438
439TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedDisabledWhenNoKioskPin) {
440 // Update check is allowed.
441 SetUpdateCheckAllowed(true);
442
443 // Disable AU policy is set but kiosk pin policy is set to false. Update is
444 // disabled in such case.
445 fake_state_.device_policy_provider()->var_update_disabled()->reset(
446 new bool(true));
447 fake_state_.device_policy_provider()
448 ->var_allow_kiosk_app_control_chrome_version()
449 ->reset(new bool(false));
450
451 UpdateCheckParams result;
452 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
453 &Policy::UpdateCheckAllowed, &result);
454}
455
456TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPinWithNoRequiredVersion) {
457 // Update check is allowed.
458 SetUpdateCheckAllowed(true);
459
460 // AU disabled, allow kiosk to pin but there is no kiosk required platform
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700461 // version (i.e. app does not provide the info). Update to latest in such
462 // case.
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800463 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));
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700468 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
469 new string());
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800470
471 UpdateCheckParams result;
472 ExpectPolicyStatus(EvalStatus::kSucceeded,
473 &Policy::UpdateCheckAllowed, &result);
474 EXPECT_TRUE(result.updates_enabled);
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700475 EXPECT_TRUE(result.target_version_prefix.empty());
Amin Hassanied37d682018-04-06 13:22:00 -0700476 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800477}
478
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700479TEST_F(UmChromeOSPolicyTest,
480 UpdateCheckAllowedKioskPinWithFailedGetRequiredVersionCall) {
481 // AU disabled, allow kiosk to pin but D-Bus call to get required platform
482 // version failed. Defer update check in this case.
483 fake_state_.device_policy_provider()->var_update_disabled()->reset(
484 new bool(true));
485 fake_state_.device_policy_provider()
486 ->var_allow_kiosk_app_control_chrome_version()
487 ->reset(new bool(true));
488 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
489 nullptr);
490
491 UpdateCheckParams result;
492 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
493 &Policy::UpdateCheckAllowed, &result);
494}
495
Alex Deymo63784a52014-05-28 10:46:14 -0700496TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsCheckAllowedError) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700497 // The UpdateCanStart policy fails, not being able to query
498 // UpdateCheckAllowed.
499
500 // Configure the UpdateCheckAllowed policy to fail.
501 fake_state_.updater_provider()->var_updater_started_time()->reset(nullptr);
502
503 // Check that the UpdateCanStart fails.
504 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700505 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700506 ExpectPolicyStatus(EvalStatus::kFailed,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700507 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700508}
509
Alex Deymo63784a52014-05-28 10:46:14 -0700510TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedCheckDue) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700511 // The UpdateCanStart policy returns false because we are due for another
Gilad Arnold14a9e702014-10-08 08:09:09 -0700512 // update check. Ensure that download related values are still returned.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700513
514 SetUpdateCheckAllowed(true);
515
516 // Check that the UpdateCanStart returns false.
517 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700518 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700519 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700520 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700521 EXPECT_FALSE(result.update_can_start);
522 EXPECT_EQ(UpdateCannotStartReason::kCheckDue, result.cannot_start_reason);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700523 EXPECT_EQ(0, result.download_url_idx);
524 EXPECT_EQ(0, result.download_url_num_errors);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700525}
526
Alex Deymo63784a52014-05-28 10:46:14 -0700527TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoDevicePolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700528 // The UpdateCanStart policy returns true; no device policy is loaded.
529
530 SetUpdateCheckAllowed(false);
531 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
532 new bool(false));
533
534 // Check that the UpdateCanStart returns true with no further attributes.
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);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700546}
547
Alex Deymo63784a52014-05-28 10:46:14 -0700548TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBlankPolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700549 // The UpdateCanStart policy returns true; device policy is loaded but imposes
550 // no restrictions on updating.
551
552 SetUpdateCheckAllowed(false);
553
554 // Check that the UpdateCanStart returns true.
555 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700556 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700557 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700558 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700559 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700560 EXPECT_FALSE(result.p2p_downloading_allowed);
561 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700562 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700563 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700564 EXPECT_EQ(0, result.download_url_num_errors);
565 EXPECT_FALSE(result.do_increment_failures);
566}
567
568TEST_F(UmChromeOSPolicyTest,
569 UpdateCanStartNotAllowedBackoffNewWaitPeriodApplies) {
570 // The UpdateCanStart policy returns false; failures are reported and a new
571 // backoff period is enacted.
572
573 SetUpdateCheckAllowed(false);
574
575 const Time curr_time = fake_clock_.GetWallclockTime();
576 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
577 update_state.download_errors_max = 1;
578 update_state.download_errors.emplace_back(
579 0, ErrorCode::kDownloadTransferError,
580 curr_time - TimeDelta::FromSeconds(8));
581 update_state.download_errors.emplace_back(
582 0, ErrorCode::kDownloadTransferError,
583 curr_time - TimeDelta::FromSeconds(2));
584
585 // Check that UpdateCanStart returns false and a new backoff expiry is
586 // generated.
587 UpdateDownloadParams result;
588 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
589 update_state);
590 EXPECT_FALSE(result.update_can_start);
591 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
592 EXPECT_TRUE(result.do_increment_failures);
593 EXPECT_LT(curr_time, result.backoff_expiry);
594}
595
596TEST_F(UmChromeOSPolicyTest,
597 UpdateCanStartNotAllowedBackoffPrevWaitPeriodStillApplies) {
598 // The UpdateCanStart policy returns false; a previously enacted backoff
599 // period still applies.
600
601 SetUpdateCheckAllowed(false);
602
603 const Time curr_time = fake_clock_.GetWallclockTime();
604 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
605 update_state.download_errors_max = 1;
606 update_state.download_errors.emplace_back(
607 0, ErrorCode::kDownloadTransferError,
608 curr_time - TimeDelta::FromSeconds(8));
609 update_state.download_errors.emplace_back(
610 0, ErrorCode::kDownloadTransferError,
611 curr_time - TimeDelta::FromSeconds(2));
612 update_state.failures_last_updated = curr_time;
613 update_state.backoff_expiry = curr_time + TimeDelta::FromMinutes(3);
614
615 // Check that UpdateCanStart returns false and a new backoff expiry is
616 // generated.
617 UpdateDownloadParams result;
618 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::UpdateCanStart,
619 &result, update_state);
620 EXPECT_FALSE(result.update_can_start);
621 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
622 EXPECT_FALSE(result.do_increment_failures);
623 EXPECT_LT(curr_time, result.backoff_expiry);
624}
625
626TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffSatisfied) {
627 // The UpdateCanStart policy returns true; a previously enacted backoff period
628 // has elapsed, we're good to go.
629
630 SetUpdateCheckAllowed(false);
631
632 const Time curr_time = fake_clock_.GetWallclockTime();
633 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
634 update_state.download_errors_max = 1;
635 update_state.download_errors.emplace_back(
636 0, ErrorCode::kDownloadTransferError,
637 curr_time - TimeDelta::FromSeconds(8));
638 update_state.download_errors.emplace_back(
639 0, ErrorCode::kDownloadTransferError,
640 curr_time - TimeDelta::FromSeconds(2));
641 update_state.failures_last_updated = curr_time - TimeDelta::FromSeconds(1);
642 update_state.backoff_expiry = curr_time - TimeDelta::FromSeconds(1);
643
644 // Check that UpdateCanStart returns false and a new backoff expiry is
645 // generated.
646 UpdateDownloadParams result;
647 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart,
648 &result, update_state);
649 EXPECT_TRUE(result.update_can_start);
650 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
651 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700652 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700653 EXPECT_EQ(0, result.download_url_num_errors);
654 EXPECT_FALSE(result.do_increment_failures);
655 EXPECT_EQ(Time(), result.backoff_expiry);
656}
657
658TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffDisabled) {
659 // The UpdateCanStart policy returns false; failures are reported but backoff
660 // is disabled.
661
662 SetUpdateCheckAllowed(false);
663
664 const Time curr_time = fake_clock_.GetWallclockTime();
665 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
666 update_state.download_errors_max = 1;
667 update_state.download_errors.emplace_back(
668 0, ErrorCode::kDownloadTransferError,
669 curr_time - TimeDelta::FromSeconds(8));
670 update_state.download_errors.emplace_back(
671 0, ErrorCode::kDownloadTransferError,
672 curr_time - TimeDelta::FromSeconds(2));
673 update_state.is_backoff_disabled = true;
674
675 // Check that UpdateCanStart returns false and a new backoff expiry is
676 // generated.
677 UpdateDownloadParams result;
678 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
679 update_state);
680 EXPECT_TRUE(result.update_can_start);
681 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
682 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700683 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700684 EXPECT_EQ(0, result.download_url_num_errors);
685 EXPECT_TRUE(result.do_increment_failures);
686 EXPECT_EQ(Time(), result.backoff_expiry);
687}
688
689TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffInteractive) {
690 // The UpdateCanStart policy returns false; failures are reported but this is
691 // an interactive update check.
692
693 SetUpdateCheckAllowed(false);
694
695 const Time curr_time = fake_clock_.GetWallclockTime();
696 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
697 update_state.download_errors_max = 1;
698 update_state.download_errors.emplace_back(
699 0, ErrorCode::kDownloadTransferError,
700 curr_time - TimeDelta::FromSeconds(8));
701 update_state.download_errors.emplace_back(
702 0, ErrorCode::kDownloadTransferError,
703 curr_time - TimeDelta::FromSeconds(2));
Amin Hassanied37d682018-04-06 13:22:00 -0700704 update_state.interactive = true;
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700705
706 // Check that UpdateCanStart returns false and a new backoff expiry is
707 // generated.
708 UpdateDownloadParams result;
709 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
710 update_state);
711 EXPECT_TRUE(result.update_can_start);
712 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
713 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700714 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700715 EXPECT_EQ(0, result.download_url_num_errors);
716 EXPECT_TRUE(result.do_increment_failures);
717 EXPECT_EQ(Time(), result.backoff_expiry);
718}
719
720TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffDelta) {
721 // The UpdateCanStart policy returns false; failures are reported but this is
722 // a delta payload.
723
724 SetUpdateCheckAllowed(false);
725
726 const Time curr_time = fake_clock_.GetWallclockTime();
727 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
728 update_state.download_errors_max = 1;
729 update_state.download_errors.emplace_back(
730 0, ErrorCode::kDownloadTransferError,
731 curr_time - TimeDelta::FromSeconds(8));
732 update_state.download_errors.emplace_back(
733 0, ErrorCode::kDownloadTransferError,
734 curr_time - TimeDelta::FromSeconds(2));
735 update_state.is_delta_payload = true;
736
737 // Check that UpdateCanStart returns false and a new backoff expiry is
738 // generated.
739 UpdateDownloadParams result;
740 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
741 update_state);
742 EXPECT_TRUE(result.update_can_start);
743 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
744 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700745 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700746 EXPECT_EQ(0, result.download_url_num_errors);
747 EXPECT_TRUE(result.do_increment_failures);
748 EXPECT_EQ(Time(), result.backoff_expiry);
749}
750
751TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffUnofficialBuild) {
752 // The UpdateCanStart policy returns false; failures are reported but this is
753 // an unofficial build.
754
755 SetUpdateCheckAllowed(false);
756
757 const Time curr_time = fake_clock_.GetWallclockTime();
758 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
759 update_state.download_errors_max = 1;
760 update_state.download_errors.emplace_back(
761 0, ErrorCode::kDownloadTransferError,
762 curr_time - TimeDelta::FromSeconds(8));
763 update_state.download_errors.emplace_back(
764 0, ErrorCode::kDownloadTransferError,
765 curr_time - TimeDelta::FromSeconds(2));
766
767 fake_state_.system_provider()->var_is_official_build()->
768 reset(new bool(false));
769
770 // Check that UpdateCanStart returns false and a new backoff expiry is
771 // generated.
772 UpdateDownloadParams result;
773 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
774 update_state);
775 EXPECT_TRUE(result.update_can_start);
776 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
777 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700778 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700779 EXPECT_EQ(0, result.download_url_num_errors);
780 EXPECT_TRUE(result.do_increment_failures);
781 EXPECT_EQ(Time(), result.backoff_expiry);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700782}
783
Alex Deymo63784a52014-05-28 10:46:14 -0700784TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsScatteringFailed) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700785 // The UpdateCanStart policy fails because the UpdateScattering policy it
786 // depends on fails (unset variable).
787
788 SetUpdateCheckAllowed(false);
789
790 // Override the default seed variable with a null value so that the policy
791 // request would fail.
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700792 // TODO(garnold) This failure may or may not fail a number
793 // sub-policies/decisions, like scattering and backoff. We'll need a more
794 // deliberate setup to ensure that we're failing what we want to be failing.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700795 fake_state_.random_provider()->var_seed()->reset(nullptr);
796
797 // Check that the UpdateCanStart fails.
798 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700799 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700800 ExpectPolicyStatus(EvalStatus::kFailed,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700801 &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700802}
803
Alex Deymo63784a52014-05-28 10:46:14 -0700804TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700805 UpdateCanStartNotAllowedScatteringNewWaitPeriodApplies) {
806 // The UpdateCanStart policy returns false; device policy is loaded and
807 // scattering applies due to an unsatisfied wait period, which was newly
808 // generated.
809
810 SetUpdateCheckAllowed(false);
811 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
812 new TimeDelta(TimeDelta::FromMinutes(2)));
813
814
815 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
816
817 // Check that the UpdateCanStart returns false and a new wait period
818 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700819 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700820 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700821 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700822 EXPECT_FALSE(result.update_can_start);
823 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
824 EXPECT_LT(TimeDelta(), result.scatter_wait_period);
825 EXPECT_EQ(0, result.scatter_check_threshold);
826}
827
Alex Deymo63784a52014-05-28 10:46:14 -0700828TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700829 UpdateCanStartNotAllowedScatteringPrevWaitPeriodStillApplies) {
830 // The UpdateCanStart policy returns false w/ kAskMeAgainLater; device policy
831 // is loaded and a previously generated scattering period still applies, none
832 // of the scattering values has changed.
833
834 SetUpdateCheckAllowed(false);
835 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
836 new TimeDelta(TimeDelta::FromMinutes(2)));
837
838 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
839 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
840
841 // Check that the UpdateCanStart returns false and a new wait period
842 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700843 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700844 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::UpdateCanStart,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700845 &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700846 EXPECT_FALSE(result.update_can_start);
847 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
848 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
849 EXPECT_EQ(0, result.scatter_check_threshold);
850}
851
Alex Deymo63784a52014-05-28 10:46:14 -0700852TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700853 UpdateCanStartNotAllowedScatteringNewCountThresholdApplies) {
854 // The UpdateCanStart policy returns false; device policy is loaded and
855 // scattering applies due to an unsatisfied update check count threshold.
856 //
857 // This ensures a non-zero check threshold, which may or may not be combined
858 // with a non-zero wait period (for which we cannot reliably control).
859
860 SetUpdateCheckAllowed(false);
861 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
862 new TimeDelta(TimeDelta::FromSeconds(1)));
863
864 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
865 update_state.scatter_check_threshold_min = 2;
866 update_state.scatter_check_threshold_max = 5;
867
868 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700869 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700870 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700871 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700872 EXPECT_FALSE(result.update_can_start);
873 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
874 EXPECT_LE(2, result.scatter_check_threshold);
875 EXPECT_GE(5, result.scatter_check_threshold);
876}
877
Alex Deymo63784a52014-05-28 10:46:14 -0700878TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700879 UpdateCanStartNotAllowedScatteringPrevCountThresholdStillApplies) {
880 // The UpdateCanStart policy returns false; device policy is loaded and
881 // scattering due to a previously generated count threshold still applies.
882
883 SetUpdateCheckAllowed(false);
884 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
885 new TimeDelta(TimeDelta::FromSeconds(1)));
886
887 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
888 update_state.scatter_check_threshold = 3;
889 update_state.scatter_check_threshold_min = 2;
890 update_state.scatter_check_threshold_max = 5;
891
892 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700893 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700894 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700895 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700896 EXPECT_FALSE(result.update_can_start);
897 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
898 EXPECT_EQ(3, result.scatter_check_threshold);
899}
900
Alex Deymo63784a52014-05-28 10:46:14 -0700901TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSatisfied) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700902 // The UpdateCanStart policy returns true; device policy is loaded and
903 // scattering is enabled, but both wait period and check threshold are
904 // satisfied.
905
906 SetUpdateCheckAllowed(false);
907 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
908 new TimeDelta(TimeDelta::FromSeconds(120)));
909
910 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(75));
911 update_state.num_checks = 4;
912 update_state.scatter_wait_period = TimeDelta::FromSeconds(60);
913 update_state.scatter_check_threshold = 3;
914 update_state.scatter_check_threshold_min = 2;
915 update_state.scatter_check_threshold_max = 5;
916
917 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700918 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700919 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700920 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700921 EXPECT_TRUE(result.update_can_start);
922 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
923 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700924 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700925 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700926 EXPECT_EQ(0, result.download_url_num_errors);
927 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700928}
929
Alex Deymo63784a52014-05-28 10:46:14 -0700930TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700931 UpdateCanStartAllowedInteractivePreventsScattering) {
932 // The UpdateCanStart policy returns true; device policy is loaded and
933 // scattering would have applied, except that the update check is interactive
934 // and so it is suppressed.
935
936 SetUpdateCheckAllowed(false);
937 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
938 new TimeDelta(TimeDelta::FromSeconds(1)));
939
940 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700941 update_state.interactive = true;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700942 update_state.scatter_check_threshold = 0;
943 update_state.scatter_check_threshold_min = 2;
944 update_state.scatter_check_threshold_max = 5;
945
946 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700947 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700948 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700949 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700950 EXPECT_TRUE(result.update_can_start);
951 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
952 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700953 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700954 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700955 EXPECT_EQ(0, result.download_url_num_errors);
956 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700957}
958
Alex Deymo63784a52014-05-28 10:46:14 -0700959TEST_F(UmChromeOSPolicyTest,
Gilad Arnold76a11f62014-05-20 09:02:12 -0700960 UpdateCanStartAllowedOobePreventsScattering) {
961 // The UpdateCanStart policy returns true; device policy is loaded and
962 // scattering would have applied, except that OOBE was not completed and so it
963 // is suppressed.
964
965 SetUpdateCheckAllowed(false);
966 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
967 new TimeDelta(TimeDelta::FromSeconds(1)));
968 fake_state_.system_provider()->var_is_oobe_complete()->reset(new bool(false));
969
970 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700971 update_state.interactive = true;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700972 update_state.scatter_check_threshold = 0;
973 update_state.scatter_check_threshold_min = 2;
974 update_state.scatter_check_threshold_max = 5;
975
976 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700977 UpdateDownloadParams result;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700978 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700979 update_state);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700980 EXPECT_TRUE(result.update_can_start);
981 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
982 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700983 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700984 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700985 EXPECT_EQ(0, result.download_url_num_errors);
986 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700987}
988
Alex Deymo63784a52014-05-28 10:46:14 -0700989TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithAttributes) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700990 // The UpdateCanStart policy returns true; device policy permits both HTTP and
991 // P2P updates, as well as a non-empty target channel string.
992
993 SetUpdateCheckAllowed(false);
994
995 // Override specific device policy attributes.
996 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
997 new bool(true));
998 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
999 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001000
1001 // Check that the UpdateCanStart returns true.
1002 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001003 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001004 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001005 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001006 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001007 EXPECT_TRUE(result.p2p_downloading_allowed);
1008 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001009 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001010 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001011 EXPECT_EQ(0, result.download_url_num_errors);
1012 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001013}
1014
Alex Deymo63784a52014-05-28 10:46:14 -07001015TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithP2PFromUpdater) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001016 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1017 // P2P updates, but the updater is configured to allow P2P and overrules the
1018 // setting.
1019
1020 SetUpdateCheckAllowed(false);
1021
1022 // Override specific device policy attributes.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001023 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1024
1025 // Check that the UpdateCanStart returns true.
1026 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001027 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001028 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001029 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001030 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001031 EXPECT_TRUE(result.p2p_downloading_allowed);
1032 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001033 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001034 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001035 EXPECT_EQ(0, result.download_url_num_errors);
1036 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001037}
1038
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001039TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001040 UpdateCanStartAllowedP2PDownloadingBlockedDueToOmaha) {
1041 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1042 // policy blocks P2P downloading because Omaha forbids it. P2P sharing is
1043 // still permitted.
1044
1045 SetUpdateCheckAllowed(false);
1046
1047 // Override specific device policy attributes.
1048 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1049 new bool(true));
1050 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1051 new bool(true));
1052
1053 // Check that the UpdateCanStart returns true.
1054 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1055 update_state.p2p_downloading_disabled = true;
1056 UpdateDownloadParams result;
1057 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1058 update_state);
1059 EXPECT_TRUE(result.update_can_start);
1060 EXPECT_FALSE(result.p2p_downloading_allowed);
1061 EXPECT_TRUE(result.p2p_sharing_allowed);
1062}
1063
1064TEST_F(UmChromeOSPolicyTest,
1065 UpdateCanStartAllowedP2PSharingBlockedDueToOmaha) {
1066 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1067 // policy blocks P2P sharing because Omaha forbids it. P2P downloading is
1068 // still permitted.
1069
1070 SetUpdateCheckAllowed(false);
1071
1072 // Override specific device policy attributes.
1073 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1074 new bool(true));
1075 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1076 new bool(true));
1077
1078 // Check that the UpdateCanStart returns true.
1079 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1080 update_state.p2p_sharing_disabled = true;
1081 UpdateDownloadParams result;
1082 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1083 update_state);
1084 EXPECT_TRUE(result.update_can_start);
1085 EXPECT_TRUE(result.p2p_downloading_allowed);
1086 EXPECT_FALSE(result.p2p_sharing_allowed);
1087}
1088
1089TEST_F(UmChromeOSPolicyTest,
1090 UpdateCanStartAllowedP2PDownloadingBlockedDueToNumAttempts) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001091 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001092 // blocks P2P download, because the max number of P2P downloads have been
1093 // attempted. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001094
1095 SetUpdateCheckAllowed(false);
1096
1097 // Override specific device policy attributes.
1098 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1099 new bool(true));
1100 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1101 new bool(true));
1102
1103 // Check that the UpdateCanStart returns true.
1104 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1105 update_state.p2p_num_attempts = ChromeOSPolicy::kMaxP2PAttempts;
1106 UpdateDownloadParams result;
1107 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1108 update_state);
1109 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001110 EXPECT_FALSE(result.p2p_downloading_allowed);
1111 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001112}
1113
1114TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001115 UpdateCanStartAllowedP2PDownloadingBlockedDueToAttemptsPeriod) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001116 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001117 // blocks P2P download, because the max period for attempt to download via P2P
1118 // has elapsed. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001119
1120 SetUpdateCheckAllowed(false);
1121
1122 // Override specific device policy attributes.
1123 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1124 new bool(true));
1125 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1126 new bool(true));
1127
1128 // Check that the UpdateCanStart returns true.
1129 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1130 update_state.p2p_num_attempts = 1;
1131 update_state.p2p_first_attempted =
1132 fake_clock_.GetWallclockTime() -
Alex Deymof329b932014-10-30 01:37:48 -07001133 TimeDelta::FromSeconds(
1134 ChromeOSPolicy::kMaxP2PAttemptsPeriodInSeconds + 1);
Gilad Arnold349ac832014-10-06 14:20:28 -07001135 UpdateDownloadParams result;
1136 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1137 update_state);
1138 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001139 EXPECT_FALSE(result.p2p_downloading_allowed);
1140 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001141}
1142
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001143TEST_F(UmChromeOSPolicyTest,
1144 UpdateCanStartAllowedWithHttpUrlForUnofficialBuild) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001145 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1146 // P2P updates, but marking this an unofficial build overrules the HTTP
1147 // setting.
1148
1149 SetUpdateCheckAllowed(false);
1150
1151 // Override specific device policy attributes.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001152 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1153 new bool(false));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001154 fake_state_.system_provider()->var_is_official_build()->
1155 reset(new bool(false));
1156
1157 // Check that the UpdateCanStart returns true.
1158 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001159 UpdateDownloadParams result;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001160 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001161 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001162 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001163 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001164 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001165 EXPECT_EQ(0, result.download_url_num_errors);
1166 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001167}
1168
1169TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithHttpsUrl) {
1170 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1171 // P2P updates, but an HTTPS URL is provided and selected for download.
1172
1173 SetUpdateCheckAllowed(false);
1174
1175 // Override specific device policy attributes.
1176 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1177 new bool(false));
1178
1179 // Add an HTTPS URL.
1180 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001181 update_state.download_urls.emplace_back("https://secure/url/");
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001182
1183 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001184 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001185 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001186 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001187 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001188 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001189 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001190 EXPECT_EQ(0, result.download_url_num_errors);
1191 EXPECT_FALSE(result.do_increment_failures);
1192}
1193
1194TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedMaxErrorsNotExceeded) {
1195 // The UpdateCanStart policy returns true; the first URL has download errors
1196 // but does not exceed the maximum allowed number of failures, so it is stilli
1197 // usable.
1198
1199 SetUpdateCheckAllowed(false);
1200
1201 // Add a second URL; update with this URL attempted and failed enough times to
1202 // disqualify the current (first) URL.
1203 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1204 update_state.num_checks = 5;
1205 update_state.download_urls.emplace_back("http://another/fake/url/");
1206 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1207 for (int i = 0; i < 5; i++) {
1208 update_state.download_errors.emplace_back(
1209 0, ErrorCode::kDownloadTransferError, t);
1210 t += TimeDelta::FromSeconds(1);
1211 }
1212
1213 // Check that the UpdateCanStart returns true.
1214 UpdateDownloadParams result;
1215 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1216 update_state);
1217 EXPECT_TRUE(result.update_can_start);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001218 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001219 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001220 EXPECT_EQ(5, result.download_url_num_errors);
1221 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001222}
1223
1224TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlMaxExceeded) {
1225 // The UpdateCanStart policy returns true; the first URL exceeded the maximum
1226 // allowed number of failures, but a second URL is available.
1227
1228 SetUpdateCheckAllowed(false);
1229
1230 // Add a second URL; update with this URL attempted and failed enough times to
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001231 // disqualify the current (first) URL.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001232 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1233 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001234 update_state.download_urls.emplace_back("http://another/fake/url/");
1235 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1236 for (int i = 0; i < 11; i++) {
1237 update_state.download_errors.emplace_back(
1238 0, ErrorCode::kDownloadTransferError, t);
1239 t += TimeDelta::FromSeconds(1);
1240 }
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001241
1242 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001243 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001244 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001245 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001246 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001247 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001248 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001249 EXPECT_EQ(0, result.download_url_num_errors);
1250 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001251}
1252
1253TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlHardError) {
1254 // The UpdateCanStart policy returns true; the first URL fails with a hard
1255 // error, but a second URL is available.
1256
1257 SetUpdateCheckAllowed(false);
1258
1259 // Add a second URL; update with this URL attempted and failed in a way that
1260 // causes it to switch directly to the next URL.
1261 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1262 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001263 update_state.download_urls.emplace_back("http://another/fake/url/");
1264 update_state.download_errors.emplace_back(
1265 0, ErrorCode::kPayloadHashMismatchError,
1266 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001267
1268 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001269 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001270 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001271 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001272 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001273 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001274 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001275 EXPECT_EQ(0, result.download_url_num_errors);
1276 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001277}
1278
1279TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedUrlWrapsAround) {
1280 // The UpdateCanStart policy returns true; URL search properly wraps around
1281 // the last one on the list.
1282
1283 SetUpdateCheckAllowed(false);
1284
1285 // Add a second URL; update with this URL attempted and failed in a way that
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001286 // causes it to switch directly to the next URL. We must disable backoff in
1287 // order for it not to interfere.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001288 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001289 update_state.num_checks = 1;
1290 update_state.is_backoff_disabled = true;
1291 update_state.download_urls.emplace_back("http://another/fake/url/");
1292 update_state.download_errors.emplace_back(
1293 1, ErrorCode::kPayloadHashMismatchError,
1294 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001295
1296 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001297 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001298 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001299 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001300 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001301 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001302 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001303 EXPECT_EQ(0, result.download_url_num_errors);
1304 EXPECT_TRUE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001305}
1306
1307TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedNoUsableUrls) {
1308 // The UpdateCanStart policy returns false; there's a single HTTP URL but its
1309 // use is forbidden by policy.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001310 //
1311 // Note: In the case where no usable URLs are found, the policy should not
1312 // increment the number of failed attempts! Doing so would result in a
1313 // non-idempotent semantics, and does not fall within the intended purpose of
1314 // the backoff mechanism anyway.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001315
1316 SetUpdateCheckAllowed(false);
1317
1318 // Override specific device policy attributes.
1319 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1320 new bool(false));
1321
1322 // Check that the UpdateCanStart returns false.
1323 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001324 UpdateDownloadParams result;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001325 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1326 update_state);
1327 EXPECT_FALSE(result.update_can_start);
1328 EXPECT_EQ(UpdateCannotStartReason::kCannotDownload,
1329 result.cannot_start_reason);
1330 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001331}
1332
1333TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoUsableUrlsButP2PEnabled) {
1334 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1335 // use is forbidden by policy, however P2P is enabled. The result indicates
1336 // that no URL can be used.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001337 //
1338 // Note: The number of failed attempts should not increase in this case (see
1339 // above test).
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001340
1341 SetUpdateCheckAllowed(false);
1342
1343 // Override specific device policy attributes.
1344 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1345 new bool(true));
1346 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1347 new bool(false));
1348
1349 // Check that the UpdateCanStart returns true.
1350 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001351 UpdateDownloadParams result;
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001352 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001353 update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001354 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001355 EXPECT_TRUE(result.p2p_downloading_allowed);
1356 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001357 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001358 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001359 EXPECT_EQ(0, result.download_url_num_errors);
1360 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001361}
1362
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001363TEST_F(UmChromeOSPolicyTest,
1364 UpdateCanStartAllowedNoUsableUrlsButEnterpriseEnrolled) {
1365 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1366 // use is forbidden by policy, and P2P is unset on the policy, however the
1367 // device is enterprise-enrolled so P2P is allowed. The result indicates that
1368 // no URL can be used.
1369 //
1370 // Note: The number of failed attempts should not increase in this case (see
1371 // above test).
1372
1373 SetUpdateCheckAllowed(false);
1374
1375 // Override specific device policy attributes.
1376 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
1377 fake_state_.device_policy_provider()->var_owner()->reset(nullptr);
1378 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1379 new bool(false));
1380
1381 // Check that the UpdateCanStart returns true.
1382 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1383 UpdateDownloadParams result;
1384 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1385 update_state);
1386 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001387 EXPECT_TRUE(result.p2p_downloading_allowed);
1388 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001389 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001390 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001391 EXPECT_EQ(0, result.download_url_num_errors);
1392 EXPECT_FALSE(result.do_increment_failures);
1393}
1394
Gilad Arnold684219d2014-07-07 14:54:57 -07001395TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedEthernetDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001396 // Ethernet is always allowed.
1397
1398 fake_state_.shill_provider()->var_conn_type()->
1399 reset(new ConnectionType(ConnectionType::kEthernet));
1400
1401 bool result;
1402 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001403 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001404 EXPECT_TRUE(result);
1405}
1406
Gilad Arnold684219d2014-07-07 14:54:57 -07001407TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWifiDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001408 // Wifi is allowed if not tethered.
1409
1410 fake_state_.shill_provider()->var_conn_type()->
1411 reset(new ConnectionType(ConnectionType::kWifi));
1412
1413 bool result;
1414 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001415 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001416 EXPECT_TRUE(result);
1417}
1418
Alex Deymo63784a52014-05-28 10:46:14 -07001419TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001420 UpdateCurrentConnectionNotAllowedWifiTetheredDefault) {
1421 // Tethered wifi is not allowed by default.
1422
1423 fake_state_.shill_provider()->var_conn_type()->
1424 reset(new ConnectionType(ConnectionType::kWifi));
1425 fake_state_.shill_provider()->var_conn_tethering()->
1426 reset(new ConnectionTethering(ConnectionTethering::kConfirmed));
1427
1428 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001429 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001430 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001431}
1432
Alex Deymo63784a52014-05-28 10:46:14 -07001433TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001434 UpdateDownloadAllowedWifiTetheredPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001435 // Tethered wifi can be allowed by policy.
1436
1437 fake_state_.shill_provider()->var_conn_type()->
1438 reset(new ConnectionType(ConnectionType::kWifi));
1439 fake_state_.shill_provider()->var_conn_tethering()->
1440 reset(new ConnectionTethering(ConnectionTethering::kConfirmed));
1441 set<ConnectionType> allowed_connections;
1442 allowed_connections.insert(ConnectionType::kCellular);
1443 fake_state_.device_policy_provider()->
1444 var_allowed_connection_types_for_update()->
1445 reset(new set<ConnectionType>(allowed_connections));
1446
1447 bool result;
1448 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001449 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001450 EXPECT_TRUE(result);
1451}
1452
Gilad Arnold684219d2014-07-07 14:54:57 -07001453TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWimaxDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001454 // Wimax is always allowed.
1455
1456 fake_state_.shill_provider()->var_conn_type()->
1457 reset(new ConnectionType(ConnectionType::kWifi));
1458
1459 bool result;
1460 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001461 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001462 EXPECT_TRUE(result);
1463}
1464
Alex Deymo63784a52014-05-28 10:46:14 -07001465TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001466 UpdateCurrentConnectionNotAllowedBluetoothDefault) {
1467 // Bluetooth is never allowed.
1468
1469 fake_state_.shill_provider()->var_conn_type()->
1470 reset(new ConnectionType(ConnectionType::kBluetooth));
1471
1472 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001473 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001474 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001475}
1476
Alex Deymo63784a52014-05-28 10:46:14 -07001477TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001478 UpdateCurrentConnectionNotAllowedBluetoothPolicyCannotOverride) {
1479 // Bluetooth cannot be allowed even by policy.
1480
1481 fake_state_.shill_provider()->var_conn_type()->
1482 reset(new ConnectionType(ConnectionType::kBluetooth));
1483 set<ConnectionType> allowed_connections;
1484 allowed_connections.insert(ConnectionType::kBluetooth);
1485 fake_state_.device_policy_provider()->
1486 var_allowed_connection_types_for_update()->
1487 reset(new set<ConnectionType>(allowed_connections));
1488
1489 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001490 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001491 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001492}
1493
Alex Deymo63784a52014-05-28 10:46:14 -07001494TEST_F(UmChromeOSPolicyTest, UpdateCurrentConnectionNotAllowedCellularDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001495 // Cellular is not allowed by default.
1496
1497 fake_state_.shill_provider()->var_conn_type()->
1498 reset(new ConnectionType(ConnectionType::kCellular));
1499
1500 bool result;
Gilad Arnold28d6be62014-06-30 14:04:04 -07001501 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
Gilad Arnold684219d2014-07-07 14:54:57 -07001502 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001503}
1504
Alex Deymo63784a52014-05-28 10:46:14 -07001505TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001506 UpdateDownloadAllowedCellularPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001507 // Update over cellular can be enabled by policy.
1508
1509 fake_state_.shill_provider()->var_conn_type()->
1510 reset(new ConnectionType(ConnectionType::kCellular));
1511 set<ConnectionType> allowed_connections;
1512 allowed_connections.insert(ConnectionType::kCellular);
1513 fake_state_.device_policy_provider()->
1514 var_allowed_connection_types_for_update()->
1515 reset(new set<ConnectionType>(allowed_connections));
1516
1517 bool result;
1518 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001519 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001520 EXPECT_TRUE(result);
1521}
1522
Alex Deymo63784a52014-05-28 10:46:14 -07001523TEST_F(UmChromeOSPolicyTest,
Gilad Arnold684219d2014-07-07 14:54:57 -07001524 UpdateDownloadAllowedCellularUserOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001525 // Update over cellular can be enabled by user settings, but only if policy
1526 // is present and does not determine allowed connections.
1527
1528 fake_state_.shill_provider()->var_conn_type()->
1529 reset(new ConnectionType(ConnectionType::kCellular));
1530 set<ConnectionType> allowed_connections;
1531 allowed_connections.insert(ConnectionType::kCellular);
1532 fake_state_.updater_provider()->var_cellular_enabled()->
1533 reset(new bool(true));
1534
1535 bool result;
1536 ExpectPolicyStatus(EvalStatus::kSucceeded,
Gilad Arnold684219d2014-07-07 14:54:57 -07001537 &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001538 EXPECT_TRUE(result);
1539}
1540
Gilad Arnold14a9e702014-10-08 08:09:09 -07001541TEST_F(UmChromeOSPolicyTest,
1542 UpdateCanStartAllowedScatteringSupressedDueToP2P) {
1543 // The UpdateCanStart policy returns true; scattering should have applied, but
1544 // P2P download is allowed. Scattering values are nonetheless returned, and so
1545 // are download URL values, albeit the latter are not allowed to be used.
1546
1547 SetUpdateCheckAllowed(false);
1548 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
1549 new TimeDelta(TimeDelta::FromMinutes(2)));
1550 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1551
1552 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
1553 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
1554
1555 UpdateDownloadParams result;
1556 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart,
1557 &result, update_state);
1558 EXPECT_TRUE(result.update_can_start);
1559 EXPECT_EQ(0, result.download_url_idx);
1560 EXPECT_FALSE(result.download_url_allowed);
1561 EXPECT_EQ(0, result.download_url_num_errors);
1562 EXPECT_TRUE(result.p2p_downloading_allowed);
1563 EXPECT_TRUE(result.p2p_sharing_allowed);
1564 EXPECT_FALSE(result.do_increment_failures);
1565 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
1566 EXPECT_EQ(0, result.scatter_check_threshold);
1567}
1568
1569TEST_F(UmChromeOSPolicyTest,
1570 UpdateCanStartAllowedBackoffSupressedDueToP2P) {
1571 // The UpdateCanStart policy returns true; backoff should have applied, but
1572 // P2P download is allowed. Backoff values are nonetheless returned, and so
1573 // are download URL values, albeit the latter are not allowed to be used.
1574
1575 SetUpdateCheckAllowed(false);
1576
1577 const Time curr_time = fake_clock_.GetWallclockTime();
1578 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
1579 update_state.download_errors_max = 1;
1580 update_state.download_errors.emplace_back(
1581 0, ErrorCode::kDownloadTransferError,
1582 curr_time - TimeDelta::FromSeconds(8));
1583 update_state.download_errors.emplace_back(
1584 0, ErrorCode::kDownloadTransferError,
1585 curr_time - TimeDelta::FromSeconds(2));
1586 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1587
1588 UpdateDownloadParams result;
1589 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result,
1590 update_state);
1591 EXPECT_TRUE(result.update_can_start);
1592 EXPECT_EQ(0, result.download_url_idx);
1593 EXPECT_FALSE(result.download_url_allowed);
1594 EXPECT_EQ(0, result.download_url_num_errors);
1595 EXPECT_TRUE(result.p2p_downloading_allowed);
1596 EXPECT_TRUE(result.p2p_sharing_allowed);
1597 EXPECT_TRUE(result.do_increment_failures);
1598 EXPECT_LT(curr_time, result.backoff_expiry);
1599}
1600
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001601TEST_F(UmChromeOSPolicyTest, P2PEnabledNotAllowed) {
1602 bool result;
1603 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1604 EXPECT_FALSE(result);
1605}
1606
1607TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByDevicePolicy) {
1608 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1609 new bool(true));
1610
1611 bool result;
1612 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1613 EXPECT_TRUE(result);
1614}
1615
1616TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByUpdater) {
1617 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1618
1619 bool result;
1620 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1621 EXPECT_TRUE(result);
1622}
1623
1624TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedDeviceEnterpriseEnrolled) {
1625 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
1626 fake_state_.device_policy_provider()->var_owner()->reset(nullptr);
1627
1628 bool result;
1629 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1630 EXPECT_TRUE(result);
1631}
1632
1633TEST_F(UmChromeOSPolicyTest, P2PEnabledChangedBlocks) {
1634 bool result;
1635 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater, &Policy::P2PEnabledChanged,
1636 &result, false);
1637}
1638
Alex Deymo63784a52014-05-28 10:46:14 -07001639} // namespace chromeos_update_manager