blob: f4ad165c83ac2d3cd3e8934d931db5263b3c70a7 [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
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700344TEST_F(UmChromeOSPolicyTest,
Aaron Wood56d8ab32017-09-22 15:56:18 -0700345 UpdateCheckAllowedUpdatesDisabledWhenNotEnoughSlotsAbUpdates) {
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700346 // UpdateCheckAllowed should return false (kSucceeded) if the image booted
Aaron Wood56d8ab32017-09-22 15:56:18 -0700347 // without enough slots to do A/B updates.
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700348
Aaron Woodc73fdc12017-12-06 11:09:15 -0800349 // NOLINTNEXTLINE(readability/casting)
Alex Deymo763e7db2015-08-27 21:08:08 -0700350 fake_state_.system_provider()->var_num_slots()->reset(new unsigned int(1));
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700351
352 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800353 ExpectPolicyStatus(
354 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldbfc44f72014-07-09 14:41:39 -0700355 EXPECT_FALSE(result.updates_enabled);
356}
357
Gilad Arnoldfe12a0f2014-07-09 14:26:57 -0700358TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedUpdatesDisabledByPolicy) {
Gilad Arnold42f253b2014-06-25 12:39:17 -0700359 // UpdateCheckAllowed should return kAskMeAgainLater because a device policy
360 // is loaded and prohibits updates.
361
362 SetUpdateCheckAllowed(false);
363 fake_state_.device_policy_provider()->var_update_disabled()->reset(
364 new bool(true));
365
Gilad Arnold42f253b2014-06-25 12:39:17 -0700366 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800367 ExpectPolicyStatus(
368 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Gilad Arnold42f253b2014-06-25 12:39:17 -0700369}
370
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700371TEST_F(UmChromeOSPolicyTest,
372 UpdateCheckAllowedForcedUpdateRequestedInteractive) {
373 // UpdateCheckAllowed should return true because a forced update request was
374 // signaled for an interactive update.
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700375
376 SetUpdateCheckAllowed(true);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700377 fake_state_.updater_provider()->var_forced_update_requested()->reset(
378 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700379
380 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800381 ExpectPolicyStatus(
382 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700383 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700384 EXPECT_TRUE(result.interactive);
Gilad Arnold44dc3bf2014-07-18 23:39:38 -0700385}
386
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700387TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedForcedUpdateRequestedPeriodic) {
388 // UpdateCheckAllowed should return true because a forced update request was
389 // signaled for a periodic check.
390
391 SetUpdateCheckAllowed(true);
392 fake_state_.updater_provider()->var_forced_update_requested()->reset(
393 new UpdateRequestStatus(UpdateRequestStatus::kPeriodic));
394
395 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800396 ExpectPolicyStatus(
397 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700398 EXPECT_TRUE(result.updates_enabled);
Amin Hassanied37d682018-04-06 13:22:00 -0700399 EXPECT_FALSE(result.interactive);
Gilad Arnoldec7f9162014-07-15 13:24:46 -0700400}
401
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800402TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPin) {
403 // Update check is allowed.
404 SetUpdateCheckAllowed(true);
405
Marton Hunyady8b936f22018-06-15 16:44:37 +0200406 SetKioskAppControlsChromeOsVersion();
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800407
408 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800409 ExpectPolicyStatus(
410 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800411 EXPECT_TRUE(result.updates_enabled);
Marton Hunyady8b936f22018-06-15 16:44:37 +0200412 EXPECT_EQ("1234.", result.target_version_prefix);
Amin Hassanied37d682018-04-06 13:22:00 -0700413 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800414}
415
416TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedDisabledWhenNoKioskPin) {
417 // Update check is allowed.
418 SetUpdateCheckAllowed(true);
419
420 // Disable AU policy is set but kiosk pin policy is set to false. Update is
421 // disabled in such case.
422 fake_state_.device_policy_provider()->var_update_disabled()->reset(
423 new bool(true));
424 fake_state_.device_policy_provider()
425 ->var_allow_kiosk_app_control_chrome_version()
426 ->reset(new bool(false));
427
428 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800429 ExpectPolicyStatus(
430 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800431}
432
433TEST_F(UmChromeOSPolicyTest, UpdateCheckAllowedKioskPinWithNoRequiredVersion) {
434 // Update check is allowed.
435 SetUpdateCheckAllowed(true);
436
437 // AU disabled, allow kiosk to pin but there is no kiosk required platform
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700438 // version (i.e. app does not provide the info). Update to latest in such
439 // case.
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800440 fake_state_.device_policy_provider()->var_update_disabled()->reset(
441 new bool(true));
442 fake_state_.device_policy_provider()
443 ->var_allow_kiosk_app_control_chrome_version()
444 ->reset(new bool(true));
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700445 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
446 new string());
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800447
448 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800449 ExpectPolicyStatus(
450 EvalStatus::kSucceeded, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800451 EXPECT_TRUE(result.updates_enabled);
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700452 EXPECT_TRUE(result.target_version_prefix.empty());
Amin Hassanied37d682018-04-06 13:22:00 -0700453 EXPECT_FALSE(result.interactive);
Xiyuan Xia6e30bc52016-02-24 15:35:42 -0800454}
455
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700456TEST_F(UmChromeOSPolicyTest,
457 UpdateCheckAllowedKioskPinWithFailedGetRequiredVersionCall) {
458 // AU disabled, allow kiosk to pin but D-Bus call to get required platform
459 // version failed. Defer update check in this case.
460 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));
465 fake_state_.system_provider()->var_kiosk_required_platform_version()->reset(
466 nullptr);
467
468 UpdateCheckParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800469 ExpectPolicyStatus(
470 EvalStatus::kAskMeAgainLater, &Policy::UpdateCheckAllowed, &result);
Xiyuan Xiaed9bd922016-04-07 14:45:16 -0700471}
472
Alex Deymo63784a52014-05-28 10:46:14 -0700473TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsCheckAllowedError) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700474 // The UpdateCanStart policy fails, not being able to query
475 // UpdateCheckAllowed.
476
477 // Configure the UpdateCheckAllowed policy to fail.
478 fake_state_.updater_provider()->var_updater_started_time()->reset(nullptr);
479
480 // Check that the UpdateCanStart fails.
481 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700482 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800483 ExpectPolicyStatus(
484 EvalStatus::kFailed, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700485}
486
Alex Deymo63784a52014-05-28 10:46:14 -0700487TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedCheckDue) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700488 // The UpdateCanStart policy returns false because we are due for another
Gilad Arnold14a9e702014-10-08 08:09:09 -0700489 // update check. Ensure that download related values are still returned.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700490
491 SetUpdateCheckAllowed(true);
492
493 // Check that the UpdateCanStart returns false.
494 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700495 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800496 ExpectPolicyStatus(
497 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700498 EXPECT_FALSE(result.update_can_start);
499 EXPECT_EQ(UpdateCannotStartReason::kCheckDue, result.cannot_start_reason);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700500 EXPECT_EQ(0, result.download_url_idx);
501 EXPECT_EQ(0, result.download_url_num_errors);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700502}
503
Alex Deymo63784a52014-05-28 10:46:14 -0700504TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoDevicePolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700505 // The UpdateCanStart policy returns true; no device policy is loaded.
506
507 SetUpdateCheckAllowed(false);
508 fake_state_.device_policy_provider()->var_device_policy_is_loaded()->reset(
509 new bool(false));
510
511 // Check that the UpdateCanStart returns true with no further attributes.
512 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700513 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800514 ExpectPolicyStatus(
515 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700516 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -0700517 EXPECT_FALSE(result.p2p_downloading_allowed);
518 EXPECT_FALSE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700519 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700520 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700521 EXPECT_EQ(0, result.download_url_num_errors);
522 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700523}
524
Alex Deymo63784a52014-05-28 10:46:14 -0700525TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBlankPolicy) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700526 // The UpdateCanStart policy returns true; device policy is loaded but imposes
527 // no restrictions on updating.
528
529 SetUpdateCheckAllowed(false);
530
531 // Check that the UpdateCanStart returns true.
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);
543}
544
545TEST_F(UmChromeOSPolicyTest,
546 UpdateCanStartNotAllowedBackoffNewWaitPeriodApplies) {
547 // The UpdateCanStart policy returns false; failures are reported and a new
548 // backoff period is enacted.
549
550 SetUpdateCheckAllowed(false);
551
552 const Time curr_time = fake_clock_.GetWallclockTime();
553 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
554 update_state.download_errors_max = 1;
555 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800556 0,
557 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700558 curr_time - TimeDelta::FromSeconds(8));
559 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800560 0,
561 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700562 curr_time - TimeDelta::FromSeconds(2));
563
564 // Check that UpdateCanStart returns false and a new backoff expiry is
565 // generated.
566 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800567 ExpectPolicyStatus(
568 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700569 EXPECT_FALSE(result.update_can_start);
570 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
571 EXPECT_TRUE(result.do_increment_failures);
572 EXPECT_LT(curr_time, result.backoff_expiry);
573}
574
575TEST_F(UmChromeOSPolicyTest,
576 UpdateCanStartNotAllowedBackoffPrevWaitPeriodStillApplies) {
577 // The UpdateCanStart policy returns false; a previously enacted backoff
578 // period still applies.
579
580 SetUpdateCheckAllowed(false);
581
582 const Time curr_time = fake_clock_.GetWallclockTime();
583 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
584 update_state.download_errors_max = 1;
585 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800586 0,
587 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700588 curr_time - TimeDelta::FromSeconds(8));
589 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800590 0,
591 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700592 curr_time - TimeDelta::FromSeconds(2));
593 update_state.failures_last_updated = curr_time;
594 update_state.backoff_expiry = curr_time + TimeDelta::FromMinutes(3);
595
596 // Check that UpdateCanStart returns false and a new backoff expiry is
597 // generated.
598 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800599 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
600 &Policy::UpdateCanStart,
601 &result,
602 update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700603 EXPECT_FALSE(result.update_can_start);
604 EXPECT_EQ(UpdateCannotStartReason::kBackoff, result.cannot_start_reason);
605 EXPECT_FALSE(result.do_increment_failures);
606 EXPECT_LT(curr_time, result.backoff_expiry);
607}
608
609TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffSatisfied) {
610 // The UpdateCanStart policy returns true; a previously enacted backoff period
611 // has elapsed, we're good to go.
612
613 SetUpdateCheckAllowed(false);
614
615 const Time curr_time = fake_clock_.GetWallclockTime();
616 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
617 update_state.download_errors_max = 1;
618 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800619 0,
620 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700621 curr_time - TimeDelta::FromSeconds(8));
622 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800623 0,
624 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700625 curr_time - TimeDelta::FromSeconds(2));
626 update_state.failures_last_updated = curr_time - TimeDelta::FromSeconds(1);
627 update_state.backoff_expiry = curr_time - TimeDelta::FromSeconds(1);
628
629 // Check that UpdateCanStart returns false and a new backoff expiry is
630 // generated.
631 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800632 ExpectPolicyStatus(
633 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700634 EXPECT_TRUE(result.update_can_start);
635 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
636 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700637 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700638 EXPECT_EQ(0, result.download_url_num_errors);
639 EXPECT_FALSE(result.do_increment_failures);
640 EXPECT_EQ(Time(), result.backoff_expiry);
641}
642
643TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffDisabled) {
644 // The UpdateCanStart policy returns false; failures are reported but backoff
645 // is disabled.
646
647 SetUpdateCheckAllowed(false);
648
649 const Time curr_time = fake_clock_.GetWallclockTime();
650 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
651 update_state.download_errors_max = 1;
652 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800653 0,
654 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700655 curr_time - TimeDelta::FromSeconds(8));
656 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800657 0,
658 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700659 curr_time - TimeDelta::FromSeconds(2));
660 update_state.is_backoff_disabled = true;
661
662 // Check that UpdateCanStart returns false and a new backoff expiry is
663 // generated.
664 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800665 ExpectPolicyStatus(
666 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700667 EXPECT_TRUE(result.update_can_start);
668 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
669 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700670 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700671 EXPECT_EQ(0, result.download_url_num_errors);
672 EXPECT_TRUE(result.do_increment_failures);
673 EXPECT_EQ(Time(), result.backoff_expiry);
674}
675
676TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffInteractive) {
677 // The UpdateCanStart policy returns false; failures are reported but this is
678 // an interactive update check.
679
680 SetUpdateCheckAllowed(false);
681
682 const Time curr_time = fake_clock_.GetWallclockTime();
683 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
684 update_state.download_errors_max = 1;
685 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800686 0,
687 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700688 curr_time - TimeDelta::FromSeconds(8));
689 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800690 0,
691 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700692 curr_time - TimeDelta::FromSeconds(2));
Amin Hassanied37d682018-04-06 13:22:00 -0700693 update_state.interactive = true;
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700694
695 // Check that UpdateCanStart returns false and a new backoff expiry is
696 // generated.
697 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800698 ExpectPolicyStatus(
699 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700700 EXPECT_TRUE(result.update_can_start);
701 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
702 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700703 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700704 EXPECT_EQ(0, result.download_url_num_errors);
705 EXPECT_TRUE(result.do_increment_failures);
706 EXPECT_EQ(Time(), result.backoff_expiry);
707}
708
709TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffDelta) {
710 // The UpdateCanStart policy returns false; failures are reported but this is
711 // a delta payload.
712
713 SetUpdateCheckAllowed(false);
714
715 const Time curr_time = fake_clock_.GetWallclockTime();
716 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
717 update_state.download_errors_max = 1;
718 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800719 0,
720 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700721 curr_time - TimeDelta::FromSeconds(8));
722 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800723 0,
724 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700725 curr_time - TimeDelta::FromSeconds(2));
726 update_state.is_delta_payload = true;
727
728 // Check that UpdateCanStart returns false and a new backoff expiry is
729 // generated.
730 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800731 ExpectPolicyStatus(
732 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700733 EXPECT_TRUE(result.update_can_start);
734 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
735 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700736 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700737 EXPECT_EQ(0, result.download_url_num_errors);
738 EXPECT_TRUE(result.do_increment_failures);
739 EXPECT_EQ(Time(), result.backoff_expiry);
740}
741
742TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoBackoffUnofficialBuild) {
743 // The UpdateCanStart policy returns false; failures are reported but this is
744 // an unofficial build.
745
746 SetUpdateCheckAllowed(false);
747
748 const Time curr_time = fake_clock_.GetWallclockTime();
749 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
750 update_state.download_errors_max = 1;
751 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800752 0,
753 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700754 curr_time - TimeDelta::FromSeconds(8));
755 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -0800756 0,
757 ErrorCode::kDownloadTransferError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700758 curr_time - TimeDelta::FromSeconds(2));
759
Amin Hassani4b717432019-01-14 16:24:20 -0800760 fake_state_.system_provider()->var_is_official_build()->reset(
761 new bool(false));
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700762
763 // Check that UpdateCanStart returns false and a new backoff expiry is
764 // generated.
765 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800766 ExpectPolicyStatus(
767 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700768 EXPECT_TRUE(result.update_can_start);
769 EXPECT_EQ(UpdateCannotStartReason::kUndefined, result.cannot_start_reason);
770 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700771 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700772 EXPECT_EQ(0, result.download_url_num_errors);
773 EXPECT_TRUE(result.do_increment_failures);
774 EXPECT_EQ(Time(), result.backoff_expiry);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700775}
776
Alex Deymo63784a52014-05-28 10:46:14 -0700777TEST_F(UmChromeOSPolicyTest, UpdateCanStartFailsScatteringFailed) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700778 // The UpdateCanStart policy fails because the UpdateScattering policy it
779 // depends on fails (unset variable).
780
781 SetUpdateCheckAllowed(false);
782
783 // Override the default seed variable with a null value so that the policy
784 // request would fail.
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700785 // TODO(garnold) This failure may or may not fail a number
786 // sub-policies/decisions, like scattering and backoff. We'll need a more
787 // deliberate setup to ensure that we're failing what we want to be failing.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700788 fake_state_.random_provider()->var_seed()->reset(nullptr);
789
790 // Check that the UpdateCanStart fails.
791 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700792 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800793 ExpectPolicyStatus(
794 EvalStatus::kFailed, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700795}
796
Alex Deymo63784a52014-05-28 10:46:14 -0700797TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700798 UpdateCanStartNotAllowedScatteringNewWaitPeriodApplies) {
799 // The UpdateCanStart policy returns false; device policy is loaded and
800 // scattering applies due to an unsatisfied wait period, which was newly
801 // generated.
802
803 SetUpdateCheckAllowed(false);
804 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
805 new TimeDelta(TimeDelta::FromMinutes(2)));
806
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700807 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
808
809 // Check that the UpdateCanStart returns false and a new wait period
810 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700811 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800812 ExpectPolicyStatus(
813 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700814 EXPECT_FALSE(result.update_can_start);
815 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
816 EXPECT_LT(TimeDelta(), result.scatter_wait_period);
817 EXPECT_EQ(0, result.scatter_check_threshold);
818}
819
Alex Deymo63784a52014-05-28 10:46:14 -0700820TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700821 UpdateCanStartNotAllowedScatteringPrevWaitPeriodStillApplies) {
822 // The UpdateCanStart policy returns false w/ kAskMeAgainLater; device policy
823 // is loaded and a previously generated scattering period still applies, none
824 // of the scattering values has changed.
825
826 SetUpdateCheckAllowed(false);
827 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
828 new TimeDelta(TimeDelta::FromMinutes(2)));
829
830 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
831 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
832
833 // Check that the UpdateCanStart returns false and a new wait period
834 // generated.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700835 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800836 ExpectPolicyStatus(EvalStatus::kAskMeAgainLater,
837 &Policy::UpdateCanStart,
838 &result,
839 update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700840 EXPECT_FALSE(result.update_can_start);
841 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
842 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
843 EXPECT_EQ(0, result.scatter_check_threshold);
844}
845
Alex Deymo63784a52014-05-28 10:46:14 -0700846TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700847 UpdateCanStartNotAllowedScatteringNewCountThresholdApplies) {
848 // The UpdateCanStart policy returns false; device policy is loaded and
849 // scattering applies due to an unsatisfied update check count threshold.
850 //
851 // This ensures a non-zero check threshold, which may or may not be combined
852 // with a non-zero wait period (for which we cannot reliably control).
853
854 SetUpdateCheckAllowed(false);
855 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
856 new TimeDelta(TimeDelta::FromSeconds(1)));
857
858 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
859 update_state.scatter_check_threshold_min = 2;
860 update_state.scatter_check_threshold_max = 5;
861
862 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700863 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800864 ExpectPolicyStatus(
865 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700866 EXPECT_FALSE(result.update_can_start);
867 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
868 EXPECT_LE(2, result.scatter_check_threshold);
869 EXPECT_GE(5, result.scatter_check_threshold);
870}
871
Alex Deymo63784a52014-05-28 10:46:14 -0700872TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700873 UpdateCanStartNotAllowedScatteringPrevCountThresholdStillApplies) {
874 // The UpdateCanStart policy returns false; device policy is loaded and
875 // scattering due to a previously generated count threshold still applies.
876
877 SetUpdateCheckAllowed(false);
878 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
879 new TimeDelta(TimeDelta::FromSeconds(1)));
880
881 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
882 update_state.scatter_check_threshold = 3;
883 update_state.scatter_check_threshold_min = 2;
884 update_state.scatter_check_threshold_max = 5;
885
886 // Check that the UpdateCanStart returns false.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700887 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800888 ExpectPolicyStatus(
889 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700890 EXPECT_FALSE(result.update_can_start);
891 EXPECT_EQ(UpdateCannotStartReason::kScattering, result.cannot_start_reason);
892 EXPECT_EQ(3, result.scatter_check_threshold);
893}
894
Alex Deymo63784a52014-05-28 10:46:14 -0700895TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSatisfied) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700896 // The UpdateCanStart policy returns true; device policy is loaded and
897 // scattering is enabled, but both wait period and check threshold are
898 // satisfied.
899
900 SetUpdateCheckAllowed(false);
901 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
902 new TimeDelta(TimeDelta::FromSeconds(120)));
903
904 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(75));
905 update_state.num_checks = 4;
906 update_state.scatter_wait_period = TimeDelta::FromSeconds(60);
907 update_state.scatter_check_threshold = 3;
908 update_state.scatter_check_threshold_min = 2;
909 update_state.scatter_check_threshold_max = 5;
910
911 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700912 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800913 ExpectPolicyStatus(
914 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700915 EXPECT_TRUE(result.update_can_start);
916 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
917 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700918 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700919 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700920 EXPECT_EQ(0, result.download_url_num_errors);
921 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700922}
923
Alex Deymo63784a52014-05-28 10:46:14 -0700924TEST_F(UmChromeOSPolicyTest,
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700925 UpdateCanStartAllowedInteractivePreventsScattering) {
926 // The UpdateCanStart policy returns true; device policy is loaded and
927 // scattering would have applied, except that the update check is interactive
928 // and so it is suppressed.
929
930 SetUpdateCheckAllowed(false);
931 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
932 new TimeDelta(TimeDelta::FromSeconds(1)));
933
934 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700935 update_state.interactive = true;
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700936 update_state.scatter_check_threshold = 0;
937 update_state.scatter_check_threshold_min = 2;
938 update_state.scatter_check_threshold_max = 5;
939
940 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700941 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800942 ExpectPolicyStatus(
943 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700944 EXPECT_TRUE(result.update_can_start);
945 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
946 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700947 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700948 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700949 EXPECT_EQ(0, result.download_url_num_errors);
950 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700951}
952
Amin Hassani4b717432019-01-14 16:24:20 -0800953TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedOobePreventsScattering) {
Gilad Arnold76a11f62014-05-20 09:02:12 -0700954 // The UpdateCanStart policy returns true; device policy is loaded and
955 // scattering would have applied, except that OOBE was not completed and so it
956 // is suppressed.
957
958 SetUpdateCheckAllowed(false);
959 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
960 new TimeDelta(TimeDelta::FromSeconds(1)));
961 fake_state_.system_provider()->var_is_oobe_complete()->reset(new bool(false));
962
963 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
Amin Hassanied37d682018-04-06 13:22:00 -0700964 update_state.interactive = true;
Gilad Arnold76a11f62014-05-20 09:02:12 -0700965 update_state.scatter_check_threshold = 0;
966 update_state.scatter_check_threshold_min = 2;
967 update_state.scatter_check_threshold_max = 5;
968
969 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -0700970 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800971 ExpectPolicyStatus(
972 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700973 EXPECT_TRUE(result.update_can_start);
974 EXPECT_EQ(TimeDelta(), result.scatter_wait_period);
975 EXPECT_EQ(0, result.scatter_check_threshold);
Gilad Arnoldb3b05442014-05-30 14:25:05 -0700976 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -0700977 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -0700978 EXPECT_EQ(0, result.download_url_num_errors);
979 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnold76a11f62014-05-20 09:02:12 -0700980}
981
Alex Deymo63784a52014-05-28 10:46:14 -0700982TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithAttributes) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700983 // The UpdateCanStart policy returns true; device policy permits both HTTP and
984 // P2P updates, as well as a non-empty target channel string.
985
986 SetUpdateCheckAllowed(false);
987
988 // Override specific device policy attributes.
989 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
990 new bool(true));
991 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
992 new bool(true));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700993
994 // Check that the UpdateCanStart returns true.
995 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -0700996 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -0800997 ExpectPolicyStatus(
998 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -0700999 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001000 EXPECT_TRUE(result.p2p_downloading_allowed);
1001 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001002 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001003 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001004 EXPECT_EQ(0, result.download_url_num_errors);
1005 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001006}
1007
Alex Deymo63784a52014-05-28 10:46:14 -07001008TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithP2PFromUpdater) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001009 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1010 // P2P updates, but the updater is configured to allow P2P and overrules the
1011 // setting.
1012
1013 SetUpdateCheckAllowed(false);
1014
1015 // Override specific device policy attributes.
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001016 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1017
1018 // Check that the UpdateCanStart returns true.
1019 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001020 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001021 ExpectPolicyStatus(
1022 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001023 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001024 EXPECT_TRUE(result.p2p_downloading_allowed);
1025 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001026 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001027 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001028 EXPECT_EQ(0, result.download_url_num_errors);
1029 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001030}
1031
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001032TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001033 UpdateCanStartAllowedP2PDownloadingBlockedDueToOmaha) {
1034 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1035 // policy blocks P2P downloading because Omaha forbids it. P2P sharing is
1036 // still permitted.
1037
1038 SetUpdateCheckAllowed(false);
1039
1040 // Override specific device policy attributes.
1041 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1042 new bool(true));
1043 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1044 new bool(true));
1045
1046 // Check that the UpdateCanStart returns true.
1047 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1048 update_state.p2p_downloading_disabled = true;
1049 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001050 ExpectPolicyStatus(
1051 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001052 EXPECT_TRUE(result.update_can_start);
1053 EXPECT_FALSE(result.p2p_downloading_allowed);
1054 EXPECT_TRUE(result.p2p_sharing_allowed);
1055}
1056
Amin Hassani4b717432019-01-14 16:24:20 -08001057TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedP2PSharingBlockedDueToOmaha) {
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001058 // The UpdateCanStart policy returns true; device policy permits HTTP, but
1059 // policy blocks P2P sharing because Omaha forbids it. P2P downloading is
1060 // still permitted.
1061
1062 SetUpdateCheckAllowed(false);
1063
1064 // Override specific device policy attributes.
1065 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1066 new bool(true));
1067 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1068 new bool(true));
1069
1070 // Check that the UpdateCanStart returns true.
1071 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1072 update_state.p2p_sharing_disabled = true;
1073 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001074 ExpectPolicyStatus(
1075 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001076 EXPECT_TRUE(result.update_can_start);
1077 EXPECT_TRUE(result.p2p_downloading_allowed);
1078 EXPECT_FALSE(result.p2p_sharing_allowed);
1079}
1080
1081TEST_F(UmChromeOSPolicyTest,
1082 UpdateCanStartAllowedP2PDownloadingBlockedDueToNumAttempts) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001083 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001084 // blocks P2P download, because the max number of P2P downloads have been
1085 // attempted. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001086
1087 SetUpdateCheckAllowed(false);
1088
1089 // Override specific device policy attributes.
1090 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1091 new bool(true));
1092 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1093 new bool(true));
1094
1095 // Check that the UpdateCanStart returns true.
1096 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1097 update_state.p2p_num_attempts = ChromeOSPolicy::kMaxP2PAttempts;
1098 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001099 ExpectPolicyStatus(
1100 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold349ac832014-10-06 14:20:28 -07001101 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001102 EXPECT_FALSE(result.p2p_downloading_allowed);
1103 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001104}
1105
1106TEST_F(UmChromeOSPolicyTest,
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001107 UpdateCanStartAllowedP2PDownloadingBlockedDueToAttemptsPeriod) {
Gilad Arnold349ac832014-10-06 14:20:28 -07001108 // The UpdateCanStart policy returns true; device policy permits HTTP but
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001109 // blocks P2P download, because the max period for attempt to download via P2P
1110 // has elapsed. P2P sharing is still permitted.
Gilad Arnold349ac832014-10-06 14:20:28 -07001111
1112 SetUpdateCheckAllowed(false);
1113
1114 // Override specific device policy attributes.
1115 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1116 new bool(true));
1117 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1118 new bool(true));
1119
1120 // Check that the UpdateCanStart returns true.
1121 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1122 update_state.p2p_num_attempts = 1;
1123 update_state.p2p_first_attempted =
1124 fake_clock_.GetWallclockTime() -
Amin Hassani4b717432019-01-14 16:24:20 -08001125 TimeDelta::FromSeconds(ChromeOSPolicy::kMaxP2PAttemptsPeriodInSeconds +
1126 1);
Gilad Arnold349ac832014-10-06 14:20:28 -07001127 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001128 ExpectPolicyStatus(
1129 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold349ac832014-10-06 14:20:28 -07001130 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001131 EXPECT_FALSE(result.p2p_downloading_allowed);
1132 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnold349ac832014-10-06 14:20:28 -07001133}
1134
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001135TEST_F(UmChromeOSPolicyTest,
1136 UpdateCanStartAllowedWithHttpUrlForUnofficialBuild) {
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001137 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1138 // P2P updates, but marking this an unofficial build overrules the HTTP
1139 // setting.
1140
1141 SetUpdateCheckAllowed(false);
1142
1143 // Override specific device policy attributes.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001144 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1145 new bool(false));
Amin Hassani4b717432019-01-14 16:24:20 -08001146 fake_state_.system_provider()->var_is_official_build()->reset(
1147 new bool(false));
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001148
1149 // Check that the UpdateCanStart returns true.
1150 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001151 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001152 ExpectPolicyStatus(
1153 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001154 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001155 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001156 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001157 EXPECT_EQ(0, result.download_url_num_errors);
1158 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001159}
1160
1161TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithHttpsUrl) {
1162 // The UpdateCanStart policy returns true; device policy forbids both HTTP and
1163 // P2P updates, but an HTTPS URL is provided and selected for download.
1164
1165 SetUpdateCheckAllowed(false);
1166
1167 // Override specific device policy attributes.
1168 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1169 new bool(false));
1170
1171 // Add an HTTPS URL.
1172 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001173 update_state.download_urls.emplace_back("https://secure/url/");
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001174
1175 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001176 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001177 ExpectPolicyStatus(
1178 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001179 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001180 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001181 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001182 EXPECT_EQ(0, result.download_url_num_errors);
1183 EXPECT_FALSE(result.do_increment_failures);
1184}
1185
1186TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedMaxErrorsNotExceeded) {
1187 // The UpdateCanStart policy returns true; the first URL has download errors
1188 // but does not exceed the maximum allowed number of failures, so it is stilli
1189 // usable.
1190
1191 SetUpdateCheckAllowed(false);
1192
1193 // Add a second URL; update with this URL attempted and failed enough times to
1194 // disqualify the current (first) URL.
1195 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1196 update_state.num_checks = 5;
1197 update_state.download_urls.emplace_back("http://another/fake/url/");
1198 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1199 for (int i = 0; i < 5; i++) {
1200 update_state.download_errors.emplace_back(
1201 0, ErrorCode::kDownloadTransferError, t);
1202 t += TimeDelta::FromSeconds(1);
1203 }
1204
1205 // Check that the UpdateCanStart returns true.
1206 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001207 ExpectPolicyStatus(
1208 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001209 EXPECT_TRUE(result.update_can_start);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001210 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001211 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001212 EXPECT_EQ(5, result.download_url_num_errors);
1213 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001214}
1215
1216TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlMaxExceeded) {
1217 // The UpdateCanStart policy returns true; the first URL exceeded the maximum
1218 // allowed number of failures, but a second URL is available.
1219
1220 SetUpdateCheckAllowed(false);
1221
1222 // Add a second URL; update with this URL attempted and failed enough times to
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001223 // disqualify the current (first) URL.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001224 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1225 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001226 update_state.download_urls.emplace_back("http://another/fake/url/");
1227 Time t = fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(12);
1228 for (int i = 0; i < 11; i++) {
1229 update_state.download_errors.emplace_back(
1230 0, ErrorCode::kDownloadTransferError, t);
1231 t += TimeDelta::FromSeconds(1);
1232 }
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001233
1234 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001235 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001236 ExpectPolicyStatus(
1237 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001238 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001239 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001240 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001241 EXPECT_EQ(0, result.download_url_num_errors);
1242 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001243}
1244
1245TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedWithSecondUrlHardError) {
1246 // The UpdateCanStart policy returns true; the first URL fails with a hard
1247 // error, but a second URL is available.
1248
1249 SetUpdateCheckAllowed(false);
1250
1251 // Add a second URL; update with this URL attempted and failed in a way that
1252 // causes it to switch directly to the next URL.
1253 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1254 update_state.num_checks = 10;
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001255 update_state.download_urls.emplace_back("http://another/fake/url/");
1256 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001257 0,
1258 ErrorCode::kPayloadHashMismatchError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001259 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001260
1261 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001262 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001263 ExpectPolicyStatus(
1264 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001265 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001266 EXPECT_EQ(1, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001267 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001268 EXPECT_EQ(0, result.download_url_num_errors);
1269 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001270}
1271
1272TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedUrlWrapsAround) {
1273 // The UpdateCanStart policy returns true; URL search properly wraps around
1274 // the last one on the list.
1275
1276 SetUpdateCheckAllowed(false);
1277
1278 // Add a second URL; update with this URL attempted and failed in a way that
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001279 // causes it to switch directly to the next URL. We must disable backoff in
1280 // order for it not to interfere.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001281 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001282 update_state.num_checks = 1;
1283 update_state.is_backoff_disabled = true;
1284 update_state.download_urls.emplace_back("http://another/fake/url/");
1285 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001286 1,
1287 ErrorCode::kPayloadHashMismatchError,
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001288 fake_clock_.GetWallclockTime() - TimeDelta::FromSeconds(1));
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001289
1290 // Check that the UpdateCanStart returns true.
Gilad Arnold42f253b2014-06-25 12:39:17 -07001291 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001292 ExpectPolicyStatus(
1293 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001294 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001295 EXPECT_EQ(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001296 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001297 EXPECT_EQ(0, result.download_url_num_errors);
1298 EXPECT_TRUE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001299}
1300
1301TEST_F(UmChromeOSPolicyTest, UpdateCanStartNotAllowedNoUsableUrls) {
1302 // The UpdateCanStart policy returns false; there's a single HTTP URL but its
1303 // use is forbidden by policy.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001304 //
1305 // Note: In the case where no usable URLs are found, the policy should not
1306 // increment the number of failed attempts! Doing so would result in a
1307 // non-idempotent semantics, and does not fall within the intended purpose of
1308 // the backoff mechanism anyway.
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001309
1310 SetUpdateCheckAllowed(false);
1311
1312 // Override specific device policy attributes.
1313 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1314 new bool(false));
1315
1316 // Check that the UpdateCanStart returns false.
1317 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001318 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001319 ExpectPolicyStatus(
1320 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001321 EXPECT_FALSE(result.update_can_start);
1322 EXPECT_EQ(UpdateCannotStartReason::kCannotDownload,
1323 result.cannot_start_reason);
1324 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001325}
1326
1327TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedNoUsableUrlsButP2PEnabled) {
1328 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1329 // use is forbidden by policy, however P2P is enabled. The result indicates
1330 // that no URL can be used.
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001331 //
1332 // Note: The number of failed attempts should not increase in this case (see
1333 // above test).
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001334
1335 SetUpdateCheckAllowed(false);
1336
1337 // Override specific device policy attributes.
1338 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1339 new bool(true));
1340 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1341 new bool(false));
1342
1343 // Check that the UpdateCanStart returns true.
1344 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
Gilad Arnold42f253b2014-06-25 12:39:17 -07001345 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001346 ExpectPolicyStatus(
1347 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001348 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001349 EXPECT_TRUE(result.p2p_downloading_allowed);
1350 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldb3b05442014-05-30 14:25:05 -07001351 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001352 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnolddc4bb262014-07-23 10:45:19 -07001353 EXPECT_EQ(0, result.download_url_num_errors);
1354 EXPECT_FALSE(result.do_increment_failures);
Gilad Arnoldf62a4b82014-05-01 07:41:07 -07001355}
1356
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001357TEST_F(UmChromeOSPolicyTest,
1358 UpdateCanStartAllowedNoUsableUrlsButEnterpriseEnrolled) {
1359 // The UpdateCanStart policy returns true; there's a single HTTP URL but its
1360 // use is forbidden by policy, and P2P is unset on the policy, however the
1361 // device is enterprise-enrolled so P2P is allowed. The result indicates that
1362 // no URL can be used.
1363 //
1364 // Note: The number of failed attempts should not increase in this case (see
1365 // above test).
1366
1367 SetUpdateCheckAllowed(false);
1368
1369 // Override specific device policy attributes.
1370 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
Jae Hoon Kim9d9492f2019-06-17 14:52:48 -07001371 fake_state_.device_policy_provider()->var_has_owner()->reset(new bool(false));
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001372 fake_state_.device_policy_provider()->var_http_downloads_enabled()->reset(
1373 new bool(false));
1374
1375 // Check that the UpdateCanStart returns true.
1376 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromMinutes(10));
1377 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001378 ExpectPolicyStatus(
1379 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001380 EXPECT_TRUE(result.update_can_start);
Gilad Arnoldb2f99192014-10-07 13:01:52 -07001381 EXPECT_TRUE(result.p2p_downloading_allowed);
1382 EXPECT_TRUE(result.p2p_sharing_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001383 EXPECT_GT(0, result.download_url_idx);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001384 EXPECT_TRUE(result.download_url_allowed);
Gilad Arnoldef8d0872014-10-03 14:14:06 -07001385 EXPECT_EQ(0, result.download_url_num_errors);
1386 EXPECT_FALSE(result.do_increment_failures);
1387}
1388
Gilad Arnold684219d2014-07-07 14:54:57 -07001389TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedEthernetDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001390 // Ethernet is always allowed.
1391
Amin Hassani4b717432019-01-14 16:24:20 -08001392 fake_state_.shill_provider()->var_conn_type()->reset(
1393 new ConnectionType(ConnectionType::kEthernet));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001394
1395 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001396 ExpectPolicyStatus(
1397 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001398 EXPECT_TRUE(result);
1399}
1400
Gilad Arnold684219d2014-07-07 14:54:57 -07001401TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWifiDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001402 // Wifi is allowed if not tethered.
1403
Amin Hassani4b717432019-01-14 16:24:20 -08001404 fake_state_.shill_provider()->var_conn_type()->reset(
1405 new ConnectionType(ConnectionType::kWifi));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001406
1407 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001408 ExpectPolicyStatus(
1409 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001410 EXPECT_TRUE(result);
1411}
1412
Alex Deymo63784a52014-05-28 10:46:14 -07001413TEST_F(UmChromeOSPolicyTest,
Gilad Arnold0adbc942014-05-12 10:35:43 -07001414 UpdateCurrentConnectionNotAllowedWifiTetheredDefault) {
1415 // Tethered wifi is not allowed by default.
1416
Amin Hassani4b717432019-01-14 16:24:20 -08001417 fake_state_.shill_provider()->var_conn_type()->reset(
1418 new ConnectionType(ConnectionType::kWifi));
1419 fake_state_.shill_provider()->var_conn_tethering()->reset(
1420 new ConnectionTethering(ConnectionTethering::kConfirmed));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001421
1422 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001423 ExpectPolicyStatus(
1424 EvalStatus::kAskMeAgainLater, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001425}
1426
Amin Hassani4b717432019-01-14 16:24:20 -08001427TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedWifiTetheredPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001428 // Tethered wifi can be allowed by policy.
1429
Amin Hassani4b717432019-01-14 16:24:20 -08001430 fake_state_.shill_provider()->var_conn_type()->reset(
1431 new ConnectionType(ConnectionType::kWifi));
1432 fake_state_.shill_provider()->var_conn_tethering()->reset(
1433 new ConnectionTethering(ConnectionTethering::kConfirmed));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001434 set<ConnectionType> allowed_connections;
1435 allowed_connections.insert(ConnectionType::kCellular);
Amin Hassani4b717432019-01-14 16:24:20 -08001436 fake_state_.device_policy_provider()
1437 ->var_allowed_connection_types_for_update()
1438 ->reset(new set<ConnectionType>(allowed_connections));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001439
1440 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001441 ExpectPolicyStatus(
1442 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001443 EXPECT_TRUE(result);
1444}
1445
Alex Deymo63784a52014-05-28 10:46:14 -07001446TEST_F(UmChromeOSPolicyTest, UpdateCurrentConnectionNotAllowedCellularDefault) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001447 // Cellular is not allowed by default.
1448
Amin Hassani4b717432019-01-14 16:24:20 -08001449 fake_state_.shill_provider()->var_conn_type()->reset(
1450 new ConnectionType(ConnectionType::kCellular));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001451
1452 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001453 ExpectPolicyStatus(
1454 EvalStatus::kAskMeAgainLater, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001455}
1456
Amin Hassani4b717432019-01-14 16:24:20 -08001457TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedCellularPolicyOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001458 // Update over cellular can be enabled by policy.
1459
Amin Hassani4b717432019-01-14 16:24:20 -08001460 fake_state_.shill_provider()->var_conn_type()->reset(
1461 new ConnectionType(ConnectionType::kCellular));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001462 set<ConnectionType> allowed_connections;
1463 allowed_connections.insert(ConnectionType::kCellular);
Amin Hassani4b717432019-01-14 16:24:20 -08001464 fake_state_.device_policy_provider()
1465 ->var_allowed_connection_types_for_update()
1466 ->reset(new set<ConnectionType>(allowed_connections));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001467
1468 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001469 ExpectPolicyStatus(
1470 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001471 EXPECT_TRUE(result);
1472}
1473
Amin Hassani4b717432019-01-14 16:24:20 -08001474TEST_F(UmChromeOSPolicyTest, UpdateDownloadAllowedCellularUserOverride) {
Gilad Arnold0adbc942014-05-12 10:35:43 -07001475 // Update over cellular can be enabled by user settings, but only if policy
1476 // is present and does not determine allowed connections.
1477
Amin Hassani4b717432019-01-14 16:24:20 -08001478 fake_state_.shill_provider()->var_conn_type()->reset(
1479 new ConnectionType(ConnectionType::kCellular));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001480 set<ConnectionType> allowed_connections;
1481 allowed_connections.insert(ConnectionType::kCellular);
Amin Hassani4b717432019-01-14 16:24:20 -08001482 fake_state_.updater_provider()->var_cellular_enabled()->reset(new bool(true));
Gilad Arnold0adbc942014-05-12 10:35:43 -07001483
1484 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001485 ExpectPolicyStatus(
1486 EvalStatus::kSucceeded, &Policy::UpdateDownloadAllowed, &result);
Gilad Arnold0adbc942014-05-12 10:35:43 -07001487 EXPECT_TRUE(result);
1488}
1489
Amin Hassani4b717432019-01-14 16:24:20 -08001490TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSupressedDueToP2P) {
Gilad Arnold14a9e702014-10-08 08:09:09 -07001491 // The UpdateCanStart policy returns true; scattering should have applied, but
1492 // P2P download is allowed. Scattering values are nonetheless returned, and so
1493 // are download URL values, albeit the latter are not allowed to be used.
1494
1495 SetUpdateCheckAllowed(false);
1496 fake_state_.device_policy_provider()->var_scatter_factor()->reset(
1497 new TimeDelta(TimeDelta::FromMinutes(2)));
1498 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1499
1500 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(1));
1501 update_state.scatter_wait_period = TimeDelta::FromSeconds(35);
1502
1503 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001504 ExpectPolicyStatus(
1505 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001506 EXPECT_TRUE(result.update_can_start);
1507 EXPECT_EQ(0, result.download_url_idx);
1508 EXPECT_FALSE(result.download_url_allowed);
1509 EXPECT_EQ(0, result.download_url_num_errors);
1510 EXPECT_TRUE(result.p2p_downloading_allowed);
1511 EXPECT_TRUE(result.p2p_sharing_allowed);
1512 EXPECT_FALSE(result.do_increment_failures);
1513 EXPECT_EQ(TimeDelta::FromSeconds(35), result.scatter_wait_period);
1514 EXPECT_EQ(0, result.scatter_check_threshold);
1515}
1516
Amin Hassani4b717432019-01-14 16:24:20 -08001517TEST_F(UmChromeOSPolicyTest, UpdateCanStartAllowedBackoffSupressedDueToP2P) {
Gilad Arnold14a9e702014-10-08 08:09:09 -07001518 // The UpdateCanStart policy returns true; backoff should have applied, but
1519 // P2P download is allowed. Backoff values are nonetheless returned, and so
1520 // are download URL values, albeit the latter are not allowed to be used.
1521
1522 SetUpdateCheckAllowed(false);
1523
1524 const Time curr_time = fake_clock_.GetWallclockTime();
1525 UpdateState update_state = GetDefaultUpdateState(TimeDelta::FromSeconds(10));
1526 update_state.download_errors_max = 1;
1527 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001528 0,
1529 ErrorCode::kDownloadTransferError,
Gilad Arnold14a9e702014-10-08 08:09:09 -07001530 curr_time - TimeDelta::FromSeconds(8));
1531 update_state.download_errors.emplace_back(
Amin Hassani4b717432019-01-14 16:24:20 -08001532 0,
1533 ErrorCode::kDownloadTransferError,
Gilad Arnold14a9e702014-10-08 08:09:09 -07001534 curr_time - TimeDelta::FromSeconds(2));
1535 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1536
1537 UpdateDownloadParams result;
Amin Hassani4b717432019-01-14 16:24:20 -08001538 ExpectPolicyStatus(
1539 EvalStatus::kSucceeded, &Policy::UpdateCanStart, &result, update_state);
Gilad Arnold14a9e702014-10-08 08:09:09 -07001540 EXPECT_TRUE(result.update_can_start);
1541 EXPECT_EQ(0, result.download_url_idx);
1542 EXPECT_FALSE(result.download_url_allowed);
1543 EXPECT_EQ(0, result.download_url_num_errors);
1544 EXPECT_TRUE(result.p2p_downloading_allowed);
1545 EXPECT_TRUE(result.p2p_sharing_allowed);
1546 EXPECT_TRUE(result.do_increment_failures);
1547 EXPECT_LT(curr_time, result.backoff_expiry);
1548}
1549
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001550TEST_F(UmChromeOSPolicyTest, P2PEnabledNotAllowed) {
1551 bool result;
1552 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1553 EXPECT_FALSE(result);
1554}
1555
1556TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByDevicePolicy) {
1557 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(
1558 new bool(true));
1559
1560 bool result;
1561 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1562 EXPECT_TRUE(result);
1563}
1564
1565TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedByUpdater) {
1566 fake_state_.updater_provider()->var_p2p_enabled()->reset(new bool(true));
1567
1568 bool result;
1569 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1570 EXPECT_TRUE(result);
1571}
1572
1573TEST_F(UmChromeOSPolicyTest, P2PEnabledAllowedDeviceEnterpriseEnrolled) {
1574 fake_state_.device_policy_provider()->var_au_p2p_enabled()->reset(nullptr);
Jae Hoon Kim9d9492f2019-06-17 14:52:48 -07001575 fake_state_.device_policy_provider()->var_has_owner()->reset(new bool(false));
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001576
1577 bool result;
1578 ExpectPolicyStatus(EvalStatus::kSucceeded, &Policy::P2PEnabled, &result);
1579 EXPECT_TRUE(result);
1580}
1581
1582TEST_F(UmChromeOSPolicyTest, P2PEnabledChangedBlocks) {
1583 bool result;
Amin Hassani4b717432019-01-14 16:24:20 -08001584 ExpectPolicyStatus(
1585 EvalStatus::kAskMeAgainLater, &Policy::P2PEnabledChanged, &result, false);
Gilad Arnold78ecbfc2014-10-22 14:38:25 -07001586}
1587
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001588TEST_F(UmChromeOSPolicyTest,
1589 UpdateCanBeAppliedForcedUpdatesDisablesTimeRestrictions) {
1590 Time curr_time = fake_clock_.GetWallclockTime();
1591 fake_state_.updater_provider()->var_forced_update_requested()->reset(
1592 new UpdateRequestStatus(UpdateRequestStatus::kInteractive));
1593 // Should return kAskMeAgainLater when updated are not forced.
1594 TestDisallowedTimeIntervals(
1595 {WeeklyTimeInterval(
1596 WeeklyTime::FromTime(curr_time),
1597 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001598 ErrorCode::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001599 /* kiosk = */ true);
1600}
1601
1602TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedFailsInDisallowedTime) {
1603 Time curr_time = fake_clock_.GetWallclockTime();
1604 TestDisallowedTimeIntervals(
1605 {WeeklyTimeInterval(
1606 WeeklyTime::FromTime(curr_time),
1607 WeeklyTime::FromTime(curr_time + TimeDelta::FromMinutes(1)))},
Adolfo Victoria7a7a0822018-07-27 13:35:24 -07001608 ErrorCode::kOmahaUpdateDeferredPerPolicy,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001609 /* kiosk = */ true);
1610}
1611
1612TEST_F(UmChromeOSPolicyTest, UpdateCanBeAppliedOutsideDisallowedTime) {
1613 Time curr_time = fake_clock_.GetWallclockTime();
1614 TestDisallowedTimeIntervals(
1615 {WeeklyTimeInterval(
1616 WeeklyTime::FromTime(curr_time - TimeDelta::FromHours(3)),
1617 WeeklyTime::FromTime(curr_time))},
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, UpdateCanBeAppliedPassesOnNonKiosk) {
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::kSuccess,
Adolfo Victoria0dbf1f92018-07-19 14:18:11 -07001629 /* kiosk = */ false);
1630}
1631
Alex Deymo63784a52014-05-28 10:46:14 -07001632} // namespace chromeos_update_manager