Add additional restriction to policy schema internal (part2)

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\" }"
+    "    },"
+    "    \"IntegerWithEnums\": {"
+    "      \"type\": \"integer\","
+    "      \"enum\": [1, 2, 3]"
+    "    },"
+    "    \"IntegerWithEnumsGaps\": {"
+    "      \"type\": \"integer\","
+    "      \"enum\": [10, 20, 30]"
+    "    },"
+    "    \"StringWithEnums\": {"
+    "      \"type\": \"string\","
+    "      \"enum\": [\"one\", \"two\", \"three\"]"
+    "    },"
+    "    \"IntegerWithRange\": {"
+    "      \"type\": \"integer\","
+    "      \"minimum\": 1,"
+    "      \"maximum\": 3"
     "    }"
     "  }"
     "}";
 
 bool ParseFails(const std::string& content) {
   std::string error;
   Schema schema = Schema::Parse(content, &error);
   if (schema.valid())
     return false;
   EXPECT_FALSE(error.empty());
@@ skipping 170 matching lines @@
   subsub = sub.GetProperty("one");
   ASSERT_TRUE(subsub.valid());
   EXPECT_EQ(base::Value::TYPE_BOOLEAN, subsub.type());
   subsub = sub.GetProperty("two");
   ASSERT_TRUE(subsub.valid());
   EXPECT_EQ(base::Value::TYPE_INTEGER, subsub.type());
   subsub = sub.GetProperty("undeclared");
   ASSERT_TRUE(subsub.valid());
   EXPECT_EQ(base::Value::TYPE_STRING, subsub.type());
 
+  sub = schema.GetProperty("IntegerWithEnums");
+  ASSERT_TRUE(sub.valid());
+  ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
+
+  sub = schema.GetProperty("IntegerWithEnumsGaps");
+  ASSERT_TRUE(sub.valid());
+  ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
+
+  sub = schema.GetProperty("StringWithEnums");
+  ASSERT_TRUE(sub.valid());
+  ASSERT_EQ(base::Value::TYPE_STRING, sub.type());
+
+  sub = schema.GetProperty("IntegerWithRange");
+  ASSERT_TRUE(sub.valid());
+  ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
+
   struct {
     const char* expected_key;
     base::Value::Type expected_type;
   } kExpectedProperties[] = {
-    { "Array",            base::Value::TYPE_LIST },
-    { "ArrayOfArray",     base::Value::TYPE_LIST },
-    { "ArrayOfObjects",   base::Value::TYPE_LIST },
-    { "Boolean",          base::Value::TYPE_BOOLEAN },
-    { "Integer",          base::Value::TYPE_INTEGER },
-    { "Null",             base::Value::TYPE_NULL },
-    { "Number",           base::Value::TYPE_DOUBLE },
-    { "Object",           base::Value::TYPE_DICTIONARY },
-    { "String",           base::Value::TYPE_STRING },
+    { "Array",                base::Value::TYPE_LIST },
+    { "ArrayOfArray",         base::Value::TYPE_LIST },
+    { "ArrayOfObjects",       base::Value::TYPE_LIST },
+    { "Boolean",              base::Value::TYPE_BOOLEAN },
+    { "Integer",              base::Value::TYPE_INTEGER },
+    { "IntegerWithEnums",     base::Value::TYPE_INTEGER },
+    { "IntegerWithEnumsGaps", base::Value::TYPE_INTEGER },
+    { "IntegerWithRange",     base::Value::TYPE_INTEGER },
+    { "Null",                 base::Value::TYPE_NULL },
+    { "Number",               base::Value::TYPE_DOUBLE },
+    { "Object",               base::Value::TYPE_DICTIONARY },
+    { "String",               base::Value::TYPE_STRING },
+    { "StringWithEnums",      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].expected_key, it.key());
     ASSERT_TRUE(it.schema().valid());
     EXPECT_EQ(kExpectedProperties[i].expected_type, it.schema().type());
     it.Advance();
   }
   EXPECT_TRUE(it.IsAtEnd());
@@ skipping 232 matching lines @@
 
   {
     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());
   }
 
+  bundle.SetInteger("IntegerWithEnums", 1);
+  bundle.SetInteger("IntegerWithEnumsGaps", 20);
+  bundle.SetString("StringWithEnums", "two");
+  bundle.SetInteger("IntegerWithRange", 3);
+
   EXPECT_TRUE(schema.Validate(bundle));
 
   bundle.SetString("boom", "bang");
   EXPECT_FALSE(schema.Validate(bundle));
+  bundle.Remove("boom", NULL);
+
+  bundle.SetInteger("IntegerWithEnums", 0);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnums", 1);
+
+  bundle.SetInteger("IntegerWithEnumsGaps", 0);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 9);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 10);
+  EXPECT_TRUE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 11);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 19);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 21);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 29);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 30);
+  EXPECT_TRUE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 31);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 100);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithEnumsGaps", 20);
+
+  bundle.SetString("StringWithEnums", "FOUR");
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetString("StringWithEnums", "two");
+
+  bundle.SetInteger("IntegerWithRange", 4);
+  EXPECT_FALSE(schema.Validate(bundle));
+  bundle.SetInteger("IntegerWithRange", 3);
 
 }
 TEST(SchemaTest, InvalidReferences) {
   // References to undeclared schemas fail.
   EXPECT_TRUE(ParseFails(
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"name\": { \"$ref\": \"undeclared\" }"
       "  }"
@@ skipping 241 matching lines @@
 
   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
       "{"
       "  \"type\": \"integer\","
       "  \"minimum\": 10,"
       "  \"maximum\": 20"
       "}")));
 }
 
 }  // namespace policy