Add additional restriction to policy schema internal (part1)

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 {
@@ skipping 30 matching lines @@
     "        \"items\": { \"type\": \"string\" }"
     "      }"
     "    },"
     "    \"Object\": {"
     "      \"type\": \"object\","
     "      \"properties\": {"
     "        \"one\": { \"type\": \"boolean\" },"
     "        \"two\": { \"type\": \"integer\" }"
     "      },"
     "      \"additionalProperties\": { \"type\": \"string\" }"
     "    }"

[Joao da Silva, 2014/01/20 10:49:10]

Add integer with enum, integer with range and string with enums to this test
schema.

Then the SchemaTest.Validate() test below will not enforce it but will verify
that enums and ranges don't break the validation of existing schemas.

[binjin, 2014/01/20 14:09:23]

I prefer to leave this to the coming CL as work on Validate() is part of that
CL.

     "  }"
     "}";
 
 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;
 }
 
+std::string schemaObjectWrapper(const std::string &subschema) {

[Joao da Silva, 2014/01/20 10:49:10]

SchemaObjectWrapper

Also, put the & next to the type:

const std::string& subschema

[binjin, 2014/01/20 14:09:23]

Done.

+  return "{"
+         "  \"type\": \"object\","
+         "  \"properties\": {"
+         "    \"SomePropertyName\":" + subschema +
+         "  }"
+         "}";
+}
+
 }  // namespace
 
 TEST(SchemaTest, MinimalSchema) {
   EXPECT_FALSE(ParseFails("{ \"type\": \"object\" }"));
 }
 
 TEST(SchemaTest, InvalidSchemas) {
   EXPECT_TRUE(ParseFails(""));
   EXPECT_TRUE(ParseFails("omg"));
   EXPECT_TRUE(ParseFails("\"omg\""));
@@ skipping 242 matching lines @@
 
 TEST(SchemaTest, Wrap) {
   const internal::SchemaNode kSchemas[] = {
     { base::Value::TYPE_DICTIONARY,   0 },    // 0: root node
     { base::Value::TYPE_BOOLEAN,      -1 },   // 1
     { base::Value::TYPE_INTEGER,      -1 },   // 2
     { base::Value::TYPE_DOUBLE,       -1 },   // 3
     { base::Value::TYPE_STRING,       -1 },   // 4
     { base::Value::TYPE_LIST,         4 },    // 5: list of strings.
     { base::Value::TYPE_LIST,         5 },    // 6: list of lists of strings.
+    { base::Value::TYPE_INTEGER,      0 },    // 7: integer enumerations.
+    { base::Value::TYPE_INTEGER,      1 },    // 8: ranged integers.
+    { base::Value::TYPE_STRING,       2 },    // 9: string enumerations.
   };
 
   const internal::PropertyNode kPropertyNodes[] = {
-    { "Boolean",  1 },
-    { "Integer",  2 },
-    { "Number",   3 },
-    { "String",   4 },
-    { "List",     5 },
+    { "Boolean",   1 },  // 0
+    { "Integer",   2 },  // 1
+    { "Number",    3 },  // 2
+    { "String",    4 },  // 3
+    { "List",      5 },  // 4
+    { "IntEnum",   7 },  // 5
+    { "RangedInt", 8 },  // 6
+    { "StrEnum",   9 }   // 7

[Joao da Silva, 2014/01/20 10:49:10]

Leave a comma after the last }

[binjin, 2014/01/20 14:09:23]

Done.

   };
 
   const internal::PropertiesNode kProperties[] = {
     // Properties 0 to 5 (exclusive) are known, from kPropertyNodes.
     // SchemaNode offset 6 is for additionalProperties (list of lists).
-    { 0, 5, 6 },
+    { 0, 8, 6 },

[Joao da Silva, 2014/01/20 10:49:10]

Update the comment: 0 to 8 (exclusive) are the known properties in
kPropertyNodes, and 6 is the addionalProperties node.

[binjin, 2014/01/20 14:09:23]

Done.

+  };
+
+  const internal::RestrictionNode kRestriction[] = {
+    {{0, 3}},  // [1, 2, 3]
+    {{5, 1}},  // minimum = 1, maximum = 5
+    {{0, 3}}   // ["one", "two", "three"]

[Joao da Silva, 2014/01/20 10:49:10]

Comma after last element

[binjin, 2014/01/20 14:09:23]

Done.

+  };
+
+  const int kIntEnums[] = {1, 2, 3};
+
+  const char* kStringEnums[] = {
+    "one",
+    "two",
+    "three"

[Joao da Silva, 2014/01/20 10:49:10]

Comma after last element

[binjin, 2014/01/20 14:09:23]

Done.

   };
 
   const internal::SchemaData kData = {
     kSchemas,
     kPropertyNodes,
     kProperties,
+    kRestriction,
+    kIntEnums,
+    kStringEnums

[Joao da Silva, 2014/01/20 10:49:10]

Comma after last element

[binjin, 2014/01/20 14:09:23]

Done.

   };
 
   Schema schema = Schema::Wrap(&kData);
   ASSERT_TRUE(schema.valid());
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   struct {
     const char* key;
     base::Value::Type type;
   } kExpectedProperties[] = {
     { "Boolean", base::Value::TYPE_BOOLEAN },
     { "Integer", base::Value::TYPE_INTEGER },
     { "Number", base::Value::TYPE_DOUBLE },
     { "String", base::Value::TYPE_STRING },
     { "List", base::Value::TYPE_LIST },
+    { "IntEnum", base::Value::TYPE_INTEGER },
+    { "RangedInt", base::Value::TYPE_INTEGER },
+    { "StrEnum", base::Value::TYPE_STRING }
   };
 
   Schema::Iterator it = schema.GetPropertiesIterator();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kExpectedProperties); ++i) {
     ASSERT_FALSE(it.IsAtEnd());
     EXPECT_STREQ(kExpectedProperties[i].key, it.key());
     Schema sub = it.schema();
     ASSERT_TRUE(sub.valid());
     EXPECT_EQ(kExpectedProperties[i].type, sub.type());
 
     if (sub.type() == base::Value::TYPE_LIST) {
-      ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
       Schema items = sub.GetItems();
       ASSERT_TRUE(items.valid());
       EXPECT_EQ(base::Value::TYPE_STRING, items.type());
     }
 
     it.Advance();
   }
   EXPECT_TRUE(it.IsAtEnd());
 
   Schema sub = schema.GetAdditionalProperties();
