Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(926)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/test/data/extensions/json_schema_test.js

Issue 375243002: Move ModuleSystemTest and the tests that use it into extensions/. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: namespace extensions Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/test/base/module_system_test.cc ('k') | extensions/extensions.gyp » ('j') | extensions/test/extensions_unittests_main.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/test/data/extensions/json_schema_test.js
diff --git a/chrome/test/data/extensions/json_schema_test.js b/chrome/test/data/extensions/json_schema_test.js
deleted file mode 100644
index efbd16ee85dc8df9547053780612e08b2872eac3..0000000000000000000000000000000000000000
--- a/chrome/test/data/extensions/json_schema_test.js
+++ /dev/null
@@ -1,668 +0,0 @@
-// 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.
-
-var AssertTrue = requireNative('assert').AssertTrue;
-var JSONSchemaValidator = require('json_schema').JSONSchemaValidator;
-var LOG = requireNative('logging').LOG;
-
-function assertValid(type, instance, schema, types) {
- var validator = new JSONSchemaValidator();
- if (types)
- validator.addTypes(types);
- validator["validate" + type](instance, schema, "");
- var success = true;
- if (validator.errors.length != 0) {
- LOG("Got unexpected errors");
- for (var i = 0; i < validator.errors.length; i++) {
- LOG(validator.errors[i].message + " path: " + validator.errors[i].path);
- }
- success = false;
- }
- AssertTrue(success);
-}
-
-function assertNotValid(type, instance, schema, errors, types) {
- var validator = new JSONSchemaValidator();
- if (types)
- validator.addTypes(types);
- validator["validate" + type](instance, schema, "");
- AssertTrue(validator.errors.length === errors.length);
- var success = true;
- for (var i = 0; i < errors.length; i++) {
- if (validator.errors[i].message == errors[i]) {
- LOG("Got expected error: " + validator.errors[i].message +
- " for path: " + validator.errors[i].path);
- } else {
- LOG("Missed expected error: " + errors[i] + ". Got: " +
- validator.errors[i].message + " instead.");
- success = false;
- }
- }
- AssertTrue(success);
-}
-
-function assertListConsistsOfElements(list, elements) {
- var success = true;
- for (var li = 0; li < list.length; li++) {
- for (var ei = 0; ei < elements.length && list[li] != elements[ei]; ei++) { }
- if (ei == elements.length) {
- LOG("Expected type not found: " + list[li]);
- success = false;
- }
- }
- AssertTrue(success);
-}
-
-function assertEqualSets(set1, set2) {
- assertListConsistsOfElements(set1, set2);
- assertListConsistsOfElements(set2, set1);
-}
-
-function formatError(key, replacements) {
- return JSONSchemaValidator.formatError(key, replacements);
-}
-
-function testFormatError() {
- AssertTrue(formatError("propertyRequired") == "Property is required.");
- AssertTrue(formatError("invalidEnum", ["foo, bar"]) ==
- "Value must be one of: [foo, bar].");
- AssertTrue(formatError("invalidType", ["foo", "bar"]) ==
- "Expected 'foo' but got 'bar'.");
-}
-
-function testComplex() {
- var schema = {
- type: "array",
- items: [
- {
- type: "object",
- properties: {
- id: {
- type: "integer",
- minimum: 1
- },
- url: {
- type: "string",
- pattern: /^https?\:/,
- optional: true
- },
- index: {
- type: "integer",
- minimum: 0,
- optional: true
- },
- selected: {
- type: "boolean",
- optional: true
- }
- }
- },
- { type: "function", optional: true },
- { type: "function", optional: true }
- ]
- };
-
- var instance = [
- {
- id: 42,
- url: "http://www.google.com/",
- index: 2,
- selected: true
- },
- function(){},
- function(){}
- ];
-
- assertValid("", instance, schema);
- instance.length = 2;
- assertValid("", instance, schema);
- instance.length = 1;
- instance.push({});
- assertNotValid("", instance, schema,
- [formatError("invalidType", ["function", "object"])]);
- instance[1] = function(){};
-
- instance[0].url = "foo";
- assertNotValid("", instance, schema,
- [formatError("stringPattern",
- [schema.items[0].properties.url.pattern])]);
- delete instance[0].url;
- assertValid("", instance, schema);
-
- instance[0].id = 0;
- assertNotValid("", instance, schema,
- [formatError("numberMinValue",
- [schema.items[0].properties.id.minimum])]);
-}
-
-function testEnum() {
- var schema = {
- enum: ["foo", 42, false]
- };
-
- assertValid("", "foo", schema);
- assertValid("", 42, schema);
- assertValid("", false, schema);
- assertNotValid("", "42", schema, [formatError("invalidEnum",
- [schema.enum.join(", ")])]);
- assertNotValid("", null, schema, [formatError("invalidEnum",
- [schema.enum.join(", ")])]);
-}
-
-function testChoices() {
- var schema = {
- choices: [
- { type: "null" },
- { type: "undefined" },
- { type: "integer", minimum:42, maximum:42 },
- { type: "object", properties: { foo: { type: "string" } } }
- ]
- }
- assertValid("", null, schema);
- assertValid("", undefined, schema);
- assertValid("", 42, schema);
- assertValid("", {foo: "bar"}, schema);
-
- assertNotValid("", "foo", schema, [formatError("invalidChoice", [])]);
- assertNotValid("", [], schema, [formatError("invalidChoice", [])]);
- assertNotValid("", {foo: 42}, schema, [formatError("invalidChoice", [])]);
-}
-
-function testExtends() {
- var parent = {
- type: "number"
- }
- var schema = {
- extends: parent
- };
-
- assertValid("", 42, schema);
- assertNotValid("", "42", schema,
- [formatError("invalidType", ["number", "string"])]);
-
- // Make the derived schema more restrictive
- parent.minimum = 43;
- assertNotValid("", 42, schema, [formatError("numberMinValue", [43])]);
- assertValid("", 43, schema);
-}
-
-function testObject() {
- var schema = {
- properties: {
- "foo": {
- type: "string"
- },
- "bar": {
- type: "integer"
- }
- }
- };
-
- assertValid("Object", {foo:"foo", bar:42}, schema);
- assertNotValid("Object", {foo:"foo", bar:42,"extra":true}, schema,
- [formatError("unexpectedProperty")]);
- assertNotValid("Object", {foo:"foo"}, schema,
- [formatError("propertyRequired")]);
- assertNotValid("Object", {foo:"foo", bar:"42"}, schema,
- [formatError("invalidType", ["integer", "string"])]);
-
- schema.additionalProperties = { type: "any" };
- assertValid("Object", {foo:"foo", bar:42, "extra":true}, schema);
- assertValid("Object", {foo:"foo", bar:42, "extra":"foo"}, schema);
-
- schema.additionalProperties = { type: "boolean" };
- assertValid("Object", {foo:"foo", bar:42, "extra":true}, schema);
- assertNotValid("Object", {foo:"foo", bar:42, "extra":"foo"}, schema,
- [formatError("invalidType", ["boolean", "string"])]);
-
- schema.properties.bar.optional = true;
- assertValid("Object", {foo:"foo", bar:42}, schema);
- assertValid("Object", {foo:"foo"}, schema);
- assertValid("Object", {foo:"foo", bar:null}, schema);
- assertValid("Object", {foo:"foo", bar:undefined}, schema);
- assertNotValid("Object", {foo:"foo", bar:"42"}, schema,
- [formatError("invalidType", ["integer", "string"])]);
-}
-
-function testTypeReference() {
- var referencedTypes = [
- {
- id: "MinLengthString",
- type: "string",
- minLength: 2
- },
- {
- id: "Max10Int",
- type: "integer",
- maximum: 10
- }
- ];
-
- var schema = {
- type: "object",
- properties: {
- "foo": {
- type: "string"
- },
- "bar": {
- $ref: "Max10Int"
- },
- "baz": {
- $ref: "MinLengthString"
- }
- }
- };
-
- var schemaInlineReference = {
- type: "object",
- properties: {
- "foo": {
- type: "string"
- },
- "bar": {
- id: "NegativeInt",
- type: "integer",
- maximum: 0
- },
- "baz": {
- $ref: "NegativeInt"
- }
- }
- }
-
- // Valid type references externally added.
- assertValid("", {foo:"foo",bar:4,baz:"ab"}, schema, referencedTypes);
-
- // Valida type references internally defined.
- assertValid("", {foo:"foo",bar:-4,baz:-2}, schemaInlineReference);
-
- // Failures in validation, but succesful schema reference.
- assertNotValid("", {foo:"foo",bar:4,baz:"a"}, schema,
- [formatError("stringMinLength", [2])], referencedTypes);
- assertNotValid("", {foo:"foo",bar:20,baz:"abc"}, schema,
- [formatError("numberMaxValue", [10])], referencedTypes);
-
- // Remove MinLengthString type.
- referencedTypes.shift();
- assertNotValid("", {foo:"foo",bar:4,baz:"ab"}, schema,
- [formatError("unknownSchemaReference", ["MinLengthString"])],
- referencedTypes);
-
- // Remove internal type "NegativeInt"
- delete schemaInlineReference.properties.bar;
- assertNotValid("", {foo:"foo",baz:-2}, schemaInlineReference,
- [formatError("unknownSchemaReference", ["NegativeInt"])]);
-}
-
-function testArrayTuple() {
- var schema = {
- items: [
- {
- type: "string"
- },
- {
- type: "integer"
- }
- ]
- };
-
- assertValid("Array", ["42", 42], schema);
- assertNotValid("Array", ["42", 42, "anything"], schema,
- [formatError("arrayMaxItems", [schema.items.length])]);
- assertNotValid("Array", ["42"], schema, [formatError("itemRequired")]);
- assertNotValid("Array", [42, 42], schema,
- [formatError("invalidType", ["string", "integer"])]);
-
- schema.additionalProperties = { type: "any" };
- assertValid("Array", ["42", 42, "anything"], schema);
- assertValid("Array", ["42", 42, []], schema);
-
- schema.additionalProperties = { type: "boolean" };
- assertNotValid("Array", ["42", 42, "anything"], schema,
- [formatError("invalidType", ["boolean", "string"])]);
- assertValid("Array", ["42", 42, false], schema);
-
- schema.items[0].optional = true;
- assertValid("Array", ["42", 42], schema);
- assertValid("Array", [, 42], schema);
- assertValid("Array", [null, 42], schema);
- assertValid("Array", [undefined, 42], schema);
- assertNotValid("Array", [42, 42], schema,
- [formatError("invalidType", ["string", "integer"])]);
-}
-
-function testArrayNonTuple() {
- var schema = {
- items: {
- type: "string"
- },
- minItems: 2,
- maxItems: 3
- };
-
- assertValid("Array", ["x", "x"], schema);
- assertValid("Array", ["x", "x", "x"], schema);
-
- assertNotValid("Array", ["x"], schema,
- [formatError("arrayMinItems", [schema.minItems])]);
- assertNotValid("Array", ["x", "x", "x", "x"], schema,
- [formatError("arrayMaxItems", [schema.maxItems])]);
- assertNotValid("Array", [42], schema,
- [formatError("arrayMinItems", [schema.minItems]),
- formatError("invalidType", ["string", "integer"])]);
-}
-
-function testString() {
- var schema = {
- minLength: 1,
- maxLength: 10,
- pattern: /^x/
- };
-
- assertValid("String", "x", schema);
- assertValid("String", "xxxxxxxxxx", schema);
-
- assertNotValid("String", "y", schema,
- [formatError("stringPattern", [schema.pattern])]);
- assertNotValid("String", "xxxxxxxxxxx", schema,
- [formatError("stringMaxLength", [schema.maxLength])]);
- assertNotValid("String", "", schema,
- [formatError("stringMinLength", [schema.minLength]),
- formatError("stringPattern", [schema.pattern])]);
-}
-
-function testNumber() {
- var schema = {
- minimum: 1,
- maximum: 100,
- maxDecimal: 2
- };
-
- assertValid("Number", 1, schema);
- assertValid("Number", 50, schema);
- assertValid("Number", 100, schema);
- assertValid("Number", 88.88, schema);
-
- assertNotValid("Number", 0.5, schema,
- [formatError("numberMinValue", [schema.minimum])]);
- assertNotValid("Number", 100.1, schema,
- [formatError("numberMaxValue", [schema.maximum])]);
- assertNotValid("Number", 100.111, schema,
- [formatError("numberMaxValue", [schema.maximum]),
- formatError("numberMaxDecimal", [schema.maxDecimal])]);
-
- var nan = 0/0;
- AssertTrue(isNaN(nan));
- assertNotValid("Number", nan, schema,
- [formatError("numberFiniteNotNan", ["NaN"])]);
-
- assertNotValid("Number", Number.POSITIVE_INFINITY, schema,
- [formatError("numberFiniteNotNan", ["Infinity"]),
- formatError("numberMaxValue", [schema.maximum])
- ]);
-
- assertNotValid("Number", Number.NEGATIVE_INFINITY, schema,
- [formatError("numberFiniteNotNan", ["-Infinity"]),
- formatError("numberMinValue", [schema.minimum])
- ]);
-}
-
-function testIntegerBounds() {
- assertValid("Number", 0, {type:"integer"});
- assertValid("Number", -1, {type:"integer"});
- assertValid("Number", 2147483647, {type:"integer"});
- assertValid("Number", -2147483648, {type:"integer"});
- assertNotValid("Number", 0.5, {type:"integer"},
- [formatError("numberIntValue", [])]);
- assertNotValid("Number", 10000000000, {type:"integer"},
- [formatError("numberIntValue", [])]);
- assertNotValid("Number", 2147483647.5, {type:"integer"},
- [formatError("numberIntValue", [])]);
- assertNotValid("Number", 2147483648, {type:"integer"},
- [formatError("numberIntValue", [])]);
- assertNotValid("Number", 2147483649, {type:"integer"},
- [formatError("numberIntValue", [])]);
- assertNotValid("Number", -2147483649, {type:"integer"},
- [formatError("numberIntValue", [])]);
-}
-
-function testType() {
- // valid
- assertValid("Type", {}, {type:"object"});
- assertValid("Type", [], {type:"array"});
- assertValid("Type", function(){}, {type:"function"});
- assertValid("Type", "foobar", {type:"string"});
- assertValid("Type", "", {type:"string"});
- assertValid("Type", 88.8, {type:"number"});
- assertValid("Type", 42, {type:"number"});
- assertValid("Type", 0, {type:"number"});
- assertValid("Type", 42, {type:"integer"});
- assertValid("Type", 0, {type:"integer"});
- assertValid("Type", true, {type:"boolean"});
- assertValid("Type", false, {type:"boolean"});
- assertValid("Type", null, {type:"null"});
- assertValid("Type", undefined, {type:"undefined"});
-
- // not valid
- assertNotValid("Type", [], {type: "object"},
- [formatError("invalidType", ["object", "array"])]);
- assertNotValid("Type", null, {type: "object"},
- [formatError("invalidType", ["object", "null"])]);
- assertNotValid("Type", function(){}, {type: "object"},
- [formatError("invalidType", ["object", "function"])]);
- assertNotValid("Type", 42, {type: "array"},
- [formatError("invalidType", ["array", "integer"])]);
- assertNotValid("Type", 42, {type: "string"},
- [formatError("invalidType", ["string", "integer"])]);
- assertNotValid("Type", "42", {type: "number"},
- [formatError("invalidType", ["number", "string"])]);
- assertNotValid("Type", 88.8, {type: "integer"},
- [formatError("invalidTypeIntegerNumber")]);
- assertNotValid("Type", 1, {type: "boolean"},
- [formatError("invalidType", ["boolean", "integer"])]);
- assertNotValid("Type", false, {type: "null"},
- [formatError("invalidType", ["null", "boolean"])]);
- assertNotValid("Type", undefined, {type: "null"},
- [formatError("invalidType", ["null", "undefined"])]);
- assertNotValid("Type", {}, {type: "function"},
- [formatError("invalidType", ["function", "object"])]);
-}
-
-function testGetAllTypesForSchema() {
- var referencedTypes = [
- {
- id: "ChoicesRef",
- choices: [
- { type: "integer" },
- { type: "string" }
- ]
- },
- {
- id: "ObjectRef",
- type: "object",
- }
- ];
-
- var arraySchema = {
- type: "array"
- };
-
- var choicesSchema = {
- choices: [
- { type: "object" },
- { type: "function" }
- ]
- };
-
- var objectRefSchema = {
- $ref: "ObjectRef"
- };
-
- var complexSchema = {
- choices: [
- { $ref: "ChoicesRef" },
- { type: "function" },
- { $ref: "ObjectRef" }
- ]
- };
-
- var validator = new JSONSchemaValidator();
- validator.addTypes(referencedTypes);
-
- var arraySchemaTypes = validator.getAllTypesForSchema(arraySchema);
- assertEqualSets(arraySchemaTypes, ["array"]);
-
- var choicesSchemaTypes = validator.getAllTypesForSchema(choicesSchema);
- assertEqualSets(choicesSchemaTypes, ["object", "function"]);
-
- var objectRefSchemaTypes = validator.getAllTypesForSchema(objectRefSchema);
- assertEqualSets(objectRefSchemaTypes, ["object"]);
-
- var complexSchemaTypes = validator.getAllTypesForSchema(complexSchema);
- assertEqualSets(complexSchemaTypes,
- ["integer", "string", "function", "object"]);
-}
-
-function testIsValidSchemaType() {
- var referencedTypes = [
- {
- id: "ChoicesRef",
- choices: [
- { type: "integer" },
- { type: "string" }
- ]
- }
- ];
-
- var objectSchema = {
- type: "object",
- optional: true
- };
-
- var complexSchema = {
- choices: [
- { $ref: "ChoicesRef" },
- { type: "function" },
- ]
- };
-
- var validator = new JSONSchemaValidator();
- validator.addTypes(referencedTypes);
-
- AssertTrue(validator.isValidSchemaType("object", objectSchema));
- AssertTrue(!validator.isValidSchemaType("integer", objectSchema));
- AssertTrue(!validator.isValidSchemaType("array", objectSchema));
- AssertTrue(validator.isValidSchemaType("null", objectSchema));
- AssertTrue(validator.isValidSchemaType("undefined", objectSchema));
-
- AssertTrue(validator.isValidSchemaType("integer", complexSchema));
- AssertTrue(validator.isValidSchemaType("function", complexSchema));
- AssertTrue(validator.isValidSchemaType("string", complexSchema));
- AssertTrue(!validator.isValidSchemaType("object", complexSchema));
- AssertTrue(!validator.isValidSchemaType("null", complexSchema));
- AssertTrue(!validator.isValidSchemaType("undefined", complexSchema));
-}
-
-function testCheckSchemaOverlap() {
- var referencedTypes = [
- {
- id: "ChoicesRef",
- choices: [
- { type: "integer" },
- { type: "string" }
- ]
- },
- {
- id: "ObjectRef",
- type: "object",
- }
- ];
-
- var arraySchema = {
- type: "array"
- };
-
- var choicesSchema = {
- choices: [
- { type: "object" },
- { type: "function" }
- ]
- };
-
- var objectRefSchema = {
- $ref: "ObjectRef"
- };
-
- var complexSchema = {
- choices: [
- { $ref: "ChoicesRef" },
- { type: "function" },
- { $ref: "ObjectRef" }
- ]
- };
-
- var validator = new JSONSchemaValidator();
- validator.addTypes(referencedTypes);
-
- AssertTrue(!validator.checkSchemaOverlap(arraySchema, choicesSchema));
- AssertTrue(!validator.checkSchemaOverlap(arraySchema, objectRefSchema));
- AssertTrue(!validator.checkSchemaOverlap(arraySchema, complexSchema));
- AssertTrue(validator.checkSchemaOverlap(choicesSchema, objectRefSchema));
- AssertTrue(validator.checkSchemaOverlap(choicesSchema, complexSchema));
- AssertTrue(validator.checkSchemaOverlap(objectRefSchema, complexSchema));
-}
-
-function testInstanceOf() {
- function Animal() {};
- function Cat() {};
- function Dog() {};
- Cat.prototype = new Animal;
- Cat.prototype.constructor = Cat;
- Dog.prototype = new Animal;
- Dog.prototype.constructor = Dog;
- var cat = new Cat();
- var dog = new Dog();
- var num = new Number(1);
-
- // instanceOf should check type by walking up prototype chain.
- assertValid("", cat, {type:"object", isInstanceOf:"Cat"});
- assertValid("", cat, {type:"object", isInstanceOf:"Animal"});
- assertValid("", cat, {type:"object", isInstanceOf:"Object"});
- assertValid("", dog, {type:"object", isInstanceOf:"Dog"});
- assertValid("", dog, {type:"object", isInstanceOf:"Animal"});
- assertValid("", dog, {type:"object", isInstanceOf:"Object"});
- assertValid("", num, {type:"object", isInstanceOf:"Number"});
- assertValid("", num, {type:"object", isInstanceOf:"Object"});
-
- assertNotValid("", cat, {type:"object", isInstanceOf:"Dog"},
- [formatError("notInstance", ["Dog"])]);
- assertNotValid("", dog, {type:"object", isInstanceOf:"Cat"},
- [formatError("notInstance", ["Cat"])]);
- assertNotValid("", cat, {type:"object", isInstanceOf:"String"},
- [formatError("notInstance", ["String"])]);
- assertNotValid("", dog, {type:"object", isInstanceOf:"String"},
- [formatError("notInstance", ["String"])]);
- assertNotValid("", num, {type:"object", isInstanceOf:"Array"},
- [formatError("notInstance", ["Array"])]);
- assertNotValid("", num, {type:"object", isInstanceOf:"String"},
- [formatError("notInstance", ["String"])]);
-}
-
-// Tests exposed to schema_unittest.cc.
-exports.testFormatError = testFormatError;
-exports.testComplex = testComplex;
-exports.testEnum = testEnum;
-exports.testExtends = testExtends;
-exports.testObject = testObject;
-exports.testArrayTuple = testArrayTuple;
-exports.testArrayNonTuple = testArrayNonTuple;
-exports.testString = testString;
-exports.testNumber = testNumber;
-exports.testIntegerBounds = testIntegerBounds;
-exports.testType = testType;
-exports.testTypeReference = testTypeReference;
-exports.testGetAllTypesForSchema = testGetAllTypesForSchema;
-exports.testIsValidSchemaType = testIsValidSchemaType;
-exports.testCheckSchemaOverlap = testCheckSchemaOverlap;
-exports.testInstanceOf = testInstanceOf;
« no previous file with comments | « chrome/test/base/module_system_test.cc ('k') | extensions/extensions.gyp » ('j') | extensions/test/extensions_unittests_main.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698