blob: 996db2bfbf8e530a35d5aa61ced4bcf93f49c8c9 [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.
Amin Hassani4b717432019-01-14 16:24:20 -080052 fake_state_.config_provider()->var_is_oobe_enabled()->reset(new bool(true));
Gilad Arnolda1eabcd2014-07-09 15:42:40 -070053
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.
Amin Hassani4b717432019-01-14 16:24:20 -080064 fake_state_.shill_provider()->var_conn_type()->reset(
65 new ConnectionType(ConnectionType::kWifi));
66 fake_state_.shill_provider()->var_conn_tethering()->reset(
67 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));
Amin Hassani4b717432019-01-14 16:24:20 -080077 fake_state_.device_policy_provider()
78 ->var_allowed_connection_types_for_update()
79 ->reset(nullptr);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070080 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));
Amin Hassani4b717432019-01-14 16:24:20 -080086 fake_state_.device_policy_provider()
87 ->var_release_channel_delegated()
88 ->reset(new bool(true));
Adolfo Victoria94ffe132018-06-28 16:14:56 -070089 fake_state_.device_policy_provider()
90 ->var_disallowed_time_intervals()
91 ->reset(new WeeklyTimeIntervalVector());
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070092 }
93
Amin Hassani186ff6a2018-02-27 11:06:03 -080094 // Configures the policy to return a desired value from UpdateCheckAllowed by
Gilad Arnoldf62a4b82014-05-01 07:41:07 -070095 // faking the current wall clock time as needed. Restores the default state.
96 // This is used when testing policies that depend on this one.
Amin Hassani186ff6a2018-02-27 11:06:03 -080097 //
98 // Note that the default implementation relies on NextUpdateCheckPolicyImpl to
99 // set the FakeClock to the appropriate time.
100 virtual void SetUpdateCheckAllowed(bool allow_check) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700101 Time next_update_check;
Amin Hassani186ff6a2018-02-27 11:06:03 -0800102 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
103 &next_update_check,
104 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700105 SetUpDefaultState();
106 SetUpDefaultDevicePolicy();
107 Time curr_time = next_update_check;
108 if (allow_check)
109 curr_time += TimeDelta::FromSeconds(1);
110 else
111 curr_time -= TimeDelta::FromSeconds(1);
112 fake_clock_.SetWallclockTime(curr_time);
113 }
Marton Hunyady8b936f22018-06-15 16:44:37 +0200114
115 // Sets the policies required for a kiosk app to control Chrome OS version:
116 // - AllowKioskAppControlChromeVersion = True
117 // - UpdateDisabled = True
118 // In the kiosk app manifest:
119 // - RequiredPlatformVersion = 1234.
120 void SetKioskAppControlsChromeOsVersion() {
121 fake_state_.device_policy_provider()
122 ->var_allow_kiosk_app_control_chrome_version()
123 ->reset(new bool(true));
124 fake_state_.device_policy_provider()->var_update_disabled()->reset(
125 new bool(true));
126 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
127 new string("1234."));
128 }
129
130 // Sets up a test with the value of RollbackToTargetVersion policy (and
131 // whether it's set), and returns the value of
132 // UpdateCheckParams.rollback_allowed.
133 bool TestRollbackAllowed(bool set_policy,
134 RollbackToTargetVersion rollback_to_target_version) {
135 // Update check is allowed, response includes attributes for use in the
136 // request.
137 SetUpdateCheckAllowed(true);
138
139 if (set_policy) {
140 // Override RollbackToTargetVersion device policy attribute.
141 fake_state_.device_policy_provider()
142 ->var_rollback_to_target_version()
143 ->reset(new RollbackToTargetVersion(rollback_to_target_version));
144 }
145
146 UpdateCheckParams result;
147 ExpectPolicyStatus(
148 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
149 return result.rollback_allowed;
150 }
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700151
152 // Sets up a test with the given intervals and the current fake wallclock
153 // time.
154 void TestDisallowedTimeIntervals(const WeeklyTimeIntervalVector& intervals,
Adolfo Victoria7a7a0822018-07-27 13:35:24 -0700155 const ErrorCode& expected_error_code,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -0700156 bool kiosk) {
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700157 SetUpDefaultTimeProvider();
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -0700158 if (kiosk)
159 fake_state_.device_policy_provider()
160 ->var_auto_launched_kiosk_app_id()
161 ->reset(new string("myapp"));
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700162 fake_state_.device_policy_provider()
163 ->var_disallowed_time_intervals()
164 ->reset(new WeeklyTimeIntervalVector(intervals));
165
166 // Check that |expected_status| matches the value of UpdateCheckAllowed
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -0700167 ErrorCode result;
168 InstallPlan install_plan;
Adolfo Victoria7a7a0822018-07-27 13:35:24 -0700169 ExpectPolicyStatus(EvalStatus::kSucceeded,
170 &Policy::UpdateCanBeApplied,
171 &result,
172 &install_plan);
173 EXPECT_EQ(result, expected_error_code);
Adolfo Victoria94ffe132018-06-28 16:14:56 -0700174 }
Alex Deymo0d11c602014-04-23 20:12:20 -0700175};
176
Alex Deymo63784a52014-05-28 10:46:14 -0700177TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForTheTimeout) {
Alex Deymo0d11c602014-04-23 20:12:20 -0700178 // We get the next update_check timestamp from the policy's private method
179 // and then we check the public method respects that value on the normal
180 // case.
181 Time next_update_check;
182 Time last_checked_time =
183 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
184
Alex Deymo0d11c602014-04-23 20:12:20 -0700185 fake_state_.updater_provider()->var_last_checked_time()->reset(
186 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800187 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
188 &next_update_check,
189 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Alex Deymo0d11c602014-04-23 20:12:20 -0700190
191 UpdateCheckParams result;
192
193 // Check that the policy blocks until the next_update_check is reached.
194 SetUpDefaultClock();
195 SetUpDefaultState();
196 fake_state_.updater_provider()->var_last_checked_time()->reset(
197 new Time(last_checked_time));
198 fake_clock_.SetWallclockTime(next_update_check - TimeDelta::FromSeconds(1));
Amin Hassani4b717432019-01-14 16:24:20 -0800199 ExpectPolicyStatus(
200 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Alex Deymo0d11c602014-04-23 20:12:20 -0700201
202 SetUpDefaultClock();
203 SetUpDefaultState();
204 fake_state_.updater_provider()->var_last_checked_time()->reset(
205 new Time(last_checked_time));
206 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
Amin Hassani4b717432019-01-14 16:24:20 -0800207 ExpectPolicyStatus(
208 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700209 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700210 EXPECT_FALSE(result.interactive);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700211}
212
213TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForOOBE) {
Alex Vakulenko072359c2014-07-18 11:41:07 -0700214 // Update checks are deferred until OOBE is completed.
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700215
216 // Ensure that update is not allowed even if wait period is satisfied.
217 Time next_update_check;
218 Time last_checked_time =
219 fake_clock_.GetWallclockTime() + TimeDelta::FromMinutes(1234);
220
221 fake_state_.updater_provider()->var_last_checked_time()->reset(
222 new Time(last_checked_time));
Amin Hassani186ff6a2018-02-27 11:06:03 -0800223 CallMethodWithContext(&NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime,
224 &next_update_check,
225 ChromeOSPolicy::kNextUpdateCheckPolicyConstants);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700226
227 SetUpDefaultClock();
228 SetUpDefaultState();
229 fake_state_.updater_provider()->var_last_checked_time()->reset(
230 new Time(last_checked_time));
231 fake_clock_.SetWallclockTime(next_update_check + TimeDelta::FromSeconds(1));
Amin Hassani4b717432019-01-14 16:24:20 -0800232 fake_state_.system_provider()->var_is_oobe_complete()->reset(new bool(false));
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700233
234 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800235 ExpectPolicyStatus(
236 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700237
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));
Amin Hassani4b717432019-01-14 16:24:20 -0800244 ExpectPolicyStatus(
245 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnolda1eabcd2014-07-09 15:42:40 -0700246 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.
Amin Hassani4b717432019-01-14 16:24:20 -0800256 fake_state_.device_policy_provider()->var_target_version_prefix()->reset(
257 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));
Amin Hassani4b717432019-01-14 16:24:20 -0800263 fake_state_.device_policy_provider()->var_release_channel()->reset(
264 new string("foo-channel"));
Amin Hassani37b67232020-08-13 09:29:48 -0700265 fake_state_.device_policy_provider()->var_release_lts_tag()->reset(
266 new string("foo-hint"));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700267
268 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800269 ExpectPolicyStatus(
270 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700271 EXPECT_TRUE(result.updates_enabled);
Gilad Arnoldd4b30322014-07-21 15:35:27 -0700272 EXPECT_EQ("1.2", result.target_version_prefix);
Marton Hunyady0e0e3542018-02-21 18:51:39 +0100273 EXPECT_EQ(5, result.rollback_allowed_milestones);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700274 EXPECT_EQ("foo-channel", result.target_channel);
Amin Hassani37b67232020-08-13 09:29:48 -0700275 EXPECT_EQ("foo-hint", result.lts_tag);
Amin Hassanied37d682018-04-06 13:22:00 -0700276 EXPECT_FALSE(result.interactive);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700277}
278
Marton Hunyadyd4bc4622018-08-30 15:52:23 +0200279TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackAndPowerwash) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200280 EXPECT_TRUE(TestRollbackAllowed(
Marton Hunyadyd4bc4622018-08-30 15:52:23 +0200281 true, RollbackToTargetVersion::kRollbackAndPowerwash));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200282}
283
Marton Hunyady31aefb92018-08-29 16:17:03 +0200284TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackAndRestoreIfPossible) {
285 // We're doing rollback even if we don't support data save and restore.
286 EXPECT_TRUE(TestRollbackAllowed(
287 true, RollbackToTargetVersion::kRollbackAndRestoreIfPossible));
288}
289
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200290TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackDisabled) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200291 EXPECT_FALSE(TestRollbackAllowed(true, RollbackToTargetVersion::kDisabled));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200292}
293
294TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackUnspecified) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200295 EXPECT_FALSE(
296 TestRollbackAllowed(true, RollbackToTargetVersion::kUnspecified));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200297}
298
299TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedRollbackNotSet) {
Marton Hunyady8b936f22018-06-15 16:44:37 +0200300 EXPECT_FALSE(
301 TestRollbackAllowed(false, RollbackToTargetVersion::kUnspecified));
302}
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200303
Marton Hunyady8b936f22018-06-15 16:44:37 +0200304TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackAllowed) {
305 SetKioskAppControlsChromeOsVersion();
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200306
Marton Hunyady8b936f22018-06-15 16:44:37 +0200307 EXPECT_TRUE(TestRollbackAllowed(
Marton Hunyadyd4bc4622018-08-30 15:52:23 +0200308 true, RollbackToTargetVersion::kRollbackAndPowerwash));
Marton Hunyady8b936f22018-06-15 16:44:37 +0200309}
310
311TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackDisabled) {
312 SetKioskAppControlsChromeOsVersion();
313
314 EXPECT_FALSE(TestRollbackAllowed(true, RollbackToTargetVersion::kDisabled));
315}
316
317TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackUnspecified) {
318 SetKioskAppControlsChromeOsVersion();
319
320 EXPECT_FALSE(
321 TestRollbackAllowed(true, RollbackToTargetVersion::kUnspecified));
322}
323
324TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskRollbackNotSet) {
325 SetKioskAppControlsChromeOsVersion();
326
327 EXPECT_FALSE(
328 TestRollbackAllowed(false, RollbackToTargetVersion::kUnspecified));
Marton Hunyadyba51c3f2018-04-25 15:18:10 +0200329}
330
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700331TEST_F(UmChromeOSPolicyTest,
332 UpdateCheckAllowedUpdatesDisabledForUnofficialBuilds) {
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700333 // UpdateCheckAllowed should return kAskMeAgainLater if this is an unofficial
334 // build; we don't want periodic update checks on developer images.
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700335
336 fake_state_.system_provider()->var_is_official_build()->reset(
337 new bool(false));
338
339 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800340 ExpectPolicyStatus(
341 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700342}
343
Amin Hassani03277de2020-07-28 12:32:49 -0700344TEST_F(UmChromeOSPolicyTest, TestUpdateCheckIntervalTimeout) {
345 fake_state_.updater_provider()
346 ->var_test_update_check_interval_timeout()
347 ->reset(new int64_t(10));
348 fake_state_.system_provider()->var_is_official_build()->reset(
349 new bool(false));
350
351 // The first time, update should not be allowed.
352 UpdateCheckParams result;
353 ExpectPolicyStatus(
354 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
355
356 // After moving the time forward more than the update check interval, it
357 // should now allow for update.
358 fake_clock_.SetWallclockTime(fake_clock_.GetWallclockTime() +
359 TimeDelta::FromSeconds(11));
360 ExpectPolicyStatus(
361 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
362}
363
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700364TEST_F(UmChromeOSPolicyTest,
Aaron Wood56d8ab32017-09-22 15:56:18 -0700365 UpdateCheckAllowedUpdatesDisabledWhenNotEnoughSlotsAbUpdates) {
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700366 // UpdateCheckAllowed should return false (kSucceeded) if the image booted
Aaron Wood56d8ab32017-09-22 15:56:18 -0700367 // without enough slots to do A/B updates.
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700368
Aaron Woodc73fdc12017-12-06 11:09:15 -0800369 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -0700370 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(1));
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700371
372 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800373 ExpectPolicyStatus(
374 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700375 EXPECT_FALSE(result.updates_enabled);
376}
377
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700378TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedUpdatesDisabledByPolicy) {
Gilad Arnold42f253b2014-06-25 12:39:17 -0700379 // UpdateCheckAllowed should return kAskMeAgainLater because a device policy
380 // is loaded and prohibits updates.
381
382 SetUpdateCheckAllowed(false);
383 fake_state_.device_policy_provider()->var_update_disabled()->reset(
384 new bool(true));
385
Gilad Arnold42f253b2014-06-25 12:39:17 -0700386 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800387 ExpectPolicyStatus(
388 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700389}
390
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700391TEST_F(UmChromeOSPolicyTest,
392 UpdateCheckAllowedForcedUpdateRequestedInteractive) {
393 // UpdateCheckAllowed should return true because a forced update request was
394 // signaled for an interactive update.
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700395
396 SetUpdateCheckAllowed(true);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700397 fake_state_.updater_provider()->var_forced_update_requested()->reset(
398 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700399
400 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800401 ExpectPolicyStatus(
402 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700403 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700404 EXPECT_TRUE(result.interactive);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700405}
406
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700407TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedForcedUpdateRequestedPeriodic) {
408 // UpdateCheckAllowed should return true because a forced update request was
409 // signaled for a periodic check.
410
411 SetUpdateCheckAllowed(true);
412 fake_state_.updater_provider()->var_forced_update_requested()->reset(
413 new UpdateRequestStatus(UpdateRequestStatus::kPeriodic));
414
415 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800416 ExpectPolicyStatus(
417 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700418 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700419 EXPECT_FALSE(result.interactive);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700420}
421
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800422TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPin) {
423 // Update check is allowed.
424 SetUpdateCheckAllowed(true);
425
Marton Hunyady8b936f22018-06-15 16:44:37 +0200426 SetKioskAppControlsChromeOsVersion();
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800427
428 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800429 ExpectPolicyStatus(
430 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800431 EXPECT_TRUE(result.updates_enabled);
Marton Hunyady8b936f22018-06-15 16:44:37 +0200432 EXPECT_EQ("1234.", result.target_version_prefix);
Amin Hassanied37d682018-04-06 13:22:00 -0700433 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800434}
435
436TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedDisabledWhenNoKioskPin) {
437 // Update check is allowed.
438 SetUpdateCheckAllowed(true);
439
440 // Disable AU policy is set but kiosk pin policy is set to false. Update is
441 // disabled in such case.
442 fake_state_.device_policy_provider()->var_update_disabled()->reset(
443 new bool(true));
444 fake_state_.device_policy_provider()
445 ->var_allow_kiosk_app_control_chrome_version()
446 ->reset(new bool(false));
447
448 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800449 ExpectPolicyStatus(
450 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800451}
452
453TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPinWithNoRequiredVersion) {
454 // Update check is allowed.
455 SetUpdateCheckAllowed(true);
456
457 // AU disabled, allow kiosk to pin but there is no kiosk required platform
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700458 // version (i.e. app does not provide the info). Update to latest in such
459 // case.
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800460 fake_state_.device_policy_provider()->var_update_disabled()->reset(
461 new bool(true));
462 fake_state_.device_policy_provider()
463 ->var_allow_kiosk_app_control_chrome_version()
464 ->reset(new bool(true));
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700465 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
466 new string());
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800467
468 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800469 ExpectPolicyStatus(
470 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800471 EXPECT_TRUE(result.updates_enabled);
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700472 EXPECT_TRUE(result.target_version_prefix.empty());
Amin Hassanied37d682018-04-06 13:22:00 -0700473 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800474}
475
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700476TEST_F(UmChromeOSPolicyTest,
477 UpdateCheckAllowedKioskPinWithFailedGetRequiredVersionCall) {
478 // AU disabled, allow kiosk to pin but D-Bus call to get required platform
479 // version failed. Defer update check in this case.
480 fake_state_.device_policy_provider()->var_update_disabled()->reset(
481 new bool(true));
482 fake_state_.device_policy_provider()
483 ->var_allow_kiosk_app_control_chrome_version()
484 ->reset(new bool(true));
485 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
486 nullptr);
487
488 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800489 ExpectPolicyStatus(
490 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700491}
492
Alex Deymo63784a52014-05-28 10:46:14 -0700493TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsCheckAllowedError) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700494 // The UpdateCanStart policy fails, not being able to query
495 // UpdateCheckAllowed.
496
497 // Configure the UpdateCheckAllowed policy to fail.
498 fake_state_.updater_provider()->var_updater_started_time()->reset(nullptr);
499
500 // Check that the UpdateCanStart fails.
501 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700502 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800503 ExpectPolicyStatus(
504 EvalStatus::kFailed, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700505}
506
Alex Deymo63784a52014-05-28 10:46:14 -0700507TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedCheckDue) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700508 // The UpdateCanStart policy returns false because we are due for another
Gilad Arnold14a9e702014-10-08 08:09:09 -0700509 // update check. Ensure that download related values are still returned.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700510
511 SetUpdateCheckAllowed(true);
512
513 // Check that the UpdateCanStart returns false.
514 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700515 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800516 ExpectPolicyStatus(
517 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700518 EXPECT_FALSE(result.update_can_start);
519 EXPECT_EQ(UpdateCannotStartReason::kCheckDue, result.cannot_start_reason);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700520 EXPECT_EQ(0, result.download_url_idx);
521 EXPECT_EQ(0, result.download_url_num_errors);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700522}
523
Alex Deymo63784a52014-05-28 10:46:14 -0700524TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoDevicePolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700525 // The UpdateCanStart policy returns true; no device policy is loaded.
526
527 SetUpdateCheckAllowed(false);
528 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
529 new bool(false));
530
531 // Check that the UpdateCanStart returns true with no further attributes.
532 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700533 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800534 ExpectPolicyStatus(
535 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700536 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700537 EXPECT_FALSE(result.p2p_downloading_allowed);
538 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700539 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700540 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700541 EXPECT_EQ(0, result.download_url_num_errors);
542 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700543}
544
Alex Deymo63784a52014-05-28 10:46:14 -0700545TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBlankPolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700546 // The UpdateCanStart policy returns true; device policy is loaded but imposes
547 // no restrictions on updating.
548
549 SetUpdateCheckAllowed(false);
550
551 // Check that the UpdateCanStart returns true.
552 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700553 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800554 ExpectPolicyStatus(
555 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700556 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700557 EXPECT_FALSE(result.p2p_downloading_allowed);
558 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700559 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700560 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700561 EXPECT_EQ(0, result.download_url_num_errors);
562 EXPECT_FALSE(result.do_increment_failures);
563}
564
565TEST_F(UmChromeOSPolicyTest,
566 UpdateCanStartNotAllowedBackoffNewWaitPeriodApplies) {
567 // The UpdateCanStart policy returns false; failures are reported and a new
568 // backoff period is enacted.
569
570 SetUpdateCheckAllowed(false);
571
572 const Time curr_time = fake_clock_.GetWallclockTime();
573 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
574 update_state.download_errors_max = 1;
575 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800576 0,
577 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700578 curr_time - TimeDelta::FromSeconds(8));
579 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800580 0,
581 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700582 curr_time - TimeDelta::FromSeconds(2));
583
584 // Check that UpdateCanStart returns false and a new backoff expiry is
585 // generated.
586 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800587 ExpectPolicyStatus(
588 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700589 EXPECT_FALSE(result.update_can_start);
590 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
591 EXPECT_TRUE(result.do_increment_failures);
592 EXPECT_LT(curr_time, result.backoff_expiry);
593}
594
595TEST_F(UmChromeOSPolicyTest,
596 UpdateCanStartNotAllowedBackoffPrevWaitPeriodStillApplies) {
597 // The UpdateCanStart policy returns false; a previously enacted backoff
598 // period still applies.
599
600 SetUpdateCheckAllowed(false);
601
602 const Time curr_time = fake_clock_.GetWallclockTime();
603 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
604 update_state.download_errors_max = 1;
605 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800606 0,
607 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700608 curr_time - TimeDelta::FromSeconds(8));
609 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800610 0,
611 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700612 curr_time - TimeDelta::FromSeconds(2));
613 update_state.failures_last_updated = curr_time;
614 update_state.backoff_expiry = curr_time + TimeDelta::FromMinutes(3);
615
616 // Check that UpdateCanStart returns false and a new backoff expiry is
617 // generated.
618 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800619 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
620 &Policy::UpdateCanStart,
621 &result,
622 update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700623 EXPECT_FALSE(result.update_can_start);
624 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
625 EXPECT_FALSE(result.do_increment_failures);
626 EXPECT_LT(curr_time, result.backoff_expiry);
627}
628
629TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffSatisfied) {
630 // The UpdateCanStart policy returns true; a previously enacted backoff period
631 // has elapsed, we're good to go.
632
633 SetUpdateCheckAllowed(false);
634
635 const Time curr_time = fake_clock_.GetWallclockTime();
636 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
637 update_state.download_errors_max = 1;
638 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800639 0,
640 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700641 curr_time - TimeDelta::FromSeconds(8));
642 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800643 0,
644 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700645 curr_time - TimeDelta::FromSeconds(2));
646 update_state.failures_last_updated = curr_time - TimeDelta::FromSeconds(1);
647 update_state.backoff_expiry = curr_time - TimeDelta::FromSeconds(1);
648
649 // Check that UpdateCanStart returns false and a new backoff expiry is
650 // generated.
651 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800652 ExpectPolicyStatus(
653 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700654 EXPECT_TRUE(result.update_can_start);
655 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
656 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700657 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700658 EXPECT_EQ(0, result.download_url_num_errors);
659 EXPECT_FALSE(result.do_increment_failures);
660 EXPECT_EQ(Time(), result.backoff_expiry);
661}
662
663TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffDisabled) {
664 // The UpdateCanStart policy returns false; failures are reported but backoff
665 // is disabled.
666
667 SetUpdateCheckAllowed(false);
668
669 const Time curr_time = fake_clock_.GetWallclockTime();
670 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
671 update_state.download_errors_max = 1;
672 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800673 0,
674 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700675 curr_time - TimeDelta::FromSeconds(8));
676 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800677 0,
678 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700679 curr_time - TimeDelta::FromSeconds(2));
680 update_state.is_backoff_disabled = true;
681
682 // Check that UpdateCanStart returns false and a new backoff expiry is
683 // generated.
684 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800685 ExpectPolicyStatus(
686 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700687 EXPECT_TRUE(result.update_can_start);
688 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
689 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700690 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700691 EXPECT_EQ(0, result.download_url_num_errors);
692 EXPECT_TRUE(result.do_increment_failures);
693 EXPECT_EQ(Time(), result.backoff_expiry);
694}
695
696TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffInteractive) {
697 // The UpdateCanStart policy returns false; failures are reported but this is
698 // an interactive update check.
699
700 SetUpdateCheckAllowed(false);
701
702 const Time curr_time = fake_clock_.GetWallclockTime();
703 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
704 update_state.download_errors_max = 1;
705 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800706 0,
707 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700708 curr_time - TimeDelta::FromSeconds(8));
709 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800710 0,
711 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700712 curr_time - TimeDelta::FromSeconds(2));
Amin Hassanied37d682018-04-06 13:22:00 -0700713 update_state.interactive = true;
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700714
715 // Check that UpdateCanStart returns false and a new backoff expiry is
716 // generated.
717 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800718 ExpectPolicyStatus(
719 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700720 EXPECT_TRUE(result.update_can_start);
721 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
722 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700723 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700724 EXPECT_EQ(0, result.download_url_num_errors);
725 EXPECT_TRUE(result.do_increment_failures);
726 EXPECT_EQ(Time(), result.backoff_expiry);
727}
728
729TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffDelta) {
730 // The UpdateCanStart policy returns false; failures are reported but this is
731 // a delta payload.
732
733 SetUpdateCheckAllowed(false);
734
735 const Time curr_time = fake_clock_.GetWallclockTime();
736 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
737 update_state.download_errors_max = 1;
738 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800739 0,
740 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700741 curr_time - TimeDelta::FromSeconds(8));
742 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800743 0,
744 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700745 curr_time - TimeDelta::FromSeconds(2));
746 update_state.is_delta_payload = true;
747
748 // Check that UpdateCanStart returns false and a new backoff expiry is
749 // generated.
750 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800751 ExpectPolicyStatus(
752 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700753 EXPECT_TRUE(result.update_can_start);
754 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
755 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700756 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700757 EXPECT_EQ(0, result.download_url_num_errors);
758 EXPECT_TRUE(result.do_increment_failures);
759 EXPECT_EQ(Time(), result.backoff_expiry);
760}
761
762TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffUnofficialBuild) {
763 // The UpdateCanStart policy returns false; failures are reported but this is
764 // an unofficial build.
765
766 SetUpdateCheckAllowed(false);
767
768 const Time curr_time = fake_clock_.GetWallclockTime();
769 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
770 update_state.download_errors_max = 1;
771 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800772 0,
773 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700774 curr_time - TimeDelta::FromSeconds(8));
775 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800776 0,
777 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700778 curr_time - TimeDelta::FromSeconds(2));
779
Amin Hassani4b717432019-01-14 16:24:20 -0800780 fake_state_.system_provider()->var_is_official_build()->reset(
781 new bool(false));
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700782
783 // Check that UpdateCanStart returns false and a new backoff expiry is
784 // generated.
785 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800786 ExpectPolicyStatus(
787 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700788 EXPECT_TRUE(result.update_can_start);
789 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
790 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700791 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700792 EXPECT_EQ(0, result.download_url_num_errors);
793 EXPECT_TRUE(result.do_increment_failures);
794 EXPECT_EQ(Time(), result.backoff_expiry);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700795}
796
Alex Deymo63784a52014-05-28 10:46:14 -0700797TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsScatteringFailed) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700798 // The UpdateCanStart policy fails because the UpdateScattering policy it
799 // depends on fails (unset variable).
800
801 SetUpdateCheckAllowed(false);
802
803 // Override the default seed variable with a null value so that the policy
804 // request would fail.
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700805 // TODO(garnold) This failure may or may not fail a number
806 // sub-policies/decisions, like scattering and backoff. We'll need a more
807 // deliberate setup to ensure that we're failing what we want to be failing.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700808 fake_state_.random_provider()->var_seed()->reset(nullptr);
809
810 // Check that the UpdateCanStart fails.
811 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700812 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800813 ExpectPolicyStatus(
814 EvalStatus::kFailed, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700815}
816
Alex Deymo63784a52014-05-28 10:46:14 -0700817TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700818 UpdateCanStartNotAllowedScatteringNewWaitPeriodApplies) {
819 // The UpdateCanStart policy returns false; device policy is loaded and
820 // scattering applies due to an unsatisfied wait period, which was newly
821 // generated.
822
823 SetUpdateCheckAllowed(false);
824 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
825 new TimeDelta(TimeDelta::FromMinutes(2)));
826
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700827 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
828
829 // Check that the UpdateCanStart returns false and a new wait period
830 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700831 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800832 ExpectPolicyStatus(
833 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700834 EXPECT_FALSE(result.update_can_start);
835 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
836 EXPECT_LT(TimeDelta(), result.scatter_wait_period);
837 EXPECT_EQ(0, result.scatter_check_threshold);
838}
839
Alex Deymo63784a52014-05-28 10:46:14 -0700840TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700841 UpdateCanStartNotAllowedScatteringPrevWaitPeriodStillApplies) {
842 // The UpdateCanStart policy returns false w/ kAskMeAgainLater; device policy
843 // is loaded and a previously generated scattering period still applies, none
844 // of the scattering values has changed.
845
846 SetUpdateCheckAllowed(false);
847 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
848 new TimeDelta(TimeDelta::FromMinutes(2)));
849
850 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
851 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
852
853 // Check that the UpdateCanStart returns false and a new wait period
854 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700855 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800856 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
857 &Policy::UpdateCanStart,
858 &result,
859 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700860 EXPECT_FALSE(result.update_can_start);
861 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
862 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
863 EXPECT_EQ(0, result.scatter_check_threshold);
864}
865
Alex Deymo63784a52014-05-28 10:46:14 -0700866TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700867 UpdateCanStartNotAllowedScatteringNewCountThresholdApplies) {
868 // The UpdateCanStart policy returns false; device policy is loaded and
869 // scattering applies due to an unsatisfied update check count threshold.
870 //
871 // This ensures a non-zero check threshold, which may or may not be combined
872 // with a non-zero wait period (for which we cannot reliably control).
873
874 SetUpdateCheckAllowed(false);
875 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
876 new TimeDelta(TimeDelta::FromSeconds(1)));
877
878 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
879 update_state.scatter_check_threshold_min = 2;
880 update_state.scatter_check_threshold_max = 5;
881
882 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700883 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800884 ExpectPolicyStatus(
885 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700886 EXPECT_FALSE(result.update_can_start);
887 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
888 EXPECT_LE(2, result.scatter_check_threshold);
889 EXPECT_GE(5, result.scatter_check_threshold);
890}
891
Alex Deymo63784a52014-05-28 10:46:14 -0700892TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700893 UpdateCanStartNotAllowedScatteringPrevCountThresholdStillApplies) {
894 // The UpdateCanStart policy returns false; device policy is loaded and
895 // scattering due to a previously generated count threshold still applies.
896
897 SetUpdateCheckAllowed(false);
898 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
899 new TimeDelta(TimeDelta::FromSeconds(1)));
900
901 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
902 update_state.scatter_check_threshold = 3;
903 update_state.scatter_check_threshold_min = 2;
904 update_state.scatter_check_threshold_max = 5;
905
906 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700907 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800908 ExpectPolicyStatus(
909 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700910 EXPECT_FALSE(result.update_can_start);
911 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
912 EXPECT_EQ(3, result.scatter_check_threshold);
913}
914
Alex Deymo63784a52014-05-28 10:46:14 -0700915TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSatisfied) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700916 // The UpdateCanStart policy returns true; device policy is loaded and
917 // scattering is enabled, but both wait period and check threshold are
918 // satisfied.
919
920 SetUpdateCheckAllowed(false);
921 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
922 new TimeDelta(TimeDelta::FromSeconds(120)));
923
924 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(75));
925 update_state.num_checks = 4;
926 update_state.scatter_wait_period = TimeDelta::FromSeconds(60);
927 update_state.scatter_check_threshold = 3;
928 update_state.scatter_check_threshold_min = 2;
929 update_state.scatter_check_threshold_max = 5;
930
931 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700932 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800933 ExpectPolicyStatus(
934 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700935 EXPECT_TRUE(result.update_can_start);
936 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
937 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700938 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700939 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700940 EXPECT_EQ(0, result.download_url_num_errors);
941 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700942}
943
Alex Deymo63784a52014-05-28 10:46:14 -0700944TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700945 UpdateCanStartAllowedInteractivePreventsScattering) {
946 // The UpdateCanStart policy returns true; device policy is loaded and
947 // scattering would have applied, except that the update check is interactive
948 // and so it is suppressed.
949
950 SetUpdateCheckAllowed(false);
951 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
952 new TimeDelta(TimeDelta::FromSeconds(1)));
953
954 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700955 update_state.interactive = true;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700956 update_state.scatter_check_threshold = 0;
957 update_state.scatter_check_threshold_min = 2;
958 update_state.scatter_check_threshold_max = 5;
959
960 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700961 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800962 ExpectPolicyStatus(
963 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700964 EXPECT_TRUE(result.update_can_start);
965 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
966 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700967 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700968 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700969 EXPECT_EQ(0, result.download_url_num_errors);
970 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700971}
972
Amin Hassani4b717432019-01-14 16:24:20 -0800973TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedOobePreventsScattering) {
Gilad Arnold76a11f62014-05-20 09:02:12 -0700974 // The UpdateCanStart policy returns true; device policy is loaded and
975 // scattering would have applied, except that OOBE was not completed and so it
976 // is suppressed.
977
978 SetUpdateCheckAllowed(false);
979 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
980 new TimeDelta(TimeDelta::FromSeconds(1)));
981 fake_state_.system_provider()->var_is_oobe_complete()->reset(new bool(false));
982
983 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700984 update_state.interactive = true;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700985 update_state.scatter_check_threshold = 0;
986 update_state.scatter_check_threshold_min = 2;
987 update_state.scatter_check_threshold_max = 5;
988
989 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700990 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800991 ExpectPolicyStatus(
992 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700993 EXPECT_TRUE(result.update_can_start);
994 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
995 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700996 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700997 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700998 EXPECT_EQ(0, result.download_url_num_errors);
999 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnold76a11f62014-05-20 09:02:12 -07001000}
1001
Alex Deymo63784a52014-05-28 10:46:14 -07001002TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithAttributes) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001003 // The UpdateCanStart policy returns true; device policy permits both HTTP and
1004 // P2P updates, as well as a non-empty target channel string.
1005
1006 SetUpdateCheckAllowed(false);
1007
1008 // Override specific device policy attributes.
1009 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1010 new bool(true));
1011 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1012 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001013
1014 // Check that the UpdateCanStart returns true.
1015 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001016 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001017 ExpectPolicyStatus(
1018 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001019 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001020 EXPECT_TRUE(result.p2p_downloading_allowed);
1021 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001022 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001023 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001024 EXPECT_EQ(0, result.download_url_num_errors);
1025 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001026}
1027
Alex Deymo63784a52014-05-28 10:46:14 -07001028TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithP2PFromUpdater) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001029 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1030 // P2P updates, but the updater is configured to allow P2P and overrules the
1031 // setting.
1032
1033 SetUpdateCheckAllowed(false);
1034
1035 // Override specific device policy attributes.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001036 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1037
1038 // Check that the UpdateCanStart returns true.
1039 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001040 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001041 ExpectPolicyStatus(
1042 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001043 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001044 EXPECT_TRUE(result.p2p_downloading_allowed);
1045 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001046 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001047 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001048 EXPECT_EQ(0, result.download_url_num_errors);
1049 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001050}
1051
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001052TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001053 UpdateCanStartAllowedP2PDownloadingBlockedDueToOmaha) {
1054 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1055 // policy blocks P2P downloading because Omaha forbids it. P2P sharing is
1056 // still permitted.
1057
1058 SetUpdateCheckAllowed(false);
1059
1060 // Override specific device policy attributes.
1061 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1062 new bool(true));
1063 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1064 new bool(true));
1065
1066 // Check that the UpdateCanStart returns true.
1067 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1068 update_state.p2p_downloading_disabled = true;
1069 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001070 ExpectPolicyStatus(
1071 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001072 EXPECT_TRUE(result.update_can_start);
1073 EXPECT_FALSE(result.p2p_downloading_allowed);
1074 EXPECT_TRUE(result.p2p_sharing_allowed);
1075}
1076
Amin Hassani4b717432019-01-14 16:24:20 -08001077TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedP2PSharingBlockedDueToOmaha) {
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001078 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1079 // policy blocks P2P sharing because Omaha forbids it. P2P downloading is
1080 // still permitted.
1081
1082 SetUpdateCheckAllowed(false);
1083
1084 // Override specific device policy attributes.
1085 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1086 new bool(true));
1087 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1088 new bool(true));
1089
1090 // Check that the UpdateCanStart returns true.
1091 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1092 update_state.p2p_sharing_disabled = true;
1093 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001094 ExpectPolicyStatus(
1095 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001096 EXPECT_TRUE(result.update_can_start);
1097 EXPECT_TRUE(result.p2p_downloading_allowed);
1098 EXPECT_FALSE(result.p2p_sharing_allowed);
1099}
1100
1101TEST_F(UmChromeOSPolicyTest,
1102 UpdateCanStartAllowedP2PDownloadingBlockedDueToNumAttempts) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001103 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001104 // blocks P2P download, because the max number of P2P downloads have been
1105 // attempted. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001106
1107 SetUpdateCheckAllowed(false);
1108
1109 // Override specific device policy attributes.
1110 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1111 new bool(true));
1112 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1113 new bool(true));
1114
1115 // Check that the UpdateCanStart returns true.
1116 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1117 update_state.p2p_num_attempts = ChromeOSPolicy::kMaxP2PAttempts;
1118 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001119 ExpectPolicyStatus(
1120 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold349ac832014-10-06 14:20:28 -07001121 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001122 EXPECT_FALSE(result.p2p_downloading_allowed);
1123 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001124}
1125
1126TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001127 UpdateCanStartAllowedP2PDownloadingBlockedDueToAttemptsPeriod) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001128 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001129 // blocks P2P download, because the max period for attempt to download via P2P
1130 // has elapsed. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001131
1132 SetUpdateCheckAllowed(false);
1133
1134 // Override specific device policy attributes.
1135 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1136 new bool(true));
1137 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1138 new bool(true));
1139
1140 // Check that the UpdateCanStart returns true.
1141 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1142 update_state.p2p_num_attempts = 1;
1143 update_state.p2p_first_attempted =
1144 fake_clock_.GetWallclockTime() -
Amin Hassani4b717432019-01-14 16:24:20 -08001145 TimeDelta::FromSeconds(ChromeOSPolicy::kMaxP2PAttemptsPeriodInSeconds +
1146 1);
Gilad Arnold349ac832014-10-06 14:20:28 -07001147 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001148 ExpectPolicyStatus(
1149 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold349ac832014-10-06 14:20:28 -07001150 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001151 EXPECT_FALSE(result.p2p_downloading_allowed);
1152 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001153}
1154
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001155TEST_F(UmChromeOSPolicyTest,
1156 UpdateCanStartAllowedWithHttpUrlForUnofficialBuild) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001157 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1158 // P2P updates, but marking this an unofficial build overrules the HTTP
1159 // setting.
1160
1161 SetUpdateCheckAllowed(false);
1162
1163 // Override specific device policy attributes.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001164 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1165 new bool(false));
Amin Hassani4b717432019-01-14 16:24:20 -08001166 fake_state_.system_provider()->var_is_official_build()->reset(
1167 new bool(false));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001168
1169 // Check that the UpdateCanStart returns true.
1170 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001171 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001172 ExpectPolicyStatus(
1173 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001174 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001175 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001176 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001177 EXPECT_EQ(0, result.download_url_num_errors);
1178 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001179}
1180
1181TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithHttpsUrl) {
1182 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1183 // P2P updates, but an HTTPS URL is provided and selected for download.
1184
1185 SetUpdateCheckAllowed(false);
1186
1187 // Override specific device policy attributes.
1188 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1189 new bool(false));
1190
1191 // Add an HTTPS URL.
1192 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001193 update_state.download_urls.emplace_back("https://secure/url/");
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001194
1195 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001196 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001197 ExpectPolicyStatus(
1198 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001199 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001200 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001201 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001202 EXPECT_EQ(0, result.download_url_num_errors);
1203 EXPECT_FALSE(result.do_increment_failures);
1204}
1205
1206TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedMaxErrorsNotExceeded) {
1207 // The UpdateCanStart policy returns true; the first URL has download errors
1208 // but does not exceed the maximum allowed number of failures, so it is stilli
1209 // usable.
1210
1211 SetUpdateCheckAllowed(false);
1212
1213 // Add a second URL; update with this URL attempted and failed enough times to
1214 // disqualify the current (first) URL.
1215 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1216 update_state.num_checks = 5;
1217 update_state.download_urls.emplace_back("http://another/fake/url/");
1218 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1219 for (int i = 0; i < 5; i++) {
1220 update_state.download_errors.emplace_back(
1221 0, ErrorCode::kDownloadTransferError, t);
1222 t += TimeDelta::FromSeconds(1);
1223 }
1224
1225 // Check that the UpdateCanStart returns true.
1226 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001227 ExpectPolicyStatus(
1228 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001229 EXPECT_TRUE(result.update_can_start);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001230 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001231 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001232 EXPECT_EQ(5, result.download_url_num_errors);
1233 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001234}
1235
1236TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlMaxExceeded) {
1237 // The UpdateCanStart policy returns true; the first URL exceeded the maximum
1238 // allowed number of failures, but a second URL is available.
1239
1240 SetUpdateCheckAllowed(false);
1241
1242 // Add a second URL; update with this URL attempted and failed enough times to
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001243 // disqualify the current (first) URL.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001244 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1245 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001246 update_state.download_urls.emplace_back("http://another/fake/url/");
1247 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1248 for (int i = 0; i < 11; i++) {
1249 update_state.download_errors.emplace_back(
1250 0, ErrorCode::kDownloadTransferError, t);
1251 t += TimeDelta::FromSeconds(1);
1252 }
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001253
1254 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001255 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001256 ExpectPolicyStatus(
1257 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001258 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001259 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001260 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001261 EXPECT_EQ(0, result.download_url_num_errors);
1262 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001263}
1264
1265TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlHardError) {
1266 // The UpdateCanStart policy returns true; the first URL fails with a hard
1267 // error, but a second URL is available.
1268
1269 SetUpdateCheckAllowed(false);
1270
1271 // Add a second URL; update with this URL attempted and failed in a way that
1272 // causes it to switch directly to the next URL.
1273 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1274 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001275 update_state.download_urls.emplace_back("http://another/fake/url/");
1276 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001277 0,
1278 ErrorCode::kPayloadHashMismatchError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001279 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001280
1281 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001282 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001283 ExpectPolicyStatus(
1284 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001285 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001286 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001287 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001288 EXPECT_EQ(0, result.download_url_num_errors);
1289 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001290}
1291
1292TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedUrlWrapsAround) {
1293 // The UpdateCanStart policy returns true; URL search properly wraps around
1294 // the last one on the list.
1295
1296 SetUpdateCheckAllowed(false);
1297
1298 // Add a second URL; update with this URL attempted and failed in a way that
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001299 // causes it to switch directly to the next URL. We must disable backoff in
1300 // order for it not to interfere.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001301 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001302 update_state.num_checks = 1;
1303 update_state.is_backoff_disabled = true;
1304 update_state.download_urls.emplace_back("http://another/fake/url/");
1305 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001306 1,
1307 ErrorCode::kPayloadHashMismatchError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001308 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001309
1310 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001311 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001312 ExpectPolicyStatus(
1313 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001314 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001315 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001316 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001317 EXPECT_EQ(0, result.download_url_num_errors);
1318 EXPECT_TRUE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001319}
1320
1321TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedNoUsableUrls) {
1322 // The UpdateCanStart policy returns false; there's a single HTTP URL but its
1323 // use is forbidden by policy.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001324 //
1325 // Note: In the case where no usable URLs are found, the policy should not
1326 // increment the number of failed attempts! Doing so would result in a
1327 // non-idempotent semantics, and does not fall within the intended purpose of
1328 // the backoff mechanism anyway.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001329
1330 SetUpdateCheckAllowed(false);
1331
1332 // Override specific device policy attributes.
1333 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1334 new bool(false));
1335
1336 // Check that the UpdateCanStart returns false.
1337 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001338 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001339 ExpectPolicyStatus(
1340 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001341 EXPECT_FALSE(result.update_can_start);
1342 EXPECT_EQ(UpdateCannotStartReason::kCannotDownload,
1343 result.cannot_start_reason);
1344 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001345}
1346
1347TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoUsableUrlsButP2PEnabled) {
1348 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1349 // use is forbidden by policy, however P2P is enabled. The result indicates
1350 // that no URL can be used.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001351 //
1352 // Note: The number of failed attempts should not increase in this case (see
1353 // above test).
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001354
1355 SetUpdateCheckAllowed(false);
1356
1357 // Override specific device policy attributes.
1358 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1359 new bool(true));
1360 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1361 new bool(false));
1362
1363 // Check that the UpdateCanStart returns true.
1364 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001365 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001366 ExpectPolicyStatus(
1367 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001368 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001369 EXPECT_TRUE(result.p2p_downloading_allowed);
1370 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001371 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001372 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001373 EXPECT_EQ(0, result.download_url_num_errors);
1374 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001375}
1376
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001377TEST_F(UmChromeOSPolicyTest,
1378 UpdateCanStartAllowedNoUsableUrlsButEnterpriseEnrolled) {
1379 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1380 // use is forbidden by policy, and P2P is unset on the policy, however the
1381 // device is enterprise-enrolled so P2P is allowed. The result indicates that
1382 // no URL can be used.
1383 //
1384 // Note: The number of failed attempts should not increase in this case (see
1385 // above test).
1386
1387 SetUpdateCheckAllowed(false);
1388
1389 // Override specific device policy attributes.
1390 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
Jae Hoon Kim9d9492f2019-06-17 14:52:48 -07001391 fake_state_.device_policy_provider()->var_has_owner()->reset(new bool(false));
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001392 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1393 new bool(false));
1394
1395 // Check that the UpdateCanStart returns true.
1396 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1397 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001398 ExpectPolicyStatus(
1399 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001400 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001401 EXPECT_TRUE(result.p2p_downloading_allowed);
1402 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001403 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001404 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001405 EXPECT_EQ(0, result.download_url_num_errors);
1406 EXPECT_FALSE(result.do_increment_failures);
1407}
1408
Gilad Arnold684219d2014-07-07 14:54:57 -07001409TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedEthernetDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001410 // Ethernet is always allowed.
1411
Amin Hassani4b717432019-01-14 16:24:20 -08001412 fake_state_.shill_provider()->var_conn_type()->reset(
1413 new ConnectionType(ConnectionType::kEthernet));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001414
1415 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001416 ExpectPolicyStatus(
1417 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001418 EXPECT_TRUE(result);
1419}
1420
Gilad Arnold684219d2014-07-07 14:54:57 -07001421TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWifiDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001422 // Wifi is allowed if not tethered.
1423
Amin Hassani4b717432019-01-14 16:24:20 -08001424 fake_state_.shill_provider()->var_conn_type()->reset(
1425 new ConnectionType(ConnectionType::kWifi));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001426
1427 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001428 ExpectPolicyStatus(
1429 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001430 EXPECT_TRUE(result);
1431}
1432
Alex Deymo63784a52014-05-28 10:46:14 -07001433TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001434 UpdateCurrentConnectionNotAllowedWifiTetheredDefault) {
1435 // Tethered wifi is not allowed by default.
1436
Amin Hassani4b717432019-01-14 16:24:20 -08001437 fake_state_.shill_provider()->var_conn_type()->reset(
1438 new ConnectionType(ConnectionType::kWifi));
1439 fake_state_.shill_provider()->var_conn_tethering()->reset(
1440 new ConnectionTethering(ConnectionTethering::kConfirmed));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001441
1442 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001443 ExpectPolicyStatus(
1444 EvalStatus::kAskMeAgainLater, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001445}
1446
Amin Hassani4b717432019-01-14 16:24:20 -08001447TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWifiTetheredPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001448 // Tethered wifi can be allowed by policy.
1449
Amin Hassani4b717432019-01-14 16:24:20 -08001450 fake_state_.shill_provider()->var_conn_type()->reset(
1451 new ConnectionType(ConnectionType::kWifi));
1452 fake_state_.shill_provider()->var_conn_tethering()->reset(
1453 new ConnectionTethering(ConnectionTethering::kConfirmed));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001454 set<ConnectionType> allowed_connections;
1455 allowed_connections.insert(ConnectionType::kCellular);
Amin Hassani4b717432019-01-14 16:24:20 -08001456 fake_state_.device_policy_provider()
1457 ->var_allowed_connection_types_for_update()
1458 ->reset(new set<ConnectionType>(allowed_connections));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001459
1460 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001461 ExpectPolicyStatus(
1462 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001463 EXPECT_TRUE(result);
1464}
1465
Alex Deymo63784a52014-05-28 10:46:14 -07001466TEST_F(UmChromeOSPolicyTest, UpdateCurrentConnectionNotAllowedCellularDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001467 // Cellular is not allowed by default.
1468
Amin Hassani4b717432019-01-14 16:24:20 -08001469 fake_state_.shill_provider()->var_conn_type()->reset(
1470 new ConnectionType(ConnectionType::kCellular));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001471
1472 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001473 ExpectPolicyStatus(
1474 EvalStatus::kAskMeAgainLater, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001475}
1476
Amin Hassani4b717432019-01-14 16:24:20 -08001477TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedCellularPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001478 // Update over cellular can be enabled by policy.
1479
Amin Hassani4b717432019-01-14 16:24:20 -08001480 fake_state_.shill_provider()->var_conn_type()->reset(
1481 new ConnectionType(ConnectionType::kCellular));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001482 set<ConnectionType> allowed_connections;
1483 allowed_connections.insert(ConnectionType::kCellular);
Amin Hassani4b717432019-01-14 16:24:20 -08001484 fake_state_.device_policy_provider()
1485 ->var_allowed_connection_types_for_update()
1486 ->reset(new set<ConnectionType>(allowed_connections));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001487
1488 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001489 ExpectPolicyStatus(
1490 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001491 EXPECT_TRUE(result);
1492}
1493
Amin Hassani4b717432019-01-14 16:24:20 -08001494TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedCellularUserOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001495 // Update over cellular can be enabled by user settings, but only if policy
1496 // is present and does not determine allowed connections.
1497
Amin Hassani4b717432019-01-14 16:24:20 -08001498 fake_state_.shill_provider()->var_conn_type()->reset(
1499 new ConnectionType(ConnectionType::kCellular));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001500 set<ConnectionType> allowed_connections;
1501 allowed_connections.insert(ConnectionType::kCellular);
Amin Hassani4b717432019-01-14 16:24:20 -08001502 fake_state_.updater_provider()->var_cellular_enabled()->reset(new bool(true));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001503
1504 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001505 ExpectPolicyStatus(
1506 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001507 EXPECT_TRUE(result);
1508}
1509
Amin Hassani4b717432019-01-14 16:24:20 -08001510TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSupressedDueToP2P) {
Gilad Arnold14a9e702014-10-08 08:09:09 -07001511 // The UpdateCanStart policy returns true; scattering should have applied, but
1512 // P2P download is allowed. Scattering values are nonetheless returned, and so
1513 // are download URL values, albeit the latter are not allowed to be used.
1514
1515 SetUpdateCheckAllowed(false);
1516 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
1517 new TimeDelta(TimeDelta::FromMinutes(2)));
1518 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1519
1520 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
1521 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
1522
1523 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001524 ExpectPolicyStatus(
1525 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001526 EXPECT_TRUE(result.update_can_start);
1527 EXPECT_EQ(0, result.download_url_idx);
1528 EXPECT_FALSE(result.download_url_allowed);
1529 EXPECT_EQ(0, result.download_url_num_errors);
1530 EXPECT_TRUE(result.p2p_downloading_allowed);
1531 EXPECT_TRUE(result.p2p_sharing_allowed);
1532 EXPECT_FALSE(result.do_increment_failures);
1533 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
1534 EXPECT_EQ(0, result.scatter_check_threshold);
1535}
1536
Amin Hassani4b717432019-01-14 16:24:20 -08001537TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffSupressedDueToP2P) {
Gilad Arnold14a9e702014-10-08 08:09:09 -07001538 // The UpdateCanStart policy returns true; backoff should have applied, but
1539 // P2P download is allowed. Backoff values are nonetheless returned, and so
1540 // are download URL values, albeit the latter are not allowed to be used.
1541
1542 SetUpdateCheckAllowed(false);
1543
1544 const Time curr_time = fake_clock_.GetWallclockTime();
1545 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
1546 update_state.download_errors_max = 1;
1547 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001548 0,
1549 ErrorCode::kDownloadTransferError,
Gilad Arnold14a9e702014-10-08 08:09:09 -07001550 curr_time - TimeDelta::FromSeconds(8));
1551 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001552 0,
1553 ErrorCode::kDownloadTransferError,
Gilad Arnold14a9e702014-10-08 08:09:09 -07001554 curr_time - TimeDelta::FromSeconds(2));
1555 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1556
1557 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001558 ExpectPolicyStatus(
1559 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001560 EXPECT_TRUE(result.update_can_start);
1561 EXPECT_EQ(0, result.download_url_idx);
1562 EXPECT_FALSE(result.download_url_allowed);
1563 EXPECT_EQ(0, result.download_url_num_errors);
1564 EXPECT_TRUE(result.p2p_downloading_allowed);
1565 EXPECT_TRUE(result.p2p_sharing_allowed);
1566 EXPECT_TRUE(result.do_increment_failures);
1567 EXPECT_LT(curr_time, result.backoff_expiry);
1568}
1569
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001570TEST_F(UmChromeOSPolicyTest, P2PEnabledNotAllowed) {
1571 bool result;
1572 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1573 EXPECT_FALSE(result);
1574}
1575
1576TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByDevicePolicy) {
1577 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1578 new bool(true));
1579
1580 bool result;
1581 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1582 EXPECT_TRUE(result);
1583}
1584
1585TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByUpdater) {
1586 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1587
1588 bool result;
1589 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1590 EXPECT_TRUE(result);
1591}
1592
1593TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedDeviceEnterpriseEnrolled) {
1594 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
Jae Hoon Kim9d9492f2019-06-17 14:52:48 -07001595 fake_state_.device_policy_provider()->var_has_owner()->reset(new bool(false));
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001596
1597 bool result;
1598 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1599 EXPECT_TRUE(result);
1600}
1601
1602TEST_F(UmChromeOSPolicyTest, P2PEnabledChangedBlocks) {
1603 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001604 ExpectPolicyStatus(
1605 EvalStatus::kAskMeAgainLater, &Policy::P2PEnabledChanged, &result, false);
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001606}
1607
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001608TEST_F(UmChromeOSPolicyTest,
1609 UpdateCanBeAppliedForcedUpdatesDisablesTimeRestrictions) {
1610 Time curr_time = fake_clock_.GetWallclockTime();
1611 fake_state_.updater_provider()->var_forced_update_requested()->reset(
1612 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
1613 // Should return kAskMeAgainLater when updated are not forced.
1614 TestDisallowedTimeIntervals(
1615 {WeeklyTimeInterval(
1616 WeeklyTime::FromTime(curr_time),
1617 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001618 ErrorCode::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001619 /* kiosk = */ true);
1620}
1621
1622TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedFailsInDisallowedTime) {
1623 Time curr_time = fake_clock_.GetWallclockTime();
1624 TestDisallowedTimeIntervals(
1625 {WeeklyTimeInterval(
1626 WeeklyTime::FromTime(curr_time),
1627 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001628 ErrorCode::kOmahaUpdateDeferredPerPolicy,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001629 /* kiosk = */ true);
1630}
1631
1632TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedOutsideDisallowedTime) {
1633 Time curr_time = fake_clock_.GetWallclockTime();
1634 TestDisallowedTimeIntervals(
1635 {WeeklyTimeInterval(
1636 WeeklyTime::FromTime(curr_time - TimeDelta::FromHours(3)),
1637 WeeklyTime::FromTime(curr_time))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001638 ErrorCode::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001639 /* kiosk = */ true);
1640}
1641
1642TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedPassesOnNonKiosk) {
1643 Time curr_time = fake_clock_.GetWallclockTime();
1644 TestDisallowedTimeIntervals(
1645 {WeeklyTimeInterval(
1646 WeeklyTime::FromTime(curr_time),
1647 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001648 ErrorCode::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001649 /* kiosk = */ false);
1650}
1651
Alex Deymo63784a52014-05-28 10:46:14 -07001652} // namespace chromeos_update_manager