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 43 matching lines @@
 
 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) {
+  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 233 matching lines @@
     { "abab",   base::Value::TYPE_STRING },
     { "bb",     base::Value::TYPE_NULL },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kExpectedKeys); ++i) {
     Schema sub = schema.GetKnownProperty(kExpectedKeys[i].expected_key);
     ASSERT_TRUE(sub.valid());
     EXPECT_EQ(kExpectedKeys[i].expected_type, sub.type());
   }
 }
 
 TEST(SchemaTest, Wrap) {

[Joao da Silva, 2014/01/16 10:56:34]

Add enums and ranges to this test too

[binjin, 2014/01/17 14:29:01]

Done.

   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.
   };
 
@@ skipping 347 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