From 7af5e1a7bd7df35c4b62e1020bd532c508e6d2e7 Mon Sep 17 00:00:00 2001 From: "asargent@chromium.org" Date: Tue, 19 Mar 2013 03:31:31 +0000 Subject: Move JSON schema validator code into its own directory in chrome/common Also add an OWNERS file there with some people who've worked on JSON schema in the extensions/apps system. BUG=none Review URL: https://chromiumcodereview.appspot.com/12886024 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@188940 0039d316-1c4b-4281-b951-d872f2087c98 --- chrome/common/json_schema/OWNERS | 5 + chrome/common/json_schema/json_schema_constants.cc | 34 ++ chrome/common/json_schema/json_schema_constants.h | 38 ++ chrome/common/json_schema/json_schema_validator.cc | 496 +++++++++++++++ chrome/common/json_schema/json_schema_validator.h | 225 +++++++ .../json_schema/json_schema_validator_unittest.cc | 52 ++ .../json_schema_validator_unittest_base.cc | 678 +++++++++++++++++++++ .../json_schema_validator_unittest_base.h | 63 ++ 8 files changed, 1591 insertions(+) create mode 100644 chrome/common/json_schema/OWNERS create mode 100644 chrome/common/json_schema/json_schema_constants.cc create mode 100644 chrome/common/json_schema/json_schema_constants.h create mode 100644 chrome/common/json_schema/json_schema_validator.cc create mode 100644 chrome/common/json_schema/json_schema_validator.h create mode 100644 chrome/common/json_schema/json_schema_validator_unittest.cc create mode 100644 chrome/common/json_schema/json_schema_validator_unittest_base.cc create mode 100644 chrome/common/json_schema/json_schema_validator_unittest_base.h (limited to 'chrome/common/json_schema') diff --git a/chrome/common/json_schema/OWNERS b/chrome/common/json_schema/OWNERS new file mode 100644 index 0000000..f7e95c9 --- /dev/null +++ b/chrome/common/json_schema/OWNERS @@ -0,0 +1,5 @@ +asargent@chromium.org +calamity@chromium.org +kalman@chromium.org +koz@chromium.org +mpcomplete@chromium.org diff --git a/chrome/common/json_schema/json_schema_constants.cc b/chrome/common/json_schema/json_schema_constants.cc new file mode 100644 index 0000000..cfdca28 --- /dev/null +++ b/chrome/common/json_schema/json_schema_constants.cc @@ -0,0 +1,34 @@ +// Copyright (c) 2012 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 "chrome/common/json_schema/json_schema_constants.h" + +namespace json_schema_constants { + +const char kAdditionalProperties[] = "additionalProperties"; +const char kAny[] = "any"; +const char kArray[] = "array"; +const char kBoolean[] = "boolean"; +const char kChoices[] = "choices"; +const char kEnum[] = "enum"; +const char kId[] = "id"; +const char kInteger[] = "integer"; +const char kItems[] = "items"; +const char kMaximum[] = "maximum"; +const char kMaxItems[] = "maxItems"; +const char kMaxLength[] = "maxLength"; +const char kMinimum[] = "minimum"; +const char kMinItems[] = "minItems"; +const char kMinLength[] = "minLength"; +const char kNull[] = "null"; +const char kNumber[] = "number"; +const char kObject[] = "object"; +const char kOptional[] = "optional"; +const char kPattern[] = "pattern"; +const char kProperties[] = "properties"; +const char kRef[] = "$ref"; +const char kString[] = "string"; +const char kType[] = "type"; + +} // namespace json_schema_constants diff --git a/chrome/common/json_schema/json_schema_constants.h b/chrome/common/json_schema/json_schema_constants.h new file mode 100644 index 0000000..fa4b80b --- /dev/null +++ b/chrome/common/json_schema/json_schema_constants.h @@ -0,0 +1,38 @@ +// Copyright (c) 2012 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. + +#ifndef CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_CONSTANTS_H_ +#define CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_CONSTANTS_H_ + +// These constants are shared by code that uses JSON schemas. +namespace json_schema_constants { + +extern const char kAdditionalProperties[]; +extern const char kAny[]; +extern const char kArray[]; +extern const char kBoolean[]; +extern const char kChoices[]; +extern const char kEnum[]; +extern const char kId[]; +extern const char kInteger[]; +extern const char kItems[]; +extern const char kMaximum[]; +extern const char kMaxItems[]; +extern const char kMaxLength[]; +extern const char kMinimum[]; +extern const char kMinItems[]; +extern const char kMinLength[]; +extern const char kNull[]; +extern const char kNumber[]; +extern const char kObject[]; +extern const char kOptional[]; +extern const char kPattern[]; +extern const char kProperties[]; +extern const char kRef[]; +extern const char kString[]; +extern const char kType[]; + +} // namespace json_schema_constants + +#endif // CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_CONSTANTS_H_ diff --git a/chrome/common/json_schema/json_schema_validator.cc b/chrome/common/json_schema/json_schema_validator.cc new file mode 100644 index 0000000..a303442 --- /dev/null +++ b/chrome/common/json_schema/json_schema_validator.cc @@ -0,0 +1,496 @@ +// Copyright (c) 2011 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 "chrome/common/json_schema/json_schema_validator.h" + +#include +#include + +#include "base/string_util.h" +#include "base/strings/string_number_conversions.h" +#include "base/values.h" +#include "chrome/common/json_schema/json_schema_constants.h" +#include "ui/base/l10n/l10n_util.h" + +namespace schema = json_schema_constants; + +namespace { + +double GetNumberValue(const Value* value) { + double result = 0; + CHECK(value->GetAsDouble(&result)) + << "Unexpected value type: " << value->GetType(); + return result; +} + +} // namespace + + +JSONSchemaValidator::Error::Error() { +} + +JSONSchemaValidator::Error::Error(const std::string& message) + : path(message) { +} + +JSONSchemaValidator::Error::Error(const std::string& path, + const std::string& message) + : path(path), message(message) { +} + + +const char JSONSchemaValidator::kUnknownTypeReference[] = + "Unknown schema reference: *."; +const char JSONSchemaValidator::kInvalidChoice[] = + "Value does not match any valid type choices."; +const char JSONSchemaValidator::kInvalidEnum[] = + "Value does not match any valid enum choices."; +const char JSONSchemaValidator::kObjectPropertyIsRequired[] = + "Property is required."; +const char JSONSchemaValidator::kUnexpectedProperty[] = + "Unexpected property."; +const char JSONSchemaValidator::kArrayMinItems[] = + "Array must have at least * items."; +const char JSONSchemaValidator::kArrayMaxItems[] = + "Array must not have more than * items."; +const char JSONSchemaValidator::kArrayItemRequired[] = + "Item is required."; +const char JSONSchemaValidator::kStringMinLength[] = + "String must be at least * characters long."; +const char JSONSchemaValidator::kStringMaxLength[] = + "String must not be more than * characters long."; +const char JSONSchemaValidator::kStringPattern[] = + "String must match the pattern: *."; +const char JSONSchemaValidator::kNumberMinimum[] = + "Value must not be less than *."; +const char JSONSchemaValidator::kNumberMaximum[] = + "Value must not be greater than *."; +const char JSONSchemaValidator::kInvalidType[] = + "Expected '*' but got '*'."; +const char JSONSchemaValidator::kInvalidTypeIntegerNumber[] = + "Expected 'integer' but got 'number', consider using Math.round()."; + + +// static +std::string JSONSchemaValidator::GetJSONSchemaType(const Value* value) { + switch (value->GetType()) { + case Value::TYPE_NULL: + return schema::kNull; + case Value::TYPE_BOOLEAN: + return schema::kBoolean; + case Value::TYPE_INTEGER: + return schema::kInteger; + case Value::TYPE_DOUBLE: { + double double_value = 0; + value->GetAsDouble(&double_value); + if (std::abs(double_value) <= std::pow(2.0, DBL_MANT_DIG) && + double_value == floor(double_value)) { + return schema::kInteger; + } else { + return schema::kNumber; + } + } + case Value::TYPE_STRING: + return schema::kString; + case Value::TYPE_DICTIONARY: + return schema::kObject; + case Value::TYPE_LIST: + return schema::kArray; + default: + NOTREACHED() << "Unexpected value type: " << value->GetType(); + return ""; + } +} + +// static +std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format, + const std::string& s1) { + std::string ret_val = format; + ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1); + return ret_val; +} + +// static +std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format, + const std::string& s1, + const std::string& s2) { + std::string ret_val = format; + ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1); + ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s2); + return ret_val; +} + +JSONSchemaValidator::JSONSchemaValidator(DictionaryValue* schema) + : schema_root_(schema), default_allow_additional_properties_(false) { +} + +JSONSchemaValidator::JSONSchemaValidator(DictionaryValue* schema, + ListValue* types) + : schema_root_(schema), default_allow_additional_properties_(false) { + if (!types) + return; + + for (size_t i = 0; i < types->GetSize(); ++i) { + DictionaryValue* type = NULL; + CHECK(types->GetDictionary(i, &type)); + + std::string id; + CHECK(type->GetString(schema::kId, &id)); + + CHECK(types_.find(id) == types_.end()); + types_[id] = type; + } +} + +JSONSchemaValidator::~JSONSchemaValidator() {} + +bool JSONSchemaValidator::Validate(const Value* instance) { + errors_.clear(); + Validate(instance, schema_root_, ""); + return errors_.empty(); +} + +void JSONSchemaValidator::Validate(const Value* instance, + const DictionaryValue* schema, + const std::string& path) { + // If this schema defines itself as reference type, save it in this.types. + std::string id; + if (schema->GetString(schema::kId, &id)) { + TypeMap::iterator iter = types_.find(id); + if (iter == types_.end()) + types_[id] = schema; + else + DCHECK(iter->second == schema); + } + + // If the schema has a $ref property, the instance must validate against + // that schema. It must be present in types_ to be referenced. + std::string ref; + if (schema->GetString(schema::kRef, &ref)) { + TypeMap::iterator type = types_.find(ref); + if (type == types_.end()) { + errors_.push_back( + Error(path, FormatErrorMessage(kUnknownTypeReference, ref))); + } else { + Validate(instance, type->second, path); + } + return; + } + + // If the schema has a choices property, the instance must validate against at + // least one of the items in that array. + const ListValue* choices = NULL; + if (schema->GetList(schema::kChoices, &choices)) { + ValidateChoices(instance, choices, path); + return; + } + + // If the schema has an enum property, the instance must be one of those + // values. + const ListValue* enumeration = NULL; + if (schema->GetList(schema::kEnum, &enumeration)) { + ValidateEnum(instance, enumeration, path); + return; + } + + std::string type; + schema->GetString(schema::kType, &type); + CHECK(!type.empty()); + if (type != schema::kAny) { + if (!ValidateType(instance, type, path)) + return; + + // These casts are safe because of checks in ValidateType(). + if (type == schema::kObject) { + ValidateObject(static_cast(instance), + schema, + path); + } else if (type == schema::kArray) { + ValidateArray(static_cast(instance), schema, path); + } else if (type == schema::kString) { + // Intentionally NOT downcasting to StringValue*. TYPE_STRING only implies + // GetAsString() can safely be carried out, not that it's a StringValue. + ValidateString(instance, schema, path); + } else if (type == schema::kNumber || type == schema::kInteger) { + ValidateNumber(instance, schema, path); + } else if (type != schema::kBoolean && type != schema::kNull) { + NOTREACHED() << "Unexpected type: " << type; + } + } +} + +void JSONSchemaValidator::ValidateChoices(const Value* instance, + const ListValue* choices, + const std::string& path) { + size_t original_num_errors = errors_.size(); + + for (size_t i = 0; i < choices->GetSize(); ++i) { + const DictionaryValue* choice = NULL; + CHECK(choices->GetDictionary(i, &choice)); + + Validate(instance, choice, path); + if (errors_.size() == original_num_errors) + return; + + // We discard the error from each choice. We only want to know if any of the + // validations succeeded. + errors_.resize(original_num_errors); + } + + // Now add a generic error that no choices matched. + errors_.push_back(Error(path, kInvalidChoice)); + return; +} + +void JSONSchemaValidator::ValidateEnum(const Value* instance, + const ListValue* choices, + const std::string& path) { + for (size_t i = 0; i < choices->GetSize(); ++i) { + const Value* choice = NULL; + CHECK(choices->Get(i, &choice)); + switch (choice->GetType()) { + case Value::TYPE_NULL: + case Value::TYPE_BOOLEAN: + case Value::TYPE_STRING: + if (instance->Equals(choice)) + return; + break; + + case Value::TYPE_INTEGER: + case Value::TYPE_DOUBLE: + if (instance->IsType(Value::TYPE_INTEGER) || + instance->IsType(Value::TYPE_DOUBLE)) { + if (GetNumberValue(choice) == GetNumberValue(instance)) + return; + } + break; + + default: + NOTREACHED() << "Unexpected type in enum: " << choice->GetType(); + } + } + + errors_.push_back(Error(path, kInvalidEnum)); +} + +void JSONSchemaValidator::ValidateObject(const DictionaryValue* instance, + const DictionaryValue* schema, + const std::string& path) { + const DictionaryValue* properties = NULL; + schema->GetDictionary(schema::kProperties, &properties); + if (properties) { + for (DictionaryValue::Iterator it(*properties); !it.IsAtEnd(); + it.Advance()) { + std::string prop_path = path.empty() ? it.key() : (path + "." + it.key()); + const DictionaryValue* prop_schema = NULL; + CHECK(it.value().GetAsDictionary(&prop_schema)); + + const Value* prop_value = NULL; + if (instance->Get(it.key(), &prop_value)) { + Validate(prop_value, prop_schema, prop_path); + } else { + // Properties are required unless there is an optional field set to + // 'true'. + bool is_optional = false; + prop_schema->GetBoolean(schema::kOptional, &is_optional); + if (!is_optional) { + errors_.push_back(Error(prop_path, kObjectPropertyIsRequired)); + } + } + } + } + + const DictionaryValue* additional_properties_schema = NULL; + if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema)) + return; + + // Validate additional properties. + for (DictionaryValue::Iterator it(*instance); !it.IsAtEnd(); it.Advance()) { + if (properties && properties->HasKey(it.key())) + continue; + + std::string prop_path = path.empty() ? it.key() : path + "." + it.key(); + if (!additional_properties_schema) { + errors_.push_back(Error(prop_path, kUnexpectedProperty)); + } else { + Validate(&it.value(), additional_properties_schema, prop_path); + } + } +} + +void JSONSchemaValidator::ValidateArray(const ListValue* instance, + const DictionaryValue* schema, + const std::string& path) { + const DictionaryValue* single_type = NULL; + size_t instance_size = instance->GetSize(); + if (schema->GetDictionary(schema::kItems, &single_type)) { + int min_items = 0; + if (schema->GetInteger(schema::kMinItems, &min_items)) { + CHECK(min_items >= 0); + if (instance_size < static_cast(min_items)) { + errors_.push_back(Error(path, FormatErrorMessage( + kArrayMinItems, base::IntToString(min_items)))); + } + } + + int max_items = 0; + if (schema->GetInteger(schema::kMaxItems, &max_items)) { + CHECK(max_items >= 0); + if (instance_size > static_cast(max_items)) { + errors_.push_back(Error(path, FormatErrorMessage( + kArrayMaxItems, base::IntToString(max_items)))); + } + } + + // If the items property is a single schema, each item in the array must + // validate against that schema. + for (size_t i = 0; i < instance_size; ++i) { + const Value* item = NULL; + CHECK(instance->Get(i, &item)); + std::string i_str = base::UintToString(i); + std::string item_path = path.empty() ? i_str : (path + "." + i_str); + Validate(item, single_type, item_path); + } + + return; + } + + // Otherwise, the list must be a tuple type, where each item in the list has a + // particular schema. + ValidateTuple(instance, schema, path); +} + +void JSONSchemaValidator::ValidateTuple(const ListValue* instance, + const DictionaryValue* schema, + const std::string& path) { + const ListValue* tuple_type = NULL; + schema->GetList(schema::kItems, &tuple_type); + size_t tuple_size = tuple_type ? tuple_type->GetSize() : 0; + if (tuple_type) { + for (size_t i = 0; i < tuple_size; ++i) { + std::string i_str = base::UintToString(i); + std::string item_path = path.empty() ? i_str : (path + "." + i_str); + const DictionaryValue* item_schema = NULL; + CHECK(tuple_type->GetDictionary(i, &item_schema)); + const Value* item_value = NULL; + instance->Get(i, &item_value); + if (item_value && item_value->GetType() != Value::TYPE_NULL) { + Validate(item_value, item_schema, item_path); + } else { + bool is_optional = false; + item_schema->GetBoolean(schema::kOptional, &is_optional); + if (!is_optional) { + errors_.push_back(Error(item_path, kArrayItemRequired)); + return; + } + } + } + } + + const DictionaryValue* additional_properties_schema = NULL; + if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema)) + return; + + size_t instance_size = instance->GetSize(); + if (additional_properties_schema) { + // Any additional properties must validate against the additionalProperties + // schema. + for (size_t i = tuple_size; i < instance_size; ++i) { + std::string i_str = base::UintToString(i); + std::string item_path = path.empty() ? i_str : (path + "." + i_str); + const Value* item_value = NULL; + CHECK(instance->Get(i, &item_value)); + Validate(item_value, additional_properties_schema, item_path); + } + } else if (instance_size > tuple_size) { + errors_.push_back(Error(path, FormatErrorMessage( + kArrayMaxItems, base::UintToString(tuple_size)))); + } +} + +void JSONSchemaValidator::ValidateString(const Value* instance, + const DictionaryValue* schema, + const std::string& path) { + std::string value; + CHECK(instance->GetAsString(&value)); + + int min_length = 0; + if (schema->GetInteger(schema::kMinLength, &min_length)) { + CHECK(min_length >= 0); + if (value.size() < static_cast(min_length)) { + errors_.push_back(Error(path, FormatErrorMessage( + kStringMinLength, base::IntToString(min_length)))); + } + } + + int max_length = 0; + if (schema->GetInteger(schema::kMaxLength, &max_length)) { + CHECK(max_length >= 0); + if (value.size() > static_cast(max_length)) { + errors_.push_back(Error(path, FormatErrorMessage( + kStringMaxLength, base::IntToString(max_length)))); + } + } + + CHECK(!schema->HasKey(schema::kPattern)) << "Pattern is not supported."; +} + +void JSONSchemaValidator::ValidateNumber(const Value* instance, + const DictionaryValue* schema, + const std::string& path) { + double value = GetNumberValue(instance); + + // TODO(aa): It would be good to test that the double is not infinity or nan, + // but isnan and isinf aren't defined on Windows. + + double minimum = 0; + if (schema->GetDouble(schema::kMinimum, &minimum)) { + if (value < minimum) + errors_.push_back(Error(path, FormatErrorMessage( + kNumberMinimum, base::DoubleToString(minimum)))); + } + + double maximum = 0; + if (schema->GetDouble(schema::kMaximum, &maximum)) { + if (value > maximum) + errors_.push_back(Error(path, FormatErrorMessage( + kNumberMaximum, base::DoubleToString(maximum)))); + } +} + +bool JSONSchemaValidator::ValidateType(const Value* instance, + const std::string& expected_type, + const std::string& path) { + std::string actual_type = GetJSONSchemaType(instance); + if (expected_type == actual_type || + (expected_type == schema::kNumber && actual_type == schema::kInteger)) { + return true; + } else if (expected_type == schema::kInteger && + actual_type == schema::kNumber) { + errors_.push_back(Error(path, kInvalidTypeIntegerNumber)); + return false; + } else { + errors_.push_back(Error(path, FormatErrorMessage( + kInvalidType, expected_type, actual_type))); + return false; + } +} + +bool JSONSchemaValidator::SchemaAllowsAnyAdditionalItems( + const DictionaryValue* schema, + const DictionaryValue** additional_properties_schema) { + // If the validator allows additional properties globally, and this schema + // doesn't override, then we can exit early. + schema->GetDictionary(schema::kAdditionalProperties, + additional_properties_schema); + + if (*additional_properties_schema) { + std::string additional_properties_type(schema::kAny); + CHECK((*additional_properties_schema)->GetString( + schema::kType, &additional_properties_type)); + return additional_properties_type == schema::kAny; + } else { + return default_allow_additional_properties_; + } +} diff --git a/chrome/common/json_schema/json_schema_validator.h b/chrome/common/json_schema/json_schema_validator.h new file mode 100644 index 0000000..e9a1a92 --- /dev/null +++ b/chrome/common/json_schema/json_schema_validator.h @@ -0,0 +1,225 @@ +// Copyright (c) 2011 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. + +#ifndef CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_H_ +#define CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_H_ + +#include +#include +#include + +#include "base/basictypes.h" + +namespace base { +class DictionaryValue; +class ListValue; +class StringValue; +class Value; +} + +//============================================================================== +// This class implements a subset of JSON Schema. +// See: http://www.json.com/json-schema-proposal/ for more details. +// +// There is also an older JavaScript implementation of the same functionality in +// chrome/renderer/resources/json_schema.js. +// +// The following features of JSON Schema are not implemented: +// - requires +// - unique +// - disallow +// - union types (but replaced with 'choices') +// - number.maxDecimal +// - string.pattern +// +// The following properties are not applicable to the interface exposed by +// this class: +// - options +// - readonly +// - title +// - description +// - format +// - default +// - transient +// - hidden +// +// There are also these departures from the JSON Schema proposal: +// - null counts as 'unspecified' for optional values +// - added the 'choices' property, to allow specifying a list of possible types +// for a value +// - by default an "object" typed schema does not allow additional properties. +// if present, "additionalProperties" is to be a schema against which all +// additional properties will be validated. +//============================================================================== +class JSONSchemaValidator { + public: + // Details about a validation error. + struct Error { + Error(); + + explicit Error(const std::string& message); + + Error(const std::string& path, const std::string& message); + + // The path to the location of the error in the JSON structure. + std::string path; + + // An english message describing the error. + std::string message; + }; + + // Error messages. + static const char kUnknownTypeReference[]; + static const char kInvalidChoice[]; + static const char kInvalidEnum[]; + static const char kObjectPropertyIsRequired[]; + static const char kUnexpectedProperty[]; + static const char kArrayMinItems[]; + static const char kArrayMaxItems[]; + static const char kArrayItemRequired[]; + static const char kStringMinLength[]; + static const char kStringMaxLength[]; + static const char kStringPattern[]; + static const char kNumberMinimum[]; + static const char kNumberMaximum[]; + static const char kInvalidType[]; + static const char kInvalidTypeIntegerNumber[]; + + // Classifies a Value as one of the JSON schema primitive types. + static std::string GetJSONSchemaType(const base::Value* value); + + // Utility methods to format error messages. The first method can have one + // wildcard represented by '*', which is replaced with s1. The second method + // can have two, which are replaced by s1 and s2. + static std::string FormatErrorMessage(const std::string& format, + const std::string& s1); + static std::string FormatErrorMessage(const std::string& format, + const std::string& s1, + const std::string& s2); + + // Creates a validator for the specified schema. + // + // NOTE: This constructor assumes that |schema| is well formed and valid. + // Errors will result in CHECK at runtime; this constructor should not be used + // with untrusted schemas. + explicit JSONSchemaValidator(base::DictionaryValue* schema); + + // Creates a validator for the specified schema and user-defined types. Each + // type must be a valid JSONSchema type description with an additional "id" + // field. Schema objects in |schema| can refer to these types with the "$ref" + // property. + // + // NOTE: This constructor assumes that |schema| and |types| are well-formed + // and valid. Errors will result in CHECK at runtime; this constructor should + // not be used with untrusted schemas. + JSONSchemaValidator(base::DictionaryValue* schema, base::ListValue* types); + + ~JSONSchemaValidator(); + + // Whether the validator allows additional items for objects and lists, beyond + // those defined by their schema, by default. + // + // This setting defaults to false: all items in an instance list or object + // must be defined by the corresponding schema. + // + // This setting can be overridden on individual object and list schemas by + // setting the "additionalProperties" field. + bool default_allow_additional_properties() const { + return default_allow_additional_properties_; + } + + void set_default_allow_additional_properties(bool val) { + default_allow_additional_properties_ = val; + } + + // Returns any errors from the last call to to Validate(). + const std::vector& errors() const { + return errors_; + } + + // Validates a JSON value. Returns true if the instance is valid, false + // otherwise. If false is returned any errors are available from the errors() + // getter. + bool Validate(const base::Value* instance); + + private: + typedef std::map TypeMap; + + // Each of the below methods handle a subset of the validation process. The + // path paramater is the path to |instance| from the root of the instance tree + // and is used in error messages. + + // Validates any instance node against any schema node. This is called for + // every node in the instance tree, and it just decides which of the more + // detailed methods to call. + void Validate(const base::Value* instance, + const base::DictionaryValue* schema, + const std::string& path); + + // Validates a node against a list of possible schemas. If any one of the + // schemas match, the node is valid. + void ValidateChoices(const base::Value* instance, + const base::ListValue* choices, + const std::string& path); + + // Validates a node against a list of exact primitive values, eg 42, "foobar". + void ValidateEnum(const base::Value* instance, + const base::ListValue* choices, + const std::string& path); + + // Validates a JSON object against an object schema node. + void ValidateObject(const base::DictionaryValue* instance, + const base::DictionaryValue* schema, + const std::string& path); + + // Validates a JSON array against an array schema node. + void ValidateArray(const base::ListValue* instance, + const base::DictionaryValue* schema, + const std::string& path); + + // Validates a JSON array against an array schema node configured to be a + // tuple. In a tuple, there is one schema node for each item expected in the + // array. + void ValidateTuple(const base::ListValue* instance, + const base::DictionaryValue* schema, + const std::string& path); + + // Validate a JSON string against a string schema node. + void ValidateString(const base::Value* instance, + const base::DictionaryValue* schema, + const std::string& path); + + // Validate a JSON number against a number schema node. + void ValidateNumber(const base::Value* instance, + const base::DictionaryValue* schema, + const std::string& path); + + // Validates that the JSON node |instance| has |expected_type|. + bool ValidateType(const base::Value* instance, + const std::string& expected_type, + const std::string& path); + + // Returns true if |schema| will allow additional items of any type. + bool SchemaAllowsAnyAdditionalItems( + const base::DictionaryValue* schema, + const base::DictionaryValue** addition_items_schema); + + // The root schema node. + base::DictionaryValue* schema_root_; + + // Map of user-defined name to type. + TypeMap types_; + + // Whether we allow additional properties on objects by default. This can be + // overridden by the allow_additional_properties flag on an Object schema. + bool default_allow_additional_properties_; + + // Errors accumulated since the last call to Validate(). + std::vector errors_; + + + DISALLOW_COPY_AND_ASSIGN(JSONSchemaValidator); +}; + +#endif // CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_H_ diff --git a/chrome/common/json_schema/json_schema_validator_unittest.cc b/chrome/common/json_schema/json_schema_validator_unittest.cc new file mode 100644 index 0000000..b2fdc54 --- /dev/null +++ b/chrome/common/json_schema/json_schema_validator_unittest.cc @@ -0,0 +1,52 @@ +// Copyright (c) 2010 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 "base/values.h" +#include "chrome/common/json_schema/json_schema_validator.h" +#include "chrome/common/json_schema/json_schema_validator_unittest_base.h" +#include "testing/gtest/include/gtest/gtest.h" + +class JSONSchemaValidatorCPPTest : public JSONSchemaValidatorTestBase { + public: + JSONSchemaValidatorCPPTest() + : JSONSchemaValidatorTestBase(JSONSchemaValidatorTestBase::CPP) { + } + + protected: + virtual void ExpectValid(const std::string& test_source, + Value* instance, DictionaryValue* schema, + ListValue* types) OVERRIDE { + JSONSchemaValidator validator(schema, types); + if (validator.Validate(instance)) + return; + + for (size_t i = 0; i < validator.errors().size(); ++i) { + ADD_FAILURE() << test_source << ": " + << validator.errors()[i].path << ": " + << validator.errors()[i].message; + } + } + + virtual void ExpectNotValid( + const std::string& test_source, + Value* instance, DictionaryValue* schema, + ListValue* types, + const std::string& expected_error_path, + const std::string& expected_error_message) OVERRIDE { + JSONSchemaValidator validator(schema, types); + if (validator.Validate(instance)) { + ADD_FAILURE() << test_source; + return; + } + + ASSERT_EQ(1u, validator.errors().size()) << test_source; + EXPECT_EQ(expected_error_path, validator.errors()[0].path) << test_source; + EXPECT_EQ(expected_error_message, validator.errors()[0].message) + << test_source; + } +}; + +TEST_F(JSONSchemaValidatorCPPTest, Test) { + RunTests(); +} diff --git a/chrome/common/json_schema/json_schema_validator_unittest_base.cc b/chrome/common/json_schema/json_schema_validator_unittest_base.cc new file mode 100644 index 0000000..ecd9846 --- /dev/null +++ b/chrome/common/json_schema/json_schema_validator_unittest_base.cc @@ -0,0 +1,678 @@ +// Copyright (c) 2012 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 "chrome/common/json_schema/json_schema_validator_unittest_base.h" + +#include +#include +#include + +#include "base/file_util.h" +#include "base/json/json_file_value_serializer.h" +#include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/path_service.h" +#include "base/stringprintf.h" +#include "base/values.h" +#include "chrome/common/chrome_paths.h" +#include "chrome/common/json_schema/json_schema_constants.h" +#include "chrome/common/json_schema/json_schema_validator.h" + +namespace schema = json_schema_constants; + +namespace { + +#define TEST_SOURCE base::StringPrintf("%s:%i", __FILE__, __LINE__) + +base::Value* LoadValue(const std::string& filename) { + base::FilePath path; + PathService::Get(chrome::DIR_TEST_DATA, &path); + path = path.AppendASCII("json_schema_validator").AppendASCII(filename); + EXPECT_TRUE(file_util::PathExists(path)); + + std::string error_message; + JSONFileValueSerializer serializer(path); + base::Value* result = serializer.Deserialize(NULL, &error_message); + if (!result) + ADD_FAILURE() << "Could not parse JSON: " << error_message; + return result; +} + +base::Value* LoadValue(const std::string& filename, base::Value::Type type) { + scoped_ptr result(LoadValue(filename)); + if (!result.get()) + return NULL; + if (!result->IsType(type)) { + ADD_FAILURE() << "Expected type " << type << ", got: " << result->GetType(); + return NULL; + } + return result.release(); +} + +base::ListValue* LoadList(const std::string& filename) { + return static_cast( + LoadValue(filename, base::Value::TYPE_LIST)); +} + +base::DictionaryValue* LoadDictionary(const std::string& filename) { + return static_cast( + LoadValue(filename, base::Value::TYPE_DICTIONARY)); +} + +} // namespace + + +JSONSchemaValidatorTestBase::JSONSchemaValidatorTestBase( + JSONSchemaValidatorTestBase::ValidatorType type) + : type_(type) { +} + +void JSONSchemaValidatorTestBase::RunTests() { + TestComplex(); + TestStringPattern(); + TestEnum(); + TestChoices(); + TestExtends(); + TestObject(); + TestTypeReference(); + TestArrayTuple(); + TestArrayNonTuple(); + TestString(); + TestNumber(); + TestTypeClassifier(); + TestTypes(); +} + +void JSONSchemaValidatorTestBase::TestComplex() { + scoped_ptr schema( + LoadDictionary("complex_schema.json")); + scoped_ptr instance(LoadList("complex_instance.json")); + + ASSERT_TRUE(schema.get()); + ASSERT_TRUE(instance.get()); + + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + instance->Remove(instance->GetSize() - 1, NULL); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + instance->Append(new base::DictionaryValue()); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kNumber, + schema::kObject)); + instance->Remove(instance->GetSize() - 1, NULL); + + base::DictionaryValue* item = NULL; + ASSERT_TRUE(instance->GetDictionary(0, &item)); + item->SetString("url", "xxxxxxxxxxx"); + + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, + "0.url", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kStringMaxLength, "10")); +} + +void JSONSchemaValidatorTestBase::TestStringPattern() { + // Regex patterns not supported in CPP validator. + if (type_ == CPP) + return; + + scoped_ptr schema(new base::DictionaryValue()); + schema->SetString(schema::kType, schema::kString); + schema->SetString(schema::kPattern, "foo+"); + + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("foo")).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("foooooo")).get(), + schema.get(), NULL); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("bar")).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kStringPattern, "foo+")); +} + +void JSONSchemaValidatorTestBase::TestEnum() { + scoped_ptr schema(LoadDictionary("enum_schema.json")); + + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("foo")).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(false)).get(), + schema.get(), NULL); + + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("42")).get(), + schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(base::Value::CreateNullValue()).get(), + schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum); +} + +void JSONSchemaValidatorTestBase::TestChoices() { + scoped_ptr schema( + LoadDictionary("choices_schema.json")); + + ExpectValid(TEST_SOURCE, + scoped_ptr(base::Value::CreateNullValue()).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL); + + scoped_ptr instance(new base::DictionaryValue()); + instance->SetString("foo", "bar"); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("foo")).get(), + schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::ListValue()).get(), + schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice); + + instance->SetInteger("foo", 42); + ExpectNotValid(TEST_SOURCE, instance.get(), + schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice); +} + +void JSONSchemaValidatorTestBase::TestExtends() { + // TODO(aa): JS only +} + +void JSONSchemaValidatorTestBase::TestObject() { + scoped_ptr schema(new base::DictionaryValue()); + schema->SetString(schema::kType, schema::kObject); + schema->SetString("properties.foo.type", schema::kString); + schema->SetString("properties.bar.type", schema::kInteger); + + scoped_ptr instance(new base::DictionaryValue()); + instance->SetString("foo", "foo"); + instance->SetInteger("bar", 42); + + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + instance->SetBoolean("extra", true); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, + "extra", JSONSchemaValidator::kUnexpectedProperty); + + instance->Remove("extra", NULL); + instance->Remove("bar", NULL); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar", + JSONSchemaValidator::kObjectPropertyIsRequired); + + instance->SetString("bar", "42"); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kInteger, + schema::kString)); + + base::DictionaryValue* additional_properties = new base::DictionaryValue(); + additional_properties->SetString(schema::kType, schema::kAny); + schema->Set(schema::kAdditionalProperties, additional_properties); + + instance->SetInteger("bar", 42); + instance->SetBoolean("extra", true); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + instance->SetString("extra", "foo"); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + additional_properties->SetString(schema::kType, schema::kBoolean); + instance->SetBoolean("extra", true); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + instance->SetString("extra", "foo"); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, + "extra", JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kBoolean, + schema::kString)); + + base::DictionaryValue* properties = NULL; + base::DictionaryValue* bar_property = NULL; + ASSERT_TRUE(schema->GetDictionary(schema::kProperties, &properties)); + ASSERT_TRUE(properties->GetDictionary("bar", &bar_property)); + + bar_property->SetBoolean(schema::kOptional, true); + instance->Remove("extra", NULL); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + instance->Remove("bar", NULL); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + instance->Set("bar", base::Value::CreateNullValue()); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, + "bar", JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kInteger, + schema::kNull)); + instance->SetString("bar", "42"); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, + "bar", JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kInteger, + schema::kString)); +} + +void JSONSchemaValidatorTestBase::TestTypeReference() { + scoped_ptr types(LoadList("reference_types.json")); + ASSERT_TRUE(types.get()); + + scoped_ptr schema(new base::DictionaryValue()); + schema->SetString(schema::kType, schema::kObject); + schema->SetString("properties.foo.type", schema::kString); + schema->SetString("properties.bar.$ref", "Max10Int"); + schema->SetString("properties.baz.$ref", "MinLengthString"); + + scoped_ptr schema_inline(new base::DictionaryValue()); + schema_inline->SetString(schema::kType, schema::kObject); + schema_inline->SetString("properties.foo.type", schema::kString); + schema_inline->SetString("properties.bar.id", "NegativeInt"); + schema_inline->SetString("properties.bar.type", schema::kInteger); + schema_inline->SetInteger("properties.bar.maximum", 0); + schema_inline->SetString("properties.baz.$ref", "NegativeInt"); + + scoped_ptr instance(new base::DictionaryValue()); + instance->SetString("foo", "foo"); + instance->SetInteger("bar", 4); + instance->SetString("baz", "ab"); + + scoped_ptr instance_inline( + new base::DictionaryValue()); + instance_inline->SetString("foo", "foo"); + instance_inline->SetInteger("bar", -4); + instance_inline->SetInteger("baz", -2); + + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), types.get()); + ExpectValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL); + + // Validation failure, but successful schema reference. + instance->SetString("baz", "a"); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(), + "baz", JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kStringMinLength, "2")); + + instance_inline->SetInteger("bar", 20); + ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL, + "bar", JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kNumberMaximum, "0")); + + // Remove MinLengthString type. + types->Remove(types->GetSize() - 1, NULL); + instance->SetString("baz", "ab"); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(), + "bar", JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kUnknownTypeReference, + "Max10Int")); + + // Remove internal type "NegativeInt". + schema_inline->Remove("properties.bar", NULL); + instance_inline->Remove("bar", NULL); + ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL, + "baz", JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kUnknownTypeReference, + "NegativeInt")); +} + +void JSONSchemaValidatorTestBase::TestArrayTuple() { + scoped_ptr schema( + LoadDictionary("array_tuple_schema.json")); + ASSERT_TRUE(schema.get()); + + scoped_ptr instance(new base::ListValue()); + instance->Append(new base::StringValue("42")); + instance->Append(new base::FundamentalValue(42)); + + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + instance->Append(new base::StringValue("anything")); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kArrayMaxItems, "2")); + + instance->Remove(1, NULL); + instance->Remove(1, NULL); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1", + JSONSchemaValidator::kArrayItemRequired); + + instance->Set(0, new base::FundamentalValue(42)); + instance->Append(new base::FundamentalValue(42)); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kString, + schema::kInteger)); + + base::DictionaryValue* additional_properties = new base::DictionaryValue(); + additional_properties->SetString(schema::kType, schema::kAny); + schema->Set(schema::kAdditionalProperties, additional_properties); + instance->Set(0, new base::StringValue("42")); + instance->Append(new base::StringValue("anything")); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + instance->Set(2, new base::ListValue()); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + additional_properties->SetString(schema::kType, schema::kBoolean); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "2", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kBoolean, + schema::kArray)); + instance->Set(2, new base::FundamentalValue(false)); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + base::ListValue* items_schema = NULL; + base::DictionaryValue* item0_schema = NULL; + ASSERT_TRUE(schema->GetList(schema::kItems, &items_schema)); + ASSERT_TRUE(items_schema->GetDictionary(0, &item0_schema)); + item0_schema->SetBoolean(schema::kOptional, true); + instance->Remove(2, NULL); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + // TODO(aa): I think this is inconsistent with the handling of NULL+optional + // for objects. + instance->Set(0, base::Value::CreateNullValue()); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + instance->Set(0, new base::FundamentalValue(42)); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kString, + schema::kInteger)); +} + +void JSONSchemaValidatorTestBase::TestArrayNonTuple() { + scoped_ptr schema(new base::DictionaryValue()); + schema->SetString(schema::kType, schema::kArray); + schema->SetString("items.type", schema::kString); + schema->SetInteger(schema::kMinItems, 2); + schema->SetInteger(schema::kMaxItems, 3); + + scoped_ptr instance(new base::ListValue()); + instance->Append(new base::StringValue("x")); + instance->Append(new base::StringValue("x")); + + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + instance->Append(new base::StringValue("x")); + ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); + + instance->Append(new base::StringValue("x")); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kArrayMaxItems, "3")); + instance->Remove(1, NULL); + instance->Remove(1, NULL); + instance->Remove(1, NULL); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kArrayMinItems, "2")); + + instance->Remove(1, NULL); + instance->Append(new base::FundamentalValue(42)); + ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kString, + schema::kInteger)); +} + +void JSONSchemaValidatorTestBase::TestString() { + scoped_ptr schema(new base::DictionaryValue()); + schema->SetString(schema::kType, schema::kString); + schema->SetInteger(schema::kMinLength, 1); + schema->SetInteger(schema::kMaxLength, 10); + + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("x")).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr( + new base::StringValue("xxxxxxxxxx")).get(), + schema.get(), NULL); + + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("")).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kStringMinLength, "1")); + ExpectNotValid( + TEST_SOURCE, + scoped_ptr(new base::StringValue("xxxxxxxxxxx")).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kStringMaxLength, "10")); +} + +void JSONSchemaValidatorTestBase::TestNumber() { + scoped_ptr schema(new base::DictionaryValue()); + schema->SetString(schema::kType, schema::kNumber); + schema->SetInteger(schema::kMinimum, 1); + schema->SetInteger(schema::kMaximum, 100); + schema->SetInteger("maxDecimal", 2); + + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(1)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(50)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(100)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(88.88)).get(), + schema.get(), NULL); + + ExpectNotValid( + TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(0.5)).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kNumberMinimum, "1")); + ExpectNotValid( + TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(100.1)).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kNumberMaximum, "100")); +} + +void JSONSchemaValidatorTestBase::TestTypeClassifier() { + EXPECT_EQ(std::string(schema::kBoolean), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr( + new base::FundamentalValue(true)).get())); + EXPECT_EQ(std::string(schema::kBoolean), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr( + new base::FundamentalValue(false)).get())); + + // It doesn't matter whether the C++ type is 'integer' or 'real'. If the + // number is integral and within the representable range of integers in + // double, it's classified as 'integer'. + EXPECT_EQ(std::string(schema::kInteger), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr(new base::FundamentalValue(42)).get())); + EXPECT_EQ(std::string(schema::kInteger), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr(new base::FundamentalValue(0)).get())); + EXPECT_EQ(std::string(schema::kInteger), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr(new base::FundamentalValue(42)).get())); + EXPECT_EQ(std::string(schema::kInteger), + JSONSchemaValidator::GetJSONSchemaType(scoped_ptr( + new base::FundamentalValue(pow(2.0, DBL_MANT_DIG))).get())); + EXPECT_EQ(std::string(schema::kInteger), + JSONSchemaValidator::GetJSONSchemaType(scoped_ptr( + new base::FundamentalValue(pow(-2.0, DBL_MANT_DIG))).get())); + + // "number" is only used for non-integral numbers, or numbers beyond what + // double can accurately represent. + EXPECT_EQ(std::string(schema::kNumber), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr( + new base::FundamentalValue(88.8)).get())); + EXPECT_EQ(std::string(schema::kNumber), + JSONSchemaValidator::GetJSONSchemaType(scoped_ptr( + new base::FundamentalValue(pow(2.0, DBL_MANT_DIG) * 2)).get())); + EXPECT_EQ(std::string(schema::kNumber), + JSONSchemaValidator::GetJSONSchemaType(scoped_ptr( + new base::FundamentalValue( + pow(-2.0, DBL_MANT_DIG) * 2)).get())); + + EXPECT_EQ(std::string(schema::kString), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr(new base::StringValue("foo")).get())); + EXPECT_EQ(std::string(schema::kArray), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr(new base::ListValue()).get())); + EXPECT_EQ(std::string(schema::kObject), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr(new base::DictionaryValue()).get())); + EXPECT_EQ(std::string(schema::kNull), + JSONSchemaValidator::GetJSONSchemaType( + scoped_ptr(base::Value::CreateNullValue()).get())); +} + +void JSONSchemaValidatorTestBase::TestTypes() { + scoped_ptr schema(new base::DictionaryValue()); + + // valid + schema->SetString(schema::kType, schema::kObject); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::DictionaryValue()).get(), + schema.get(), NULL); + + schema->SetString(schema::kType, schema::kArray); + ExpectValid(TEST_SOURCE, scoped_ptr(new base::ListValue()).get(), + schema.get(), NULL); + + schema->SetString(schema::kType, schema::kString); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("foobar")).get(), + schema.get(), NULL); + + schema->SetString(schema::kType, schema::kNumber); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(88.8)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(0)).get(), + schema.get(), NULL); + + schema->SetString(schema::kType, schema::kInteger); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(0)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr( + new base::FundamentalValue(pow(2.0, DBL_MANT_DIG))).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr( + new base::FundamentalValue(pow(-2.0, DBL_MANT_DIG))).get(), + schema.get(), NULL); + + schema->SetString(schema::kType, schema::kBoolean); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(false)).get(), + schema.get(), NULL); + ExpectValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(true)).get(), + schema.get(), NULL); + + schema->SetString(schema::kType, schema::kNull); + ExpectValid(TEST_SOURCE, + scoped_ptr(base::Value::CreateNullValue()).get(), + schema.get(), NULL); + + // not valid + schema->SetString(schema::kType, schema::kObject); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::ListValue()).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kObject, + schema::kArray)); + + schema->SetString(schema::kType, schema::kObject); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(base::Value::CreateNullValue()).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kObject, + schema::kNull)); + + schema->SetString(schema::kType, schema::kArray); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kArray, + schema::kInteger)); + + schema->SetString(schema::kType, schema::kString); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(42)).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kString, + schema::kInteger)); + + schema->SetString(schema::kType, schema::kNumber); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::StringValue("42")).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kNumber, + schema::kString)); + + schema->SetString(schema::kType, schema::kInteger); + ExpectNotValid(TEST_SOURCE, + scoped_ptr( + new base::FundamentalValue(88.8)).get(), + schema.get(), NULL, "", + JSONSchemaValidator::kInvalidTypeIntegerNumber); + + schema->SetString(schema::kType, schema::kBoolean); + ExpectNotValid(TEST_SOURCE, + scoped_ptr(new base::FundamentalValue(1)).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kBoolean, + schema::kInteger)); + + schema->SetString(schema::kType, schema::kNull); + ExpectNotValid(TEST_SOURCE, + scoped_ptr( + new base::FundamentalValue(false)).get(), + schema.get(), NULL, "", + JSONSchemaValidator::FormatErrorMessage( + JSONSchemaValidator::kInvalidType, + schema::kNull, + schema::kBoolean)); +} diff --git a/chrome/common/json_schema/json_schema_validator_unittest_base.h b/chrome/common/json_schema/json_schema_validator_unittest_base.h new file mode 100644 index 0000000..63988f5 --- /dev/null +++ b/chrome/common/json_schema/json_schema_validator_unittest_base.h @@ -0,0 +1,63 @@ +// Copyright (c) 2010 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. + +#ifndef CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_ +#define CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_ + +#include "testing/gtest/include/gtest/gtest.h" + +namespace base { +class DictionaryValue; +class ListValue; +class Value; +} + +// Base class for unit tests for JSONSchemaValidator. There is currently only +// one implementation, JSONSchemaValidatorCPPTest. +// +// TODO(aa): Refactor chrome/test/data/json_schema_test.js into +// JSONSchemaValidatorJSTest that inherits from this. +class JSONSchemaValidatorTestBase : public testing::Test { + public: + enum ValidatorType { + CPP = 1, + JS = 2 + }; + + explicit JSONSchemaValidatorTestBase(ValidatorType type); + + void RunTests(); + + protected: + virtual void ExpectValid(const std::string& test_source, + base::Value* instance, + base::DictionaryValue* schema, + base::ListValue* types) = 0; + + virtual void ExpectNotValid(const std::string& test_source, + base::Value* instance, + base::DictionaryValue* schema, + base::ListValue* types, + const std::string& expected_error_path, + const std::string& expected_error_message) = 0; + + private: + void TestComplex(); + void TestStringPattern(); + void TestEnum(); + void TestChoices(); + void TestExtends(); + void TestObject(); + void TestTypeReference(); + void TestArrayTuple(); + void TestArrayNonTuple(); + void TestString(); + void TestNumber(); + void TestTypeClassifier(); + void TestTypes(); + + ValidatorType type_; +}; + +#endif // CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_ -- cgit v1.1