@@ skipping 292 matching lines @@
 
   Schema list = schema.GetKnownProperty("list");
   ASSERT_TRUE(list.valid());
   ASSERT_EQ(base::Value::TYPE_LIST, list.type());
 
   Schema items = list.GetItems();
   ASSERT_TRUE(items.valid());
   ASSERT_EQ(base::Value::TYPE_BOOLEAN, items.type());
 }
 
+TEST(SchemaTest, EnumerationRestriction) {
+  // Enum attribute is a list.
+  EXPECT_TRUE(ParseFails(schemaObjectWrapper(
+      "{"
+      "  \"type\": \"string\","
+      "  \"enum\": 12"
+      "}")));
+
+  // Empty enum attributes is not allowed.
+  EXPECT_TRUE(ParseFails(schemaObjectWrapper(
+      "{"
+      "  \"type\": \"integer\","
+      "  \"enum\": []"
+      "}")));
+
+  // Enum elements type should be same as stated.
+  EXPECT_TRUE(ParseFails(schemaObjectWrapper(
+      "{"
+      "  \"type\": \"string\","
+      "  \"enum\": [1, 2, 3]"
+      "}")));
+
+  EXPECT_FALSE(ParseFails(schemaObjectWrapper(
+      "{"
+      "  \"type\": \"integer\","
+      "  \"enum\": [1, 2, 3]"
+      "}")));
+
+  EXPECT_FALSE(ParseFails(schemaObjectWrapper(
+      "{"
+      "  \"type\": \"string\","
+      "  \"enum\": [\"1\", \"2\", \"3\"]"
+      "}")));
+}
+
+TEST(SchemaTest, RangedRestriction) {
+  EXPECT_TRUE(ParseFails(schemaObjectWrapper(
+      "{"
+      "  \"type\": \"integer\","
+      "  \"minimum\": 10,"
+      "  \"maximum\": 5"
+      "}")));
+
+  EXPECT_FALSE(ParseFails(schemaObjectWrapper(
+      "{"
+      "  \"type\": \"integer\","
+      "  \"minimum\": 10,"
+      "  \"maximum\": 20"
+      "}")));
+}
 
 }  // namespace policy