OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/common/policy_map.h" | 5 #include "components/policy/core/common/policy_map.h" |
6 | 6 |
| 7 #include <utility> |
| 8 |
7 #include "base/callback.h" | 9 #include "base/callback.h" |
8 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
9 #include "base/memory/weak_ptr.h" | 11 #include "base/memory/weak_ptr.h" |
10 #include "components/policy/core/common/external_data_manager.h" | 12 #include "components/policy/core/common/external_data_manager.h" |
11 #include "components/policy/core/common/policy_types.h" | 13 #include "components/policy/core/common/policy_types.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
13 | 15 |
14 namespace policy { | 16 namespace policy { |
15 | 17 |
16 namespace { | 18 namespace { |
17 | 19 |
18 // Dummy policy names. | 20 // Dummy policy names. |
19 const char kTestPolicyName1[] = "policy.test.1"; | 21 const char kTestPolicyName1[] = "policy.test.1"; |
20 const char kTestPolicyName2[] = "policy.test.2"; | 22 const char kTestPolicyName2[] = "policy.test.2"; |
21 const char kTestPolicyName3[] = "policy.test.3"; | 23 const char kTestPolicyName3[] = "policy.test.3"; |
22 const char kTestPolicyName4[] = "policy.test.4"; | 24 const char kTestPolicyName4[] = "policy.test.4"; |
23 const char kTestPolicyName5[] = "policy.test.5"; | 25 const char kTestPolicyName5[] = "policy.test.5"; |
24 const char kTestPolicyName6[] = "policy.test.6"; | 26 const char kTestPolicyName6[] = "policy.test.6"; |
25 const char kTestPolicyName7[] = "policy.test.7"; | 27 const char kTestPolicyName7[] = "policy.test.7"; |
26 const char kTestPolicyName8[] = "policy.test.8"; | 28 const char kTestPolicyName8[] = "policy.test.8"; |
27 | 29 |
28 // Utility functions for the tests. | 30 // Utility functions for the tests. |
29 void SetPolicy(PolicyMap* map, const char* name, base::Value* value) { | 31 void SetPolicy(PolicyMap* map, |
| 32 const char* name, |
| 33 std::unique_ptr<base::Value> value) { |
30 map->Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, | 34 map->Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
31 value, nullptr); | 35 std::move(value), nullptr); |
32 } | 36 } |
33 | 37 |
34 void SetPolicy(PolicyMap* map, | 38 void SetPolicy(PolicyMap* map, |
35 const char* name, | 39 const char* name, |
36 ExternalDataFetcher* external_data_fetcher) { | 40 std::unique_ptr<ExternalDataFetcher> external_data_fetcher) { |
37 map->Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, | 41 map->Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD, |
38 NULL, external_data_fetcher); | 42 nullptr, std::move(external_data_fetcher)); |
39 } | 43 } |
40 | 44 |
41 } // namespace | 45 } // namespace |
42 | 46 |
43 class PolicyMapTest : public testing::Test { | 47 class PolicyMapTest : public testing::Test { |
44 protected: | 48 protected: |
45 std::unique_ptr<ExternalDataFetcher> CreateExternalDataFetcher( | 49 std::unique_ptr<ExternalDataFetcher> CreateExternalDataFetcher( |
46 const std::string& policy) const; | 50 const std::string& policy) const; |
47 }; | 51 }; |
48 | 52 |
49 std::unique_ptr<ExternalDataFetcher> PolicyMapTest::CreateExternalDataFetcher( | 53 std::unique_ptr<ExternalDataFetcher> PolicyMapTest::CreateExternalDataFetcher( |
50 const std::string& policy) const { | 54 const std::string& policy) const { |
51 return base::WrapUnique( | 55 return base::WrapUnique( |
52 new ExternalDataFetcher(base::WeakPtr<ExternalDataManager>(), policy)); | 56 new ExternalDataFetcher(base::WeakPtr<ExternalDataManager>(), policy)); |
53 } | 57 } |
54 | 58 |
55 TEST_F(PolicyMapTest, SetAndGet) { | 59 TEST_F(PolicyMapTest, SetAndGet) { |
56 PolicyMap map; | 60 PolicyMap map; |
57 SetPolicy(&map, kTestPolicyName1, new base::StringValue("aaa")); | 61 SetPolicy(&map, kTestPolicyName1, |
| 62 base::WrapUnique(new base::StringValue("aaa"))); |
58 base::StringValue expected("aaa"); | 63 base::StringValue expected("aaa"); |
59 EXPECT_TRUE(expected.Equals(map.GetValue(kTestPolicyName1))); | 64 EXPECT_TRUE(expected.Equals(map.GetValue(kTestPolicyName1))); |
60 SetPolicy(&map, kTestPolicyName1, new base::StringValue("bbb")); | 65 SetPolicy(&map, kTestPolicyName1, |
| 66 base::WrapUnique(new base::StringValue("bbb"))); |
61 base::StringValue expected_b("bbb"); | 67 base::StringValue expected_b("bbb"); |
62 EXPECT_TRUE(expected_b.Equals(map.GetValue(kTestPolicyName1))); | 68 EXPECT_TRUE(expected_b.Equals(map.GetValue(kTestPolicyName1))); |
63 SetPolicy(&map, kTestPolicyName1, | 69 SetPolicy(&map, kTestPolicyName1, CreateExternalDataFetcher("dummy")); |
64 CreateExternalDataFetcher("dummy").release()); | |
65 EXPECT_FALSE(map.GetValue(kTestPolicyName1)); | 70 EXPECT_FALSE(map.GetValue(kTestPolicyName1)); |
66 const PolicyMap::Entry* entry = map.Get(kTestPolicyName1); | 71 const PolicyMap::Entry* entry = map.Get(kTestPolicyName1); |
67 ASSERT_TRUE(entry != NULL); | 72 ASSERT_TRUE(entry != NULL); |
68 EXPECT_EQ(POLICY_LEVEL_MANDATORY, entry->level); | 73 EXPECT_EQ(POLICY_LEVEL_MANDATORY, entry->level); |
69 EXPECT_EQ(POLICY_SCOPE_USER, entry->scope); | 74 EXPECT_EQ(POLICY_SCOPE_USER, entry->scope); |
70 EXPECT_EQ(POLICY_SOURCE_CLOUD, entry->source); | 75 EXPECT_EQ(POLICY_SOURCE_CLOUD, entry->source); |
71 EXPECT_TRUE(ExternalDataFetcher::Equals( | 76 EXPECT_TRUE( |
72 entry->external_data_fetcher, CreateExternalDataFetcher("dummy").get())); | 77 ExternalDataFetcher::Equals(entry->external_data_fetcher.get(), |
| 78 CreateExternalDataFetcher("dummy").get())); |
73 map.Set(kTestPolicyName1, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE, | 79 map.Set(kTestPolicyName1, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE, |
74 POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr, nullptr); | 80 POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr, nullptr); |
75 EXPECT_FALSE(map.GetValue(kTestPolicyName1)); | 81 EXPECT_FALSE(map.GetValue(kTestPolicyName1)); |
76 entry = map.Get(kTestPolicyName1); | 82 entry = map.Get(kTestPolicyName1); |
77 ASSERT_TRUE(entry != NULL); | 83 ASSERT_TRUE(entry != NULL); |
78 EXPECT_EQ(POLICY_LEVEL_RECOMMENDED, entry->level); | 84 EXPECT_EQ(POLICY_LEVEL_RECOMMENDED, entry->level); |
79 EXPECT_EQ(POLICY_SCOPE_MACHINE, entry->scope); | 85 EXPECT_EQ(POLICY_SCOPE_MACHINE, entry->scope); |
80 EXPECT_EQ(POLICY_SOURCE_ENTERPRISE_DEFAULT, entry->source); | 86 EXPECT_EQ(POLICY_SOURCE_ENTERPRISE_DEFAULT, entry->source); |
81 EXPECT_FALSE(entry->external_data_fetcher); | 87 EXPECT_FALSE(entry->external_data_fetcher); |
82 } | 88 } |
83 | 89 |
84 TEST_F(PolicyMapTest, Equals) { | 90 TEST_F(PolicyMapTest, Equals) { |
85 PolicyMap a; | 91 PolicyMap a; |
86 SetPolicy(&a, kTestPolicyName1, new base::StringValue("aaa")); | 92 SetPolicy(&a, kTestPolicyName1, |
| 93 base::WrapUnique(new base::StringValue("aaa"))); |
87 PolicyMap a2; | 94 PolicyMap a2; |
88 SetPolicy(&a2, kTestPolicyName1, new base::StringValue("aaa")); | 95 SetPolicy(&a2, kTestPolicyName1, |
| 96 base::WrapUnique(new base::StringValue("aaa"))); |
89 PolicyMap b; | 97 PolicyMap b; |
90 SetPolicy(&b, kTestPolicyName1, new base::StringValue("bbb")); | 98 SetPolicy(&b, kTestPolicyName1, |
| 99 base::WrapUnique(new base::StringValue("bbb"))); |
91 PolicyMap c; | 100 PolicyMap c; |
92 SetPolicy(&c, kTestPolicyName1, new base::StringValue("aaa")); | 101 SetPolicy(&c, kTestPolicyName1, |
93 SetPolicy(&c, kTestPolicyName2, new base::FundamentalValue(true)); | 102 base::WrapUnique(new base::StringValue("aaa"))); |
| 103 SetPolicy(&c, kTestPolicyName2, |
| 104 base::WrapUnique(new base::FundamentalValue(true))); |
94 PolicyMap d; | 105 PolicyMap d; |
95 SetPolicy(&d, kTestPolicyName1, | 106 SetPolicy(&d, kTestPolicyName1, CreateExternalDataFetcher("ddd")); |
96 CreateExternalDataFetcher("ddd").release()); | |
97 PolicyMap d2; | 107 PolicyMap d2; |
98 SetPolicy(&d2, kTestPolicyName1, | 108 SetPolicy(&d2, kTestPolicyName1, CreateExternalDataFetcher("ddd")); |
99 CreateExternalDataFetcher("ddd").release()); | |
100 PolicyMap e; | 109 PolicyMap e; |
101 SetPolicy(&e, kTestPolicyName1, | 110 SetPolicy(&e, kTestPolicyName1, CreateExternalDataFetcher("eee")); |
102 CreateExternalDataFetcher("eee").release()); | |
103 EXPECT_FALSE(a.Equals(b)); | 111 EXPECT_FALSE(a.Equals(b)); |
104 EXPECT_FALSE(a.Equals(c)); | 112 EXPECT_FALSE(a.Equals(c)); |
105 EXPECT_FALSE(a.Equals(d)); | 113 EXPECT_FALSE(a.Equals(d)); |
106 EXPECT_FALSE(a.Equals(e)); | 114 EXPECT_FALSE(a.Equals(e)); |
107 EXPECT_FALSE(b.Equals(a)); | 115 EXPECT_FALSE(b.Equals(a)); |
108 EXPECT_FALSE(b.Equals(c)); | 116 EXPECT_FALSE(b.Equals(c)); |
109 EXPECT_FALSE(b.Equals(d)); | 117 EXPECT_FALSE(b.Equals(d)); |
110 EXPECT_FALSE(b.Equals(e)); | 118 EXPECT_FALSE(b.Equals(e)); |
111 EXPECT_FALSE(c.Equals(a)); | 119 EXPECT_FALSE(c.Equals(a)); |
112 EXPECT_FALSE(c.Equals(b)); | 120 EXPECT_FALSE(c.Equals(b)); |
(...skipping 14 matching lines...) Expand all Loading... |
127 PolicyMap empty1; | 135 PolicyMap empty1; |
128 PolicyMap empty2; | 136 PolicyMap empty2; |
129 EXPECT_TRUE(empty1.Equals(empty2)); | 137 EXPECT_TRUE(empty1.Equals(empty2)); |
130 EXPECT_TRUE(empty2.Equals(empty1)); | 138 EXPECT_TRUE(empty2.Equals(empty1)); |
131 EXPECT_FALSE(empty1.Equals(a)); | 139 EXPECT_FALSE(empty1.Equals(a)); |
132 EXPECT_FALSE(a.Equals(empty1)); | 140 EXPECT_FALSE(a.Equals(empty1)); |
133 } | 141 } |
134 | 142 |
135 TEST_F(PolicyMapTest, Swap) { | 143 TEST_F(PolicyMapTest, Swap) { |
136 PolicyMap a; | 144 PolicyMap a; |
137 SetPolicy(&a, kTestPolicyName1, new base::StringValue("aaa")); | 145 SetPolicy(&a, kTestPolicyName1, |
138 SetPolicy(&a, kTestPolicyName2, | 146 base::WrapUnique(new base::StringValue("aaa"))); |
139 CreateExternalDataFetcher("dummy").release()); | 147 SetPolicy(&a, kTestPolicyName2, CreateExternalDataFetcher("dummy")); |
140 PolicyMap b; | 148 PolicyMap b; |
141 SetPolicy(&b, kTestPolicyName1, new base::StringValue("bbb")); | 149 SetPolicy(&b, kTestPolicyName1, |
142 SetPolicy(&b, kTestPolicyName3, new base::FundamentalValue(true)); | 150 base::WrapUnique(new base::StringValue("bbb"))); |
| 151 SetPolicy(&b, kTestPolicyName3, |
| 152 base::WrapUnique(new base::FundamentalValue(true))); |
143 | 153 |
144 a.Swap(&b); | 154 a.Swap(&b); |
145 base::StringValue expected("bbb"); | 155 base::StringValue expected("bbb"); |
146 EXPECT_TRUE(expected.Equals(a.GetValue(kTestPolicyName1))); | 156 EXPECT_TRUE(expected.Equals(a.GetValue(kTestPolicyName1))); |
147 base::FundamentalValue expected_bool(true); | 157 base::FundamentalValue expected_bool(true); |
148 EXPECT_TRUE(expected_bool.Equals(a.GetValue(kTestPolicyName3))); | 158 EXPECT_TRUE(expected_bool.Equals(a.GetValue(kTestPolicyName3))); |
149 EXPECT_FALSE(a.GetValue(kTestPolicyName2)); | 159 EXPECT_FALSE(a.GetValue(kTestPolicyName2)); |
150 EXPECT_FALSE(a.Get(kTestPolicyName2)); | 160 EXPECT_FALSE(a.Get(kTestPolicyName2)); |
151 base::StringValue expected_a("aaa"); | 161 base::StringValue expected_a("aaa"); |
152 EXPECT_TRUE(expected_a.Equals(b.GetValue(kTestPolicyName1))); | 162 EXPECT_TRUE(expected_a.Equals(b.GetValue(kTestPolicyName1))); |
153 EXPECT_FALSE(b.GetValue(kTestPolicyName3)); | 163 EXPECT_FALSE(b.GetValue(kTestPolicyName3)); |
154 EXPECT_FALSE(a.GetValue(kTestPolicyName2)); | 164 EXPECT_FALSE(a.GetValue(kTestPolicyName2)); |
155 const PolicyMap::Entry* entry = b.Get(kTestPolicyName2); | 165 const PolicyMap::Entry* entry = b.Get(kTestPolicyName2); |
156 ASSERT_TRUE(entry); | 166 ASSERT_TRUE(entry); |
157 EXPECT_TRUE(ExternalDataFetcher::Equals( | 167 EXPECT_TRUE( |
158 CreateExternalDataFetcher("dummy").get(), entry->external_data_fetcher)); | 168 ExternalDataFetcher::Equals(CreateExternalDataFetcher("dummy").get(), |
| 169 entry->external_data_fetcher.get())); |
159 | 170 |
160 b.Clear(); | 171 b.Clear(); |
161 a.Swap(&b); | 172 a.Swap(&b); |
162 PolicyMap empty; | 173 PolicyMap empty; |
163 EXPECT_TRUE(a.Equals(empty)); | 174 EXPECT_TRUE(a.Equals(empty)); |
164 EXPECT_FALSE(b.Equals(empty)); | 175 EXPECT_FALSE(b.Equals(empty)); |
165 } | 176 } |
166 | 177 |
167 TEST_F(PolicyMapTest, MergeFrom) { | 178 TEST_F(PolicyMapTest, MergeFrom) { |
168 PolicyMap a; | 179 PolicyMap a; |
169 a.Set(kTestPolicyName1, | 180 a.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
170 POLICY_LEVEL_MANDATORY, | |
171 POLICY_SCOPE_USER, | |
172 POLICY_SOURCE_CLOUD, | 181 POLICY_SOURCE_CLOUD, |
173 new base::StringValue("google.com"), | 182 base::WrapUnique(new base::StringValue("google.com")), nullptr); |
174 NULL); | 183 a.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
175 a.Set(kTestPolicyName2, | 184 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)), |
176 POLICY_LEVEL_MANDATORY, | 185 nullptr); |
177 POLICY_SCOPE_MACHINE, | 186 a.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
| 187 POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr, |
| 188 CreateExternalDataFetcher("a")); |
| 189 a.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, |
178 POLICY_SOURCE_CLOUD, | 190 POLICY_SOURCE_CLOUD, |
179 new base::FundamentalValue(true), | 191 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
180 NULL); | 192 a.Set(kTestPolicyName5, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE, |
181 a.Set(kTestPolicyName3, | |
182 POLICY_LEVEL_MANDATORY, | |
183 POLICY_SCOPE_MACHINE, | |
184 POLICY_SOURCE_ENTERPRISE_DEFAULT, | |
185 NULL, CreateExternalDataFetcher("a").release()); | |
186 a.Set(kTestPolicyName4, | |
187 POLICY_LEVEL_RECOMMENDED, | |
188 POLICY_SCOPE_USER, | |
189 POLICY_SOURCE_CLOUD, | 193 POLICY_SOURCE_CLOUD, |
190 new base::FundamentalValue(false), | 194 base::WrapUnique(new base::StringValue("google.com/q={x}")), nullptr); |
191 NULL); | |
192 a.Set(kTestPolicyName5, | |
193 POLICY_LEVEL_RECOMMENDED, | |
194 POLICY_SCOPE_MACHINE, | |
195 POLICY_SOURCE_CLOUD, | |
196 new base::StringValue("google.com/q={x}"), | |
197 NULL); | |
198 | 195 |
199 PolicyMap b; | 196 PolicyMap b; |
200 b.Set(kTestPolicyName1, | 197 b.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
201 POLICY_LEVEL_MANDATORY, | |
202 POLICY_SCOPE_MACHINE, | |
203 POLICY_SOURCE_CLOUD, | 198 POLICY_SOURCE_CLOUD, |
204 new base::StringValue("chromium.org"), | 199 base::WrapUnique(new base::StringValue("chromium.org")), nullptr); |
205 NULL); | 200 b.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
206 b.Set(kTestPolicyName2, | |
207 POLICY_LEVEL_MANDATORY, | |
208 POLICY_SCOPE_MACHINE, | |
209 POLICY_SOURCE_CLOUD, | 201 POLICY_SOURCE_CLOUD, |
210 new base::FundamentalValue(false), | 202 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
211 NULL); | 203 b.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
212 b.Set(kTestPolicyName3, | 204 POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("b")); |
213 POLICY_LEVEL_MANDATORY, | 205 b.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE, |
214 POLICY_SCOPE_MACHINE, | |
215 POLICY_SOURCE_CLOUD, | |
216 NULL, CreateExternalDataFetcher("b").release()); | |
217 b.Set(kTestPolicyName4, | |
218 POLICY_LEVEL_RECOMMENDED, | |
219 POLICY_SCOPE_MACHINE, | |
220 POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE, | 206 POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE, |
221 new base::FundamentalValue(true), | 207 base::WrapUnique(new base::FundamentalValue(true)), nullptr); |
222 NULL); | 208 b.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
223 b.Set(kTestPolicyName5, | |
224 POLICY_LEVEL_MANDATORY, | |
225 POLICY_SCOPE_MACHINE, | |
226 POLICY_SOURCE_PLATFORM, | 209 POLICY_SOURCE_PLATFORM, |
227 new base::StringValue(std::string()), | 210 base::WrapUnique(new base::StringValue(std::string())), nullptr); |
228 NULL); | 211 b.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, |
229 b.Set(kTestPolicyName6, | 212 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)), |
230 POLICY_LEVEL_RECOMMENDED, | 213 nullptr); |
231 POLICY_SCOPE_USER, | |
232 POLICY_SOURCE_CLOUD, | |
233 new base::FundamentalValue(true), | |
234 NULL); | |
235 | 214 |
236 a.MergeFrom(b); | 215 a.MergeFrom(b); |
237 | 216 |
238 PolicyMap c; | 217 PolicyMap c; |
239 // POLICY_SCOPE_MACHINE over POLICY_SCOPE_USER. | 218 // POLICY_SCOPE_MACHINE over POLICY_SCOPE_USER. |
240 c.Set(kTestPolicyName1, | 219 c.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
241 POLICY_LEVEL_MANDATORY, | |
242 POLICY_SCOPE_MACHINE, | |
243 POLICY_SOURCE_CLOUD, | 220 POLICY_SOURCE_CLOUD, |
244 new base::StringValue("chromium.org"), | 221 base::WrapUnique(new base::StringValue("chromium.org")), nullptr); |
245 NULL); | |
246 // |a| has precedence over |b|. | 222 // |a| has precedence over |b|. |
247 c.Set(kTestPolicyName2, | 223 c.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
248 POLICY_LEVEL_MANDATORY, | 224 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)), |
249 POLICY_SCOPE_MACHINE, | 225 nullptr); |
250 POLICY_SOURCE_CLOUD, | 226 c.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
251 new base::FundamentalValue(true), | 227 POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr, |
252 NULL); | 228 CreateExternalDataFetcher("a")); |
253 c.Set(kTestPolicyName3, | |
254 POLICY_LEVEL_MANDATORY, | |
255 POLICY_SCOPE_MACHINE, | |
256 POLICY_SOURCE_ENTERPRISE_DEFAULT, | |
257 NULL, CreateExternalDataFetcher("a").release()); | |
258 // POLICY_SCOPE_MACHINE over POLICY_SCOPE_USER for POLICY_LEVEL_RECOMMENDED. | 229 // POLICY_SCOPE_MACHINE over POLICY_SCOPE_USER for POLICY_LEVEL_RECOMMENDED. |
259 c.Set(kTestPolicyName4, | 230 c.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE, |
260 POLICY_LEVEL_RECOMMENDED, | |
261 POLICY_SCOPE_MACHINE, | |
262 POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE, | 231 POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE, |
263 new base::FundamentalValue(true), | 232 base::WrapUnique(new base::FundamentalValue(true)), nullptr); |
264 NULL); | |
265 // POLICY_LEVEL_MANDATORY over POLICY_LEVEL_RECOMMENDED. | 233 // POLICY_LEVEL_MANDATORY over POLICY_LEVEL_RECOMMENDED. |
266 c.Set(kTestPolicyName5, | 234 c.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
267 POLICY_LEVEL_MANDATORY, | |
268 POLICY_SCOPE_MACHINE, | |
269 POLICY_SOURCE_PLATFORM, | 235 POLICY_SOURCE_PLATFORM, |
270 new base::StringValue(std::string()), | 236 base::WrapUnique(new base::StringValue(std::string())), nullptr); |
271 NULL); | |
272 // Merge new ones. | 237 // Merge new ones. |
273 c.Set(kTestPolicyName6, | 238 c.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, |
274 POLICY_LEVEL_RECOMMENDED, | 239 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)), |
275 POLICY_SCOPE_USER, | 240 nullptr); |
276 POLICY_SOURCE_CLOUD, | |
277 new base::FundamentalValue(true), | |
278 NULL); | |
279 | 241 |
280 EXPECT_TRUE(a.Equals(c)); | 242 EXPECT_TRUE(a.Equals(c)); |
281 } | 243 } |
282 | 244 |
283 TEST_F(PolicyMapTest, GetDifferingKeys) { | 245 TEST_F(PolicyMapTest, GetDifferingKeys) { |
284 PolicyMap a; | 246 PolicyMap a; |
285 a.Set(kTestPolicyName1, | 247 a.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
286 POLICY_LEVEL_MANDATORY, | |
287 POLICY_SCOPE_USER, | |
288 POLICY_SOURCE_CLOUD, | 248 POLICY_SOURCE_CLOUD, |
289 new base::StringValue("google.com"), | 249 base::WrapUnique(new base::StringValue("google.com")), nullptr); |
290 NULL); | 250 a.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
291 a.Set(kTestPolicyName2, | 251 POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("dummy")); |
292 POLICY_LEVEL_MANDATORY, | 252 a.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
293 POLICY_SCOPE_MACHINE, | 253 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)), |
| 254 nullptr); |
| 255 a.Set(kTestPolicyName4, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
| 256 POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("a")); |
| 257 a.Set(kTestPolicyName5, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, |
294 POLICY_SOURCE_CLOUD, | 258 POLICY_SOURCE_CLOUD, |
295 NULL, CreateExternalDataFetcher("dummy").release()); | 259 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
296 a.Set(kTestPolicyName3, | 260 a.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE, |
297 POLICY_LEVEL_MANDATORY, | |
298 POLICY_SCOPE_MACHINE, | |
299 POLICY_SOURCE_CLOUD, | 261 POLICY_SOURCE_CLOUD, |
300 new base::FundamentalValue(true), | 262 base::WrapUnique(new base::StringValue("google.com/q={x}")), nullptr); |
301 NULL); | 263 a.Set(kTestPolicyName7, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
302 a.Set(kTestPolicyName4, | 264 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)), |
303 POLICY_LEVEL_MANDATORY, | 265 nullptr); |
304 POLICY_SCOPE_MACHINE, | |
305 POLICY_SOURCE_CLOUD, | |
306 NULL, CreateExternalDataFetcher("a").release()); | |
307 a.Set(kTestPolicyName5, | |
308 POLICY_LEVEL_RECOMMENDED, | |
309 POLICY_SCOPE_USER, | |
310 POLICY_SOURCE_CLOUD, | |
311 new base::FundamentalValue(false), | |
312 NULL); | |
313 a.Set(kTestPolicyName6, | |
314 POLICY_LEVEL_RECOMMENDED, | |
315 POLICY_SCOPE_MACHINE, | |
316 POLICY_SOURCE_CLOUD, | |
317 new base::StringValue("google.com/q={x}"), | |
318 NULL); | |
319 a.Set(kTestPolicyName7, | |
320 POLICY_LEVEL_MANDATORY, | |
321 POLICY_SCOPE_USER, | |
322 POLICY_SOURCE_CLOUD, | |
323 new base::FundamentalValue(true), | |
324 NULL); | |
325 | 266 |
326 PolicyMap b; | 267 PolicyMap b; |
327 b.Set(kTestPolicyName1, | 268 b.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
328 POLICY_LEVEL_MANDATORY, | |
329 POLICY_SCOPE_USER, | |
330 POLICY_SOURCE_CLOUD, | 269 POLICY_SOURCE_CLOUD, |
331 new base::StringValue("google.com"), | 270 base::WrapUnique(new base::StringValue("google.com")), nullptr); |
332 NULL); | 271 b.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
333 b.Set(kTestPolicyName2, | 272 POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("dummy")); |
334 POLICY_LEVEL_MANDATORY, | 273 b.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
335 POLICY_SCOPE_MACHINE, | |
336 POLICY_SOURCE_CLOUD, | 274 POLICY_SOURCE_CLOUD, |
337 NULL, CreateExternalDataFetcher("dummy").release()); | 275 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
338 b.Set(kTestPolicyName3, | 276 b.Set(kTestPolicyName4, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, |
339 POLICY_LEVEL_MANDATORY, | 277 POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("b")); |
340 POLICY_SCOPE_MACHINE, | 278 b.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
341 POLICY_SOURCE_CLOUD, | 279 POLICY_SOURCE_CLOUD, |
342 new base::FundamentalValue(false), | 280 base::WrapUnique(new base::FundamentalValue(false)), nullptr); |
343 NULL); | 281 b.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, |
344 b.Set(kTestPolicyName4, | |
345 POLICY_LEVEL_MANDATORY, | |
346 POLICY_SCOPE_MACHINE, | |
347 POLICY_SOURCE_CLOUD, | 282 POLICY_SOURCE_CLOUD, |
348 NULL, CreateExternalDataFetcher("b").release()); | 283 base::WrapUnique(new base::StringValue("google.com/q={x}")), nullptr); |
349 b.Set(kTestPolicyName5, | 284 b.Set(kTestPolicyName8, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, |
350 POLICY_LEVEL_MANDATORY, | 285 POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)), |
351 POLICY_SCOPE_USER, | 286 nullptr); |
352 POLICY_SOURCE_CLOUD, | |
353 new base::FundamentalValue(false), | |
354 NULL); | |
355 b.Set(kTestPolicyName6, | |
356 POLICY_LEVEL_RECOMMENDED, | |
357 POLICY_SCOPE_USER, | |
358 POLICY_SOURCE_CLOUD, | |
359 new base::StringValue("google.com/q={x}"), | |
360 NULL); | |
361 b.Set(kTestPolicyName8, | |
362 POLICY_LEVEL_RECOMMENDED, | |
363 POLICY_SCOPE_USER, | |
364 POLICY_SOURCE_CLOUD, | |
365 new base::FundamentalValue(true), | |
366 NULL); | |
367 | 287 |
368 std::set<std::string> diff; | 288 std::set<std::string> diff; |
369 std::set<std::string> diff2; | 289 std::set<std::string> diff2; |
370 a.GetDifferingKeys(b, &diff); | 290 a.GetDifferingKeys(b, &diff); |
371 b.GetDifferingKeys(a, &diff2); | 291 b.GetDifferingKeys(a, &diff2); |
372 // Order shouldn't matter. | 292 // Order shouldn't matter. |
373 EXPECT_EQ(diff, diff2); | 293 EXPECT_EQ(diff, diff2); |
374 // No change. | 294 // No change. |
375 EXPECT_TRUE(diff.find(kTestPolicyName1) == diff.end()); | 295 EXPECT_TRUE(diff.find(kTestPolicyName1) == diff.end()); |
376 EXPECT_TRUE(diff.find(kTestPolicyName2) == diff.end()); | 296 EXPECT_TRUE(diff.find(kTestPolicyName2) == diff.end()); |
(...skipping 19 matching lines...) Expand all Loading... |
396 policies.SetBoolean("TestPolicy2", true); | 316 policies.SetBoolean("TestPolicy2", true); |
397 policies.SetInteger("TestPolicy3", -12321); | 317 policies.SetInteger("TestPolicy3", -12321); |
398 | 318 |
399 PolicyMap loaded; | 319 PolicyMap loaded; |
400 loaded.LoadFrom(&policies, | 320 loaded.LoadFrom(&policies, |
401 POLICY_LEVEL_MANDATORY, | 321 POLICY_LEVEL_MANDATORY, |
402 POLICY_SCOPE_USER, | 322 POLICY_SCOPE_USER, |
403 POLICY_SOURCE_PLATFORM); | 323 POLICY_SOURCE_PLATFORM); |
404 | 324 |
405 PolicyMap expected; | 325 PolicyMap expected; |
406 expected.Set("TestPolicy1", | 326 expected.Set("TestPolicy1", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
407 POLICY_LEVEL_MANDATORY, | |
408 POLICY_SCOPE_USER, | |
409 POLICY_SOURCE_PLATFORM, | 327 POLICY_SOURCE_PLATFORM, |
410 new base::StringValue("google.com"), | 328 base::WrapUnique(new base::StringValue("google.com")), nullptr); |
411 nullptr); | 329 expected.Set("TestPolicy2", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
412 expected.Set("TestPolicy2", | |
413 POLICY_LEVEL_MANDATORY, | |
414 POLICY_SCOPE_USER, | |
415 POLICY_SOURCE_PLATFORM, | 330 POLICY_SOURCE_PLATFORM, |
416 new base::FundamentalValue(true), | 331 base::WrapUnique(new base::FundamentalValue(true)), nullptr); |
417 nullptr); | 332 expected.Set("TestPolicy3", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, |
418 expected.Set("TestPolicy3", | |
419 POLICY_LEVEL_MANDATORY, | |
420 POLICY_SCOPE_USER, | |
421 POLICY_SOURCE_PLATFORM, | 333 POLICY_SOURCE_PLATFORM, |
422 new base::FundamentalValue(-12321), | 334 base::WrapUnique(new base::FundamentalValue(-12321)), nullptr); |
423 nullptr); | |
424 EXPECT_TRUE(loaded.Equals(expected)); | 335 EXPECT_TRUE(loaded.Equals(expected)); |
425 } | 336 } |
426 | 337 |
427 } // namespace policy | 338 } // namespace policy |
OLD | NEW |