public void Simple()
{
string json = @"
{
""description"": ""A person"",
""type"": ""object"",
""properties"":
{
""name"": {""type"":""string""},
""hobbies"": {
""type"": ""array"",
""items"": {""type"":""string""}
}
}
}
";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("A person", schema.Description);
Assert.AreEqual(JsonSchemaType.Object, schema.Type);
Assert.AreEqual(2, schema.Properties.Count);
Assert.AreEqual(JsonSchemaType.String, schema.Properties["name"].Type);
Assert.AreEqual(JsonSchemaType.Array, schema.Properties["hobbies"].Type);
Assert.AreEqual(JsonSchemaType.String, schema.Properties["hobbies"].Items[0].Type);
}
public void MultipleTypes()
{
string json = @"{
""description"":""Age"",
""type"":[""string"", ""integer""]
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Age", schema.Description);
Assert.AreEqual(JsonSchemaType.String | JsonSchemaType.Integer, schema.Type);
}
private void WriteType(string propertyName, JsonWriter writer, JsonSchemaType type)
{
IList <JsonSchemaType> types;
if (System.Enum.IsDefined(typeof(JsonSchemaType), type))
{
types = new List <JsonSchemaType> {
type
}
}
;
else
{
types = EnumUtils.GetFlagsValues(type).Where(v => v != JsonSchemaType.None).ToList();
}
if (types.Count == 0)
{
return;
}
writer.WritePropertyName(propertyName);
if (types.Count == 1)
{
writer.WriteValue(JsonSchemaBuilder.MapType(types[0]));
return;
}
writer.WriteStartArray();
foreach (JsonSchemaType jsonSchemaType in types)
{
writer.WriteValue(JsonSchemaBuilder.MapType(jsonSchemaType));
}
writer.WriteEndArray();
}
public void DisallowMultipleTypes()
{
string json = @"{
""description"":""DisallowMultipleTypes"",
""disallow"":[""string"",""number""]
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DisallowMultipleTypes", schema.Description);
Assert.AreEqual(JsonSchemaType.String | JsonSchemaType.Float, schema.Disallow);
}
public void MinimumMaximum()
{
string json = @"{
""description"":""MinimumMaximum"",
""minimum"":1.1,
""maximum"":1.2,
""minItems"":1,
""maxItems"":2,
""minLength"":5,
""maxLength"":50,
""divisibleBy"":3,
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(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.DivisibleBy);
}
public void DisallowSingleType()
{
string json = @"{
""description"":""DisallowSingleType"",
""disallow"":""string""
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DisallowSingleType", schema.Description);
Assert.AreEqual(JsonSchemaType.String, schema.Disallow);
}
public void References_Array()
{
string json = @"{
""array"": [{""type"": ""integer""},{""prop"":{""type"": ""object""}}],
""properties"": {
""array"": {""$ref"": ""#/array/0""},
""arrayprop"": {""$ref"": ""#/array/1/prop""}
}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Read(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(JsonSchemaType.Integer, schema.Properties["array"].Type);
Assert.AreEqual(JsonSchemaType.Object, schema.Properties["arrayprop"].Type);
}
public void Location()
{
string json = @"{
""properties"":{
""foo"":{
""type"":""array"",
""items"":[
{
""type"":""integer""
},
{
""properties"":{
""foo"":{
""type"":""integer""
}
}
}
]
}
}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Read(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("#", schema.Location);
Assert.AreEqual("#/properties/foo", schema.Properties["foo"].Location);
Assert.AreEqual("#/properties/foo/items/1/properties/foo", schema.Properties["foo"].Items[1].Properties["foo"].Location);
}
public void Options()
{
string json = @"{
""description"":""NZ Island"",
""type"":""string"",
""options"":
[
{""value"":""NI"",""label"":""North Island""},
{""value"":""SI"",""label"":""South Island""}
]
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("NZ Island", schema.Description);
Assert.AreEqual(JsonSchemaType.String, schema.Type);
Assert.AreEqual(2, schema.Options.Count);
Assert.AreEqual("North Island", schema.Options[new JValue("NI")]);
Assert.AreEqual("South Island", schema.Options[new JValue("SI")]);
}
public void CircularReference()
{
string json = @"{
""id"":""CircularReferenceArray"",
""description"":""CircularReference"",
""type"":[""array""],
""items"":{""$ref"":""CircularReferenceArray""}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("CircularReference", schema.Description);
Assert.AreEqual("CircularReferenceArray", schema.Id);
Assert.AreEqual(JsonSchemaType.Array, schema.Type);
Assert.AreEqual(schema, schema.Items[0]);
}
public void Id()
{
string json = @"{
""description"":""Id"",
""id"":""testid""
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Id", schema.Description);
Assert.AreEqual("testid", schema.Id);
}
public void Title()
{
string json = @"{
""description"":""Title"",
""title"":""testtitle""
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Title", schema.Description);
Assert.AreEqual("testtitle", schema.Title);
}
public void ReadOnly()
{
string json = @"{
""description"":""ReadOnly"",
""readonly"":true
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("ReadOnly", schema.Description);
Assert.AreEqual(true, schema.ReadOnly);
}
public void Hidden()
{
string json = @"{
""description"":""Hidden"",
""hidden"":true
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Hidden", schema.Description);
Assert.AreEqual(true, schema.Hidden);
}
public void ExclusiveMinimum_ExclusiveMaximum()
{
string json = @"{
""exclusiveMinimum"":true,
""exclusiveMaximum"":true
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(true, schema.ExclusiveMinimum);
Assert.AreEqual(true, schema.ExclusiveMaximum);
}
public void AdditionalProperties()
{
string json = @"{
""description"":""AdditionalProperties"",
""type"":[""string"", ""integer""],
""additionalProperties"":{""type"":[""object"", ""boolean""]}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("AdditionalProperties", schema.Description);
Assert.AreEqual(JsonSchemaType.Object | JsonSchemaType.Boolean, schema.AdditionalProperties.Type);
}
public void References_IndexNotInteger()
{
string json = @"{
""array"": [{""type"": ""integer""},{""prop"":{""type"": ""object""}}],
""properties"": {
""array"": {""$ref"": ""#/array/0""},
""arrayprop"": {""$ref"": ""#/array/one""}
}
}";
ExceptionAssert.Throws<JsonException>(
"Could not resolve schema reference '#/array/one'.",
() =>
{
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
builder.Read(new JsonTextReader(new StringReader(json)));
});
}
public void DefaultPrimitiveType()
{
string json = @"{
""description"":""DefaultPrimitiveType"",
""default"":1.1
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DefaultPrimitiveType", schema.Description);
Assert.AreEqual(1.1, (double)schema.Default);
}
public void UnresolvedReference()
{
ExceptionAssert.Throws<Exception>(@"Could not resolve schema reference for Id 'MyUnresolvedReference'.",
() =>
{
string json = @"{
""id"":""CircularReferenceArray"",
""description"":""CircularReference"",
""type"":[""array""],
""items"":{""$ref"":""MyUnresolvedReference""}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
});
}
public void DefaultComplexType()
{
string json = @"{
""description"":""DefaultComplexType"",
""default"":{""pie"":true}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("DefaultComplexType", schema.Description);
Assert.IsTrue(JToken.DeepEquals(JObject.Parse(@"{""pie"":true}"), schema.Default));
}
public void Reference_NonStandardLocation()
{
string json = @"{
""properties"": {
""bar"": {""$ref"": ""#/common/foo""},
""foo"": {""$ref"": ""#/common/foo""}
},
""common"": {
""foo"": {""type"": ""integer""}
}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Read(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""]
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Type", schema.Description);
Assert.AreEqual(JsonSchemaType.String | JsonSchemaType.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]);
}
/// <summary>
/// Reads a <see cref="JsonSchema"/> from the specified <see cref="JsonReader"/>.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> containing the JSON Schema to read.</param>
/// <param name="resolver">The <see cref="JsonSchemaResolver"/> to use when resolving schema references.</param>
/// <returns>The <see cref="JsonSchema"/> object representing the JSON Schema.</returns>
public static JsonSchema Read(JsonReader reader, JsonSchemaResolver resolver)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
ValidationUtils.ArgumentNotNull(resolver, "resolver");
JsonSchemaBuilder builder = new JsonSchemaBuilder(resolver);
return builder.Parse(reader);
}
public void Pattern()
{
string json = @"{
""description"":""Pattern"",
""pattern"":""testpattern""
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Pattern", schema.Description);
Assert.AreEqual("testpattern", schema.Pattern);
}
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""}
}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Read(new JsonTextReader(new StringReader(json)));
Assert.AreEqual(JsonSchemaType.Integer, schema.Properties["tilda"].Type);
Assert.AreEqual(JsonSchemaType.Object, schema.Properties["slash"].Type);
Assert.AreEqual(JsonSchemaType.Array, schema.Properties["percent"].Type);
}
public void PatternProperties()
{
string json = @"{
""patternProperties"": {
""[abc]"": { ""id"":""Blah"" }
}
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.IsNotNull(schema.PatternProperties);
Assert.AreEqual(1, schema.PatternProperties.Count);
Assert.AreEqual("Blah", schema.PatternProperties["[abc]"].Id);
}
public void Format()
{
string json = @"{
""description"":""Format"",
""format"":""testformat""
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Format", schema.Description);
Assert.AreEqual("testformat", schema.Format);
}
public void MultipleItems()
{
string json = @"{
""description"":""MultipleItems"",
""type"":""array"",
""items"": [{""type"":""string""},{""type"":""array""}]
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("MultipleItems", schema.Description);
Assert.AreEqual(JsonSchemaType.String, schema.Items[0].Type);
Assert.AreEqual(JsonSchemaType.Array, schema.Items[1].Type);
}
public void Requires()
{
string json = @"{
""description"":""Requires"",
""requires"":""PurpleMonkeyDishwasher""
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Requires", schema.Description);
Assert.AreEqual("PurpleMonkeyDishwasher", schema.Requires);
}
public void IdentityMultiple()
{
string json = @"{
""description"":""Identity"",
""identity"":[""PurpleMonkeyDishwasher"",""Antelope""]
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Parse(new JsonTextReader(new StringReader(json)));
Assert.AreEqual("Identity", schema.Description);
Assert.AreEqual(2, schema.Identity.Count);
Assert.AreEqual("PurpleMonkeyDishwasher", schema.Identity[0]);
Assert.AreEqual("Antelope", schema.Identity[1]);
}
public void AllowAdditionalItems()
{
string json = @"{
""items"": {},
""additionalItems"": false
}";
JsonSchemaBuilder builder = new JsonSchemaBuilder(new JsonSchemaResolver());
JsonSchema schema = builder.Read(new JsonTextReader(new StringReader(json)));
Assert.IsNull(schema.AdditionalItems);
Assert.AreEqual(false, schema.AllowAdditionalItems);
}
