OLD | NEW |
1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/policy/core/browser/configuration_policy_handler.h" | 5 #include "components/policy/core/browser/configuration_policy_handler.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/callback.h" | 10 #include "base/callback.h" |
11 #include "base/json/json_reader.h" | 11 #include "base/json/json_reader.h" |
| 12 #include "base/memory/ptr_util.h" |
12 #include "base/values.h" | 13 #include "base/values.h" |
13 #include "components/policy/core/browser/policy_error_map.h" | 14 #include "components/policy/core/browser/policy_error_map.h" |
14 #include "components/policy/core/common/policy_map.h" | 15 #include "components/policy/core/common/policy_map.h" |
15 #include "components/policy/core/common/policy_types.h" | 16 #include "components/policy/core/common/policy_types.h" |
16 #include "components/policy/core/common/schema.h" | 17 #include "components/policy/core/common/schema.h" |
17 #include "components/prefs/pref_value_map.h" | 18 #include "components/prefs/pref_value_map.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
19 | 20 |
20 namespace policy { | 21 namespace policy { |
21 | 22 |
(...skipping 30 matching lines...) Expand all Loading... |
52 | 53 |
53 TEST(StringToIntEnumListPolicyHandlerTest, CheckPolicySettings) { | 54 TEST(StringToIntEnumListPolicyHandlerTest, CheckPolicySettings) { |
54 base::ListValue list; | 55 base::ListValue list; |
55 PolicyMap policy_map; | 56 PolicyMap policy_map; |
56 PolicyErrorMap errors; | 57 PolicyErrorMap errors; |
57 StringMappingListPolicyHandler handler( | 58 StringMappingListPolicyHandler handler( |
58 kTestPolicy, | 59 kTestPolicy, |
59 kTestPref, | 60 kTestPref, |
60 base::Bind(GetIntegerTypeMap)); | 61 base::Bind(GetIntegerTypeMap)); |
61 | 62 |
62 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 63 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
63 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); | 64 POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), nullptr); |
64 errors.Clear(); | 65 errors.Clear(); |
65 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 66 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
66 EXPECT_TRUE(errors.empty()); | 67 EXPECT_TRUE(errors.empty()); |
67 | 68 |
68 list.AppendString("one"); | 69 list.AppendString("one"); |
69 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 70 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
70 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); | 71 POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), nullptr); |
71 errors.Clear(); | 72 errors.Clear(); |
72 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 73 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
73 EXPECT_TRUE(errors.empty()); | 74 EXPECT_TRUE(errors.empty()); |
74 | 75 |
75 list.AppendString("invalid"); | 76 list.AppendString("invalid"); |
76 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 77 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
77 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); | 78 POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), nullptr); |
78 errors.Clear(); | 79 errors.Clear(); |
79 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 80 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
80 EXPECT_FALSE(errors.empty()); | 81 EXPECT_FALSE(errors.empty()); |
81 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); | 82 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); |
82 | 83 |
83 policy_map.Set(kTestPolicy, | 84 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
84 POLICY_LEVEL_MANDATORY, | |
85 POLICY_SCOPE_USER, | |
86 POLICY_SOURCE_CLOUD, | 85 POLICY_SOURCE_CLOUD, |
87 new base::StringValue("no list"), | 86 base::WrapUnique(new base::StringValue("no list")), NULL); |
88 NULL); | |
89 errors.Clear(); | 87 errors.Clear(); |
90 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 88 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
91 EXPECT_FALSE(errors.empty()); | 89 EXPECT_FALSE(errors.empty()); |
92 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); | 90 EXPECT_FALSE(errors.GetErrors(kTestPolicy).empty()); |
93 } | 91 } |
94 | 92 |
95 TEST(StringMappingListPolicyHandlerTest, ApplyPolicySettings) { | 93 TEST(StringMappingListPolicyHandlerTest, ApplyPolicySettings) { |
96 base::ListValue list; | 94 base::ListValue list; |
97 base::ListValue expected; | 95 base::ListValue expected; |
98 PolicyMap policy_map; | 96 PolicyMap policy_map; |
99 PrefValueMap prefs; | 97 PrefValueMap prefs; |
100 base::Value* value; | 98 base::Value* value; |
101 StringMappingListPolicyHandler handler( | 99 StringMappingListPolicyHandler handler( |
102 kTestPolicy, | 100 kTestPolicy, |
103 kTestPref, | 101 kTestPref, |
104 base::Bind(GetIntegerTypeMap)); | 102 base::Bind(GetIntegerTypeMap)); |
105 | 103 |
106 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 104 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
107 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); | 105 POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), nullptr); |
108 handler.ApplyPolicySettings(policy_map, &prefs); | 106 handler.ApplyPolicySettings(policy_map, &prefs); |
109 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 107 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
110 EXPECT_TRUE(base::Value::Equals(&expected, value)); | 108 EXPECT_TRUE(base::Value::Equals(&expected, value)); |
111 | 109 |
112 list.AppendString("two"); | 110 list.AppendString("two"); |
113 expected.AppendInteger(2); | 111 expected.AppendInteger(2); |
114 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 112 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
115 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); | 113 POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), nullptr); |
116 handler.ApplyPolicySettings(policy_map, &prefs); | 114 handler.ApplyPolicySettings(policy_map, &prefs); |
117 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 115 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
118 EXPECT_TRUE(base::Value::Equals(&expected, value)); | 116 EXPECT_TRUE(base::Value::Equals(&expected, value)); |
119 | 117 |
120 list.AppendString("invalid"); | 118 list.AppendString("invalid"); |
121 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 119 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
122 POLICY_SOURCE_CLOUD, list.DeepCopy(), nullptr); | 120 POLICY_SOURCE_CLOUD, list.CreateDeepCopy(), nullptr); |
123 handler.ApplyPolicySettings(policy_map, &prefs); | 121 handler.ApplyPolicySettings(policy_map, &prefs); |
124 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 122 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
125 EXPECT_TRUE(base::Value::Equals(&expected, value)); | 123 EXPECT_TRUE(base::Value::Equals(&expected, value)); |
126 } | 124 } |
127 | 125 |
128 TEST(IntRangePolicyHandler, CheckPolicySettingsClamp) { | 126 TEST(IntRangePolicyHandler, CheckPolicySettingsClamp) { |
129 PolicyMap policy_map; | 127 PolicyMap policy_map; |
130 PolicyErrorMap errors; | 128 PolicyErrorMap errors; |
131 | 129 |
132 // This tests needs to modify an int policy. The exact policy used and its | 130 // This tests needs to modify an int policy. The exact policy used and its |
133 // semantics outside the test are irrelevant. | 131 // semantics outside the test are irrelevant. |
134 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 132 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
135 | 133 |
136 // Check that values lying in the accepted range are not rejected. | 134 // Check that values lying in the accepted range are not rejected. |
137 policy_map.Set(kTestPolicy, | 135 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
138 POLICY_LEVEL_MANDATORY, | |
139 POLICY_SCOPE_USER, | |
140 POLICY_SOURCE_CLOUD, | 136 POLICY_SOURCE_CLOUD, |
141 new base::FundamentalValue(0), | 137 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
142 NULL); | |
143 errors.Clear(); | 138 errors.Clear(); |
144 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 139 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
145 EXPECT_TRUE(errors.empty()); | 140 EXPECT_TRUE(errors.empty()); |
146 | 141 |
147 policy_map.Set(kTestPolicy, | 142 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
148 POLICY_LEVEL_MANDATORY, | |
149 POLICY_SCOPE_USER, | |
150 POLICY_SOURCE_CLOUD, | 143 POLICY_SOURCE_CLOUD, |
151 new base::FundamentalValue(5), | 144 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
152 NULL); | |
153 errors.Clear(); | 145 errors.Clear(); |
154 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 146 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
155 EXPECT_TRUE(errors.empty()); | 147 EXPECT_TRUE(errors.empty()); |
156 | 148 |
157 policy_map.Set(kTestPolicy, | 149 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
158 POLICY_LEVEL_MANDATORY, | |
159 POLICY_SCOPE_USER, | |
160 POLICY_SOURCE_CLOUD, | 150 POLICY_SOURCE_CLOUD, |
161 new base::FundamentalValue(10), | 151 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
162 NULL); | |
163 errors.Clear(); | 152 errors.Clear(); |
164 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 153 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
165 EXPECT_TRUE(errors.empty()); | 154 EXPECT_TRUE(errors.empty()); |
166 | 155 |
167 // Check that values lying outside the accepted range are not rejected | 156 // Check that values lying outside the accepted range are not rejected |
168 // (because clamping is enabled) but do yield a warning message. | 157 // (because clamping is enabled) but do yield a warning message. |
169 policy_map.Set(kTestPolicy, | 158 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
170 POLICY_LEVEL_MANDATORY, | |
171 POLICY_SCOPE_USER, | |
172 POLICY_SOURCE_CLOUD, | 159 POLICY_SOURCE_CLOUD, |
173 new base::FundamentalValue(-5), | 160 base::WrapUnique(new base::FundamentalValue(-5)), nullptr); |
174 NULL); | |
175 errors.Clear(); | 161 errors.Clear(); |
176 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 162 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
177 EXPECT_FALSE(errors.empty()); | 163 EXPECT_FALSE(errors.empty()); |
178 | 164 |
179 policy_map.Set(kTestPolicy, | 165 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
180 POLICY_LEVEL_MANDATORY, | |
181 POLICY_SCOPE_USER, | |
182 POLICY_SOURCE_CLOUD, | 166 POLICY_SOURCE_CLOUD, |
183 new base::FundamentalValue(15), | 167 base::WrapUnique(new base::FundamentalValue(15)), nullptr); |
184 NULL); | |
185 errors.Clear(); | 168 errors.Clear(); |
186 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 169 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
187 EXPECT_FALSE(errors.empty()); | 170 EXPECT_FALSE(errors.empty()); |
188 | 171 |
189 // Check that an entirely invalid value is rejected and yields an error | 172 // Check that an entirely invalid value is rejected and yields an error |
190 // message. | 173 // message. |
191 policy_map.Set(kTestPolicy, | 174 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
192 POLICY_LEVEL_MANDATORY, | |
193 POLICY_SCOPE_USER, | |
194 POLICY_SOURCE_CLOUD, | 175 POLICY_SOURCE_CLOUD, |
195 new base::StringValue("invalid"), | 176 base::WrapUnique(new base::StringValue("invalid")), nullptr); |
196 NULL); | |
197 errors.Clear(); | 177 errors.Clear(); |
198 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 178 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
199 EXPECT_FALSE(errors.empty()); | 179 EXPECT_FALSE(errors.empty()); |
200 } | 180 } |
201 | 181 |
202 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) { | 182 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) { |
203 PolicyMap policy_map; | 183 PolicyMap policy_map; |
204 PolicyErrorMap errors; | 184 PolicyErrorMap errors; |
205 | 185 |
206 // This tests needs to modify an int policy. The exact policy used and its | 186 // This tests needs to modify an int policy. The exact policy used and its |
207 // semantics outside the test are irrelevant. | 187 // semantics outside the test are irrelevant. |
208 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, false); | 188 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, false); |
209 | 189 |
210 // Check that values lying in the accepted range are not rejected. | 190 // Check that values lying in the accepted range are not rejected. |
211 policy_map.Set(kTestPolicy, | 191 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
212 POLICY_LEVEL_MANDATORY, | |
213 POLICY_SCOPE_USER, | |
214 POLICY_SOURCE_CLOUD, | 192 POLICY_SOURCE_CLOUD, |
215 new base::FundamentalValue(0), | 193 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
216 NULL); | |
217 errors.Clear(); | 194 errors.Clear(); |
218 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 195 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
219 EXPECT_TRUE(errors.empty()); | 196 EXPECT_TRUE(errors.empty()); |
220 | 197 |
221 policy_map.Set(kTestPolicy, | 198 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
222 POLICY_LEVEL_MANDATORY, | |
223 POLICY_SCOPE_USER, | |
224 POLICY_SOURCE_CLOUD, | 199 POLICY_SOURCE_CLOUD, |
225 new base::FundamentalValue(5), | 200 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
226 NULL); | |
227 errors.Clear(); | 201 errors.Clear(); |
228 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 202 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
229 EXPECT_TRUE(errors.empty()); | 203 EXPECT_TRUE(errors.empty()); |
230 | 204 |
231 policy_map.Set(kTestPolicy, | 205 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
232 POLICY_LEVEL_MANDATORY, | |
233 POLICY_SCOPE_USER, | |
234 POLICY_SOURCE_CLOUD, | 206 POLICY_SOURCE_CLOUD, |
235 new base::FundamentalValue(10), | 207 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
236 NULL); | |
237 errors.Clear(); | 208 errors.Clear(); |
238 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 209 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
239 EXPECT_TRUE(errors.empty()); | 210 EXPECT_TRUE(errors.empty()); |
240 | 211 |
241 // Check that values lying outside the accepted range are rejected and yield | 212 // Check that values lying outside the accepted range are rejected and yield |
242 // an error message. | 213 // an error message. |
243 policy_map.Set(kTestPolicy, | 214 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
244 POLICY_LEVEL_MANDATORY, | |
245 POLICY_SCOPE_USER, | |
246 POLICY_SOURCE_CLOUD, | 215 POLICY_SOURCE_CLOUD, |
247 new base::FundamentalValue(-5), | 216 base::WrapUnique(new base::FundamentalValue(-5)), nullptr); |
248 NULL); | |
249 errors.Clear(); | 217 errors.Clear(); |
250 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 218 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
251 EXPECT_FALSE(errors.empty()); | 219 EXPECT_FALSE(errors.empty()); |
252 | 220 |
253 policy_map.Set(kTestPolicy, | 221 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
254 POLICY_LEVEL_MANDATORY, | |
255 POLICY_SCOPE_USER, | |
256 POLICY_SOURCE_CLOUD, | 222 POLICY_SOURCE_CLOUD, |
257 new base::FundamentalValue(15), | 223 base::WrapUnique(new base::FundamentalValue(15)), nullptr); |
258 NULL); | |
259 errors.Clear(); | 224 errors.Clear(); |
260 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 225 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
261 EXPECT_FALSE(errors.empty()); | 226 EXPECT_FALSE(errors.empty()); |
262 | 227 |
263 // Check that an entirely invalid value is rejected and yields an error | 228 // Check that an entirely invalid value is rejected and yields an error |
264 // message. | 229 // message. |
265 policy_map.Set(kTestPolicy, | 230 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
266 POLICY_LEVEL_MANDATORY, | |
267 POLICY_SCOPE_USER, | |
268 POLICY_SOURCE_CLOUD, | 231 POLICY_SOURCE_CLOUD, |
269 new base::StringValue("invalid"), | 232 base::WrapUnique(new base::StringValue("invalid")), nullptr); |
270 NULL); | |
271 errors.Clear(); | 233 errors.Clear(); |
272 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 234 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
273 EXPECT_FALSE(errors.empty()); | 235 EXPECT_FALSE(errors.empty()); |
274 } | 236 } |
275 | 237 |
276 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) { | 238 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) { |
277 PolicyMap policy_map; | 239 PolicyMap policy_map; |
278 PrefValueMap prefs; | 240 PrefValueMap prefs; |
279 std::unique_ptr<base::Value> expected; | 241 std::unique_ptr<base::Value> expected; |
280 const base::Value* value; | 242 const base::Value* value; |
281 | 243 |
282 // This tests needs to modify an int policy. The exact policy used and its | 244 // This tests needs to modify an int policy. The exact policy used and its |
283 // semantics outside the test are irrelevant. | 245 // semantics outside the test are irrelevant. |
284 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 246 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
285 | 247 |
286 // Check that values lying in the accepted range are written to the pref. | 248 // Check that values lying in the accepted range are written to the pref. |
287 policy_map.Set(kTestPolicy, | 249 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
288 POLICY_LEVEL_MANDATORY, | |
289 POLICY_SCOPE_USER, | |
290 POLICY_SOURCE_CLOUD, | 250 POLICY_SOURCE_CLOUD, |
291 new base::FundamentalValue(0), | 251 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
292 NULL); | |
293 prefs.Clear(); | 252 prefs.Clear(); |
294 handler.ApplyPolicySettings(policy_map, &prefs); | 253 handler.ApplyPolicySettings(policy_map, &prefs); |
295 expected.reset(new base::FundamentalValue(0)); | 254 expected.reset(new base::FundamentalValue(0)); |
296 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 255 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
297 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 256 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
298 | 257 |
299 policy_map.Set(kTestPolicy, | 258 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
300 POLICY_LEVEL_MANDATORY, | |
301 POLICY_SCOPE_USER, | |
302 POLICY_SOURCE_CLOUD, | 259 POLICY_SOURCE_CLOUD, |
303 new base::FundamentalValue(5), | 260 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
304 NULL); | |
305 prefs.Clear(); | 261 prefs.Clear(); |
306 handler.ApplyPolicySettings(policy_map, &prefs); | 262 handler.ApplyPolicySettings(policy_map, &prefs); |
307 expected.reset(new base::FundamentalValue(5)); | 263 expected.reset(new base::FundamentalValue(5)); |
308 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 264 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
309 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 265 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
310 | 266 |
311 policy_map.Set(kTestPolicy, | 267 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
312 POLICY_LEVEL_MANDATORY, | |
313 POLICY_SCOPE_USER, | |
314 POLICY_SOURCE_CLOUD, | 268 POLICY_SOURCE_CLOUD, |
315 new base::FundamentalValue(10), | 269 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
316 NULL); | |
317 prefs.Clear(); | 270 prefs.Clear(); |
318 handler.ApplyPolicySettings(policy_map, &prefs); | 271 handler.ApplyPolicySettings(policy_map, &prefs); |
319 expected.reset(new base::FundamentalValue(10)); | 272 expected.reset(new base::FundamentalValue(10)); |
320 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 273 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
321 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 274 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
322 | 275 |
323 // Check that values lying outside the accepted range are clamped and written | 276 // Check that values lying outside the accepted range are clamped and written |
324 // to the pref. | 277 // to the pref. |
325 policy_map.Set(kTestPolicy, | 278 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
326 POLICY_LEVEL_MANDATORY, | |
327 POLICY_SCOPE_USER, | |
328 POLICY_SOURCE_CLOUD, | 279 POLICY_SOURCE_CLOUD, |
329 new base::FundamentalValue(-5), | 280 base::WrapUnique(new base::FundamentalValue(-5)), nullptr); |
330 NULL); | |
331 prefs.Clear(); | 281 prefs.Clear(); |
332 handler.ApplyPolicySettings(policy_map, &prefs); | 282 handler.ApplyPolicySettings(policy_map, &prefs); |
333 expected.reset(new base::FundamentalValue(0)); | 283 expected.reset(new base::FundamentalValue(0)); |
334 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 284 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
335 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 285 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
336 | 286 |
337 policy_map.Set(kTestPolicy, | 287 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
338 POLICY_LEVEL_MANDATORY, | |
339 POLICY_SCOPE_USER, | |
340 POLICY_SOURCE_CLOUD, | 288 POLICY_SOURCE_CLOUD, |
341 new base::FundamentalValue(15), | 289 base::WrapUnique(new base::FundamentalValue(15)), nullptr); |
342 NULL); | |
343 prefs.Clear(); | 290 prefs.Clear(); |
344 handler.ApplyPolicySettings(policy_map, &prefs); | 291 handler.ApplyPolicySettings(policy_map, &prefs); |
345 expected.reset(new base::FundamentalValue(10)); | 292 expected.reset(new base::FundamentalValue(10)); |
346 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 293 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
347 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 294 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
348 } | 295 } |
349 | 296 |
350 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) { | 297 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) { |
351 PolicyMap policy_map; | 298 PolicyMap policy_map; |
352 PrefValueMap prefs; | 299 PrefValueMap prefs; |
353 std::unique_ptr<base::Value> expected; | 300 std::unique_ptr<base::Value> expected; |
354 const base::Value* value; | 301 const base::Value* value; |
355 | 302 |
356 // This tests needs to modify an int policy. The exact policy used and its | 303 // This tests needs to modify an int policy. The exact policy used and its |
357 // semantics outside the test are irrelevant. | 304 // semantics outside the test are irrelevant. |
358 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 305 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
359 | 306 |
360 // Check that values lying in the accepted range are written to the pref. | 307 // Check that values lying in the accepted range are written to the pref. |
361 policy_map.Set(kTestPolicy, | 308 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
362 POLICY_LEVEL_MANDATORY, | |
363 POLICY_SCOPE_USER, | |
364 POLICY_SOURCE_CLOUD, | 309 POLICY_SOURCE_CLOUD, |
365 new base::FundamentalValue(0), | 310 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
366 NULL); | |
367 prefs.Clear(); | 311 prefs.Clear(); |
368 handler.ApplyPolicySettings(policy_map, &prefs); | 312 handler.ApplyPolicySettings(policy_map, &prefs); |
369 expected.reset(new base::FundamentalValue(0)); | 313 expected.reset(new base::FundamentalValue(0)); |
370 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 314 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
371 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 315 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
372 | 316 |
373 policy_map.Set(kTestPolicy, | 317 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
374 POLICY_LEVEL_MANDATORY, | |
375 POLICY_SCOPE_USER, | |
376 POLICY_SOURCE_CLOUD, | 318 POLICY_SOURCE_CLOUD, |
377 new base::FundamentalValue(5), | 319 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
378 NULL); | |
379 prefs.Clear(); | 320 prefs.Clear(); |
380 handler.ApplyPolicySettings(policy_map, &prefs); | 321 handler.ApplyPolicySettings(policy_map, &prefs); |
381 expected.reset(new base::FundamentalValue(5)); | 322 expected.reset(new base::FundamentalValue(5)); |
382 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 323 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
383 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 324 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
384 | 325 |
385 policy_map.Set(kTestPolicy, | 326 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
386 POLICY_LEVEL_MANDATORY, | |
387 POLICY_SCOPE_USER, | |
388 POLICY_SOURCE_CLOUD, | 327 POLICY_SOURCE_CLOUD, |
389 new base::FundamentalValue(10), | 328 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
390 NULL); | |
391 prefs.Clear(); | 329 prefs.Clear(); |
392 handler.ApplyPolicySettings(policy_map, &prefs); | 330 handler.ApplyPolicySettings(policy_map, &prefs); |
393 expected.reset(new base::FundamentalValue(10)); | 331 expected.reset(new base::FundamentalValue(10)); |
394 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 332 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
395 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 333 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
396 } | 334 } |
397 | 335 |
398 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) { | 336 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) { |
399 PolicyMap policy_map; | 337 PolicyMap policy_map; |
400 PolicyErrorMap errors; | 338 PolicyErrorMap errors; |
401 | 339 |
402 // This tests needs to modify an int policy. The exact policy used and its | 340 // This tests needs to modify an int policy. The exact policy used and its |
403 // semantics outside the test are irrelevant. | 341 // semantics outside the test are irrelevant. |
404 IntPercentageToDoublePolicyHandler handler( | 342 IntPercentageToDoublePolicyHandler handler( |
405 kTestPolicy, kTestPref, 0, 10, true); | 343 kTestPolicy, kTestPref, 0, 10, true); |
406 | 344 |
407 // Check that values lying in the accepted range are not rejected. | 345 // Check that values lying in the accepted range are not rejected. |
408 policy_map.Set(kTestPolicy, | 346 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
409 POLICY_LEVEL_MANDATORY, | |
410 POLICY_SCOPE_USER, | |
411 POLICY_SOURCE_CLOUD, | 347 POLICY_SOURCE_CLOUD, |
412 new base::FundamentalValue(0), | 348 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
413 NULL); | |
414 errors.Clear(); | 349 errors.Clear(); |
415 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 350 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
416 EXPECT_TRUE(errors.empty()); | 351 EXPECT_TRUE(errors.empty()); |
417 | 352 |
418 policy_map.Set(kTestPolicy, | 353 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
419 POLICY_LEVEL_MANDATORY, | |
420 POLICY_SCOPE_USER, | |
421 POLICY_SOURCE_CLOUD, | 354 POLICY_SOURCE_CLOUD, |
422 new base::FundamentalValue(5), | 355 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
423 NULL); | |
424 errors.Clear(); | 356 errors.Clear(); |
425 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 357 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
426 EXPECT_TRUE(errors.empty()); | 358 EXPECT_TRUE(errors.empty()); |
427 | 359 |
428 policy_map.Set(kTestPolicy, | 360 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
429 POLICY_LEVEL_MANDATORY, | |
430 POLICY_SCOPE_USER, | |
431 POLICY_SOURCE_CLOUD, | 361 POLICY_SOURCE_CLOUD, |
432 new base::FundamentalValue(10), | 362 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
433 NULL); | |
434 errors.Clear(); | 363 errors.Clear(); |
435 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 364 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
436 EXPECT_TRUE(errors.empty()); | 365 EXPECT_TRUE(errors.empty()); |
437 | 366 |
438 // Check that values lying outside the accepted range are not rejected | 367 // Check that values lying outside the accepted range are not rejected |
439 // (because clamping is enabled) but do yield a warning message. | 368 // (because clamping is enabled) but do yield a warning message. |
440 policy_map.Set(kTestPolicy, | 369 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
441 POLICY_LEVEL_MANDATORY, | |
442 POLICY_SCOPE_USER, | |
443 POLICY_SOURCE_CLOUD, | 370 POLICY_SOURCE_CLOUD, |
444 new base::FundamentalValue(-5), | 371 base::WrapUnique(new base::FundamentalValue(-5)), nullptr); |
445 NULL); | |
446 errors.Clear(); | 372 errors.Clear(); |
447 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 373 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
448 EXPECT_FALSE(errors.empty()); | 374 EXPECT_FALSE(errors.empty()); |
449 | 375 |
450 policy_map.Set(kTestPolicy, | 376 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
451 POLICY_LEVEL_MANDATORY, | |
452 POLICY_SCOPE_USER, | |
453 POLICY_SOURCE_CLOUD, | 377 POLICY_SOURCE_CLOUD, |
454 new base::FundamentalValue(15), | 378 base::WrapUnique(new base::FundamentalValue(15)), nullptr); |
455 NULL); | |
456 errors.Clear(); | 379 errors.Clear(); |
457 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 380 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
458 EXPECT_FALSE(errors.empty()); | 381 EXPECT_FALSE(errors.empty()); |
459 | 382 |
460 // Check that an entirely invalid value is rejected and yields an error | 383 // Check that an entirely invalid value is rejected and yields an error |
461 // message. | 384 // message. |
462 policy_map.Set(kTestPolicy, | 385 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
463 POLICY_LEVEL_MANDATORY, | |
464 POLICY_SCOPE_USER, | |
465 POLICY_SOURCE_CLOUD, | 386 POLICY_SOURCE_CLOUD, |
466 new base::StringValue("invalid"), | 387 base::WrapUnique(new base::StringValue("invalid")), nullptr); |
467 NULL); | |
468 errors.Clear(); | 388 errors.Clear(); |
469 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 389 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
470 EXPECT_FALSE(errors.empty()); | 390 EXPECT_FALSE(errors.empty()); |
471 } | 391 } |
472 | 392 |
473 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) { | 393 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) { |
474 PolicyMap policy_map; | 394 PolicyMap policy_map; |
475 PolicyErrorMap errors; | 395 PolicyErrorMap errors; |
476 | 396 |
477 // This tests needs to modify an int policy. The exact policy used and its | 397 // This tests needs to modify an int policy. The exact policy used and its |
478 // semantics outside the test are irrelevant. | 398 // semantics outside the test are irrelevant. |
479 IntPercentageToDoublePolicyHandler handler( | 399 IntPercentageToDoublePolicyHandler handler( |
480 kTestPolicy, kTestPref, 0, 10, false); | 400 kTestPolicy, kTestPref, 0, 10, false); |
481 | 401 |
482 // Check that values lying in the accepted range are not rejected. | 402 // Check that values lying in the accepted range are not rejected. |
483 policy_map.Set(kTestPolicy, | 403 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
484 POLICY_LEVEL_MANDATORY, | |
485 POLICY_SCOPE_USER, | |
486 POLICY_SOURCE_CLOUD, | 404 POLICY_SOURCE_CLOUD, |
487 new base::FundamentalValue(0), | 405 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
488 NULL); | |
489 errors.Clear(); | 406 errors.Clear(); |
490 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 407 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
491 EXPECT_TRUE(errors.empty()); | 408 EXPECT_TRUE(errors.empty()); |
492 | 409 |
493 policy_map.Set(kTestPolicy, | 410 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
494 POLICY_LEVEL_MANDATORY, | |
495 POLICY_SCOPE_USER, | |
496 POLICY_SOURCE_CLOUD, | 411 POLICY_SOURCE_CLOUD, |
497 new base::FundamentalValue(5), | 412 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
498 NULL); | |
499 errors.Clear(); | 413 errors.Clear(); |
500 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 414 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
501 EXPECT_TRUE(errors.empty()); | 415 EXPECT_TRUE(errors.empty()); |
502 | 416 |
503 policy_map.Set(kTestPolicy, | 417 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
504 POLICY_LEVEL_MANDATORY, | |
505 POLICY_SCOPE_USER, | |
506 POLICY_SOURCE_CLOUD, | 418 POLICY_SOURCE_CLOUD, |
507 new base::FundamentalValue(10), | 419 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
508 NULL); | |
509 errors.Clear(); | 420 errors.Clear(); |
510 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 421 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
511 EXPECT_TRUE(errors.empty()); | 422 EXPECT_TRUE(errors.empty()); |
512 | 423 |
513 // Check that values lying outside the accepted range are rejected and yield | 424 // Check that values lying outside the accepted range are rejected and yield |
514 // an error message. | 425 // an error message. |
515 policy_map.Set(kTestPolicy, | 426 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
516 POLICY_LEVEL_MANDATORY, | |
517 POLICY_SCOPE_USER, | |
518 POLICY_SOURCE_CLOUD, | 427 POLICY_SOURCE_CLOUD, |
519 new base::FundamentalValue(-5), | 428 base::WrapUnique(new base::FundamentalValue(-5)), nullptr); |
520 NULL); | |
521 errors.Clear(); | 429 errors.Clear(); |
522 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 430 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
523 EXPECT_FALSE(errors.empty()); | 431 EXPECT_FALSE(errors.empty()); |
524 | 432 |
525 policy_map.Set(kTestPolicy, | 433 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
526 POLICY_LEVEL_MANDATORY, | |
527 POLICY_SCOPE_USER, | |
528 POLICY_SOURCE_CLOUD, | 434 POLICY_SOURCE_CLOUD, |
529 new base::FundamentalValue(15), | 435 base::WrapUnique(new base::FundamentalValue(15)), nullptr); |
530 NULL); | |
531 errors.Clear(); | 436 errors.Clear(); |
532 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 437 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
533 EXPECT_FALSE(errors.empty()); | 438 EXPECT_FALSE(errors.empty()); |
534 | 439 |
535 // Check that an entirely invalid value is rejected and yields an error | 440 // Check that an entirely invalid value is rejected and yields an error |
536 // message. | 441 // message. |
537 policy_map.Set(kTestPolicy, | 442 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
538 POLICY_LEVEL_MANDATORY, | |
539 POLICY_SCOPE_USER, | |
540 POLICY_SOURCE_CLOUD, | 443 POLICY_SOURCE_CLOUD, |
541 new base::StringValue("invalid"), | 444 base::WrapUnique(new base::StringValue("invalid")), nullptr); |
542 NULL); | |
543 errors.Clear(); | 445 errors.Clear(); |
544 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 446 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
545 EXPECT_FALSE(errors.empty()); | 447 EXPECT_FALSE(errors.empty()); |
546 } | 448 } |
547 | 449 |
548 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) { | 450 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) { |
549 PolicyMap policy_map; | 451 PolicyMap policy_map; |
550 PrefValueMap prefs; | 452 PrefValueMap prefs; |
551 std::unique_ptr<base::Value> expected; | 453 std::unique_ptr<base::Value> expected; |
552 const base::Value* value; | 454 const base::Value* value; |
553 | 455 |
554 // This tests needs to modify an int policy. The exact policy used and its | 456 // This tests needs to modify an int policy. The exact policy used and its |
555 // semantics outside the test are irrelevant. | 457 // semantics outside the test are irrelevant. |
556 IntPercentageToDoublePolicyHandler handler( | 458 IntPercentageToDoublePolicyHandler handler( |
557 kTestPolicy, kTestPref, 0, 10, true); | 459 kTestPolicy, kTestPref, 0, 10, true); |
558 | 460 |
559 // Check that values lying in the accepted range are written to the pref. | 461 // Check that values lying in the accepted range are written to the pref. |
560 policy_map.Set(kTestPolicy, | 462 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
561 POLICY_LEVEL_MANDATORY, | |
562 POLICY_SCOPE_USER, | |
563 POLICY_SOURCE_CLOUD, | 463 POLICY_SOURCE_CLOUD, |
564 new base::FundamentalValue(0), | 464 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
565 NULL); | |
566 prefs.Clear(); | 465 prefs.Clear(); |
567 handler.ApplyPolicySettings(policy_map, &prefs); | 466 handler.ApplyPolicySettings(policy_map, &prefs); |
568 expected.reset(new base::FundamentalValue(0.0)); | 467 expected.reset(new base::FundamentalValue(0.0)); |
569 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 468 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
570 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 469 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
571 | 470 |
572 policy_map.Set(kTestPolicy, | 471 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
573 POLICY_LEVEL_MANDATORY, | |
574 POLICY_SCOPE_USER, | |
575 POLICY_SOURCE_CLOUD, | 472 POLICY_SOURCE_CLOUD, |
576 new base::FundamentalValue(5), | 473 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
577 NULL); | |
578 prefs.Clear(); | 474 prefs.Clear(); |
579 handler.ApplyPolicySettings(policy_map, &prefs); | 475 handler.ApplyPolicySettings(policy_map, &prefs); |
580 expected.reset(new base::FundamentalValue(0.05)); | 476 expected.reset(new base::FundamentalValue(0.05)); |
581 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 477 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
582 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 478 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
583 | 479 |
584 policy_map.Set(kTestPolicy, | 480 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
585 POLICY_LEVEL_MANDATORY, | |
586 POLICY_SCOPE_USER, | |
587 POLICY_SOURCE_CLOUD, | 481 POLICY_SOURCE_CLOUD, |
588 new base::FundamentalValue(10), | 482 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
589 NULL); | |
590 prefs.Clear(); | 483 prefs.Clear(); |
591 handler.ApplyPolicySettings(policy_map, &prefs); | 484 handler.ApplyPolicySettings(policy_map, &prefs); |
592 expected.reset(new base::FundamentalValue(0.1)); | 485 expected.reset(new base::FundamentalValue(0.1)); |
593 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 486 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
594 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 487 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
595 | 488 |
596 // Check that values lying outside the accepted range are clamped and written | 489 // Check that values lying outside the accepted range are clamped and written |
597 // to the pref. | 490 // to the pref. |
598 policy_map.Set(kTestPolicy, | 491 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
599 POLICY_LEVEL_MANDATORY, | |
600 POLICY_SCOPE_USER, | |
601 POLICY_SOURCE_CLOUD, | 492 POLICY_SOURCE_CLOUD, |
602 new base::FundamentalValue(-5), | 493 base::WrapUnique(new base::FundamentalValue(-5)), nullptr); |
603 NULL); | |
604 prefs.Clear(); | 494 prefs.Clear(); |
605 handler.ApplyPolicySettings(policy_map, &prefs); | 495 handler.ApplyPolicySettings(policy_map, &prefs); |
606 expected.reset(new base::FundamentalValue(0.0)); | 496 expected.reset(new base::FundamentalValue(0.0)); |
607 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 497 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
608 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 498 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
609 | 499 |
610 policy_map.Set(kTestPolicy, | 500 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
611 POLICY_LEVEL_MANDATORY, | |
612 POLICY_SCOPE_USER, | |
613 POLICY_SOURCE_CLOUD, | 501 POLICY_SOURCE_CLOUD, |
614 new base::FundamentalValue(15), | 502 base::WrapUnique(new base::FundamentalValue(15)), nullptr); |
615 NULL); | |
616 prefs.Clear(); | 503 prefs.Clear(); |
617 handler.ApplyPolicySettings(policy_map, &prefs); | 504 handler.ApplyPolicySettings(policy_map, &prefs); |
618 expected.reset(new base::FundamentalValue(0.1)); | 505 expected.reset(new base::FundamentalValue(0.1)); |
619 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 506 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
620 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 507 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
621 } | 508 } |
622 | 509 |
623 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) { | 510 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) { |
624 PolicyMap policy_map; | 511 PolicyMap policy_map; |
625 PrefValueMap prefs; | 512 PrefValueMap prefs; |
626 std::unique_ptr<base::Value> expected; | 513 std::unique_ptr<base::Value> expected; |
627 const base::Value* value; | 514 const base::Value* value; |
628 | 515 |
629 // This tests needs to modify an int policy. The exact policy used and its | 516 // This tests needs to modify an int policy. The exact policy used and its |
630 // semantics outside the test are irrelevant. | 517 // semantics outside the test are irrelevant. |
631 IntPercentageToDoublePolicyHandler handler( | 518 IntPercentageToDoublePolicyHandler handler( |
632 kTestPolicy, kTestPref, 0, 10, true); | 519 kTestPolicy, kTestPref, 0, 10, true); |
633 | 520 |
634 // Check that values lying in the accepted range are written to the pref. | 521 // Check that values lying in the accepted range are written to the pref. |
635 policy_map.Set(kTestPolicy, | 522 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
636 POLICY_LEVEL_MANDATORY, | |
637 POLICY_SCOPE_USER, | |
638 POLICY_SOURCE_CLOUD, | 523 POLICY_SOURCE_CLOUD, |
639 new base::FundamentalValue(0), | 524 base::WrapUnique(new base::FundamentalValue(0)), nullptr); |
640 NULL); | |
641 prefs.Clear(); | 525 prefs.Clear(); |
642 handler.ApplyPolicySettings(policy_map, &prefs); | 526 handler.ApplyPolicySettings(policy_map, &prefs); |
643 expected.reset(new base::FundamentalValue(0.0)); | 527 expected.reset(new base::FundamentalValue(0.0)); |
644 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 528 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
645 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 529 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
646 | 530 |
647 policy_map.Set(kTestPolicy, | 531 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
648 POLICY_LEVEL_MANDATORY, | |
649 POLICY_SCOPE_USER, | |
650 POLICY_SOURCE_CLOUD, | 532 POLICY_SOURCE_CLOUD, |
651 new base::FundamentalValue(5), | 533 base::WrapUnique(new base::FundamentalValue(5)), nullptr); |
652 NULL); | |
653 prefs.Clear(); | 534 prefs.Clear(); |
654 handler.ApplyPolicySettings(policy_map, &prefs); | 535 handler.ApplyPolicySettings(policy_map, &prefs); |
655 expected.reset(new base::FundamentalValue(0.05)); | 536 expected.reset(new base::FundamentalValue(0.05)); |
656 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 537 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
657 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 538 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
658 | 539 |
659 policy_map.Set(kTestPolicy, | 540 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
660 POLICY_LEVEL_MANDATORY, | |
661 POLICY_SCOPE_USER, | |
662 POLICY_SOURCE_CLOUD, | 541 POLICY_SOURCE_CLOUD, |
663 new base::FundamentalValue(10), | 542 base::WrapUnique(new base::FundamentalValue(10)), nullptr); |
664 NULL); | |
665 prefs.Clear(); | 543 prefs.Clear(); |
666 handler.ApplyPolicySettings(policy_map, &prefs); | 544 handler.ApplyPolicySettings(policy_map, &prefs); |
667 expected.reset(new base::FundamentalValue(0.1)); | 545 expected.reset(new base::FundamentalValue(0.1)); |
668 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 546 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
669 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 547 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
670 } | 548 } |
671 | 549 |
672 TEST(SchemaValidatingPolicyHandlerTest, CheckAndGetValue) { | 550 TEST(SchemaValidatingPolicyHandlerTest, CheckAndGetValue) { |
673 std::string error; | 551 std::string error; |
674 static const char kSchemaJson[] = | 552 static const char kSchemaJson[] = |
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
856 handler_recommended.ApplyPolicySettings(policy_map_mandatory, &prefs); | 734 handler_recommended.ApplyPolicySettings(policy_map_mandatory, &prefs); |
857 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref)); | 735 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref)); |
858 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref)); | 736 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref)); |
859 | 737 |
860 EXPECT_FALSE( | 738 EXPECT_FALSE( |
861 handler_none.CheckPolicySettings(policy_map_recommended, &errors)); | 739 handler_none.CheckPolicySettings(policy_map_recommended, &errors)); |
862 EXPECT_FALSE(errors.empty()); | 740 EXPECT_FALSE(errors.empty()); |
863 } | 741 } |
864 | 742 |
865 } // namespace policy | 743 } // namespace policy |
OLD | NEW |