Generate the Chrome policy schema at compile time.

chrome/browser/policy/policy_domain_descriptor_unittest.cc

 // Copyright (c) 2013 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/policy_domain_descriptor.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/external_data_manager.h"
 #include "chrome/browser/policy/policy_bundle.h"
 #include "chrome/browser/policy/policy_map.h"
+#include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 class PolicyDomainDescriptorTest : public testing::Test {
  protected:
   scoped_ptr<ExternalDataFetcher> CreateExternalDataFetcher() const;
 };
 
 scoped_ptr<ExternalDataFetcher>
@@ skipping 182 matching lines @@
   bundle.Get(unknown_ns).Set("Surprise",
                              POLICY_LEVEL_MANDATORY,
                              POLICY_SCOPE_USER,
                              base::Value::CreateStringValue("value 5"),
                              NULL);
 
   descriptor->FilterBundle(&bundle);
   EXPECT_TRUE(bundle.Equals(expected_bundle));
 }
 
+TEST_F(PolicyDomainDescriptorTest, ChromePolicyDomainDescriptor) {
+  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
+      POLICY_DOMAIN_CHROME);
+  descriptor->RegisterComponent("", SchemaOwner::Wrap(GetChromeSchemaData()));
+
+  EXPECT_EQ(POLICY_DOMAIN_CHROME, descriptor->domain());
+  ASSERT_EQ(1u, descriptor->components().size());
+  ASSERT_EQ("", descriptor->components().begin()->first);
+  Schema schema = descriptor->components().begin()->second;
+  ASSERT_TRUE(schema.valid());
+
+  EXPECT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+
+  Schema subschema = schema.GetAdditionalProperties();
+  EXPECT_FALSE(subschema.valid());
+
+  subschema = schema.GetProperty("no such policy exists");
+  EXPECT_FALSE(subschema.valid());
+
+  subschema = schema.GetProperty(key::kAlternateErrorPagesEnabled);
+  ASSERT_TRUE(subschema.valid());
+  EXPECT_EQ(base::Value::TYPE_BOOLEAN, subschema.type());
+
+  subschema = schema.GetProperty(key::kIncognitoModeAvailability);
+  ASSERT_TRUE(subschema.valid());
+  EXPECT_EQ(base::Value::TYPE_INTEGER, subschema.type());
+
+  subschema = schema.GetProperty(key::kProxyMode);
+  ASSERT_TRUE(subschema.valid());
+  EXPECT_EQ(base::Value::TYPE_STRING, subschema.type());
+
+  subschema = schema.GetProperty(key::kCookiesAllowedForUrls);
+  ASSERT_TRUE(subschema.valid());
+  EXPECT_EQ(base::Value::TYPE_LIST, subschema.type());
+  ASSERT_TRUE(subschema.GetItems().valid());
+  EXPECT_EQ(base::Value::TYPE_STRING, subschema.GetItems().type());
+
+  subschema = schema.GetProperty(key::kProxySettings);
+  ASSERT_TRUE(subschema.valid());
+  EXPECT_EQ(base::Value::TYPE_DICTIONARY, subschema.type());
+  EXPECT_FALSE(subschema.GetAdditionalProperties().valid());
+  EXPECT_FALSE(subschema.GetProperty("no such proxy key exists").valid());
+  ASSERT_TRUE(subschema.GetProperty(key::kProxyMode).valid());
+  ASSERT_TRUE(subschema.GetProperty(key::kProxyServer).valid());
+  ASSERT_TRUE(subschema.GetProperty(key::kProxyServerMode).valid());
+  ASSERT_TRUE(subschema.GetProperty(key::kProxyPacUrl).valid());
+  ASSERT_TRUE(subschema.GetProperty(key::kProxyBypassList).valid());
+
+  // The properties are iterated in order.
+  const char* kExpectedProperties[] = {
+    key::kProxyBypassList,
+    key::kProxyMode,
+    key::kProxyPacUrl,
+    key::kProxyServer,
+    key::kProxyServerMode,
+    NULL,
+  };
+  const char** next = kExpectedProperties;
+  for (Schema::Iterator it(subschema.GetPropertiesIterator());
+       !it.IsAtEnd(); it.Advance(), ++next) {
+    ASSERT_TRUE(*next != NULL);
+    EXPECT_STREQ(*next, it.key());
+    ASSERT_TRUE(it.schema().valid());
+    EXPECT_EQ(base::Value::TYPE_STRING, it.schema().type());
+  }
+  EXPECT_TRUE(*next == NULL);
+}
+
 }  // namespace policy