Added RefreshPolicies to PolicyService.

chrome/browser/policy/configuration_policy_reader_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/configuration_policy_reader.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/mock_configuration_policy_reader.h"
+#include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Return;
 using ::testing::ReturnNull;
 using ::testing::_;
 
 namespace policy {
 
 class ConfigurationPolicyReaderTest : public testing::Test {
  protected:
-  ConfigurationPolicyReaderTest() : provider_() {
+  ConfigurationPolicyReaderTest() {
+    EXPECT_CALL(provider_, ProvideInternal(_))
+        .WillRepeatedly(CopyPolicyMap(&policy_));
+    EXPECT_CALL(provider_, IsInitializationComplete())
+        .WillRepeatedly(Return(true));
+
     reader_.reset(new ConfigurationPolicyReader(&provider_));
     status_ok_ = ASCIIToUTF16("OK");
   }
 
   DictionaryValue* CreateDictionary(const char* policy_name,
                                     Value* policy_value) {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString(PolicyStatusInfo::kNameDictPath, ASCIIToUTF16(policy_name));
     dict->SetString(PolicyStatusInfo::kLevelDictPath,
                     PolicyStatusInfo::GetPolicyLevelString(
                         POLICY_LEVEL_MANDATORY));
     dict->SetString(PolicyStatusInfo::kScopeDictPath,
                     PolicyStatusInfo::GetPolicyScopeString(
                         POLICY_SCOPE_USER));
     dict->Set(PolicyStatusInfo::kValueDictPath, policy_value);
     dict->SetBoolean(PolicyStatusInfo::kSetDictPath, true);
     dict->SetString(PolicyStatusInfo::kStatusDictPath, status_ok_);
 
     return dict;
   }
 
+  PolicyMap policy_;
   MockConfigurationPolicyProvider provider_;
   scoped_ptr<ConfigurationPolicyReader> reader_;
   string16 status_ok_;
 };
 
 TEST_F(ConfigurationPolicyReaderTest, GetDefault) {
   EXPECT_EQ(NULL, reader_->GetPolicyStatus(key::kHomepageLocation));
 }
 
 // Test for list-valued policy settings.
 TEST_F(ConfigurationPolicyReaderTest, SetListValue) {
   ListValue mandatory_value;
   mandatory_value.Append(Value::CreateStringValue("test1"));
   mandatory_value.Append(Value::CreateStringValue("test2"));
   ListValue recommended_value;
   recommended_value.Append(Value::CreateStringValue("test3"));
   recommended_value.Append(Value::CreateStringValue("test4"));
-  provider_.AddMandatoryPolicy(key::kRestoreOnStartupURLs,
-                               mandatory_value.DeepCopy());
-  provider_.AddRecommendedPolicy(key::kDisabledSchemes,
-                                 recommended_value.DeepCopy());
+  policy_.Set(key::kRestoreOnStartupURLs, POLICY_LEVEL_MANDATORY,
+              POLICY_SCOPE_USER, mandatory_value.DeepCopy());
+  policy_.Set(key::kDisabledSchemes, POLICY_LEVEL_RECOMMENDED,
+              POLICY_SCOPE_USER, recommended_value.DeepCopy());
   reader_->OnUpdatePolicy(&provider_);
 
   scoped_ptr<DictionaryValue> dict(
       CreateDictionary(key::kRestoreOnStartupURLs,
                        mandatory_value.DeepCopy()));
   scoped_ptr<DictionaryValue> result(
       reader_->GetPolicyStatus(key::kRestoreOnStartupURLs));
   EXPECT_TRUE(dict->Equals(result.get()));
 
   dict.reset(CreateDictionary(key::kDisabledSchemes,
                               recommended_value.DeepCopy()));
   dict->SetString(
       "level",
       PolicyStatusInfo::GetPolicyLevelString(POLICY_LEVEL_RECOMMENDED));
   result.reset(reader_->GetPolicyStatus(key::kDisabledSchemes));
   EXPECT_TRUE(dict->Equals(result.get()));
 }
 
 // Test for string-valued policy settings.
 TEST_F(ConfigurationPolicyReaderTest, SetStringValue) {
   StringValue mandatory_value("http://chromium.org");
   StringValue recommended_value("http://www.google.com/q={searchTerms}");
-  provider_.AddMandatoryPolicy(key::kHomepageLocation,
-                               mandatory_value.DeepCopy());
-  provider_.AddRecommendedPolicy(key::kDefaultSearchProviderSearchURL,
-                                 recommended_value.DeepCopy());
+  policy_.Set(key::kHomepageLocation, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              mandatory_value.DeepCopy());
+  policy_.Set(key::kDefaultSearchProviderSearchURL, POLICY_LEVEL_RECOMMENDED,
+              POLICY_SCOPE_USER, recommended_value.DeepCopy());
   reader_->OnUpdatePolicy(&provider_);
   scoped_ptr<DictionaryValue> dict(
       CreateDictionary(key::kHomepageLocation,
                        mandatory_value.DeepCopy()));
   scoped_ptr<DictionaryValue> result(
       reader_->GetPolicyStatus(key::kHomepageLocation));
   EXPECT_TRUE(dict->Equals(result.get()));
 
   dict.reset(CreateDictionary(key::kDefaultSearchProviderSearchURL,
                               recommended_value.DeepCopy()));
   dict->SetString(
       "level",
       PolicyStatusInfo::GetPolicyLevelString(POLICY_LEVEL_RECOMMENDED));
   result.reset(reader_->GetPolicyStatus(key::kDefaultSearchProviderSearchURL));
   EXPECT_TRUE(dict->Equals(result.get()));
 }
 
 // Test for boolean-valued policy settings.
 TEST_F(ConfigurationPolicyReaderTest, SetBooleanValue) {
-  provider_.AddMandatoryPolicy(key::kShowHomeButton,
-                               Value::CreateBooleanValue(true));
-  provider_.AddRecommendedPolicy(key::kHomepageIsNewTabPage,
-                                 Value::CreateBooleanValue(false));
+  policy_.Set(key::kShowHomeButton, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              Value::CreateBooleanValue(true));
+  policy_.Set(key::kHomepageIsNewTabPage, POLICY_LEVEL_RECOMMENDED,
+              POLICY_SCOPE_USER, Value::CreateBooleanValue(false));
   reader_->OnUpdatePolicy(&provider_);
   scoped_ptr<DictionaryValue> dict(
       CreateDictionary(key::kShowHomeButton, Value::CreateBooleanValue(true)));
   scoped_ptr<DictionaryValue> result(
       reader_->GetPolicyStatus(key::kShowHomeButton));
   EXPECT_TRUE(dict->Equals(result.get()));
 
   dict.reset(CreateDictionary(key::kHomepageIsNewTabPage,
                               Value::CreateBooleanValue(false)));
   dict->SetString(
       "level",
       PolicyStatusInfo::GetPolicyLevelString(POLICY_LEVEL_RECOMMENDED));
   result.reset(reader_->GetPolicyStatus(key::kHomepageIsNewTabPage));
   EXPECT_TRUE(dict->Equals(result.get()));
 }
 
 // Test for integer-valued policy settings.
 TEST_F(ConfigurationPolicyReaderTest, SetIntegerValue) {
-  provider_.AddMandatoryPolicy(key::kRestoreOnStartup,
-                               Value::CreateIntegerValue(4));
-  provider_.AddRecommendedPolicy(key::kIncognitoModeAvailability,
-                                 Value::CreateIntegerValue(2));
+  policy_.Set(key::kRestoreOnStartup, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+              Value::CreateIntegerValue(4));
+  policy_.Set(key::kIncognitoModeAvailability, POLICY_LEVEL_RECOMMENDED,
+              POLICY_SCOPE_USER, Value::CreateIntegerValue(2));
   reader_->OnUpdatePolicy(&provider_);
   scoped_ptr<DictionaryValue> dict(
       CreateDictionary(key::kRestoreOnStartup, Value::CreateIntegerValue(4)));
   scoped_ptr<DictionaryValue> result(
       reader_->GetPolicyStatus(key::kRestoreOnStartup));
   EXPECT_TRUE(dict->Equals(result.get()));
 
   dict.reset(CreateDictionary(key::kIncognitoModeAvailability,
                               Value::CreateIntegerValue(2)));
   dict->SetString(
@@ skipping 168 matching lines @@
                            cases[i].name != NULL,
                            cases[i].level);
         EXPECT_TRUE(dict->Equals(status_dict));
         break;
       }
     }
   }
 }
 
 } // namespace policy