configuration_policy_pref_store_unittest.cc revision 731df977c0511bca2206b5f333555b1205ff1f43 
1// Copyright (c) 2010 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <gtest/gtest.h>
6
7#include "base/file_path.h"
8#include "chrome/browser/policy/configuration_policy_pref_store.h"
9#include "chrome/browser/policy/mock_configuration_policy_provider.h"
10#include "chrome/common/pref_names.h"
11#include "chrome/common/chrome_switches.h"
12
13namespace policy {
14
15// Holds a set of test parameters, consisting of pref name and policy type.
16class TypeAndName {
17 public:
18  TypeAndName(ConfigurationPolicyStore::PolicyType type, const char* pref_name)
19      : type_(type),
20        pref_name_(pref_name) {}
21
22  ConfigurationPolicyStore::PolicyType type() const { return type_; }
23  const char* pref_name() const { return pref_name_; }
24
25 private:
26  ConfigurationPolicyStore::PolicyType type_;
27  const char* pref_name_;
28};
29
30// Test cases for list-valued policy settings.
31class ConfigurationPolicyPrefStoreListTest
32    : public testing::TestWithParam<TypeAndName> {
33};
34
35TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
36  ConfigurationPolicyPrefStore store(NULL);
37  ListValue* list = NULL;
38  EXPECT_FALSE(store.prefs()->GetList(GetParam().pref_name(), &list));
39}
40
41TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
42  ConfigurationPolicyPrefStore store(NULL);
43  ListValue* in_value = new ListValue();
44  in_value->Append(Value::CreateStringValue("test1"));
45  in_value->Append(Value::CreateStringValue("test2,"));
46  store.Apply(GetParam().type(), in_value);
47  ListValue* list = NULL;
48  EXPECT_TRUE(store.prefs()->GetList(GetParam().pref_name(), &list));
49  ListValue::const_iterator current(list->begin());
50  ListValue::const_iterator end(list->end());
51  ASSERT_TRUE(current != end);
52  std::string value;
53  (*current)->GetAsString(&value);
54  EXPECT_EQ("test1", value);
55  ++current;
56  ASSERT_TRUE(current != end);
57  (*current)->GetAsString(&value);
58  EXPECT_EQ("test2,", value);
59  ++current;
60  EXPECT_TRUE(current == end);
61}
62
63INSTANTIATE_TEST_CASE_P(
64    ConfigurationPolicyPrefStoreListTestInstance,
65    ConfigurationPolicyPrefStoreListTest,
66    testing::Values(
67        TypeAndName(ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
68                    prefs::kURLsToRestoreOnStartup),
69        TypeAndName(ConfigurationPolicyStore::kPolicyExtensionInstallAllowList,
70                    prefs::kExtensionInstallAllowList),
71        TypeAndName(ConfigurationPolicyStore::kPolicyExtensionInstallDenyList,
72                    prefs::kExtensionInstallDenyList),
73        TypeAndName(ConfigurationPolicyStore::kPolicyDisabledPlugins,
74                    prefs::kPluginsPluginsBlacklist)));
75
76// Test cases for string-valued policy settings.
77class ConfigurationPolicyPrefStoreStringTest
78    : public testing::TestWithParam<TypeAndName> {
79};
80
81TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
82  ConfigurationPolicyPrefStore store(NULL);
83  std::string result;
84  EXPECT_FALSE(store.prefs()->GetString(GetParam().pref_name(), &result));
85}
86
87TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
88  ConfigurationPolicyPrefStore store(NULL);
89  store.Apply(GetParam().type(),
90              Value::CreateStringValue("http://chromium.org"));
91  std::string result;
92  EXPECT_TRUE(store.prefs()->GetString(GetParam().pref_name(), &result));
93  EXPECT_EQ(result, "http://chromium.org");
94}
95
96INSTANTIATE_TEST_CASE_P(
97    ConfigurationPolicyPrefStoreStringTestInstance,
98    ConfigurationPolicyPrefStoreStringTest,
99    testing::Values(
100        TypeAndName(ConfigurationPolicyStore::kPolicyHomePage,
101                    prefs::kHomePage),
102        TypeAndName(ConfigurationPolicyStore::kPolicyProxyServer,
103                    prefs::kProxyServer),
104        TypeAndName(ConfigurationPolicyStore::kPolicyProxyPacUrl,
105                    prefs::kProxyPacUrl),
106        TypeAndName(ConfigurationPolicyStore::kPolicyProxyBypassList,
107                    prefs::kProxyBypassList),
108        TypeAndName(ConfigurationPolicyStore::kPolicyApplicationLocale,
109                    prefs::kApplicationLocale)));
110
111// Test cases for boolean-valued policy settings.
112class ConfigurationPolicyPrefStoreBooleanTest
113    : public testing::TestWithParam<TypeAndName> {
114};
115
116TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
117  ConfigurationPolicyPrefStore store(NULL);
118  bool result = false;
119  EXPECT_FALSE(store.prefs()->GetBoolean(GetParam().pref_name(), &result));
120}
121
122TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
123  ConfigurationPolicyPrefStore store(NULL);
124  store.Apply(GetParam().type(), Value::CreateBooleanValue(false));
125  bool result = true;
126  EXPECT_TRUE(store.prefs()->GetBoolean(GetParam().pref_name(), &result));
127  EXPECT_FALSE(result);
128
129  store.Apply(GetParam().type(), Value::CreateBooleanValue(true));
130  result = false;
131  EXPECT_TRUE(store.prefs()->GetBoolean(GetParam().pref_name(), &result));
132  EXPECT_TRUE(result);
133}
134
135INSTANTIATE_TEST_CASE_P(
136    ConfigurationPolicyPrefStoreBooleanTestInstance,
137    ConfigurationPolicyPrefStoreBooleanTest,
138    testing::Values(
139        TypeAndName(ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
140                    prefs::kHomePageIsNewTabPage),
141        TypeAndName(ConfigurationPolicyStore::kPolicyAlternateErrorPagesEnabled,
142                    prefs::kAlternateErrorPagesEnabled),
143        TypeAndName(ConfigurationPolicyStore::kPolicySearchSuggestEnabled,
144                    prefs::kSearchSuggestEnabled),
145        TypeAndName(ConfigurationPolicyStore::kPolicyDnsPrefetchingEnabled,
146                    prefs::kDnsPrefetchingEnabled),
147        TypeAndName(ConfigurationPolicyStore::kPolicyDisableSpdy,
148                    prefs::kDisableSpdy),
149        TypeAndName(ConfigurationPolicyStore::kPolicySafeBrowsingEnabled,
150                    prefs::kSafeBrowsingEnabled),
151        TypeAndName(ConfigurationPolicyStore::kPolicyMetricsReportingEnabled,
152                    prefs::kMetricsReportingEnabled),
153        TypeAndName(ConfigurationPolicyStore::kPolicyPasswordManagerEnabled,
154                    prefs::kPasswordManagerEnabled),
155        TypeAndName(ConfigurationPolicyStore::
156                        kPolicyPasswordManagerAllowShowPasswords,
157                    prefs::kPasswordManagerAllowShowPasswords),
158        TypeAndName(ConfigurationPolicyStore::kPolicyShowHomeButton,
159                    prefs::kShowHomeButton),
160        TypeAndName(ConfigurationPolicyStore::kPolicyPrintingEnabled,
161                    prefs::kPrintingEnabled),
162        TypeAndName(ConfigurationPolicyStore::kPolicyJavascriptEnabled,
163                    prefs::kWebKitJavascriptEnabled),
164        TypeAndName(ConfigurationPolicyStore::
165                        kPolicySavingBrowserHistoryDisabled,
166                    prefs::kSavingBrowserHistoryDisabled)));
167
168#if defined(OS_CHROMEOS)
169INSTANTIATE_TEST_CASE_P(
170    CrosConfigurationPolicyPrefStoreBooleanTestInstance,
171    ConfigurationPolicyPrefStoreBooleanTest,
172    testing::Values(
173        TypeAndName(ConfigurationPolicyStore::
174                        kPolicyChromeOsLockOnIdleSuspend,
175                    prefs::kEnableScreenLock)));
176#endif  // defined(OS_CHROMEOS)
177
178// Test cases for integer-valued policy settings.
179class ConfigurationPolicyPrefStoreIntegerTest
180    : public testing::TestWithParam<TypeAndName> {
181};
182
183TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
184  ConfigurationPolicyPrefStore store(NULL);
185  int result = 0;
186  EXPECT_FALSE(store.prefs()->GetInteger(GetParam().pref_name(), &result));
187}
188
189TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
190  ConfigurationPolicyPrefStore store(NULL);
191  store.Apply(GetParam().type(), Value::CreateIntegerValue(2));
192  int result = 0;
193  EXPECT_TRUE(store.prefs()->GetInteger(GetParam().pref_name(), &result));
194  EXPECT_EQ(result, 2);
195}
196
197INSTANTIATE_TEST_CASE_P(
198    ConfigurationPolicyPrefStoreIntegerTestInstance,
199    ConfigurationPolicyPrefStoreIntegerTest,
200    testing::Values(
201        TypeAndName(ConfigurationPolicyStore::kPolicyRestoreOnStartup,
202                    prefs::kRestoreOnStartup)));
203
204// Test cases for the proxy policy settings.
205class ConfigurationPolicyPrefStoreProxyTest : public testing::Test {
206};
207
208TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
209  scoped_ptr<MockConfigurationPolicyProvider> provider(
210      new MockConfigurationPolicyProvider());
211  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
212      Value::CreateStringValue("http://chromium.org/override"));
213  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyPacUrl,
214      Value::CreateStringValue("http://chromium.org/proxy.pac"));
215  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServer,
216      Value::CreateStringValue("chromium.org"));
217  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
218      Value::CreateIntegerValue(
219          ConfigurationPolicyStore::kPolicyManuallyConfiguredProxyMode));
220
221  ConfigurationPolicyPrefStore store(provider.get());
222  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
223
224  std::string string_result;
225  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyBypassList,
226                                       &string_result));
227  EXPECT_EQ("http://chromium.org/override", string_result);
228  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
229  EXPECT_EQ("http://chromium.org/proxy.pac", string_result);
230  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
231  EXPECT_EQ("chromium.org", string_result);
232  bool bool_result;
233  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
234  EXPECT_FALSE(bool_result);
235  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
236  EXPECT_FALSE(bool_result);
237}
238
239TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) {
240  scoped_ptr<MockConfigurationPolicyProvider> provider(
241      new MockConfigurationPolicyProvider());
242  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
243      Value::CreateStringValue("http://chromium.org/override"));
244  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
245      Value::CreateIntegerValue(
246          ConfigurationPolicyStore::kPolicyNoProxyServerMode));
247
248  ConfigurationPolicyPrefStore store(provider.get());
249  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
250
251  std::string string_result;
252  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
253                                        &string_result));
254  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
255  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
256  bool bool_result;
257  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
258  EXPECT_TRUE(bool_result);
259  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
260  EXPECT_FALSE(bool_result);
261}
262
263TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyReversedApplyOrder) {
264  scoped_ptr<MockConfigurationPolicyProvider> provider(
265      new MockConfigurationPolicyProvider());
266  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
267      Value::CreateIntegerValue(
268          ConfigurationPolicyStore::kPolicyNoProxyServerMode));
269  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
270      Value::CreateStringValue("http://chromium.org/override"));
271
272  ConfigurationPolicyPrefStore store(provider.get());
273  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
274
275  std::string string_result;
276  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
277                                        &string_result));
278  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
279  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
280  bool bool_result;
281  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
282  EXPECT_TRUE(bool_result);
283  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
284  EXPECT_FALSE(bool_result);
285}
286
287TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
288  scoped_ptr<MockConfigurationPolicyProvider> provider(
289      new MockConfigurationPolicyProvider());
290  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
291      Value::CreateIntegerValue(
292          ConfigurationPolicyStore::kPolicyAutoDetectProxyMode));
293
294  ConfigurationPolicyPrefStore store(provider.get());
295  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
296
297  std::string string_result;
298  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
299                                        &string_result));
300  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
301  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
302  bool bool_result;
303  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
304  EXPECT_FALSE(bool_result);
305  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
306  EXPECT_TRUE(bool_result);
307}
308
309TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) {
310  scoped_ptr<MockConfigurationPolicyProvider> provider(
311      new MockConfigurationPolicyProvider());
312  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
313      Value::CreateStringValue("http://chromium.org/override"));
314  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
315      Value::CreateIntegerValue(
316          ConfigurationPolicyStore::kPolicyUseSystemProxyMode));
317
318  ConfigurationPolicyPrefStore store(provider.get());
319  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
320
321  std::string string_result;
322  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
323                                        &string_result));
324  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
325  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
326  bool bool_result;
327  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
328  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
329                                         &bool_result));
330}
331
332TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemReversedApplyOrder) {
333  scoped_ptr<MockConfigurationPolicyProvider> provider(
334      new MockConfigurationPolicyProvider());
335  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
336      Value::CreateIntegerValue(
337          ConfigurationPolicyStore::kPolicyUseSystemProxyMode));
338  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
339      Value::CreateStringValue("http://chromium.org/override"));
340
341  ConfigurationPolicyPrefStore store(provider.get());
342  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
343
344  std::string string_result;
345  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
346                                        &string_result));
347  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
348  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
349  bool bool_result;
350  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
351  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
352                                         &bool_result));
353}
354
355class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
356};
357
358// Checks that if the policy for default search is valid, i.e. there's a
359// search URL, that all the elements have been given proper defaults.
360TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
361  const char* search_url = "http://test.com/search?t={searchTerms}";
362  scoped_ptr<MockConfigurationPolicyProvider> provider(
363      new MockConfigurationPolicyProvider());
364  provider->AddPolicy(
365      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
366      Value::CreateBooleanValue(true));
367  provider->AddPolicy(
368      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
369      Value::CreateStringValue(search_url));
370
371  ConfigurationPolicyPrefStore store(provider.get());
372
373  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
374  DictionaryValue* prefs = store.prefs();
375
376  std::string string_result;
377  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
378                               &string_result));
379  EXPECT_EQ(string_result, search_url);
380
381  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderName,
382                               &string_result));
383  EXPECT_EQ(string_result, "test.com");
384
385  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
386                               &string_result));
387  EXPECT_EQ(string_result, "");
388
389  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
390                               &string_result));
391  EXPECT_EQ(string_result, "");
392
393  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
394                               &string_result));
395  EXPECT_EQ(string_result, "");
396
397  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
398                               &string_result));
399  EXPECT_EQ(string_result, "");
400}
401
402// Checks that for a fully defined search policy, all elements have been
403// read properly.
404TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
405  const char* search_url = "http://test.com/search?t={searchTerms}";
406  const char* suggest_url = "http://test.com/sugg?={searchTerms}";
407  const char* icon_url = "http://test.com/icon.jpg";
408  const char* name = "MyName";
409  const char* keyword = "MyKeyword";
410  const char* encodings = "UTF-16;UTF-8";
411  scoped_ptr<MockConfigurationPolicyProvider> provider(
412      new MockConfigurationPolicyProvider());
413  provider->AddPolicy(
414      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
415      Value::CreateBooleanValue(true));
416  provider->AddPolicy(
417      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
418      Value::CreateStringValue(search_url));
419  provider->AddPolicy(
420      ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
421      Value::CreateStringValue(name));
422  provider->AddPolicy(
423      ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
424      Value::CreateStringValue(keyword));
425  provider->AddPolicy(
426      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
427      Value::CreateStringValue(suggest_url));
428  provider->AddPolicy(
429      ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
430      Value::CreateStringValue(icon_url));
431  provider->AddPolicy(
432      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
433      Value::CreateStringValue(encodings));
434
435  ConfigurationPolicyPrefStore store(provider.get());
436  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
437  DictionaryValue* prefs = store.prefs();
438
439  std::string result_search_url;
440  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
441                               &result_search_url));
442  EXPECT_EQ(result_search_url, search_url);
443
444  std::string result_name;
445  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderName,
446                               &result_name));
447  EXPECT_EQ(result_name, name);
448
449  std::string result_keyword;
450  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
451                               &result_keyword));
452  EXPECT_EQ(result_keyword, keyword);
453
454  std::string result_suggest_url;
455  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
456                               &result_suggest_url));
457  EXPECT_EQ(result_suggest_url, suggest_url);
458
459  std::string result_icon_url;
460  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
461                               &result_icon_url));
462  EXPECT_EQ(result_icon_url, icon_url);
463
464  std::string result_encodings;
465  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
466                               &result_encodings));
467  EXPECT_EQ(result_encodings, encodings);
468}
469
470// Checks that if the default search policy is missing, that no elements of the
471// default search policy will be present.
472TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
473  const char* suggest_url = "http://test.com/sugg?t={searchTerms}";
474  const char* icon_url = "http://test.com/icon.jpg";
475  const char* name = "MyName";
476  const char* keyword = "MyKeyword";
477  const char* encodings = "UTF-16;UTF-8";
478  scoped_ptr<MockConfigurationPolicyProvider> provider(
479      new MockConfigurationPolicyProvider());
480  provider->AddPolicy(
481      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
482      Value::CreateBooleanValue(true));
483  provider->AddPolicy(
484      ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
485      Value::CreateStringValue(name));
486  provider->AddPolicy(
487      ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
488      Value::CreateStringValue(keyword));
489  provider->AddPolicy(
490      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
491      Value::CreateStringValue(suggest_url));
492  provider->AddPolicy(
493      ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
494      Value::CreateStringValue(icon_url));
495  provider->AddPolicy(
496      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
497      Value::CreateStringValue(encodings));
498
499  ConfigurationPolicyPrefStore store(provider.get());
500  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
501  DictionaryValue* prefs = store.prefs();
502
503  std::string string_result;
504  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
505                               &string_result));
506  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderName,
507                               &string_result));
508  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
509                               &string_result));
510  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
511                               &string_result));
512  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
513                               &string_result));
514  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
515                               &string_result));
516}
517
518// Checks that if the default search policy is invalid, that no elements of the
519// default search policy will be present.
520TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
521  const char* bad_search_url = "http://test.com/noSearchTerms";
522  const char* suggest_url = "http://test.com/sugg?t={searchTerms}";
523  const char* icon_url = "http://test.com/icon.jpg";
524  const char* name = "MyName";
525  const char* keyword = "MyKeyword";
526  const char* encodings = "UTF-16;UTF-8";
527  scoped_ptr<MockConfigurationPolicyProvider> provider(
528      new MockConfigurationPolicyProvider());
529  provider->AddPolicy(
530      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
531      Value::CreateBooleanValue(true));
532  provider->AddPolicy(
533      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
534      Value::CreateStringValue(bad_search_url));
535  provider->AddPolicy(
536      ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
537      Value::CreateStringValue(name));
538  provider->AddPolicy(
539      ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
540      Value::CreateStringValue(keyword));
541  provider->AddPolicy(
542      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
543      Value::CreateStringValue(suggest_url));
544  provider->AddPolicy(
545      ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
546      Value::CreateStringValue(icon_url));
547  provider->AddPolicy(
548      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
549      Value::CreateStringValue(encodings));
550
551  ConfigurationPolicyPrefStore store(provider.get());
552  EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
553  DictionaryValue* prefs = store.prefs();
554
555  std::string string_result;
556  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEnabled,
557                               &string_result));
558  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
559                               &string_result));
560  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderName,
561                               &string_result));
562  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
563                               &string_result));
564  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
565                               &string_result));
566  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
567                               &string_result));
568  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
569                               &string_result));
570}
571
572// Test cases for the Sync policy setting.
573class ConfigurationPolicyPrefStoreSyncTest : public testing::Test {
574};
575
576TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
577  ConfigurationPolicyPrefStore store(NULL);
578  bool result = false;
579  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kSyncManaged, &result));
580}
581
582TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
583  ConfigurationPolicyPrefStore store(NULL);
584  store.Apply(ConfigurationPolicyPrefStore::kPolicySyncDisabled,
585              Value::CreateBooleanValue(false));
586  // Enabling Sync should not set the pref.
587  bool result = false;
588  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kSyncManaged, &result));
589}
590
591TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
592  ConfigurationPolicyPrefStore store(NULL);
593  store.Apply(ConfigurationPolicyPrefStore::kPolicySyncDisabled,
594              Value::CreateBooleanValue(true));
595  // Sync should be flagged as managed.
596  bool result = false;
597  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kSyncManaged, &result));
598  EXPECT_TRUE(result);
599}
600
601// Test cases for the AutoFill policy setting.
602class ConfigurationPolicyPrefStoreAutoFillTest : public testing::Test {
603};
604
605TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Default) {
606  ConfigurationPolicyPrefStore store(NULL);
607  bool result = false;
608  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
609}
610
611TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Enabled) {
612  ConfigurationPolicyPrefStore store(NULL);
613  store.Apply(ConfigurationPolicyPrefStore::kPolicyAutoFillEnabled,
614              Value::CreateBooleanValue(true));
615  // Enabling AutoFill should not set the pref.
616  bool result = false;
617  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
618}
619
620TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Disabled) {
621  ConfigurationPolicyPrefStore store(NULL);
622  store.Apply(ConfigurationPolicyPrefStore::kPolicyAutoFillEnabled,
623              Value::CreateBooleanValue(false));
624  // Disabling AutoFill should switch the pref to managed.
625  bool result = true;
626  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
627  EXPECT_FALSE(result);
628}
629
630}  // namespace policy
631