Policy providers all get a SchemaRegistry to work with.

chrome/browser/policy/configuration_policy_provider_test.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 "chrome/browser/policy/configuration_policy_provider_test.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/values.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::Mock;
 using ::testing::_;
 
 namespace policy {
 
+const char kTestChromeSchema[] =
+    "{"
+    "  \"type\": \"object\","
+    "  \"properties\": {"
+    "    \"StringPolicy\": { \"type\": \"string\" },"
+    "    \"BooleanPolicy\": { \"type\": \"boolean\" },"
+    "    \"IntegerPolicy\": { \"type\": \"integer\" },"
+    "    \"StringListPolicy\": {"
+    "      \"type\": \"array\","
+    "      \"items\": { \"type\": \"string\" }"
+    "    },"
+    "    \"DictionaryPolicy\": {"
+    "      \"type\": \"object\","
+    "      \"properties\": {"
+    "        \"bool\": { \"type\": \"boolean\" },"
+    "        \"double\": { \"type\": \"number\" },"
+    "        \"int\": { \"type\": \"integer\" },"
+    "        \"string\": { \"type\": \"string\" },"
+    "        \"array\": {"
+    "          \"type\": \"array\","
+    "          \"items\": { \"type\": \"string\" }"
+    "        },"
+    "        \"dictionary\": {"
+    "          \"type\": \"object\","
+    "          \"properties\": {"
+    "            \"sub\": { \"type\": \"string\" },"
+    "            \"sublist\": {"
+    "              \"type\": \"array\","
+    "              \"items\": {"
+    "                \"type\": \"object\","
+    "                \"properties\": {"
+    "                  \"aaa\": { \"type\": \"integer\" },"
+    "                  \"bbb\": { \"type\": \"integer\" },"
+    "                  \"ccc\": { \"type\": \"string\" },"
+    "                  \"ddd\": { \"type\": \"string\" }"
+    "                }"
+    "              }"
+    "            }"
+    "          }"
+    "        },"
+    "        \"list\": {"
+    "          \"type\": \"array\","
+    "          \"items\": {"
+    "            \"type\": \"object\","
+    "            \"properties\": {"
+    "              \"subdictindex\": { \"type\": \"integer\" },"
+    "              \"subdict\": {"
+    "                \"type\": \"object\","
+    "                \"properties\": {"
+    "                  \"bool\": { \"type\": \"boolean\" },"
+    "                  \"double\": { \"type\": \"number\" },"
+    "                  \"int\": { \"type\": \"integer\" },"
+    "                  \"string\": { \"type\": \"string\" }"
+    "                }"
+    "              }"
+    "            }"
+    "          }"
+    "        },"
+    "        \"dict\": {"
+    "          \"type\": \"object\","
+    "          \"properties\": {"
+    "            \"bool\": { \"type\": \"boolean\" },"
+    "            \"double\": { \"type\": \"number\" },"
+    "            \"int\": { \"type\": \"integer\" },"
+    "            \"string\": { \"type\": \"string\" },"
+    "            \"list\": {"
+    "              \"type\": \"array\","
+    "              \"items\": {"
+    "                \"type\": \"object\","
+    "                \"properties\": {"
+    "                  \"subdictindex\": { \"type\": \"integer\" },"
+    "                  \"subdict\": {"
+    "                    \"type\": \"object\","
+    "                    \"properties\": {"
+    "                      \"bool\": { \"type\": \"boolean\" },"
+    "                      \"double\": { \"type\": \"number\" },"
+    "                      \"int\": { \"type\": \"integer\" },"
+    "                      \"string\": { \"type\": \"string\" }"
+    "                    }"
+    "                  }"
+    "                }"
+    "              }"
+    "            }"
+    "          }"
+    "        }"
+    "      }"
+    "    }"
+    "  }"
+    "}";
+
 namespace test_policy_definitions {
 
 const char kKeyString[] = "StringPolicy";
 const char kKeyBoolean[] = "BooleanPolicy";
 const char kKeyInteger[] = "IntegerPolicy";
 const char kKeyStringList[] = "StringListPolicy";
 const char kKeyDictionary[] = "DictionaryPolicy";
 
 static const PolicyDefinitionList::Entry kEntries[] = {
   { kKeyString,     base::Value::TYPE_STRING },
   { kKeyBoolean,    base::Value::TYPE_BOOLEAN },
   { kKeyInteger,    base::Value::TYPE_INTEGER },
   { kKeyStringList, base::Value::TYPE_LIST },
   { kKeyDictionary, base::Value::TYPE_DICTIONARY },
 };
 
 const PolicyDefinitionList kList = {
   kEntries, kEntries + arraysize(kEntries)
 };
 
 }  // namespace test_policy_definitions
 
 PolicyTestBase::PolicyTestBase() {}
 
 PolicyTestBase::~PolicyTestBase() {}
 
+void PolicyTestBase::SetUp() {
+  std::string error;
+  chrome_schema_ = Schema::Parse(kTestChromeSchema, &error);
+  ASSERT_TRUE(chrome_schema_.valid()) << error;
+  schema_registry_.RegisterComponent(PolicyNamespace(POLICY_DOMAIN_CHROME, ""),

[bartfab (slow), 2013/11/05 15:53:04]

Nit: #include "components/policy/core/common/policy_namespace.h"

[Joao da Silva, 2013/11/07 13:15:00]

Done.

+                                     chrome_schema_);
+}
+
 void PolicyTestBase::TearDown() {
   loop_.RunUntilIdle();
 }
 
 PolicyProviderTestHarness::PolicyProviderTestHarness(PolicyLevel level,
                                                      PolicyScope scope)
     : level_(level), scope_(scope) {}
 
 PolicyProviderTestHarness::~PolicyProviderTestHarness() {}
 
@@ skipping 13 matching lines @@
 ConfigurationPolicyProviderTest::ConfigurationPolicyProviderTest() {}
 
 ConfigurationPolicyProviderTest::~ConfigurationPolicyProviderTest() {}
 
 void ConfigurationPolicyProviderTest::SetUp() {
   PolicyTestBase::SetUp();
 
   test_harness_.reset((*GetParam())());
   test_harness_->SetUp();
 
+  Schema extension_schema =
+      chrome_schema_.GetKnownProperty(test_policy_definitions::kKeyDictionary);
+  ASSERT_TRUE(extension_schema.valid());
+  schema_registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
+                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+      extension_schema);
+  schema_registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
+                      "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
+      extension_schema);
+  schema_registry_.RegisterComponent(
+      PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
+                      "cccccccccccccccccccccccccccccccc"),
+      extension_schema);
+
   provider_.reset(test_harness_->CreateProvider(
-      loop_.message_loop_proxy(), &test_policy_definitions::kList));
-  provider_->Init();
+      &schema_registry_,
+      loop_.message_loop_proxy(),
+      &test_policy_definitions::kList));
+  provider_->Init(&schema_registry_);
   // Some providers do a reload on init. Make sure any notifications generated
   // are fired now.
   loop_.RunUntilIdle();
 
   const PolicyBundle kEmptyBundle;
   EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 void ConfigurationPolicyProviderTest::TearDown() {
   // Give providers the chance to clean up after themselves on the file thread.
@@ skipping 69 matching lines @@
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringListPolicy,
                         base::Unretained(test_harness_.get()),
                         test_policy_definitions::kKeyStringList,
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, DictionaryValue) {
   base::DictionaryValue expected_value;
   expected_value.SetBoolean("bool", true);
+  expected_value.SetDouble("double", 123.456);
   expected_value.SetInteger("int", 123);
-  expected_value.SetString("str", "omg");
+  expected_value.SetString("string", "omg");
 
   base::ListValue* list = new base::ListValue();
   list->Set(0U, base::Value::CreateStringValue("first"));
   list->Set(1U, base::Value::CreateStringValue("second"));
-  expected_value.Set("list", list);
+  expected_value.Set("array", list);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("sub", "value");
   list = new base::ListValue();
   base::DictionaryValue* sub = new base::DictionaryValue();
   sub->SetInteger("aaa", 111);
   sub->SetInteger("bbb", 222);
   list->Append(sub);
   sub = new base::DictionaryValue();
   sub->SetString("ccc", "333");
   sub->SetString("ddd", "444");
   list->Append(sub);
   dict->Set("sublist", list);
-  expected_value.Set("dict", dict);
+  expected_value.Set("dictionary", dict);
 
   CheckValue(test_policy_definitions::kKeyDictionary,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallDictionaryPolicy,
                         base::Unretained(test_harness_.get()),
                         test_policy_definitions::kKeyDictionary,
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, RefreshPolicies) {
@@ skipping 70 matching lines @@
     Configuration3rdPartyPolicyProviderTest() {}
 
 Configuration3rdPartyPolicyProviderTest::
     ~Configuration3rdPartyPolicyProviderTest() {}
 
 TEST_P(Configuration3rdPartyPolicyProviderTest, Load3rdParty) {
   base::DictionaryValue policy_dict;
   policy_dict.SetBoolean("bool", true);
   policy_dict.SetDouble("double", 123.456);
   policy_dict.SetInteger("int", 789);
-  policy_dict.SetString("str", "string value");
+  policy_dict.SetString("string", "string value");
 
   base::ListValue* list = new base::ListValue();
   for (int i = 0; i < 2; ++i) {
     base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetInteger("subdictindex", i);
     dict->Set("subdict", policy_dict.DeepCopy());
     list->Append(dict);
   }
   policy_dict.Set("list", list);
   policy_dict.Set("dict", policy_dict.DeepCopy());
@@ skipping 33 matching lines @@
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
       .CopyFrom(expected_policy);
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .CopyFrom(expected_policy);
   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 }
 
 }  // namespace policy