public void RootReferenceToNestedSchemaWithIdInResolvedSchema_Root()
{
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 json = @"{""$ref"":""http://test.test/nested.json""}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(root);
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(nested, schema);
}
public void Test()
{
string json = @"{
""id"": ""TestComplexClass1"",
""definitions"": {
""TestClass1"": {
""id"": ""TestClass1""
}
},
""type"": ""object"",
""properties"": {
""TestProperty"": {
""$ref"": ""TestClass1""
}
},
""required"": [
""TestProperty""
]
}";
JSchemaReader schemaReader = new JSchemaReader(new JSchemaReaderSettings());
JSchema schema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("TestClass1", schema.Properties["TestProperty"].Id.OriginalString);
}
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 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);
}
public void Reference_UnusedInnerSchemaOfExternalSchema()
{
JSchema baseSchema = JSchema.Parse(@"{
""definitions"": {
""unused"": {
""not"": {
""$ref"": ""#/definitions/used_by_unused""
}
},
""used_by_unused"": {
""title"": ""used by unused""
}
}
}");
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(baseSchema, new Uri("http://localhost/base"));
string json = @"{
""not"": {
""$ref"": ""http://localhost/base#/definitions/unused""
}
}";
JSchemaReader schemaReader = new JSchemaReader(resolver);
JSchema refSchema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
var unused = (JSchema)baseSchema.ExtensionData["definitions"]["unused"];
var usedByUnused = (JSchema)baseSchema.ExtensionData["definitions"]["used_by_unused"];
Assert.AreEqual(usedByUnused, unused.Not);
Assert.AreEqual(unused, refSchema.Not);
}
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);
}
/// <summary>
/// Finds a subschema using the given schema reference.
/// </summary>
/// <param name="reference">The schema reference used to get the subschema.</param>
/// <param name="rootSchema">The root schema to resolve the subschema from.</param>
/// <returns>The matching subschema.</returns>
public virtual JSchema GetSubschema(SchemaReference reference, JSchema rootSchema)
{
if (reference.SubschemaId == null)
{
return(rootSchema);
}
Uri rootSchemaId = reference.BaseUri;
Uri subschemaId = reference.SubschemaId;
JSchemaReader resolverSchemaReader = new JSchemaReader(new JSchemaReaderSettings
{
Resolver = this,
BaseUri = rootSchema.BaseUri
});
resolverSchemaReader.RootSchema = rootSchema;
JSchema subSchema = null;
SchemaDiscovery.FindSchema(s => subSchema = s, rootSchema, rootSchemaId, subschemaId, resolverSchemaReader);
if (subSchema != null)
{
resolverSchemaReader.ResolveDeferedSchemas();
return(subSchema);
}
return(null);
}
/// <summary>
/// Loads a <see cref="JSchema"/> from the specified <see cref="JsonReader"/>.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> containing the JSON Schema to load.</param>
/// <param name="resolver">The <see cref="JSchemaResolver"/> to use when resolving schema references.</param>
/// <returns>The <see cref="JSchema"/> object representing the JSON Schema.</returns>
public static JSchema Load(JsonReader reader, JSchemaResolver resolver)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
ValidationUtils.ArgumentNotNull(resolver, "resolver");
JSchemaReader schemaReader = new JSchemaReader(resolver);
return(schemaReader.ReadRoot(reader));
}
/// <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 static JSchema OpenSchemaResource(string name, JSchemaResolver resolver)
{
Stream s = OpenResource("Schemas." + name);
using (JsonReader reader = new JsonTextReader(new StreamReader(s)))
{
JSchemaReader schemaReader = new JSchemaReader(resolver);
return(schemaReader.ReadRoot(reader));
}
}
private static Uri?GetTokenId(JToken o, JSchemaReader schemaReader)
{
Uri?id = null;
if (schemaReader.EnsureVersion(SchemaVersion.Draft6) &&
o[Constants.PropertyNames.Id] is JValue idToken &&
(idToken.Type == JTokenType.String || idToken.Type == JTokenType.Uri))
{
id = GetTokenUri(idToken);
}
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 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 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 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 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 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 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 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 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 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 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 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 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 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);
}
private static Uri GetTokenId(JToken o, JSchemaReader schemaReader)
{
string id = null;
if (schemaReader.EnsureVersion(SchemaVersion.Draft6) &&
o[Constants.PropertyNames.Id] is JValue idToken &&
(idToken.Type == JTokenType.String || idToken.Type == JTokenType.Uri))
{
if (idToken.Type == JTokenType.Uri)
{
return((Uri)idToken);
}
id = (string)idToken;
}
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]);
}
/// <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 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);
}
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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_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 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 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 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 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 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 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 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);
}
