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]"

[Joao da Silva, 2014/01/20 20:22:18]

This enumeration will get converted into a range (which is a good test to have).

Add another integer enum with a gap in the range, so that it doesn't get
converted to a range and test that too. For example, [ 10, 20, 30 ]

[binjin, 2014/01/21 16:12:07]

Done.

+    "    },"
+    "    \"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("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 },
+    { "IntegerWithEnums", 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.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.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);
 

[Joao da Silva, 2014/01/20 20:22:18]

After adding the integer enum with gaps, test values here that are outside the
range and also between the gaps. For example, 0, 9, 10 (true), 11, 19, 20
(true), 21, 29, 30(true), 31, 100

[binjin, 2014/01/21 16:12:07]

Done.

 }
 TEST(SchemaTest, InvalidReferences) {
   // References to undeclared schemas fail.
   EXPECT_TRUE(ParseFails(
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"name\": { \"$ref\": \"undeclared\" }"
       "  }"
       "}"));
@@ skipping 240 matching lines @@
 
   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
       "{"
       "  \"type\": \"integer\","
       "  \"minimum\": 10,"
       "  \"maximum\": 20"
       "}")));
 }
 
 }  // namespace policy