Added a SchemaMap.

components/policy/core/common/schema_unittest.cc

 // Copyright 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 "components/policy/core/common/schema.h"
 
 #include "components/policy/core/common/schema_internal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 namespace {
 
-#define OBJECT_TYPE "\"type\":\"object\""
+const char kTestSchema[] =
+    "{"
+    "  \"type\": \"object\","
+    "  \"properties\": {"
+    "    \"Boolean\": { \"type\": \"boolean\" },"
+    "    \"Integer\": { \"type\": \"integer\" },"
+    "    \"Null\": { \"type\": \"null\" },"
+    "    \"Number\": { \"type\": \"number\" },"
+    "    \"String\": { \"type\": \"string\" },"
+    "    \"Array\": {"
+    "      \"type\": \"array\","
+    "      \"items\": { \"type\": \"string\" }"
+    "    },"
+    "    \"ArrayOfObjects\": {"
+    "      \"type\": \"array\","
+    "      \"items\": {"
+    "        \"type\": \"object\","
+    "        \"properties\": {"
+    "          \"one\": { \"type\": \"string\" },"
+    "          \"two\": { \"type\": \"integer\" }"
+    "        }"
+    "      }"
+    "    },"
+    "    \"ArrayOfArray\": {"
+    "      \"type\": \"array\","
+    "      \"items\": {"
+    "        \"type\": \"array\","
+    "        \"items\": { \"type\": \"string\" }"
+    "      }"
+    "    },"
+    "    \"Object\": {"
+    "      \"type\": \"object\","
+    "      \"properties\": {"
+    "        \"one\": { \"type\": \"boolean\" },"
+    "        \"two\": { \"type\": \"integer\" }"
+    "      },"
+    "      \"additionalProperties\": { \"type\": \"string\" }"
+    "    }"
+    "  }"
+    "}";
 
 bool ParseFails(const std::string& content) {
   std::string error;
   Schema schema = Schema::Parse(content, &error);
   if (schema.valid())
     return false;
   EXPECT_FALSE(error.empty());
   return true;
 }
 
 }  // namespace
 
 TEST(SchemaTest, MinimalSchema) {
-  EXPECT_FALSE(ParseFails(
-      "{"
-        OBJECT_TYPE
-      "}"));
+  EXPECT_FALSE(ParseFails("{ \"type\": \"object\" }"));
 }
 
 TEST(SchemaTest, InvalidSchemas) {
   EXPECT_TRUE(ParseFails(""));
   EXPECT_TRUE(ParseFails("omg"));
   EXPECT_TRUE(ParseFails("\"omg\""));
   EXPECT_TRUE(ParseFails("123"));
   EXPECT_TRUE(ParseFails("[]"));
   EXPECT_TRUE(ParseFails("null"));
   EXPECT_TRUE(ParseFails("{}"));
 
   EXPECT_TRUE(ParseFails(
       "{"
-        OBJECT_TYPE ","
+      "  \"type\": \"object\","
         "\"additionalProperties\": { \"type\":\"object\" }"
       "}"));
 
   EXPECT_TRUE(ParseFails(
       "{"
-        OBJECT_TYPE ","
-        "\"patternProperties\": { \"a+b*\": { \"type\": \"object\" } }"
+      "  \"type\": \"object\","
+      "  \"patternProperties\": { \"a+b*\": { \"type\": \"object\" } }"
       "}"));
 
   EXPECT_TRUE(ParseFails(
       "{"
-        OBJECT_TYPE ","
-        "\"properties\": { \"Policy\": { \"type\": \"bogus\" } }"
+      "  \"type\": \"object\","
+      "  \"properties\": { \"Policy\": { \"type\": \"bogus\" } }"
       "}"));
 
   EXPECT_TRUE(ParseFails(
       "{"
-        OBJECT_TYPE ","
-        "\"properties\": { \"Policy\": { \"type\": [\"string\", \"number\"] } }"
+      "  \"type\": \"object\","
+      "  \"properties\": { \"Policy\": { \"type\": [\"string\", \"number\"] } }"
       "}"));
 
   EXPECT_TRUE(ParseFails(
       "{"
-        OBJECT_TYPE ","
-        "\"properties\": { \"Policy\": { \"type\": \"any\" } }"
+      "  \"type\": \"object\","
+      "  \"properties\": { \"Policy\": { \"type\": \"any\" } }"
       "}"));
 }
 
 TEST(SchemaTest, Ownership) {
   std::string error;
   Schema schema = Schema::Parse(
       "{"
-        OBJECT_TYPE ","
-        "\"properties\": {"
-          "\"sub\": {"
-            "\"type\": \"object\","
-            "\"properties\": {"
-              "\"subsub\": { \"type\": \"string\" }"
-            "}"
-          "}"
-        "}"
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"sub\": {"
+      "      \"type\": \"object\","
+      "      \"properties\": {"
+      "        \"subsub\": { \"type\": \"string\" }"
+      "      }"
+      "    }"
+      "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   schema = schema.GetKnownProperty("sub");
   ASSERT_TRUE(schema.valid());
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   {
     Schema::Iterator it = schema.GetPropertiesIterator();
     ASSERT_FALSE(it.IsAtEnd());
     EXPECT_STREQ("subsub", it.key());
 
     schema = it.schema();
     it.Advance();
     EXPECT_TRUE(it.IsAtEnd());
   }
 
   ASSERT_TRUE(schema.valid());
   EXPECT_EQ(base::Value::TYPE_STRING, schema.type());
 
   // This test shouldn't leak nor use invalid memory.
 }
 
 TEST(SchemaTest, ValidSchema) {
   std::string error;
-  Schema schema = Schema::Parse(
-      "{"
-        OBJECT_TYPE ","
-        "\"properties\": {"
-        "  \"Boolean\": { \"type\": \"boolean\" },"
-        "  \"Integer\": { \"type\": \"integer\" },"
-        "  \"Null\": { \"type\": \"null\" },"
-        "  \"Number\": { \"type\": \"number\" },"
-        "  \"String\": { \"type\": \"string\" },"
-        "  \"Array\": {"
-        "    \"type\": \"array\","
-        "    \"items\": { \"type\": \"string\" }"
-        "  },"
-        "  \"ArrayOfObjects\": {"
-        "    \"type\": \"array\","
-        "    \"items\": {"
-        "      \"type\": \"object\","
-        "      \"properties\": {"
-        "        \"one\": { \"type\": \"string\" },"
-        "        \"two\": { \"type\": \"integer\" }"
-        "      }"
-        "    }"
-        "  },"
-        "  \"ArrayOfArray\": {"
-        "    \"type\": \"array\","
-        "    \"items\": {"
-        "      \"type\": \"array\","
-        "      \"items\": { \"type\": \"string\" }"
-        "    }"
-        "  },"
-        "  \"Object\": {"
-        "    \"type\": \"object\","
-        "    \"properties\": {"
-        "      \"one\": { \"type\": \"boolean\" },"
-        "      \"two\": { \"type\": \"integer\" }"
-        "    },"
-        "    \"additionalProperties\": { \"type\": \"string\" }"
-        "  }"
-        "}"
-      "}", &error);
+  Schema schema = Schema::Parse(kTestSchema, &error);
   ASSERT_TRUE(schema.valid()) << error;
 
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
   EXPECT_FALSE(schema.GetProperty("invalid").valid());
 
   Schema sub = schema.GetProperty("Boolean");
   ASSERT_TRUE(sub.valid());
   EXPECT_EQ(base::Value::TYPE_BOOLEAN, sub.type());
 
   sub = schema.GetProperty("Integer");
@@ skipping 78 matching lines @@
     ASSERT_TRUE(it.schema().valid());
     EXPECT_EQ(kExpectedProperties[i].expected_type, it.schema().type());
     it.Advance();
   }
   EXPECT_TRUE(it.IsAtEnd());
 }
 
 TEST(SchemaTest, Lookups) {
   std::string error;
 
-  Schema schema = Schema::Parse(
-      "{"
-        OBJECT_TYPE
-      "}", &error);
+  Schema schema = Schema::Parse("{ \"type\": \"object\" }", &error);
   ASSERT_TRUE(schema.valid()) << error;
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   // This empty schema should never find named properties.
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
   EXPECT_TRUE(schema.GetPropertiesIterator().IsAtEnd());
 
   schema = Schema::Parse(
       "{"
-        OBJECT_TYPE ","
-        "\"properties\": {"
-        "  \"Boolean\": { \"type\": \"boolean\" }"
-        "}"
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"Boolean\": { \"type\": \"boolean\" }"
+      "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
   EXPECT_TRUE(schema.GetKnownProperty("Boolean").valid());
 
   schema = Schema::Parse(
       "{"
-        OBJECT_TYPE ","
-        "\"properties\": {"
-          "  \"bb\" : { \"type\": \"null\" },"
-          "  \"aa\" : { \"type\": \"boolean\" },"
-          "  \"abab\" : { \"type\": \"string\" },"
-          "  \"ab\" : { \"type\": \"number\" },"
-          "  \"aba\" : { \"type\": \"integer\" }"
-        "}"
+      "  \"type\": \"object\","
+      "  \"properties\": {"
+      "    \"bb\" : { \"type\": \"null\" },"
+      "    \"aa\" : { \"type\": \"boolean\" },"
+      "    \"abab\" : { \"type\": \"string\" },"
+      "    \"ab\" : { \"type\": \"number\" },"
+      "    \"aba\" : { \"type\": \"integer\" }"
+      "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
 
   struct {
     const char* expected_key;
     base::Value::Type expected_type;
@@ skipping 80 matching lines @@
   ASSERT_TRUE(sub.valid());
   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
   Schema subsub = sub.GetItems();
   ASSERT_TRUE(subsub.valid());
   ASSERT_EQ(base::Value::TYPE_LIST, subsub.type());
   Schema subsubsub = subsub.GetItems();
   ASSERT_TRUE(subsubsub.valid());
   ASSERT_EQ(base::Value::TYPE_STRING, subsubsub.type());
 }
 
+TEST(SchemaTest, Validate) {
+  std::string error;
+  Schema schema = Schema::Parse(kTestSchema, &error);
+  ASSERT_TRUE(schema.valid()) << error;
+
+  base::DictionaryValue bundle;
+  EXPECT_TRUE(schema.Validate(bundle));
+
+  // Wrong type, expected integer.
+  bundle.SetBoolean("Integer", true);
+  EXPECT_FALSE(schema.Validate(bundle));
+
+  // Wrong type, expected list of strings.
+  {
+    bundle.Clear();
+    base::ListValue list;
+    list.AppendInteger(1);
+    bundle.Set("Array", list.DeepCopy());
+    EXPECT_FALSE(schema.Validate(bundle));
+  }
+
+  // Wrong type in a sub-object.
+  {
+    bundle.Clear();
+    base::DictionaryValue dict;
+    dict.SetString("one", "one");
+    bundle.Set("Object", dict.DeepCopy());
+    EXPECT_FALSE(schema.Validate(bundle));
+  }
+
+  // Unknown name.
+  bundle.Clear();
+  bundle.SetBoolean("Unknown", true);
+  EXPECT_FALSE(schema.Validate(bundle));
+
+  // All of these will be valid.
+  bundle.Clear();
+  bundle.SetBoolean("Boolean", true);
+  bundle.SetInteger("Integer", 123);
+  bundle.Set("Null", base::Value::CreateNullValue());
+  bundle.Set("Number", base::Value::CreateDoubleValue(3.14));
+  bundle.SetString("String", "omg");
+
+  {
+    base::ListValue list;
+    list.AppendString("a string");
+    list.AppendString("another string");
+    bundle.Set("Array", list.DeepCopy());
+  }
+
+  {
+    base::DictionaryValue dict;
+    dict.SetString("one", "string");
+    dict.SetInteger("two", 2);
+    base::ListValue list;
+    list.Append(dict.DeepCopy());
+    list.Append(dict.DeepCopy());
+    bundle.Set("ArrayOfObjects", list.DeepCopy());
+  }
+
+  {
+    base::ListValue list;
+    list.AppendString("a string");
+    list.AppendString("another string");
+    base::ListValue listlist;
+    listlist.Append(list.DeepCopy());
+    listlist.Append(list.DeepCopy());
+    bundle.Set("ArrayOfArray", listlist.DeepCopy());
+  }
+
+  {
+    base::DictionaryValue dict;
+    dict.SetBoolean("one", true);
+    dict.SetInteger("two", 2);
+    dict.SetString("additionally", "a string");
+    dict.SetString("and also", "another string");
+    bundle.Set("Object", dict.DeepCopy());
+  }
+
+  EXPECT_TRUE(schema.Validate(bundle));
+
+  bundle.SetString("boom", "bang");
+  EXPECT_FALSE(schema.Validate(bundle));
+}
+
 }  // namespace policy