configuration_policy_pref_store_unittest.cc revision dc0f95d653279beabeb9817299e2902918ba123e 
1// Copyright (c) 2011 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 "base/file_path.h"
6#include "base/ref_counted.h"
7#include "chrome/browser/policy/configuration_policy_pref_store.h"
8#include "chrome/browser/policy/mock_configuration_policy_provider.h"
9#include "chrome/browser/prefs/proxy_config_dictionary.h"
10#include "chrome/common/notification_service.h"
11#include "chrome/common/pref_names.h"
12#include "chrome/common/pref_store_observer_mock.h"
13#include "testing/gmock/include/gmock/gmock.h"
14#include "testing/gtest/include/gtest/gtest.h"
15
16using testing::_;
17using testing::Mock;
18
19namespace policy {
20
21// Holds a set of test parameters, consisting of pref name and policy type.
22class TypeAndName {
23 public:
24  TypeAndName(ConfigurationPolicyType type, const char* pref_name)
25      : type_(type),
26        pref_name_(pref_name) {}
27
28  ConfigurationPolicyType type() const { return type_; }
29  const char* pref_name() const { return pref_name_; }
30
31 private:
32  ConfigurationPolicyType type_;
33  const char* pref_name_;
34};
35
36template<typename TESTBASE>
37class ConfigurationPolicyPrefStoreTestBase : public TESTBASE {
38 protected:
39  ConfigurationPolicyPrefStoreTestBase()
40      : provider_(),
41        store_(new ConfigurationPolicyPrefStore(&provider_)) {}
42
43  MockConfigurationPolicyProvider provider_;
44  scoped_refptr<ConfigurationPolicyPrefStore> store_;
45};
46
47// Test cases for list-valued policy settings.
48class ConfigurationPolicyPrefStoreListTest
49    : public ConfigurationPolicyPrefStoreTestBase<
50                 testing::TestWithParam<TypeAndName> > {
51};
52
53TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
54  EXPECT_EQ(PrefStore::READ_NO_VALUE,
55            store_->GetValue(GetParam().pref_name(), NULL));
56}
57
58TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
59  ListValue* in_value = new ListValue();
60  in_value->Append(Value::CreateStringValue("test1"));
61  in_value->Append(Value::CreateStringValue("test2,"));
62  provider_.AddPolicy(GetParam().type(), in_value);
63  store_->OnUpdatePolicy();
64  Value* value;
65  EXPECT_EQ(PrefStore::READ_OK,
66            store_->GetValue(GetParam().pref_name(), &value));
67  EXPECT_TRUE(in_value->Equals(value));
68}
69
70INSTANTIATE_TEST_CASE_P(
71    ConfigurationPolicyPrefStoreListTestInstance,
72    ConfigurationPolicyPrefStoreListTest,
73    testing::Values(
74        TypeAndName(kPolicyRestoreOnStartupURLs,
75                    prefs::kURLsToRestoreOnStartup),
76        TypeAndName(kPolicyExtensionInstallWhitelist,
77                    prefs::kExtensionInstallAllowList),
78        TypeAndName(kPolicyExtensionInstallBlacklist,
79                    prefs::kExtensionInstallDenyList),
80        TypeAndName(kPolicyDisabledPlugins,
81                    prefs::kPluginsDisabledPlugins),
82        TypeAndName(kPolicyDisabledPluginsExceptions,
83                    prefs::kPluginsDisabledPluginsExceptions),
84        TypeAndName(kPolicyEnabledPlugins,
85                    prefs::kPluginsEnabledPlugins)));
86
87// Test cases for string-valued policy settings.
88class ConfigurationPolicyPrefStoreStringTest
89    : public ConfigurationPolicyPrefStoreTestBase<
90                 testing::TestWithParam<TypeAndName> > {
91};
92
93TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
94  EXPECT_EQ(PrefStore::READ_NO_VALUE,
95            store_->GetValue(GetParam().pref_name(), NULL));
96}
97
98TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
99  provider_.AddPolicy(GetParam().type(),
100                      Value::CreateStringValue("http://chromium.org"));
101  store_->OnUpdatePolicy();
102  Value* value;
103  EXPECT_EQ(PrefStore::READ_OK,
104            store_->GetValue(GetParam().pref_name(), &value));
105  EXPECT_TRUE(StringValue("http://chromium.org").Equals(value));
106}
107
108INSTANTIATE_TEST_CASE_P(
109    ConfigurationPolicyPrefStoreStringTestInstance,
110    ConfigurationPolicyPrefStoreStringTest,
111    testing::Values(
112        TypeAndName(kPolicyHomepageLocation,
113                    prefs::kHomePage),
114        TypeAndName(kPolicyApplicationLocaleValue,
115                    prefs::kApplicationLocale),
116        TypeAndName(kPolicyApplicationLocaleValue,
117                    prefs::kApplicationLocale),
118        TypeAndName(kPolicyAuthSchemes,
119                    prefs::kAuthSchemes),
120        TypeAndName(kPolicyAuthServerWhitelist,
121                    prefs::kAuthServerWhitelist),
122        TypeAndName(kPolicyAuthNegotiateDelegateWhitelist,
123                    prefs::kAuthNegotiateDelegateWhitelist),
124        TypeAndName(kPolicyGSSAPILibraryName,
125                    prefs::kGSSAPILibraryName)));
126
127// Test cases for boolean-valued policy settings.
128class ConfigurationPolicyPrefStoreBooleanTest
129    : public ConfigurationPolicyPrefStoreTestBase<
130                 testing::TestWithParam<TypeAndName> > {
131};
132
133TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
134  EXPECT_EQ(PrefStore::READ_NO_VALUE,
135            store_->GetValue(GetParam().pref_name(), NULL));
136}
137
138TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
139  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(false));
140  store_->OnUpdatePolicy();
141  Value* value;
142  bool result = true;
143  EXPECT_EQ(PrefStore::READ_OK,
144            store_->GetValue(GetParam().pref_name(), &value));
145  EXPECT_TRUE(FundamentalValue(false).Equals(value));
146
147  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(true));
148  store_->OnUpdatePolicy();
149  result = false;
150  EXPECT_EQ(PrefStore::READ_OK,
151            store_->GetValue(GetParam().pref_name(), &value));
152  EXPECT_TRUE(FundamentalValue(true).Equals(value));
153}
154
155INSTANTIATE_TEST_CASE_P(
156    ConfigurationPolicyPrefStoreBooleanTestInstance,
157    ConfigurationPolicyPrefStoreBooleanTest,
158    testing::Values(
159        TypeAndName(kPolicyHomepageIsNewTabPage,
160                    prefs::kHomePageIsNewTabPage),
161        TypeAndName(kPolicyAlternateErrorPagesEnabled,
162                    prefs::kAlternateErrorPagesEnabled),
163        TypeAndName(kPolicySearchSuggestEnabled,
164                    prefs::kSearchSuggestEnabled),
165        TypeAndName(kPolicyDnsPrefetchingEnabled,
166                    prefs::kDnsPrefetchingEnabled),
167        TypeAndName(kPolicyDisableSpdy,
168                    prefs::kDisableSpdy),
169        TypeAndName(kPolicySafeBrowsingEnabled,
170                    prefs::kSafeBrowsingEnabled),
171        TypeAndName(kPolicyMetricsReportingEnabled,
172                    prefs::kMetricsReportingEnabled),
173        TypeAndName(kPolicyPasswordManagerEnabled,
174                    prefs::kPasswordManagerEnabled),
175        TypeAndName(kPolicyPasswordManagerAllowShowPasswords,
176                    prefs::kPasswordManagerAllowShowPasswords),
177        TypeAndName(kPolicyShowHomeButton,
178                    prefs::kShowHomeButton),
179        TypeAndName(kPolicyPrintingEnabled,
180                    prefs::kPrintingEnabled),
181        TypeAndName(kPolicyJavascriptEnabled,
182                    prefs::kWebKitJavascriptEnabled),
183        TypeAndName(kPolicyIncognitoEnabled,
184                    prefs::kIncognitoEnabled),
185        TypeAndName(kPolicyCloudPrintProxyEnabled,
186                    prefs::kCloudPrintProxyEnabled),
187        TypeAndName(kPolicySavingBrowserHistoryDisabled,
188                    prefs::kSavingBrowserHistoryDisabled),
189        TypeAndName(kPolicySavingBrowserHistoryDisabled,
190                    prefs::kSavingBrowserHistoryDisabled),
191        TypeAndName(kPolicyDisableAuthNegotiateCnameLookup,
192                    prefs::kDisableAuthNegotiateCnameLookup),
193        TypeAndName(kPolicyEnableAuthNegotiatePort,
194                    prefs::kEnableAuthNegotiatePort),
195        TypeAndName(kPolicyInstantEnabled,
196                    prefs::kInstantEnabled),
197        TypeAndName(kPolicyDisable3DAPIs,
198                    prefs::kDisable3DAPIs)));
199
200#if defined(OS_CHROMEOS)
201INSTANTIATE_TEST_CASE_P(
202    CrosConfigurationPolicyPrefStoreBooleanTestInstance,
203    ConfigurationPolicyPrefStoreBooleanTest,
204    testing::Values(
205        TypeAndName(kPolicyChromeOsLockOnIdleSuspend,
206                    prefs::kEnableScreenLock)));
207#endif  // defined(OS_CHROMEOS)
208
209// Test cases for integer-valued policy settings.
210class ConfigurationPolicyPrefStoreIntegerTest
211    : public ConfigurationPolicyPrefStoreTestBase<
212                 testing::TestWithParam<TypeAndName> > {
213};
214
215TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
216  EXPECT_EQ(PrefStore::READ_NO_VALUE,
217            store_->GetValue(GetParam().pref_name(), NULL));
218}
219
220TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
221  provider_.AddPolicy(GetParam().type(), Value::CreateIntegerValue(2));
222  store_->OnUpdatePolicy();
223  Value* value = NULL;
224  EXPECT_EQ(PrefStore::READ_OK,
225            store_->GetValue(GetParam().pref_name(), &value));
226  EXPECT_TRUE(FundamentalValue(2).Equals(value));
227}
228
229INSTANTIATE_TEST_CASE_P(
230    ConfigurationPolicyPrefStoreIntegerTestInstance,
231    ConfigurationPolicyPrefStoreIntegerTest,
232    testing::Values(
233        TypeAndName(kPolicyRestoreOnStartup,
234                    prefs::kRestoreOnStartup),
235        TypeAndName(kPolicyPolicyRefreshRate,
236                    prefs::kPolicyUserPolicyRefreshRate)));
237
238// Test cases for the proxy policy settings.
239class ConfigurationPolicyPrefStoreProxyTest : public testing::Test {
240 protected:
241  // Verify that all the proxy prefs are set to the specified expected values.
242  static void VerifyProxyPrefs(
243      const ConfigurationPolicyPrefStore& store,
244      const std::string& expected_proxy_server,
245      const std::string& expected_proxy_pac_url,
246      const std::string& expected_proxy_bypass_list,
247      const ProxyPrefs::ProxyMode& expected_proxy_mode) {
248    Value* value = NULL;
249    ASSERT_EQ(PrefStore::READ_OK,
250              store.GetValue(prefs::kProxy, &value));
251    ASSERT_EQ(Value::TYPE_DICTIONARY, value->GetType());
252    ProxyConfigDictionary dict(static_cast<DictionaryValue*>(value));
253    std::string s;
254    if (expected_proxy_server.empty()) {
255      EXPECT_FALSE(dict.GetProxyServer(&s));
256    } else {
257      ASSERT_TRUE(dict.GetProxyServer(&s));
258      EXPECT_EQ(expected_proxy_server, s);
259    }
260    if (expected_proxy_pac_url.empty()) {
261      EXPECT_FALSE(dict.GetPacUrl(&s));
262    } else {
263      ASSERT_TRUE(dict.GetPacUrl(&s));
264      EXPECT_EQ(expected_proxy_pac_url, s);
265    }
266    if (expected_proxy_bypass_list.empty()) {
267      EXPECT_FALSE(dict.GetBypassList(&s));
268    } else {
269      ASSERT_TRUE(dict.GetBypassList(&s));
270      EXPECT_EQ(expected_proxy_bypass_list, s);
271    }
272    ProxyPrefs::ProxyMode mode;
273    ASSERT_TRUE(dict.GetMode(&mode));
274    EXPECT_EQ(expected_proxy_mode, mode);
275  }
276};
277
278TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
279  MockConfigurationPolicyProvider provider;
280  provider.AddPolicy(kPolicyProxyBypassList,
281                     Value::CreateStringValue("http://chromium.org/override"));
282  provider.AddPolicy(kPolicyProxyServer,
283                     Value::CreateStringValue("chromium.org"));
284  provider.AddPolicy(kPolicyProxyServerMode,
285                     Value::CreateIntegerValue(
286                         kPolicyManuallyConfiguredProxyServerMode));
287
288  scoped_refptr<ConfigurationPolicyPrefStore> store(
289      new ConfigurationPolicyPrefStore(&provider));
290  VerifyProxyPrefs(
291      *store, "chromium.org", "", "http://chromium.org/override",
292      ProxyPrefs::MODE_FIXED_SERVERS);
293}
294
295TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) {
296  MockConfigurationPolicyProvider provider;
297  provider.AddPolicy(kPolicyProxyServerMode,
298                     Value::CreateIntegerValue(
299                         kPolicyManuallyConfiguredProxyServerMode));
300  provider.AddPolicy(kPolicyProxyBypassList,
301                     Value::CreateStringValue("http://chromium.org/override"));
302  provider.AddPolicy(kPolicyProxyServer,
303                     Value::CreateStringValue("chromium.org"));
304  scoped_refptr<ConfigurationPolicyPrefStore> store(
305      new ConfigurationPolicyPrefStore(&provider));
306  VerifyProxyPrefs(
307      *store, "chromium.org", "", "http://chromium.org/override",
308      ProxyPrefs::MODE_FIXED_SERVERS);
309}
310
311TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyServerMode) {
312  MockConfigurationPolicyProvider provider;
313  provider.AddPolicy(kPolicyProxyServerMode,
314                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
315
316  scoped_refptr<ConfigurationPolicyPrefStore> store(
317      new ConfigurationPolicyPrefStore(&provider));
318  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_DIRECT);
319}
320
321TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyModeName) {
322  MockConfigurationPolicyProvider provider;
323  provider.AddPolicy(
324      kPolicyProxyMode,
325      Value::CreateStringValue(ProxyPrefs::kDirectProxyModeName));
326
327  scoped_refptr<ConfigurationPolicyPrefStore> store(
328      new ConfigurationPolicyPrefStore(&provider));
329  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_DIRECT);
330}
331
332TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyServerMode) {
333  MockConfigurationPolicyProvider provider;
334  provider.AddPolicy(
335      kPolicyProxyServerMode,
336      Value::CreateIntegerValue(kPolicyAutoDetectProxyServerMode));
337
338  scoped_refptr<ConfigurationPolicyPrefStore> store(
339      new ConfigurationPolicyPrefStore(&provider));
340  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
341}
342
343TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyModeName) {
344  MockConfigurationPolicyProvider provider;
345  provider.AddPolicy(
346      kPolicyProxyMode,
347      Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
348
349  scoped_refptr<ConfigurationPolicyPrefStore> store(
350      new ConfigurationPolicyPrefStore(&provider));
351  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
352}
353
354TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyMode) {
355  MockConfigurationPolicyProvider provider;
356  provider.AddPolicy(kPolicyProxyPacUrl,
357                     Value::CreateStringValue("http://short.org/proxy.pac"));
358  provider.AddPolicy(
359      kPolicyProxyMode,
360      Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
361
362  scoped_refptr<ConfigurationPolicyPrefStore> store(
363      new ConfigurationPolicyPrefStore(&provider));
364  VerifyProxyPrefs(*store, "", "http://short.org/proxy.pac", "",
365                   ProxyPrefs::MODE_PAC_SCRIPT);
366}
367
368TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyServerMode) {
369  MockConfigurationPolicyProvider provider;
370  provider.AddPolicy(
371      kPolicyProxyServerMode,
372      Value::CreateIntegerValue(kPolicyUseSystemProxyServerMode));
373
374  scoped_refptr<ConfigurationPolicyPrefStore> store(
375      new ConfigurationPolicyPrefStore(&provider));
376  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_SYSTEM);
377}
378
379TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyMode) {
380  MockConfigurationPolicyProvider provider;
381  provider.AddPolicy(
382      kPolicyProxyMode,
383      Value::CreateStringValue(ProxyPrefs::kSystemProxyModeName));
384
385  scoped_refptr<ConfigurationPolicyPrefStore> store(
386      new ConfigurationPolicyPrefStore(&provider));
387  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_SYSTEM);
388}
389
390TEST_F(ConfigurationPolicyPrefStoreProxyTest,
391       ProxyModeOverridesProxyServerMode) {
392  MockConfigurationPolicyProvider provider;
393  provider.AddPolicy(kPolicyProxyServerMode,
394                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
395  provider.AddPolicy(
396      kPolicyProxyMode,
397      Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
398
399  scoped_refptr<ConfigurationPolicyPrefStore> store(
400      new ConfigurationPolicyPrefStore(&provider));
401  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
402}
403
404TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) {
405  for (int i = 0; i < MODE_COUNT; ++i) {
406    MockConfigurationPolicyProvider provider;
407    provider.AddPolicy(kPolicyProxyServerMode, Value::CreateIntegerValue(i));
408    // No mode expects all three parameters being set.
409    provider.AddPolicy(kPolicyProxyPacUrl,
410                       Value::CreateStringValue("http://short.org/proxy.pac"));
411    provider.AddPolicy(kPolicyProxyBypassList,
412                       Value::CreateStringValue(
413                           "http://chromium.org/override"));
414    provider.AddPolicy(kPolicyProxyServer,
415                       Value::CreateStringValue("chromium.org"));
416
417    scoped_refptr<ConfigurationPolicyPrefStore> store(
418        new ConfigurationPolicyPrefStore(&provider));
419    Value* value = NULL;
420    EXPECT_EQ(PrefStore::READ_NO_VALUE,
421              store->GetValue(prefs::kProxy, &value));
422  }
423}
424
425class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
426};
427
428// Checks that if the policy for default search is valid, i.e. there's a
429// search URL, that all the elements have been given proper defaults.
430TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
431  const char* const search_url = "http://test.com/search?t={searchTerms}";
432  MockConfigurationPolicyProvider provider;
433  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
434                     Value::CreateBooleanValue(true));
435  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
436                     Value::CreateStringValue(search_url));
437
438  scoped_refptr<ConfigurationPolicyPrefStore> store(
439      new ConfigurationPolicyPrefStore(&provider));
440
441  Value* value = NULL;
442  EXPECT_EQ(PrefStore::READ_OK,
443            store->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
444  EXPECT_TRUE(StringValue(search_url).Equals(value));
445
446  EXPECT_EQ(PrefStore::READ_OK,
447            store->GetValue(prefs::kDefaultSearchProviderName, &value));
448  EXPECT_TRUE(StringValue("test.com").Equals(value));
449
450  EXPECT_EQ(PrefStore::READ_OK,
451            store->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
452  EXPECT_TRUE(StringValue(std::string()).Equals(value));
453
454  EXPECT_EQ(PrefStore::READ_OK,
455            store->GetValue(prefs::kDefaultSearchProviderSuggestURL, &value));
456  EXPECT_TRUE(StringValue(std::string()).Equals(value));
457
458  EXPECT_EQ(PrefStore::READ_OK,
459            store->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
460  EXPECT_TRUE(StringValue(std::string()).Equals(value));
461
462  EXPECT_EQ(PrefStore::READ_OK,
463            store->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
464  EXPECT_TRUE(StringValue(std::string()).Equals(value));
465
466  EXPECT_EQ(PrefStore::READ_OK,
467            store->GetValue(prefs::kDefaultSearchProviderInstantURL, &value));
468  EXPECT_TRUE(StringValue(std::string()).Equals(value));
469}
470
471// Checks that for a fully defined search policy, all elements have been
472// read properly.
473TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
474  const char* const search_url = "http://test.com/search?t={searchTerms}";
475  const char* const suggest_url = "http://test.com/sugg?={searchTerms}";
476  const char* const icon_url = "http://test.com/icon.jpg";
477  const char* const name = "MyName";
478  const char* const keyword = "MyKeyword";
479  const char* const encodings = "UTF-16;UTF-8";
480  MockConfigurationPolicyProvider provider;
481  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
482                     Value::CreateBooleanValue(true));
483  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
484                     Value::CreateStringValue(search_url));
485  provider.AddPolicy(kPolicyDefaultSearchProviderName,
486                     Value::CreateStringValue(name));
487  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
488                     Value::CreateStringValue(keyword));
489  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
490                     Value::CreateStringValue(suggest_url));
491  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
492                     Value::CreateStringValue(icon_url));
493  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings,
494                     Value::CreateStringValue(encodings));
495
496  scoped_refptr<ConfigurationPolicyPrefStore> store(
497      new ConfigurationPolicyPrefStore(&provider));
498
499  Value* value = NULL;
500  EXPECT_EQ(PrefStore::READ_OK,
501            store->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
502  EXPECT_TRUE(StringValue(search_url).Equals(value));
503
504  EXPECT_EQ(PrefStore::READ_OK,
505            store->GetValue(prefs::kDefaultSearchProviderName, &value));
506  EXPECT_TRUE(StringValue(name).Equals(value));
507
508  EXPECT_EQ(PrefStore::READ_OK,
509            store->GetValue(prefs::kDefaultSearchProviderKeyword, &value));
510  EXPECT_TRUE(StringValue(keyword).Equals(value));
511
512  EXPECT_EQ(PrefStore::READ_OK,
513            store->GetValue(prefs::kDefaultSearchProviderSuggestURL, &value));
514  EXPECT_TRUE(StringValue(suggest_url).Equals(value));
515
516  EXPECT_EQ(PrefStore::READ_OK,
517            store->GetValue(prefs::kDefaultSearchProviderIconURL, &value));
518  EXPECT_TRUE(StringValue(icon_url).Equals(value));
519
520  EXPECT_EQ(PrefStore::READ_OK,
521            store->GetValue(prefs::kDefaultSearchProviderEncodings, &value));
522  EXPECT_TRUE(StringValue(encodings).Equals(value));
523}
524
525// Checks that if the default search policy is missing, that no elements of the
526// default search policy will be present.
527TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
528  const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
529  const char* const icon_url = "http://test.com/icon.jpg";
530  const char* const name = "MyName";
531  const char* const keyword = "MyKeyword";
532  const char* const encodings = "UTF-16;UTF-8";
533  MockConfigurationPolicyProvider provider;
534  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
535                     Value::CreateBooleanValue(true));
536  provider.AddPolicy(kPolicyDefaultSearchProviderName,
537                     Value::CreateStringValue(name));
538  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
539                     Value::CreateStringValue(keyword));
540  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
541                     Value::CreateStringValue(suggest_url));
542  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
543                     Value::CreateStringValue(icon_url));
544  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings,
545                     Value::CreateStringValue(encodings));
546
547  scoped_refptr<ConfigurationPolicyPrefStore> store(
548      new ConfigurationPolicyPrefStore(&provider));
549
550  EXPECT_EQ(PrefStore::READ_NO_VALUE,
551            store->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
552  EXPECT_EQ(PrefStore::READ_NO_VALUE,
553            store->GetValue(prefs::kDefaultSearchProviderName, NULL));
554  EXPECT_EQ(PrefStore::READ_NO_VALUE,
555            store->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
556  EXPECT_EQ(PrefStore::READ_NO_VALUE,
557            store->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
558  EXPECT_EQ(PrefStore::READ_NO_VALUE,
559            store->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
560  EXPECT_EQ(PrefStore::READ_NO_VALUE,
561            store->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
562}
563
564// Checks that if the default search policy is invalid, that no elements of the
565// default search policy will be present.
566TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
567  const char* const bad_search_url = "http://test.com/noSearchTerms";
568  const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
569  const char* const icon_url = "http://test.com/icon.jpg";
570  const char* const name = "MyName";
571  const char* const keyword = "MyKeyword";
572  const char* const encodings = "UTF-16;UTF-8";
573  MockConfigurationPolicyProvider provider;
574  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
575                     Value::CreateBooleanValue(true));
576  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
577                     Value::CreateStringValue(bad_search_url));
578  provider.AddPolicy(kPolicyDefaultSearchProviderName,
579                     Value::CreateStringValue(name));
580  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
581                     Value::CreateStringValue(keyword));
582  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
583                     Value::CreateStringValue(suggest_url));
584  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
585                     Value::CreateStringValue(icon_url));
586  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings,
587                     Value::CreateStringValue(encodings));
588
589  scoped_refptr<ConfigurationPolicyPrefStore> store(
590      new ConfigurationPolicyPrefStore(&provider));
591
592  EXPECT_EQ(PrefStore::READ_NO_VALUE,
593            store->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
594  EXPECT_EQ(PrefStore::READ_NO_VALUE,
595            store->GetValue(prefs::kDefaultSearchProviderName, NULL));
596  EXPECT_EQ(PrefStore::READ_NO_VALUE,
597            store->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
598  EXPECT_EQ(PrefStore::READ_NO_VALUE,
599            store->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
600  EXPECT_EQ(PrefStore::READ_NO_VALUE,
601            store->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
602  EXPECT_EQ(PrefStore::READ_NO_VALUE,
603            store->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
604}
605
606// Test cases for the Sync policy setting.
607class ConfigurationPolicyPrefStoreSyncTest
608    : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
609};
610
611TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
612  EXPECT_EQ(PrefStore::READ_NO_VALUE,
613            store_->GetValue(prefs::kSyncManaged, NULL));
614}
615
616TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
617  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(false));
618  store_->OnUpdatePolicy();
619  // Enabling Sync should not set the pref.
620  EXPECT_EQ(PrefStore::READ_NO_VALUE,
621            store_->GetValue(prefs::kSyncManaged, NULL));
622}
623
624TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
625  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(true));
626  store_->OnUpdatePolicy();
627  // Sync should be flagged as managed.
628  Value* value = NULL;
629  EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kSyncManaged, &value));
630  ASSERT_TRUE(value != NULL);
631  EXPECT_TRUE(FundamentalValue(true).Equals(value));
632}
633
634// Test cases for the AutoFill policy setting.
635class ConfigurationPolicyPrefStoreAutoFillTest
636    : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
637};
638
639TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Default) {
640  EXPECT_EQ(PrefStore::READ_NO_VALUE,
641            store_->GetValue(prefs::kSyncManaged, NULL));
642}
643
644TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Enabled) {
645  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
646  store_->OnUpdatePolicy();
647  // Enabling AutoFill should not set the pref.
648  EXPECT_EQ(PrefStore::READ_NO_VALUE,
649            store_->GetValue(prefs::kSyncManaged, NULL));
650}
651
652TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Disabled) {
653  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
654  store_->OnUpdatePolicy();
655  // Disabling AutoFill should switch the pref to managed.
656  Value* value = NULL;
657  EXPECT_EQ(PrefStore::READ_OK,
658            store_->GetValue(prefs::kAutoFillEnabled, &value));
659  EXPECT_TRUE(FundamentalValue(false).Equals(value));
660}
661
662// Exercises the policy refresh mechanism.
663class ConfigurationPolicyPrefStoreRefreshTest
664    : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
665 protected:
666  virtual void SetUp() {
667    store_->AddObserver(&observer_);
668  }
669
670  virtual void TearDown() {
671    store_->RemoveObserver(&observer_);
672  }
673
674  PrefStoreObserverMock observer_;
675};
676
677TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
678  Value* value = NULL;
679  EXPECT_EQ(PrefStore::READ_NO_VALUE,
680            store_->GetValue(prefs::kHomePage, NULL));
681
682  EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
683  provider_.AddPolicy(kPolicyHomepageLocation,
684                      Value::CreateStringValue("http://www.chromium.org"));
685  store_->OnUpdatePolicy();
686  Mock::VerifyAndClearExpectations(&observer_);
687  EXPECT_EQ(PrefStore::READ_OK,
688            store_->GetValue(prefs::kHomePage, &value));
689  EXPECT_TRUE(StringValue("http://www.chromium.org").Equals(value));
690
691  EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
692  store_->OnUpdatePolicy();
693  Mock::VerifyAndClearExpectations(&observer_);
694
695  EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
696  provider_.RemovePolicy(kPolicyHomepageLocation);
697  store_->OnUpdatePolicy();
698  Mock::VerifyAndClearExpectations(&observer_);
699  EXPECT_EQ(PrefStore::READ_NO_VALUE,
700            store_->GetValue(prefs::kHomePage, NULL));
701}
702
703TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Initialization) {
704  EXPECT_FALSE(store_->IsInitializationComplete());
705
706  EXPECT_CALL(observer_, OnInitializationCompleted()).Times(1);
707
708  provider_.SetInitializationComplete(true);
709  EXPECT_FALSE(store_->IsInitializationComplete());
710
711  store_->OnUpdatePolicy();
712  Mock::VerifyAndClearExpectations(&observer_);
713  EXPECT_TRUE(store_->IsInitializationComplete());
714}
715
716}  // namespace policy
717