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/memory/ptr_util.h" |
13 #include "base/values.h" | 13 #include "base/values.h" |
14 #include "components/policy/core/browser/policy_error_map.h" | 14 #include "components/policy/core/browser/policy_error_map.h" |
15 #include "components/policy/core/common/policy_map.h" | 15 #include "components/policy/core/common/policy_map.h" |
16 #include "components/policy/core/common/policy_types.h" | 16 #include "components/policy/core/common/policy_types.h" |
17 #include "components/policy/core/common/schema.h" | 17 #include "components/policy/core/common/schema.h" |
18 #include "components/prefs/pref_value_map.h" | 18 #include "components/prefs/pref_value_map.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
20 | 20 |
21 namespace policy { | 21 namespace policy { |
22 | 22 |
23 namespace { | 23 namespace { |
24 | 24 |
25 void GetIntegerTypeMap( | 25 void GetIntegerTypeMap( |
26 std::vector<std::unique_ptr<StringMappingListPolicyHandler::MappingEntry>>* | 26 std::vector<std::unique_ptr<StringMappingListPolicyHandler::MappingEntry>>* |
27 result) { | 27 result) { |
28 result->push_back( | 28 result->push_back( |
29 base::MakeUnique<StringMappingListPolicyHandler::MappingEntry>( | 29 base::MakeUnique<StringMappingListPolicyHandler::MappingEntry>( |
30 "one", std::unique_ptr<base::Value>(new base::FundamentalValue(1)))); | 30 "one", std::unique_ptr<base::Value>(new base::Value(1)))); |
31 result->push_back( | 31 result->push_back( |
32 base::MakeUnique<StringMappingListPolicyHandler::MappingEntry>( | 32 base::MakeUnique<StringMappingListPolicyHandler::MappingEntry>( |
33 "two", std::unique_ptr<base::Value>(new base::FundamentalValue(2)))); | 33 "two", std::unique_ptr<base::Value>(new base::Value(2)))); |
34 } | 34 } |
35 | 35 |
36 const char kTestPolicy[] = "unit_test.test_policy"; | 36 const char kTestPolicy[] = "unit_test.test_policy"; |
37 const char kTestPref[] = "unit_test.test_pref"; | 37 const char kTestPref[] = "unit_test.test_pref"; |
38 | 38 |
39 class TestSchemaValidatingPolicyHandler : public SchemaValidatingPolicyHandler { | 39 class TestSchemaValidatingPolicyHandler : public SchemaValidatingPolicyHandler { |
40 public: | 40 public: |
41 TestSchemaValidatingPolicyHandler(const Schema& schema, | 41 TestSchemaValidatingPolicyHandler(const Schema& schema, |
42 SchemaOnErrorStrategy strategy) | 42 SchemaOnErrorStrategy strategy) |
43 : SchemaValidatingPolicyHandler("PolicyForTesting", schema, strategy) {} | 43 : SchemaValidatingPolicyHandler("PolicyForTesting", schema, strategy) {} |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
130 PolicyMap policy_map; | 130 PolicyMap policy_map; |
131 PolicyErrorMap errors; | 131 PolicyErrorMap errors; |
132 | 132 |
133 // This tests needs to modify an int policy. The exact policy used and its | 133 // This tests needs to modify an int policy. The exact policy used and its |
134 // semantics outside the test are irrelevant. | 134 // semantics outside the test are irrelevant. |
135 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 135 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
136 | 136 |
137 // Check that values lying in the accepted range are not rejected. | 137 // Check that values lying in the accepted range are not rejected. |
138 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 138 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
139 POLICY_SOURCE_CLOUD, | 139 POLICY_SOURCE_CLOUD, |
140 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 140 base::MakeUnique<base::Value>(0), nullptr); |
141 errors.Clear(); | 141 errors.Clear(); |
142 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 142 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
143 EXPECT_TRUE(errors.empty()); | 143 EXPECT_TRUE(errors.empty()); |
144 | 144 |
145 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 145 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
146 POLICY_SOURCE_CLOUD, | 146 POLICY_SOURCE_CLOUD, |
147 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 147 base::MakeUnique<base::Value>(5), nullptr); |
148 errors.Clear(); | 148 errors.Clear(); |
149 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 149 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
150 EXPECT_TRUE(errors.empty()); | 150 EXPECT_TRUE(errors.empty()); |
151 | 151 |
152 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 152 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
153 POLICY_SOURCE_CLOUD, | 153 POLICY_SOURCE_CLOUD, |
154 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 154 base::MakeUnique<base::Value>(10), nullptr); |
155 errors.Clear(); | 155 errors.Clear(); |
156 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 156 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
157 EXPECT_TRUE(errors.empty()); | 157 EXPECT_TRUE(errors.empty()); |
158 | 158 |
159 // Check that values lying outside the accepted range are not rejected | 159 // Check that values lying outside the accepted range are not rejected |
160 // (because clamping is enabled) but do yield a warning message. | 160 // (because clamping is enabled) but do yield a warning message. |
161 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 161 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
162 POLICY_SOURCE_CLOUD, | 162 POLICY_SOURCE_CLOUD, |
163 base::MakeUnique<base::FundamentalValue>(-5), nullptr); | 163 base::MakeUnique<base::Value>(-5), nullptr); |
164 errors.Clear(); | 164 errors.Clear(); |
165 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 165 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
166 EXPECT_FALSE(errors.empty()); | 166 EXPECT_FALSE(errors.empty()); |
167 | 167 |
168 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 168 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
169 POLICY_SOURCE_CLOUD, | 169 POLICY_SOURCE_CLOUD, |
170 base::MakeUnique<base::FundamentalValue>(15), nullptr); | 170 base::MakeUnique<base::Value>(15), nullptr); |
171 errors.Clear(); | 171 errors.Clear(); |
172 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 172 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
173 EXPECT_FALSE(errors.empty()); | 173 EXPECT_FALSE(errors.empty()); |
174 | 174 |
175 // Check that an entirely invalid value is rejected and yields an error | 175 // Check that an entirely invalid value is rejected and yields an error |
176 // message. | 176 // message. |
177 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 177 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
178 POLICY_SOURCE_CLOUD, | 178 POLICY_SOURCE_CLOUD, |
179 base::MakeUnique<base::StringValue>("invalid"), nullptr); | 179 base::MakeUnique<base::StringValue>("invalid"), nullptr); |
180 errors.Clear(); | 180 errors.Clear(); |
181 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 181 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
182 EXPECT_FALSE(errors.empty()); | 182 EXPECT_FALSE(errors.empty()); |
183 } | 183 } |
184 | 184 |
185 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) { | 185 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) { |
186 PolicyMap policy_map; | 186 PolicyMap policy_map; |
187 PolicyErrorMap errors; | 187 PolicyErrorMap errors; |
188 | 188 |
189 // This tests needs to modify an int policy. The exact policy used and its | 189 // This tests needs to modify an int policy. The exact policy used and its |
190 // semantics outside the test are irrelevant. | 190 // semantics outside the test are irrelevant. |
191 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, false); | 191 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, false); |
192 | 192 |
193 // Check that values lying in the accepted range are not rejected. | 193 // Check that values lying in the accepted range are not rejected. |
194 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 194 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
195 POLICY_SOURCE_CLOUD, | 195 POLICY_SOURCE_CLOUD, |
196 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 196 base::MakeUnique<base::Value>(0), nullptr); |
197 errors.Clear(); | 197 errors.Clear(); |
198 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 198 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
199 EXPECT_TRUE(errors.empty()); | 199 EXPECT_TRUE(errors.empty()); |
200 | 200 |
201 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 201 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
202 POLICY_SOURCE_CLOUD, | 202 POLICY_SOURCE_CLOUD, |
203 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 203 base::MakeUnique<base::Value>(5), nullptr); |
204 errors.Clear(); | 204 errors.Clear(); |
205 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 205 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
206 EXPECT_TRUE(errors.empty()); | 206 EXPECT_TRUE(errors.empty()); |
207 | 207 |
208 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 208 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
209 POLICY_SOURCE_CLOUD, | 209 POLICY_SOURCE_CLOUD, |
210 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 210 base::MakeUnique<base::Value>(10), nullptr); |
211 errors.Clear(); | 211 errors.Clear(); |
212 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 212 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
213 EXPECT_TRUE(errors.empty()); | 213 EXPECT_TRUE(errors.empty()); |
214 | 214 |
215 // Check that values lying outside the accepted range are rejected and yield | 215 // Check that values lying outside the accepted range are rejected and yield |
216 // an error message. | 216 // an error message. |
217 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 217 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
218 POLICY_SOURCE_CLOUD, | 218 POLICY_SOURCE_CLOUD, |
219 base::MakeUnique<base::FundamentalValue>(-5), nullptr); | 219 base::MakeUnique<base::Value>(-5), nullptr); |
220 errors.Clear(); | 220 errors.Clear(); |
221 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 221 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
222 EXPECT_FALSE(errors.empty()); | 222 EXPECT_FALSE(errors.empty()); |
223 | 223 |
224 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 224 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
225 POLICY_SOURCE_CLOUD, | 225 POLICY_SOURCE_CLOUD, |
226 base::MakeUnique<base::FundamentalValue>(15), nullptr); | 226 base::MakeUnique<base::Value>(15), nullptr); |
227 errors.Clear(); | 227 errors.Clear(); |
228 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 228 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
229 EXPECT_FALSE(errors.empty()); | 229 EXPECT_FALSE(errors.empty()); |
230 | 230 |
231 // Check that an entirely invalid value is rejected and yields an error | 231 // Check that an entirely invalid value is rejected and yields an error |
232 // message. | 232 // message. |
233 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 233 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
234 POLICY_SOURCE_CLOUD, | 234 POLICY_SOURCE_CLOUD, |
235 base::MakeUnique<base::StringValue>("invalid"), nullptr); | 235 base::MakeUnique<base::StringValue>("invalid"), nullptr); |
236 errors.Clear(); | 236 errors.Clear(); |
237 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 237 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
238 EXPECT_FALSE(errors.empty()); | 238 EXPECT_FALSE(errors.empty()); |
239 } | 239 } |
240 | 240 |
241 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) { | 241 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) { |
242 PolicyMap policy_map; | 242 PolicyMap policy_map; |
243 PrefValueMap prefs; | 243 PrefValueMap prefs; |
244 std::unique_ptr<base::Value> expected; | 244 std::unique_ptr<base::Value> expected; |
245 const base::Value* value; | 245 const base::Value* value; |
246 | 246 |
247 // This tests needs to modify an int policy. The exact policy used and its | 247 // This tests needs to modify an int policy. The exact policy used and its |
248 // semantics outside the test are irrelevant. | 248 // semantics outside the test are irrelevant. |
249 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 249 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
250 | 250 |
251 // Check that values lying in the accepted range are written to the pref. | 251 // Check that values lying in the accepted range are written to the pref. |
252 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 252 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
253 POLICY_SOURCE_CLOUD, | 253 POLICY_SOURCE_CLOUD, |
254 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 254 base::MakeUnique<base::Value>(0), nullptr); |
255 prefs.Clear(); | 255 prefs.Clear(); |
256 handler.ApplyPolicySettings(policy_map, &prefs); | 256 handler.ApplyPolicySettings(policy_map, &prefs); |
257 expected.reset(new base::FundamentalValue(0)); | 257 expected.reset(new base::Value(0)); |
258 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 258 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
259 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 259 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
260 | 260 |
261 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 261 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
262 POLICY_SOURCE_CLOUD, | 262 POLICY_SOURCE_CLOUD, |
263 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 263 base::MakeUnique<base::Value>(5), nullptr); |
264 prefs.Clear(); | 264 prefs.Clear(); |
265 handler.ApplyPolicySettings(policy_map, &prefs); | 265 handler.ApplyPolicySettings(policy_map, &prefs); |
266 expected.reset(new base::FundamentalValue(5)); | 266 expected.reset(new base::Value(5)); |
267 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 267 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
268 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 268 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
269 | 269 |
270 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 270 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
271 POLICY_SOURCE_CLOUD, | 271 POLICY_SOURCE_CLOUD, |
272 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 272 base::MakeUnique<base::Value>(10), nullptr); |
273 prefs.Clear(); | 273 prefs.Clear(); |
274 handler.ApplyPolicySettings(policy_map, &prefs); | 274 handler.ApplyPolicySettings(policy_map, &prefs); |
275 expected.reset(new base::FundamentalValue(10)); | 275 expected.reset(new base::Value(10)); |
276 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 276 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
277 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 277 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
278 | 278 |
279 // Check that values lying outside the accepted range are clamped and written | 279 // Check that values lying outside the accepted range are clamped and written |
280 // to the pref. | 280 // to the pref. |
281 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 281 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
282 POLICY_SOURCE_CLOUD, | 282 POLICY_SOURCE_CLOUD, |
283 base::MakeUnique<base::FundamentalValue>(-5), nullptr); | 283 base::MakeUnique<base::Value>(-5), nullptr); |
284 prefs.Clear(); | 284 prefs.Clear(); |
285 handler.ApplyPolicySettings(policy_map, &prefs); | 285 handler.ApplyPolicySettings(policy_map, &prefs); |
286 expected.reset(new base::FundamentalValue(0)); | 286 expected.reset(new base::Value(0)); |
287 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 287 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
288 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 288 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
289 | 289 |
290 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 290 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
291 POLICY_SOURCE_CLOUD, | 291 POLICY_SOURCE_CLOUD, |
292 base::MakeUnique<base::FundamentalValue>(15), nullptr); | 292 base::MakeUnique<base::Value>(15), nullptr); |
293 prefs.Clear(); | 293 prefs.Clear(); |
294 handler.ApplyPolicySettings(policy_map, &prefs); | 294 handler.ApplyPolicySettings(policy_map, &prefs); |
295 expected.reset(new base::FundamentalValue(10)); | 295 expected.reset(new base::Value(10)); |
296 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 296 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
297 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 297 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
298 } | 298 } |
299 | 299 |
300 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) { | 300 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) { |
301 PolicyMap policy_map; | 301 PolicyMap policy_map; |
302 PrefValueMap prefs; | 302 PrefValueMap prefs; |
303 std::unique_ptr<base::Value> expected; | 303 std::unique_ptr<base::Value> expected; |
304 const base::Value* value; | 304 const base::Value* value; |
305 | 305 |
306 // This tests needs to modify an int policy. The exact policy used and its | 306 // This tests needs to modify an int policy. The exact policy used and its |
307 // semantics outside the test are irrelevant. | 307 // semantics outside the test are irrelevant. |
308 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); | 308 IntRangePolicyHandler handler(kTestPolicy, kTestPref, 0, 10, true); |
309 | 309 |
310 // Check that values lying in the accepted range are written to the pref. | 310 // Check that values lying in the accepted range are written to the pref. |
311 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 311 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
312 POLICY_SOURCE_CLOUD, | 312 POLICY_SOURCE_CLOUD, |
313 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 313 base::MakeUnique<base::Value>(0), nullptr); |
314 prefs.Clear(); | 314 prefs.Clear(); |
315 handler.ApplyPolicySettings(policy_map, &prefs); | 315 handler.ApplyPolicySettings(policy_map, &prefs); |
316 expected.reset(new base::FundamentalValue(0)); | 316 expected.reset(new base::Value(0)); |
317 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 317 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
318 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 318 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
319 | 319 |
320 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 320 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
321 POLICY_SOURCE_CLOUD, | 321 POLICY_SOURCE_CLOUD, |
322 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 322 base::MakeUnique<base::Value>(5), nullptr); |
323 prefs.Clear(); | 323 prefs.Clear(); |
324 handler.ApplyPolicySettings(policy_map, &prefs); | 324 handler.ApplyPolicySettings(policy_map, &prefs); |
325 expected.reset(new base::FundamentalValue(5)); | 325 expected.reset(new base::Value(5)); |
326 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 326 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
327 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 327 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
328 | 328 |
329 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 329 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
330 POLICY_SOURCE_CLOUD, | 330 POLICY_SOURCE_CLOUD, |
331 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 331 base::MakeUnique<base::Value>(10), nullptr); |
332 prefs.Clear(); | 332 prefs.Clear(); |
333 handler.ApplyPolicySettings(policy_map, &prefs); | 333 handler.ApplyPolicySettings(policy_map, &prefs); |
334 expected.reset(new base::FundamentalValue(10)); | 334 expected.reset(new base::Value(10)); |
335 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 335 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
336 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 336 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
337 } | 337 } |
338 | 338 |
339 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) { | 339 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) { |
340 PolicyMap policy_map; | 340 PolicyMap policy_map; |
341 PolicyErrorMap errors; | 341 PolicyErrorMap errors; |
342 | 342 |
343 // This tests needs to modify an int policy. The exact policy used and its | 343 // This tests needs to modify an int policy. The exact policy used and its |
344 // semantics outside the test are irrelevant. | 344 // semantics outside the test are irrelevant. |
345 IntPercentageToDoublePolicyHandler handler( | 345 IntPercentageToDoublePolicyHandler handler( |
346 kTestPolicy, kTestPref, 0, 10, true); | 346 kTestPolicy, kTestPref, 0, 10, true); |
347 | 347 |
348 // Check that values lying in the accepted range are not rejected. | 348 // Check that values lying in the accepted range are not rejected. |
349 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 349 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
350 POLICY_SOURCE_CLOUD, | 350 POLICY_SOURCE_CLOUD, |
351 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 351 base::MakeUnique<base::Value>(0), nullptr); |
352 errors.Clear(); | 352 errors.Clear(); |
353 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 353 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
354 EXPECT_TRUE(errors.empty()); | 354 EXPECT_TRUE(errors.empty()); |
355 | 355 |
356 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 356 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
357 POLICY_SOURCE_CLOUD, | 357 POLICY_SOURCE_CLOUD, |
358 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 358 base::MakeUnique<base::Value>(5), nullptr); |
359 errors.Clear(); | 359 errors.Clear(); |
360 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 360 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
361 EXPECT_TRUE(errors.empty()); | 361 EXPECT_TRUE(errors.empty()); |
362 | 362 |
363 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 363 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
364 POLICY_SOURCE_CLOUD, | 364 POLICY_SOURCE_CLOUD, |
365 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 365 base::MakeUnique<base::Value>(10), nullptr); |
366 errors.Clear(); | 366 errors.Clear(); |
367 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 367 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
368 EXPECT_TRUE(errors.empty()); | 368 EXPECT_TRUE(errors.empty()); |
369 | 369 |
370 // Check that values lying outside the accepted range are not rejected | 370 // Check that values lying outside the accepted range are not rejected |
371 // (because clamping is enabled) but do yield a warning message. | 371 // (because clamping is enabled) but do yield a warning message. |
372 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 372 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
373 POLICY_SOURCE_CLOUD, | 373 POLICY_SOURCE_CLOUD, |
374 base::MakeUnique<base::FundamentalValue>(-5), nullptr); | 374 base::MakeUnique<base::Value>(-5), nullptr); |
375 errors.Clear(); | 375 errors.Clear(); |
376 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 376 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
377 EXPECT_FALSE(errors.empty()); | 377 EXPECT_FALSE(errors.empty()); |
378 | 378 |
379 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 379 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
380 POLICY_SOURCE_CLOUD, | 380 POLICY_SOURCE_CLOUD, |
381 base::MakeUnique<base::FundamentalValue>(15), nullptr); | 381 base::MakeUnique<base::Value>(15), nullptr); |
382 errors.Clear(); | 382 errors.Clear(); |
383 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 383 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
384 EXPECT_FALSE(errors.empty()); | 384 EXPECT_FALSE(errors.empty()); |
385 | 385 |
386 // Check that an entirely invalid value is rejected and yields an error | 386 // Check that an entirely invalid value is rejected and yields an error |
387 // message. | 387 // message. |
388 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 388 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
389 POLICY_SOURCE_CLOUD, | 389 POLICY_SOURCE_CLOUD, |
390 base::MakeUnique<base::StringValue>("invalid"), nullptr); | 390 base::MakeUnique<base::StringValue>("invalid"), nullptr); |
391 errors.Clear(); | 391 errors.Clear(); |
392 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 392 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
393 EXPECT_FALSE(errors.empty()); | 393 EXPECT_FALSE(errors.empty()); |
394 } | 394 } |
395 | 395 |
396 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) { | 396 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) { |
397 PolicyMap policy_map; | 397 PolicyMap policy_map; |
398 PolicyErrorMap errors; | 398 PolicyErrorMap errors; |
399 | 399 |
400 // This tests needs to modify an int policy. The exact policy used and its | 400 // This tests needs to modify an int policy. The exact policy used and its |
401 // semantics outside the test are irrelevant. | 401 // semantics outside the test are irrelevant. |
402 IntPercentageToDoublePolicyHandler handler( | 402 IntPercentageToDoublePolicyHandler handler( |
403 kTestPolicy, kTestPref, 0, 10, false); | 403 kTestPolicy, kTestPref, 0, 10, false); |
404 | 404 |
405 // Check that values lying in the accepted range are not rejected. | 405 // Check that values lying in the accepted range are not rejected. |
406 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 406 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
407 POLICY_SOURCE_CLOUD, | 407 POLICY_SOURCE_CLOUD, |
408 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 408 base::MakeUnique<base::Value>(0), nullptr); |
409 errors.Clear(); | 409 errors.Clear(); |
410 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 410 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
411 EXPECT_TRUE(errors.empty()); | 411 EXPECT_TRUE(errors.empty()); |
412 | 412 |
413 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 413 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
414 POLICY_SOURCE_CLOUD, | 414 POLICY_SOURCE_CLOUD, |
415 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 415 base::MakeUnique<base::Value>(5), nullptr); |
416 errors.Clear(); | 416 errors.Clear(); |
417 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 417 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
418 EXPECT_TRUE(errors.empty()); | 418 EXPECT_TRUE(errors.empty()); |
419 | 419 |
420 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 420 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
421 POLICY_SOURCE_CLOUD, | 421 POLICY_SOURCE_CLOUD, |
422 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 422 base::MakeUnique<base::Value>(10), nullptr); |
423 errors.Clear(); | 423 errors.Clear(); |
424 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); | 424 EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors)); |
425 EXPECT_TRUE(errors.empty()); | 425 EXPECT_TRUE(errors.empty()); |
426 | 426 |
427 // Check that values lying outside the accepted range are rejected and yield | 427 // Check that values lying outside the accepted range are rejected and yield |
428 // an error message. | 428 // an error message. |
429 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 429 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
430 POLICY_SOURCE_CLOUD, | 430 POLICY_SOURCE_CLOUD, |
431 base::MakeUnique<base::FundamentalValue>(-5), nullptr); | 431 base::MakeUnique<base::Value>(-5), nullptr); |
432 errors.Clear(); | 432 errors.Clear(); |
433 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 433 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
434 EXPECT_FALSE(errors.empty()); | 434 EXPECT_FALSE(errors.empty()); |
435 | 435 |
436 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 436 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
437 POLICY_SOURCE_CLOUD, | 437 POLICY_SOURCE_CLOUD, |
438 base::MakeUnique<base::FundamentalValue>(15), nullptr); | 438 base::MakeUnique<base::Value>(15), nullptr); |
439 errors.Clear(); | 439 errors.Clear(); |
440 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 440 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
441 EXPECT_FALSE(errors.empty()); | 441 EXPECT_FALSE(errors.empty()); |
442 | 442 |
443 // Check that an entirely invalid value is rejected and yields an error | 443 // Check that an entirely invalid value is rejected and yields an error |
444 // message. | 444 // message. |
445 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 445 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
446 POLICY_SOURCE_CLOUD, | 446 POLICY_SOURCE_CLOUD, |
447 base::MakeUnique<base::StringValue>("invalid"), nullptr); | 447 base::MakeUnique<base::StringValue>("invalid"), nullptr); |
448 errors.Clear(); | 448 errors.Clear(); |
449 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); | 449 EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors)); |
450 EXPECT_FALSE(errors.empty()); | 450 EXPECT_FALSE(errors.empty()); |
451 } | 451 } |
452 | 452 |
453 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) { | 453 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) { |
454 PolicyMap policy_map; | 454 PolicyMap policy_map; |
455 PrefValueMap prefs; | 455 PrefValueMap prefs; |
456 std::unique_ptr<base::Value> expected; | 456 std::unique_ptr<base::Value> expected; |
457 const base::Value* value; | 457 const base::Value* value; |
458 | 458 |
459 // This tests needs to modify an int policy. The exact policy used and its | 459 // This tests needs to modify an int policy. The exact policy used and its |
460 // semantics outside the test are irrelevant. | 460 // semantics outside the test are irrelevant. |
461 IntPercentageToDoublePolicyHandler handler( | 461 IntPercentageToDoublePolicyHandler handler( |
462 kTestPolicy, kTestPref, 0, 10, true); | 462 kTestPolicy, kTestPref, 0, 10, true); |
463 | 463 |
464 // Check that values lying in the accepted range are written to the pref. | 464 // Check that values lying in the accepted range are written to the pref. |
465 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 465 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
466 POLICY_SOURCE_CLOUD, | 466 POLICY_SOURCE_CLOUD, |
467 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 467 base::MakeUnique<base::Value>(0), nullptr); |
468 prefs.Clear(); | 468 prefs.Clear(); |
469 handler.ApplyPolicySettings(policy_map, &prefs); | 469 handler.ApplyPolicySettings(policy_map, &prefs); |
470 expected.reset(new base::FundamentalValue(0.0)); | 470 expected.reset(new base::Value(0.0)); |
471 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 471 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
472 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 472 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
473 | 473 |
474 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 474 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
475 POLICY_SOURCE_CLOUD, | 475 POLICY_SOURCE_CLOUD, |
476 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 476 base::MakeUnique<base::Value>(5), nullptr); |
477 prefs.Clear(); | 477 prefs.Clear(); |
478 handler.ApplyPolicySettings(policy_map, &prefs); | 478 handler.ApplyPolicySettings(policy_map, &prefs); |
479 expected.reset(new base::FundamentalValue(0.05)); | 479 expected.reset(new base::Value(0.05)); |
480 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 480 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
481 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 481 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
482 | 482 |
483 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 483 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
484 POLICY_SOURCE_CLOUD, | 484 POLICY_SOURCE_CLOUD, |
485 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 485 base::MakeUnique<base::Value>(10), nullptr); |
486 prefs.Clear(); | 486 prefs.Clear(); |
487 handler.ApplyPolicySettings(policy_map, &prefs); | 487 handler.ApplyPolicySettings(policy_map, &prefs); |
488 expected.reset(new base::FundamentalValue(0.1)); | 488 expected.reset(new base::Value(0.1)); |
489 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 489 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
490 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 490 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
491 | 491 |
492 // Check that values lying outside the accepted range are clamped and written | 492 // Check that values lying outside the accepted range are clamped and written |
493 // to the pref. | 493 // to the pref. |
494 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 494 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
495 POLICY_SOURCE_CLOUD, | 495 POLICY_SOURCE_CLOUD, |
496 base::MakeUnique<base::FundamentalValue>(-5), nullptr); | 496 base::MakeUnique<base::Value>(-5), nullptr); |
497 prefs.Clear(); | 497 prefs.Clear(); |
498 handler.ApplyPolicySettings(policy_map, &prefs); | 498 handler.ApplyPolicySettings(policy_map, &prefs); |
499 expected.reset(new base::FundamentalValue(0.0)); | 499 expected.reset(new base::Value(0.0)); |
500 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 500 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
501 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 501 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
502 | 502 |
503 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 503 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
504 POLICY_SOURCE_CLOUD, | 504 POLICY_SOURCE_CLOUD, |
505 base::MakeUnique<base::FundamentalValue>(15), nullptr); | 505 base::MakeUnique<base::Value>(15), nullptr); |
506 prefs.Clear(); | 506 prefs.Clear(); |
507 handler.ApplyPolicySettings(policy_map, &prefs); | 507 handler.ApplyPolicySettings(policy_map, &prefs); |
508 expected.reset(new base::FundamentalValue(0.1)); | 508 expected.reset(new base::Value(0.1)); |
509 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 509 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
510 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 510 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
511 } | 511 } |
512 | 512 |
513 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) { | 513 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) { |
514 PolicyMap policy_map; | 514 PolicyMap policy_map; |
515 PrefValueMap prefs; | 515 PrefValueMap prefs; |
516 std::unique_ptr<base::Value> expected; | 516 std::unique_ptr<base::Value> expected; |
517 const base::Value* value; | 517 const base::Value* value; |
518 | 518 |
519 // This tests needs to modify an int policy. The exact policy used and its | 519 // This tests needs to modify an int policy. The exact policy used and its |
520 // semantics outside the test are irrelevant. | 520 // semantics outside the test are irrelevant. |
521 IntPercentageToDoublePolicyHandler handler( | 521 IntPercentageToDoublePolicyHandler handler( |
522 kTestPolicy, kTestPref, 0, 10, true); | 522 kTestPolicy, kTestPref, 0, 10, true); |
523 | 523 |
524 // Check that values lying in the accepted range are written to the pref. | 524 // Check that values lying in the accepted range are written to the pref. |
525 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 525 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
526 POLICY_SOURCE_CLOUD, | 526 POLICY_SOURCE_CLOUD, |
527 base::MakeUnique<base::FundamentalValue>(0), nullptr); | 527 base::MakeUnique<base::Value>(0), nullptr); |
528 prefs.Clear(); | 528 prefs.Clear(); |
529 handler.ApplyPolicySettings(policy_map, &prefs); | 529 handler.ApplyPolicySettings(policy_map, &prefs); |
530 expected.reset(new base::FundamentalValue(0.0)); | 530 expected.reset(new base::Value(0.0)); |
531 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 531 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
532 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 532 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
533 | 533 |
534 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 534 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
535 POLICY_SOURCE_CLOUD, | 535 POLICY_SOURCE_CLOUD, |
536 base::MakeUnique<base::FundamentalValue>(5), nullptr); | 536 base::MakeUnique<base::Value>(5), nullptr); |
537 prefs.Clear(); | 537 prefs.Clear(); |
538 handler.ApplyPolicySettings(policy_map, &prefs); | 538 handler.ApplyPolicySettings(policy_map, &prefs); |
539 expected.reset(new base::FundamentalValue(0.05)); | 539 expected.reset(new base::Value(0.05)); |
540 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 540 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
541 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 541 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
542 | 542 |
543 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, | 543 policy_map.Set(kTestPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
544 POLICY_SOURCE_CLOUD, | 544 POLICY_SOURCE_CLOUD, |
545 base::MakeUnique<base::FundamentalValue>(10), nullptr); | 545 base::MakeUnique<base::Value>(10), nullptr); |
546 prefs.Clear(); | 546 prefs.Clear(); |
547 handler.ApplyPolicySettings(policy_map, &prefs); | 547 handler.ApplyPolicySettings(policy_map, &prefs); |
548 expected.reset(new base::FundamentalValue(0.1)); | 548 expected.reset(new base::Value(0.1)); |
549 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); | 549 EXPECT_TRUE(prefs.GetValue(kTestPref, &value)); |
550 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); | 550 EXPECT_TRUE(base::Value::Equals(expected.get(), value)); |
551 } | 551 } |
552 | 552 |
553 TEST(SchemaValidatingPolicyHandlerTest, CheckAndGetValue) { | 553 TEST(SchemaValidatingPolicyHandlerTest, CheckAndGetValue) { |
554 std::string error; | 554 std::string error; |
555 static const char kSchemaJson[] = | 555 static const char kSchemaJson[] = |
556 "{" | 556 "{" |
557 " \"type\": \"object\"," | 557 " \"type\": \"object\"," |
558 " \"properties\": {" | 558 " \"properties\": {" |
(...skipping 178 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
737 handler_recommended.ApplyPolicySettings(policy_map_mandatory, &prefs); | 737 handler_recommended.ApplyPolicySettings(policy_map_mandatory, &prefs); |
738 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref)); | 738 EXPECT_TRUE(prefs.GetValue(kTestPref, &value_set_in_pref)); |
739 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref)); | 739 EXPECT_TRUE(value_expected_in_pref->Equals(value_set_in_pref)); |
740 | 740 |
741 EXPECT_FALSE( | 741 EXPECT_FALSE( |
742 handler_none.CheckPolicySettings(policy_map_recommended, &errors)); | 742 handler_none.CheckPolicySettings(policy_map_recommended, &errors)); |
743 EXPECT_FALSE(errors.empty()); | 743 EXPECT_FALSE(errors.empty()); |
744 } | 744 } |
745 | 745 |
746 } // namespace policy | 746 } // namespace policy |
OLD | NEW |