/// <summary>
/// Loads a <see cref="JSchema"/> from a <see cref="JsonReader"/> using the given <see cref="JSchemaResolver"/>.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> containing the JSON Schema to load.</param>
/// <param name="settings">The <see cref="JSchemaReaderSettings"/> used to load the schema.</param>
/// <returns>The <see cref="JSchema"/> object representing the JSON Schema.</returns>
public static JSchema Load(JsonReader reader, JSchemaReaderSettings settings)
{
ValidationUtils.ArgumentNotNull(reader, nameof(reader));
ValidationUtils.ArgumentNotNull(settings, nameof(settings));
JSchemaReader schemaReader = new JSchemaReader(settings);
JSchema schema = schemaReader.ReadRoot(reader);
return(schema);
}
public void Dependencies()
{
string json = @"{
""dependencies"": {""bar"": ""foo""}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("foo", ((IList <string>)schema.Dependencies["bar"])[0]);
}
public void ReferenceSelf()
{
string json = @"{
""$ref"": ""#""
}";
ExceptionAssert.Throws <JsonException>(() =>
{
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
}, "Could not resolve schema reference '#'.");
}
public void DisallowSingleType()
{
string json = @"{
""description"":""DisallowSingleType"",
""disallow"":""string""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DisallowSingleType", schema.Description);
Assert.AreEqual(JSchemaType.String, schema.Not.Type);
}
public void AllowAdditionalItems()
{
string json = @"{
""items"": {},
""additionalItems"": false
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.IsNull(schema.AdditionalItems);
Assert.AreEqual(false, schema.AllowAdditionalItems);
}
public void DisallowMultipleTypes()
{
string json = @"{
""description"":""DisallowMultipleTypes"",
""disallow"":[""string"",""number""]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DisallowMultipleTypes", schema.Description);
Assert.AreEqual(JSchemaType.String | JSchemaType.Float, schema.Not.Type);
}
public void Title()
{
string json = @"{
""description"":""Title"",
""title"":""testtitle""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Title", schema.Description);
Assert.AreEqual("testtitle", schema.Title);
}
public void MultipleTypes()
{
string json = @"{
""description"":""Age"",
""type"":[""string"", ""integer""]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Age", schema.Description);
Assert.AreEqual(JSchemaType.String | JSchemaType.Integer, schema.Type);
}
public void Pattern()
{
string json = @"{
""description"":""Pattern"",
""pattern"":""testpattern""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Pattern", schema.Description);
Assert.AreEqual("testpattern", schema.Pattern);
}
public void Id()
{
string json = @"{
""description"":""Id"",
""id"":""testid""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Id", schema.Description);
Assert.AreEqual(new Uri("testid", UriKind.RelativeOrAbsolute), schema.Id);
}
public void ExclusiveMinimum_ExclusiveMaximum()
{
string json = @"{
""exclusiveMinimum"":true,
""exclusiveMaximum"":true
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(true, schema.ExclusiveMinimum);
Assert.AreEqual(true, schema.ExclusiveMaximum);
}
public void Required()
{
string json = @"{
""description"":""Required"",
""required"":true
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Required", schema.Description);
Assert.AreEqual(true, schema.DeprecatedRequired);
}
public void Reference_ForwardsLocation()
{
string json = @"{
""properties"": {
""bar"": {""$ref"": ""#/properties/foo""},
""foo"": {""type"": ""integer""}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(schema.Properties["foo"], schema.Properties["bar"]);
}
public void Extends()
{
string json = @"{
""extends"": [{""type"":""string""},{""type"":""null""}],
""description"":""Extends""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Extends", schema.Description);
Assert.AreEqual(JSchemaType.String, schema.AllOf[0].Type);
Assert.AreEqual(JSchemaType.Null, schema.AllOf[1].Type);
}
public void AdditionalItems()
{
string json = @"{
""items"": [],
""additionalItems"": {""type"": ""integer""}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.IsNotNull(schema.AdditionalItems);
Assert.AreEqual(JSchemaType.Integer, schema.AdditionalItems.Type);
Assert.AreEqual(true, schema.AllowAdditionalItems);
}
public void AdditionalProperties()
{
string json = @"{
""description"":""AdditionalProperties"",
""type"":[""string"", ""integer""],
""additionalProperties"":{""type"":[""object"", ""boolean""]}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("AdditionalProperties", schema.Description);
Assert.AreEqual(JSchemaType.Object | JSchemaType.Boolean, schema.AdditionalProperties.Type);
}
public void PatternProperties()
{
string json = @"{
""patternProperties"": {
""[abc]"": { ""id"":""Blah"" }
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.IsNotNull(schema.PatternProperties);
Assert.AreEqual(1, schema.PatternProperties.Count);
Assert.AreEqual(new Uri("Blah", UriKind.RelativeOrAbsolute), schema.PatternProperties["[abc]"].Id);
}
public void UnresolvedReference()
{
ExceptionAssert.Throws <Exception>(() =>
{
string json = @"{
""id"":""CircularReferenceArray"",
""description"":""CircularReference"",
""type"":[""array""],
""items"":{""$ref"":""MyUnresolvedReference""}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
}, @"Could not resolve schema reference 'MyUnresolvedReference'.");
}
public void MultipleItems()
{
string json = @"{
""description"":""MultipleItems"",
""type"":""array"",
""items"": [{""type"":""string""},{""type"":""array""}]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("MultipleItems", schema.Description);
Assert.AreEqual(JSchemaType.String, schema.Items[0].Type);
Assert.AreEqual(JSchemaType.Array, schema.Items[1].Type);
}
public void References_Items_IndexNotInteger()
{
string json = @"{
""items"": [{""type"": ""integer""},{""prop"":{""type"": ""object""}}],
""properties"": {
""array"": {""$ref"": ""#/items/0""},
""arrayprop"": {""$ref"": ""#/items/one""}
}
}";
ExceptionAssert.Throws <JsonException>(() =>
{
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
}, "Could not resolve schema reference '#/items/one'.");
}
public void Dependencies_SchemaDependency()
{
string json = @"{
""dependencies"": {
""bar"": ""foo"",
""foo"": { ""title"": ""Dependency schema"" },
""stuff"": [""blah"",""blah2""]
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("foo", ((IList <string>)schema.Dependencies["bar"])[0]);
Assert.AreEqual("Dependency schema", ((JSchema)schema.Dependencies["foo"]).Title);
Assert.AreEqual("blah", ((IList <string>)schema.Dependencies["stuff"])[0]);
Assert.AreEqual("blah2", ((IList <string>)schema.Dependencies["stuff"])[1]);
}
public void Enum()
{
string json = @"{
""description"":""Type"",
""type"":[""string"",""array""],
""enum"":[""string"",""object"",""array"",""boolean"",""number"",""integer"",""null"",""any""]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Type", schema.Description);
Assert.AreEqual(JSchemaType.String | JSchemaType.Array, schema.Type);
Assert.AreEqual(8, schema.Enum.Count);
Assert.AreEqual("string", (string)schema.Enum[0]);
Assert.AreEqual("any", (string)schema.Enum[schema.Enum.Count - 1]);
}
public void ReadRoot_ResolveSchemaReferencesFalse_DoesNotDereference()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("person.json", UriKind.RelativeOrAbsolute), _personSchemaJson);
// Arrange
JSchemaReader schemaReader = new JSchemaReader(new JSchemaReaderSettings {
ResolveSchemaReferences = false, Resolver = resolver
});
// Act
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(_employeeSchema)));
// Assert
Assert.AreEqual(new Uri("person.json", UriKind.Relative), schema.AllOf[0].Reference);
Assert.AreEqual(new Uri("#/definitions/salary", UriKind.Relative), schema.Properties["salary"].Reference);
}
public void CircularReference()
{
string json = @"{
""id"":""CircularReferenceArray"",
""description"":""CircularReference"",
""type"":[""array""],
""items"":{""$ref"":""CircularReferenceArray""}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("CircularReference", schema.Description);
Assert.AreEqual(new Uri("CircularReferenceArray", UriKind.RelativeOrAbsolute), schema.Id);
Assert.AreEqual(JSchemaType.Array, schema.Type);
Assert.AreEqual(schema, schema.Items[0]);
}
public void References_Array()
{
string json = @"{
""array"": [{""type"": ""integer""},{""prop"":{""type"": ""object""}}],
""items"": [{""type"": ""string""}],
""properties"": {
""array"": {""$ref"": ""#/array/0""},
""arrayprop"": {""$ref"": ""#/array/1/prop""},
""items"": {""$ref"": ""#/items/0""}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(JSchemaType.Integer, schema.Properties["array"].Type);
Assert.AreEqual(JSchemaType.Object, schema.Properties["arrayprop"].Type);
Assert.AreEqual(JSchemaType.String, schema.Properties["items"].Type);
}
public void EscapedReferences()
{
string json = @"{
""tilda~field"": {""type"": ""integer""},
""slash/field"": {""type"": ""object""},
""percent%field"": {""type"": ""array""},
""properties"": {
""tilda"": {""$ref"": ""#/tilda~0field""},
""slash"": {""$ref"": ""#/slash~1field""},
""percent"": {""$ref"": ""#/percent%25field""}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(JSchemaType.Integer, schema.Properties["tilda"].Type);
Assert.AreEqual(JSchemaType.Object, schema.Properties["slash"].Type);
Assert.AreEqual(JSchemaType.Array, schema.Properties["percent"].Type);
}
public void DeprecatedRequired()
{
string schemaJson = @"{
""description"":""A person"",
""type"":""object"",
""properties"":
{
""name"":{""type"":""string""},
""hobbies"":{""type"":""string"",""required"":true},
""age"":{""type"":""integer"",""required"":true}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(schemaJson)));
Assert.AreEqual(2, schema.Required.Count);
Assert.AreEqual("hobbies", schema.Required[0]);
Assert.AreEqual("age", schema.Required[1]);
}
public void Pattern()
{
string json = @"{
""description"":""Pattern"",
""pattern"":""testpattern""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Pattern", schema.Description);
Assert.AreEqual("testpattern", schema.Pattern);
}
public void Reference_NonStandardLocation()
{
string json = @"{
""properties"": {
""foo"": {""$ref"": ""#/common/foo""},
""foo2"": {""$ref"": ""#/common/foo""},
""bar"": {""$ref"": ""#/common/foo/bar""}
},
""common"": {
""foo"": {
""type"": ""integer"",
""bar"": {
""type"": ""object""
}
}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual((JSchema)schema.ExtensionData["common"]["foo"], schema.Properties["foo"]);
Assert.AreEqual((JSchema)schema.ExtensionData["common"]["foo"], schema.Properties["foo2"]);
Assert.AreEqual((JSchema)schema.ExtensionData["common"]["foo"]["bar"], schema.Properties["bar"]);
}
public void ReadSchema()
{
string json = @"{
""id"": ""root"",
""properties"": {
""storage"": {
""$ref"": ""#/definitions/file""
}
},
""items"": [
{
""type"": [
""integer"",
""null""
]
},
{
""$ref"": ""#/definitions/file""
}
],
""allOf"": [
{
""type"": [
""integer"",
""null""
]
},
{
""$ref"": ""#/definitions/file""
}
],
""oneOf"": [
{
""type"": [
""null""
]
}
],
""anyOf"": [
{
""type"": [
""string""
]
}
],
""not"": {
},
""definitions"": {
""file"": {
""id"": ""file"",
""properties"": {
""blah"": {
""$ref"": ""#""
},
""blah2"": {
""$ref"": ""root""
},
""blah3"": {
""$ref"": ""#/definitions/parent""
}
},
""definitions"": {
""parent"": {
""$ref"": ""#""
}
}
}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
JToken t1 = schema.ExtensionData["definitions"]["file"];
JSchemaAnnotation a1 = t1.Annotation <JSchemaAnnotation>();
Assert.AreEqual(new Uri("root", UriKind.RelativeOrAbsolute), schema.Id);
Assert.AreEqual(1, schema.Properties.Count);
Assert.AreEqual(a1.Schema, schema.Properties["storage"]);
JSchema fileSchema = schema.Properties["storage"];
Assert.AreEqual(fileSchema, fileSchema.Properties["blah"]);
Assert.AreEqual(schema, fileSchema.Properties["blah2"]);
Assert.AreEqual(fileSchema, fileSchema.Properties["blah3"]);
Assert.AreEqual(2, schema.Items.Count);
Assert.AreEqual(true, schema.ItemsPositionValidation);
Assert.AreEqual(JSchemaType.Integer | JSchemaType.Null, schema.Items[0].Type);
Assert.AreEqual(a1.Schema, schema.Items[1]);
Assert.AreEqual(2, schema.AllOf.Count);
Assert.AreEqual(JSchemaType.Integer | JSchemaType.Null, schema.AllOf[0].Type);
Assert.AreEqual(a1.Schema, schema.AllOf[1]);
Assert.AreEqual(1, schema.OneOf.Count);
Assert.AreEqual(JSchemaType.Null, schema.OneOf[0].Type);
Assert.AreEqual(1, schema.AnyOf.Count);
Assert.AreEqual(JSchemaType.String, schema.AnyOf[0].Type);
Assert.AreEqual(null, schema.Not.Type);
}
public void PatternProperties()
{
string json = @"{
""patternProperties"": {
""[abc]"": { ""id"":""Blah"" }
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.IsNotNull(schema.PatternProperties);
Assert.AreEqual(1, schema.PatternProperties.Count);
Assert.AreEqual(new Uri("Blah", UriKind.RelativeOrAbsolute), schema.PatternProperties["[abc]"].Id);
}
public void AllowAdditionalItems()
{
string json = @"{
""items"": {},
""additionalItems"": false
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.IsNull(schema.AdditionalItems);
Assert.AreEqual(false, schema.AllowAdditionalItems);
}
public void CircularReference()
{
string json = @"{
""id"":""CircularReferenceArray"",
""description"":""CircularReference"",
""type"":[""array""],
""items"":{""$ref"":""CircularReferenceArray""}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("CircularReference", schema.Description);
Assert.AreEqual(new Uri("CircularReferenceArray", UriKind.RelativeOrAbsolute), schema.Id);
Assert.AreEqual(JSchemaType.Array, schema.Type);
Assert.AreEqual(schema, schema.Items[0]);
}
public void ReferenceToNestedSchemaWithIdInResolvedSchema_Root()
{
JSchema nested = new JSchema();
nested.Id = new Uri("nested.json", UriKind.RelativeOrAbsolute);
nested.Type = JSchemaType.String;
JSchema root = new JSchema
{
Id = new Uri("http://test.test"),
Items =
{
nested
}
};
string json = @"{""$ref"":""http://test.test/nested.json""}";
NestedPreloadedResolver resolver = new NestedPreloadedResolver();
resolver.Add(root.Id, root.ToString());
JSchemaReader schemaReader = new JSchemaReader(resolver);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(new Uri("nested.json", UriKind.RelativeOrAbsolute), schema.Id);
Assert.AreEqual(JSchemaType.String, schema.Type);
}
public void DisallowMultipleTypes()
{
string json = @"{
""description"":""DisallowMultipleTypes"",
""disallow"":[""string"",""number""]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DisallowMultipleTypes", schema.Description);
Assert.AreEqual(JSchemaType.String | JSchemaType.Number, schema.Not.Type);
}
public void MinimumMaximum()
{
string json = @"{
""description"":""MinimumMaximum"",
""minimum"":1.1,
""maximum"":1.2,
""minItems"":1,
""maxItems"":2,
""minLength"":5,
""maxLength"":50,
""divisibleBy"":3,
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("MinimumMaximum", schema.Description);
Assert.AreEqual(1.1, schema.Minimum);
Assert.AreEqual(1.2, schema.Maximum);
Assert.AreEqual(1, schema.MinimumItems);
Assert.AreEqual(2, schema.MaximumItems);
Assert.AreEqual(5, schema.MinimumLength);
Assert.AreEqual(50, schema.MaximumLength);
Assert.AreEqual(3, schema.MultipleOf);
}
public void Dependencies()
{
string json = @"{
""dependencies"": {""bar"": ""foo""}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("foo", ((IList<string>)schema.Dependencies["bar"])[0]);
}
public void InvalidSchemaId()
{
string schemaJson = @"{
""id"": ""#root"",
""$schema"": ""http://json-schema.org/draft-04/schema#"",
""title"": ""command"",
""type"": ""object"",
""oneOf"": [
{
""$ref"": ""#/definitions/registerCommand""
},
{
""$ref"": ""#/definitions/unregisterCommand""
},
{
""$ref"": ""#/definitions/loginCommand""
},
{
""$ref"": ""#/definitions/logoutCommand""
},
{
""$ref"": ""#/definitions/syncCommand""
},
{
""$ref"": ""#/definitions/sendmsgCommand""
}
],
""required"": [
""cmd""
],
""definitions"": {
""registerCommand"": {
""properties"": {
""cmd"": {
""enum"": [
""register""
]
},
""pms"": {
""$ref"": ""#/definitions/authParams""
}
},
""required"": [
""pms""
]
},
""unregisterCommand"": {
""properties"": {
""cmd"": {
""enum"": [
""unregister""
]
}
}
},
""loginCommand"": {
""title"": ""log in"",
""properties"": {
""cmd"": {
""enum"": [
""login""
]
},
""pms"": {
""$ref"": ""#/definitions/authParams""
}
},
""required"": [
""pms""
]
},
""logoutCommand"": {
""title"": ""log out"",
""properties"": {
""cmd"": {
""enum"": [
""logout""
]
}
}
},
""syncCommand"": {
""properties"": {
""cmd"": {
""enum"": [
""sync""
]
},
""pms"": {
""$ref"": ""#/definitions/syncParams""
}
},
""required"": [
""pms""
]
},
""sendmsgCommand"": {
""properties"": {
""cmd"": {
""enum"": [
""sendmsg""
]
},
""pms"": {
}
},
""required"": [
""pms""
]
},
""authParams"": {
""type"": ""object"",
""properties"": {
""username"": {
},
""password"": {
}
},
""required"": [
""username"",
""password""
]
},
""syncParams"": {
""type"": ""object"",
""properties"": {
""inbox"": {
},
""contacts"": {
}
},
""required"": [
""inbox"",
""contacts""
]
}
}
}";
JSchemaReader schemaReader = new JSchemaReader(new JSchemaReaderSettings());
schemaReader.ReadRoot(new JsonTextReader(new StringReader(schemaJson)));
JSchemaDiscovery discovery = schemaReader._schemaDiscovery;
foreach (KnownSchema knownSchema in discovery.KnownSchemas)
{
Assert.IsFalse(knownSchema.Id.OriginalString.StartsWith("#/#/", StringComparison.Ordinal));
}
}
public void References_Array()
{
string json = @"{
""array"": [{""type"": ""integer""},{""prop"":{""type"": ""object""}}],
""items"": [{""type"": ""string""}],
""properties"": {
""array"": {""$ref"": ""#/array/0""},
""arrayprop"": {""$ref"": ""#/array/1/prop""},
""items"": {""$ref"": ""#/items/0""}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(JSchemaType.Integer, schema.Properties["array"].Type);
Assert.AreEqual(JSchemaType.Object, schema.Properties["arrayprop"].Type);
Assert.AreEqual(JSchemaType.String, schema.Properties["items"].Type);
}
public void Dependencies_SchemaDependency()
{
string json = @"{
""dependencies"": {
""bar"": ""foo"",
""foo"": { ""title"": ""Dependency schema"" },
""stuff"": [""blah"",""blah2""]
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("foo", ((IList<string>) schema.Dependencies["bar"])[0]);
Assert.AreEqual("Dependency schema", ((JSchema)schema.Dependencies["foo"]).Title);
Assert.AreEqual("blah", ((IList<string>)schema.Dependencies["stuff"])[0]);
Assert.AreEqual("blah2", ((IList<string>)schema.Dependencies["stuff"])[1]);
}
public void MultipleItems()
{
string json = @"{
""description"":""MultipleItems"",
""type"":""array"",
""items"": [{""type"":""string""},{""type"":""array""}]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("MultipleItems", schema.Description);
Assert.AreEqual(JSchemaType.String, schema.Items[0].Type);
Assert.AreEqual(JSchemaType.Array, schema.Items[1].Type);
}
public void DisallowSingleType()
{
string json = @"{
""description"":""DisallowSingleType"",
""disallow"":""string""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DisallowSingleType", schema.Description);
Assert.AreEqual(JSchemaType.String, schema.Not.Type);
}
public void Extends()
{
string json = @"{
""extends"": [{""type"":""string""},{""type"":""null""}],
""description"":""Extends""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Extends", schema.Description);
Assert.AreEqual(JSchemaType.String, schema.AllOf[0].Type);
Assert.AreEqual(JSchemaType.Null, schema.AllOf[1].Type);
}
public void Enum()
{
string json = @"{
""description"":""Type"",
""type"":[""string"",""array""],
""enum"":[""string"",""object"",""array"",""boolean"",""number"",""integer"",""null"",""any""]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Type", schema.Description);
Assert.AreEqual(JSchemaType.String | JSchemaType.Array, schema.Type);
Assert.AreEqual(8, schema.Enum.Count);
Assert.AreEqual("string", (string)schema.Enum[0]);
Assert.AreEqual("any", (string)schema.Enum[schema.Enum.Count - 1]);
}
public void AdditionalProperties()
{
string json = @"{
""description"":""AdditionalProperties"",
""type"":[""string"", ""integer""],
""additionalProperties"":{""type"":[""object"", ""boolean""]}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("AdditionalProperties", schema.Description);
Assert.AreEqual(JSchemaType.Object | JSchemaType.Boolean, schema.AdditionalProperties.Type);
}
public void ReferenceToNestedSchemaWithIdInResolvedSchema_ExtensionData()
{
JSchema nested = new JSchema();
nested.Id = new Uri("nested.json", UriKind.RelativeOrAbsolute);
JSchema root = new JSchema
{
Id = new Uri("http://test.test"),
ExtensionData =
{
{ "nested", nested }
}
};
string rootJson = root.ToString();
string json = @"{
""type"":[""array""],
""items"":{""$ref"":""http://test.test/nested.json""}
}";
NestedPreloadedResolver resolver = new NestedPreloadedResolver();
resolver.Add(root.Id, rootJson);
JSchemaReader schemaReader = new JSchemaReader(resolver);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(new Uri("nested.json", UriKind.RelativeOrAbsolute), schema.Items[0].Id);
Assert.AreEqual(nested, schema.Items[0]);
}
public void Required()
{
string json = @"{
""description"":""Required"",
""required"":true
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Required", schema.Description);
Assert.AreEqual(true, schema.DeprecatedRequired);
}
public void UnresolvedReference()
{
try
{
string json = @"{
""id"":""CircularReferenceArray"",
""description"":""CircularReference"",
""type"":[""array""],
""items"":{""$ref"":""#/definitions/nested""},
""definitions"":{
""nested"": {""$ref"":""MyUnresolvedReference""}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
}
catch (JSchemaReaderException ex)
{
Assert.AreEqual(@"Could not resolve schema reference 'MyUnresolvedReference'. Path 'definitions.nested', line 7, position 16.", ex.Message);
Assert.AreEqual(null, ex.BaseUri);
}
}
public void DeprecatedRequired()
{
string schemaJson = @"{
""description"":""A person"",
""type"":""object"",
""properties"":
{
""name"":{""type"":""string""},
""hobbies"":{""type"":""string"",""required"":true},
""age"":{""type"":""integer"",""required"":true}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(schemaJson)));
Assert.AreEqual(2, schema.Required.Count);
Assert.AreEqual("hobbies", schema.Required[0]);
Assert.AreEqual("age", schema.Required[1]);
}
public void AdditionalItems()
{
string json = @"{
""items"": [],
""additionalItems"": {""type"": ""integer""}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.IsNotNull(schema.AdditionalItems);
Assert.AreEqual(JSchemaType.Integer, schema.AdditionalItems.Type);
Assert.AreEqual(true, schema.AllowAdditionalItems);
}
public void ExclusiveMinimum_ExclusiveMaximum()
{
string json = @"{
""exclusiveMinimum"":true,
""exclusiveMaximum"":true
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(true, schema.ExclusiveMinimum);
Assert.AreEqual(true, schema.ExclusiveMaximum);
}
public void Reference_ForwardsLocation()
{
string json = @"{
""properties"": {
""bar"": {""$ref"": ""#/properties/foo""},
""foo"": {""type"": ""integer""}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(schema.Properties["foo"], schema.Properties["bar"]);
}
public void Id()
{
string json = @"{
""description"":""Id"",
""id"":""testid""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Id", schema.Description);
Assert.AreEqual(new Uri("testid", UriKind.RelativeOrAbsolute), schema.Id);
}
public void EscapedReferences()
{
string json = @"{
""tilda~field"": {""type"": ""integer""},
""slash/field"": {""type"": ""object""},
""percent%field"": {""type"": ""array""},
""properties"": {
""tilda"": {""$ref"": ""#/tilda~0field""},
""slash"": {""$ref"": ""#/slash~1field""},
""percent"": {""$ref"": ""#/percent%25field""}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(JSchemaType.Integer, schema.Properties["tilda"].Type);
Assert.AreEqual(JSchemaType.Object, schema.Properties["slash"].Type);
Assert.AreEqual(JSchemaType.Array, schema.Properties["percent"].Type);
}
public void Title()
{
string json = @"{
""description"":""Title"",
""title"":""testtitle""
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Title", schema.Description);
Assert.AreEqual("testtitle", schema.Title);
}
public void References_Items_IndexNotInteger()
{
string json = @"{
""items"": [{""type"": ""integer""},{""prop"":{""type"": ""object""}}],
""properties"": {
""array"": {""$ref"": ""#/items/0""},
""arrayprop"": {""$ref"": ""#/items/one""}
}
}";
ExceptionAssert.Throws<JSchemaReaderException>(() =>
{
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
}, "Could not resolve schema reference '#/items/one'. Path 'properties.arrayprop', line 5, position 31.");
}
public void Simple()
{
string json = @"
{
""description"": ""A person"",
""type"": ""object"",
""properties"":
{
""name"": {""type"":""string""},
""hobbies"": {
""type"": ""array"",
""items"": {""type"":""string""}
}
}
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("A person", schema.Description);
Assert.AreEqual(JSchemaType.Object, schema.Type);
Assert.AreEqual(2, schema.Properties.Count);
Assert.AreEqual(JSchemaType.String, schema.Properties["name"].Type);
Assert.AreEqual(JSchemaType.Array, schema.Properties["hobbies"].Type);
Assert.AreEqual(JSchemaType.String, schema.Properties["hobbies"].Items[0].Type);
}
/// <summary>
/// Loads a <see cref="JSchema"/> from a <see cref="JsonReader"/> using the given <see cref="JSchemaResolver"/>.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> containing the JSON Schema to load.</param>
/// <param name="settings">The <see cref="JSchemaReaderSettings"/> used to load the schema.</param>
/// <returns>The <see cref="JSchema"/> object representing the JSON Schema.</returns>
public static JSchema Load(JsonReader reader, JSchemaReaderSettings settings)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
ValidationUtils.ArgumentNotNull(settings, "settings");
JSchemaReader schemaReader = new JSchemaReader(settings);
return schemaReader.ReadRoot(reader);
}
public void MultipleTypes()
{
string json = @"{
""description"":""Age"",
""type"":[""string"", ""integer""]
}";
JSchemaReader schemaReader = new JSchemaReader(JSchemaDummyResolver.Instance);
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Age", schema.Description);
Assert.AreEqual(JSchemaType.String | JSchemaType.Integer, schema.Type);
}
