public async Task It_generates_valid_swagger_2_0_json_for_the_northwind_model()
{
using (WebApp.Start(HttpClientUtils.BaseAddress, NorthwindConfiguration))
{
// Arrange
var httpClient = HttpClientUtils.GetHttpClient(HttpClientUtils.BaseAddress);
// Act
var response = await httpClient.GetAsync("swagger/docs/v1");
// Assert
await response.ValidateSuccessAsync();
var swaggerJson = await response.Content.ReadAsStringAsync();
var resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://json-schema.org/draft-04/schema"), File.ReadAllText(@"schema-draft-v4.json"));
var swaggerSchema = File.ReadAllText(@"swagger-2.0-schema.json");
var schema = JSchema.Parse(swaggerSchema, resolver);
var swaggerJObject = JObject.Parse(swaggerJson);
IList <string> messages;
var isValid = swaggerJObject.IsValid(schema, out messages);
isValid.Should().BeTrue();
}
}
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 static async Task ValidateSwaggerJson()
{
// Arrange
var httpClient = HttpClientUtils.GetHttpClient(HttpClientUtils.BaseAddress);
// Act
var response = await httpClient.GetAsync("swagger/docs/v1");
// Assert
await response.ValidateSuccessAsync();
var swaggerJson = await response.Content.ReadAsStringAsync();
var resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://json-schema.org/draft-04/schema"), File.ReadAllText(@"schema-draft-v4.json"));
var swaggerSchema = File.ReadAllText(@"swagger-2.0-schema.json");
var schema = JSchema.Parse(swaggerSchema, resolver);
var swaggerJObject = JObject.Parse(swaggerJson);
IList <string> messages;
var isValid = swaggerJObject.IsValid(schema, out messages);
isValid.Should().BeTrue();
}
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 referencedSchemaJson = @"{
""definitions"": {},
""address"": {
""type"": ""object"",
""properties"": {
""street_address"": { ""type"": ""string"" },
""city"": { ""type"": ""string"" },
""state"": { ""type"": ""string"" }
},
""required"": [""street_address"", ""city"", ""state""]
}
}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("schema.json", UriKind.RelativeOrAbsolute), referencedSchemaJson);
JSchema sampleSchema = JSchema.Parse(@"{
'type': 'object',
'allOf': [
{ '$ref': 'schema.json#/address' }
]
}", resolver);
}
private static JSchema LoadSchema(string name, IEnumerable <JSchema> toResolve = null)
{
var resolver = new JSchemaPreloadedResolver();
if (toResolve != null)
{
foreach (var schema in toResolve)
{
resolver.Add(schema.Id, schema.ToString());
}
}
string uri = SchemaDirectory + name + ".schema.json";
try {
using (var fileReader = File.OpenText(uri)) {
using (var jsonReader = new JsonTextReader(fileReader)) {
return(JSchema.Load(jsonReader, resolver));
}
}
} catch (IOException ex) {
logger.Error(String.Format(name.ToUpper() + " schema [" + ex.GetType().Name + "]: " + ex.Message));
} catch (Exception ex) {
logger.Error(String.Format(name.ToUpper() + " schema [" + ex.GetType().Name + "]: " + ex.Message));
}
return(null);
}
public void GeoJson()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(OpenSchemaFile(@"resources\schemas\geojson\crs.json", resolver), new Uri("http://json-schema.org/geojson/crs.json#"));
resolver.Add(OpenSchemaFile(@"resources\schemas\geojson\bbox.json", resolver), new Uri("http://json-schema.org/geojson/bbox.json#"));
resolver.Add(OpenSchemaFile(@"resources\schemas\geojson\geometry.json", resolver), new Uri("http://json-schema.org/geojson/geometry.json#"));
JSchema schema = OpenSchemaFile(@"resources\schemas\geojson\geojson.json", resolver);
JObject o = JObject.Parse(@"{
""type"": ""Feature"",
""geometry"": {
""type"": ""Point"",
""coordinates"": [125.6, 10.1]
},
""properties"": {
""name"": ""Dinagat Islands""
}
}");
bool isValid = o.IsValid(schema);
Assert.IsTrue(isValid);
}
private static JSchemaPreloadedResolver GetResolver()
{
if (_resolver == null)
{
var resolver = new JSchemaPreloadedResolver();
AddSchema(resolver, "draft3.json", "http://json-schema.org/draft-03/schema");
AddSchema(resolver, "draft4.json", "http://json-schema.org/draft-04/schema");
AddSchema(resolver, "draft6.json", "http://json-schema.org/draft-06/schema");
AddSchema(resolver, "draft7.json", "http://json-schema.org/draft-07/schema");
AddSchema(resolver, "draft2019-09/draft2019-09.json", "https://json-schema.org/draft/2019-09/schema");
AddSchema(resolver, "draft2019-09/meta/applicator.json", "https://json-schema.org/draft/2019-09/meta/applicator");
AddSchema(resolver, "draft2019-09/meta/content.json", "https://json-schema.org/draft/2019-09/meta/content");
AddSchema(resolver, "draft2019-09/meta/core.json", "https://json-schema.org/draft/2019-09/meta/core");
AddSchema(resolver, "draft2019-09/meta/format.json", "https://json-schema.org/draft/2019-09/meta/format");
AddSchema(resolver, "draft2019-09/meta/hyper-schema.json", "https://json-schema.org/draft/2019-09/meta/hyper-schema");
AddSchema(resolver, "draft2019-09/meta/meta-data.json", "https://json-schema.org/draft/2019-09/meta/meta-data");
AddSchema(resolver, "draft2019-09/meta/validation.json", "https://json-schema.org/draft/2019-09/meta/validation");
AddSchema(resolver, "integer.json", "http://localhost:1234/integer.json");
AddSchema(resolver, "folder/folderInteger.json", "http://localhost:1234/folder/folderInteger.json");
AddSchema(resolver, "subSchemas.json", "http://localhost:1234/subSchemas.json");
AddSchema(resolver, "subSchemas-defs.json", "http://localhost:1234/subSchemas-defs.json");
AddSchema(resolver, "name.json", "http://localhost:1234/name.json");
AddSchema(resolver, "name-defs.json", "http://localhost:1234/name-defs.json");
_resolver = resolver;
}
return(_resolver);
}
public void Test()
{
string referencedSchemaJson = @"{
""definitions"": {},
""address"": {
""type"": ""object"",
""properties"": {
""street_address"": { ""type"": ""string"" },
""city"": { ""type"": ""string"" },
""state"": { ""type"": ""string"" }
},
""required"": [""street_address"", ""city"", ""state""]
}
}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("schema.json", UriKind.RelativeOrAbsolute), referencedSchemaJson);
JSchema sampleSchema = JSchema.Parse(@"{
'type': 'object',
'allOf': [
{ '$ref': 'schema.json#/address' }
]
}", resolver);
}
public void ReadSpecTest(SchemaSpecTest schemaSpecTest)
{
Console.WriteLine("Running reader JSON Schema {0} test {1}: {2}", schemaSpecTest.Version, schemaSpecTest.TestNumber, schemaSpecTest);
IList <string> errorMessages = new List <string>();
JSchemaPreloadedResolver resolver = GetResolver();
JSchema s = JSchema.Load(schemaSpecTest.Schema.CreateReader(), resolver);
JsonReader jsonReader = schemaSpecTest.Data.CreateReader();
using (JSchemaValidatingReader reader = new JSchemaValidatingReader(jsonReader))
{
reader.Schema = s;
reader.ValidationEventHandler += (sender, args) => errorMessages.Add(args.Message);
while (reader.Read())
{
}
}
bool isValid = (errorMessages.Count == 0);
Assert.AreEqual(schemaSpecTest.IsValid, isValid, schemaSpecTest.TestCaseDescription + " - " + schemaSpecTest.TestDescription + " - errors: " + StringHelpers.Join(", ", errorMessages));
}
/// <summary>
/// Links parent JSON schema validation rules with child rules through the referenceUri.
/// See ForgeSchemaValidatorTests for examples.
/// </summary>
/// <param name="parentRules">The parentRules that get validated against and link to the childRules.</param>
/// <param name="childRules">The childRules that get referenced by the parentRules.</param>
/// <param name="referenceUri">The reference URI in parentRules pointing to the childRules.</param>
/// <returns>The parentRules linked with the childRules through the referenceUri.</returns>
public static JSchema GetLinkedJSchemaRules(string parentRules, string childRules, string referenceUri)
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri(referenceUri), childRules);
return(JSchema.Parse(parentRules, resolver));
}
private static void AddSchema(JSchemaPreloadedResolver resolver, string schemaFileName, string id)
{
string baseRemotePath = ResolvePath(Path.Combine("Specs", "remotes"));
string json = File.ReadAllText(Path.Combine(baseRemotePath, schemaFileName));
resolver.Add(new Uri(id), json);
}
private static void AddSchema(JSchemaPreloadedResolver resolver, string schemaFileName, string id)
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string baseRemotePath = Path.Combine(baseDirectory, Path.Combine("Specs", "remotes"));
string json = File.ReadAllText(Path.Combine(baseRemotePath, schemaFileName));
resolver.Add(new Uri(id), json);
}
private static void getResolvers(ref JSchemaPreloadedResolver resolver, string path)
{
#region Data
resolver.Add(new Uri("dataJsonAPI.json", UriKind.RelativeOrAbsolute), new FileStream(path + @"Data/dataJsonAPI.json", FileMode.Open, FileAccess.Read));
#endregion
#region RegexPatterns
resolver.Add(new Uri("clientIdRegex.json", UriKind.RelativeOrAbsolute), new FileStream(path + @"RegexPatterns/clientIdRegex.json", FileMode.Open, FileAccess.Read));
#endregion
}
private static void AddPreloadedSchema(JSchemaPreloadedResolver resolver, Uri uri, string resourceName)
{
Stream schemaData = GetEmbeddedResourceStream(resourceName);
MemoryStream ms = new MemoryStream();
schemaData.CopyTo(ms);
resolver.Add(uri, ms.ToArray());
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="baseDir"></param>
public JSchemaRemoteResolver(string baseDir)
{
this.baseDir = baseDir ?? throw new ArgumentNullException(nameof(baseDir));
nested = new JSchemaPreloadedResolver();
nested.Add(new Uri("http://json-schema.org/draft-03/schema"), File.ReadAllText(Path.Combine(baseDir, @"schema-draft-03.json")));
nested.Add(new Uri("http://json-schema.org/draft-04/schema"), File.ReadAllText(Path.Combine(baseDir, @"schema-draft-04.json")));
nested.Add(new Uri("http://json-schema.org/draft-06/schema"), File.ReadAllText(Path.Combine(baseDir, @"schema-draft-06.json")));
nested.Add(new Uri("http://json-schema.org/draft-07/schema"), File.ReadAllText(Path.Combine(baseDir, @"schema-draft-07.json")));
}
static JsonStoreBase()
{
// preload schemas
PreloadedResolver = new JSchemaPreloadedResolver();
PreloadedResolver.Add(EnvelopeSchemaUri, EnvelopeSchemaString);
PreloadedResolver.Add(MessageSchemaUri, MessageSchemaString);
PreloadedResolver.Add(MetadataSchemaUri, MetadataSchemaString);
PreloadedResolver.Add(CatalogSchemaUri, CatalogSchemaString);
PreloadedResolver.Add(DataSchemaUri, DataSchemaString);
}
public void Test()
{
var resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("https://a.b.c/schemas/definitions.schema.json"), SchemaRef);
JSchema schema = JSchema.Parse(Schema, resolver);
Assert.AreEqual("https://a.b.c/schemas/message-base.schema.json", schema.Id.OriginalString);
Assert.AreEqual("https://a.b.c/schemas/definitions.schema.json", schema.Properties["gauges"].BaseUri.OriginalString);
Assert.AreEqual("https://a.b.c/schemas/definitions.schema.json", schema.Properties["gauges"].PatternProperties[".*"].OneOf[1].BaseUri.OriginalString);
}
private static JSchemaPreloadedResolver GetResolver()
{
if (_resolver == null)
{
var resolver = new JSchemaPreloadedResolver();
AddSchema(resolver, "draft3.json", "http://json-schema.org/draft-03/schema");
AddSchema(resolver, "draft4.json", "http://json-schema.org/draft-04/schema");
AddSchema(resolver, "integer.json", "http://localhost:1234/integer.json");
AddSchema(resolver, "folder/folderInteger.json", "http://localhost:1234/folder/folderInteger.json");
AddSchema(resolver, "subSchemas.json", "http://localhost:1234/subSchemas.json");
_resolver = resolver;
}
return(_resolver);
}
public void Reference_InnerSchemaOfExternalSchema()
{
JSchema baseSchema = TestHelpers.OpenSchemaFile(@"resources\schemas\grunt-task.json");
JSchema fileFormatSchema = (JSchema)baseSchema.ExtensionData["definitions"]["fileFormat"];
Assert.AreEqual("JSON schema for any Grunt task", baseSchema.Title);
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(baseSchema, new Uri("http://json.schemastore.org/grunt-task"));
JSchema cleanSchema = TestHelpers.OpenSchemaFile(@"resources\schemas\grunt-clean-task.json", resolver);
Assert.AreEqual(fileFormatSchema, cleanSchema.AdditionalProperties.AnyOf[0]);
}
public void Example()
{
#region Usage
string personSchemaJson = @"{
'type': 'object',
'properties': {
'name': { 'type': 'string' },
'age': { 'type': 'integer' }
}
}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("person.json", UriKind.RelativeOrAbsolute), personSchemaJson);
// the external 'person.json' schema will be found using the resolver
// the internal 'salary' schema will be found using the default resolution logic
JSchema employeeSchema = JSchema.Parse(@"{
'type': 'object',
'allOf': [
{ '$ref': 'person.json' }
],
'properties': {
'salary': { '$ref': '#/definitions/salary' },
'jobTitle': { 'type': 'string' }
},
'definitions': {
'salary': { 'type': 'number' }
}
}", resolver);
string json = @"{
'name': 'James',
'age': 29,
'salary': 9000.01,
'jobTitle': 'Junior Vice President'
}";
JObject employee = JObject.Parse(json);
bool valid = employee.IsValid(employeeSchema);
Console.WriteLine(valid);
// true
#endregion
Assert.IsTrue(valid);
}
public void Example()
{
#region Usage
string personSchemaJson = @"{
'type': 'object',
'properties': {
'name': { 'type': 'string' },
'age': { 'type': 'integer' }
}
}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("person.json", UriKind.RelativeOrAbsolute), personSchemaJson);
// the external 'person.json' schema will be found using the resolver
// the internal 'salary' schema will be found using the default resolution logic
JSchema employeeSchema = JSchema.Parse(@"{
'type': 'object',
'allOf': [
{ '$ref': 'person.json' }
],
'properties': {
'salary': { '$ref': '#/definitions/salary' },
'jobTitle': { 'type': 'string' }
},
'definitions': {
'salary': { 'type': 'number' }
}
}", resolver);
string json = @"{
'name': 'James',
'age': 29,
'salary': 9000.01,
'jobTitle': 'Junior Vice President'
}";
JObject employee = JObject.Parse(json);
bool valid = employee.IsValid(employeeSchema);
Console.WriteLine(valid);
// true
#endregion
Assert.IsTrue(valid);
}
public void Example()
{
#region Usage
string schemaJson = @"{
'id': 'person',
'type': 'object',
'properties': {
'name': {'type':'string'},
'age': {'type':'integer'}
}
}";
JSchema personSchema = JSchema.Parse(schemaJson);
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(personSchema);
schemaJson = @"{
'id': 'employee',
'type': 'object',
'extends': {'$ref':'person'},
'properties': {
'salary': {'type':'number'},
'jobTitle': {'type':'string'}
}
}";
JSchema employeeSchema = JSchema.Parse(schemaJson, resolver);
string json = @"{
'name': 'James',
'age': 29,
'salary': 9000.01,
'jobTitle': 'Junior Vice President'
}";
JObject employee = JObject.Parse(json);
bool valid = employee.IsValid(employeeSchema);
Console.WriteLine(valid);
// true
#endregion
Assert.IsTrue(valid);
}
private static async Task IsValidAgainstJsonSchemaAsync(HttpResponseMessage response)
{
var swaggerJson = await response.Content.ReadAsStringAsync();
var resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://json-schema.org/draft-04/schema"), File.ReadAllText(@"schema-draft-v4.json"));
var swaggerSchema = File.ReadAllText(@"swagger-2.0-schema.json");
var schema = JSchema.Parse(swaggerSchema, resolver);
var swaggerJObject = JObject.Parse(swaggerJson);
IList <string> messages;
var isValid = swaggerJObject.IsValid(schema, out messages);
isValid.Should().BeTrue();
}
public static bool validateJsonSchema(string JSON, JsonSchemas schemeToValidate, out IList <string> errorMessages, string schemasPath = "")
{
string path = getDirectoryPath(schemasPath, @"Schemas/");
errorMessages = new List <string>();
var resolver = new JSchemaPreloadedResolver();
getResolvers(ref resolver, path);
string fileSchema = string.Empty;
switch (schemeToValidate)
{
case JsonSchemas.PostClientRequest: fileSchema = @"ClientsAPI/postClient.json"; break;
case JsonSchemas.PutClientRequest: fileSchema = @"ClientsAPI/putClient.json"; break;
}
if (string.IsNullOrEmpty(fileSchema))
{
errorMessages.Add("JSON schema definition missing"); return(false);
}
JSchema schema;
JObject json;
try
{
using (StreamReader file = File.OpenText(path + fileSchema))
using (JsonTextReader reader = new JsonTextReader(file))
{
schema = JSchema.Load(reader, resolver);
json = new JObject();
try
{
json = JObject.Parse(JSON);
}
catch (JsonReaderException ex) { throw new GlobalException(HttpStatusCode.NotFound, "Not Valid JSON Format"); }
}
}
catch (FileNotFoundException fex) { throw new GlobalException(HttpStatusCode.NotFound, "File not found"); }
return(json.IsValid(schema, out errorMessages));
}
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 Test_WithBaseUri()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://example.com/schema1.json"), Schema1);
resolver.Add(new Uri("http://example.com/schema2.json"), Schema2);
JSchema schema = JSchema.Parse(Schema1, new JSchemaReaderSettings
{
Resolver = resolver,
BaseUri = new Uri("http://example.com/schema1.json")
});
JSchema fooSchema = schema.Properties["foo"];
Assert.AreEqual(JSchemaType.String, fooSchema.Properties["value"].Type);
JSchema bazSchema = (JSchema)schema.ExtensionData["definitions"]["baz"];
Assert.AreEqual(JSchemaType.Number, bazSchema.Properties["value"].Type);
}
public void JSchemaPreloadedResolver()
{
#region JSchemaPreloadedResolver
JSchema addressSchema = JSchema.Parse(@"{
'type': 'object',
'properties': {
'line1': {'type': 'string'},
'line2': {'type': 'string'},
'country': {'type': 'string'}
}
}");
// preload schema with ID 'http://schema.org/address.json'
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(addressSchema, new Uri("http://schema.org/address.json"));
// the external ref will use the preloaded schema
JSchema schema = JSchema.Parse(@"{
'type': 'object',
'properties': {
'name': {'type':'string'},
'addresses': {
'type': 'array',
'items': {'$ref': 'http://schema.org/address.json'}
}
}
}", resolver);
JToken json = JToken.Parse(@"{
'name': 'James',
'addresses': [
{
'line1': '99 Smithington Street',
'line2': 'Real Town',
'Country': 'USA'
}
]
}");
IList <string> errorMessages;
bool isValid = json.IsValid(schema, out errorMessages);
#endregion
}
public void FailToMatchPreloadedUriWithFragment()
{
try
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://json-schema.org/geojson/crs.json#"), TestHelpers.OpenFile(@"resources\schemas\geojson\crs.json"));
resolver.Add(new Uri("http://json-schema.org/geojson/bbox.json#"), TestHelpers.OpenFile(@"resources\schemas\geojson\bbox.json"));
resolver.Add(new Uri("http://json-schema.org/geojson/geometry.json#"), TestHelpers.OpenFile(@"resources\schemas\geojson\geometry.json"));
OpenSchemaFile(@"resources\schemas\geojson\geojson.json", resolver);
}
catch (JSchemaReaderException ex)
{
Assert.AreEqual("Could not resolve schema reference 'http://json-schema.org/geojson/crs.json#'. Path 'properties.crs', line 9, position 17.", ex.Message);
Uri baseUri = new Uri(TestHelpers.ResolveFilePath(@"resources\schemas\geojson\geojson.json"));
Assert.AreEqual(baseUri, ex.BaseUri);
}
}
public void Test_WithBaseUri()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://example.com/schema1.json"), Schema1);
resolver.Add(new Uri("http://example.com/schema2.json"), Schema2);
JSchema schema = JSchema.Parse(Schema1, new JSchemaReaderSettings
{
Resolver = resolver,
BaseUri = new Uri("http://example.com/schema1.json")
});
JSchema fooSchema = schema.Properties["foo"];
Assert.AreEqual(JSchemaType.String, fooSchema.Properties["value"].Type);
JSchema bazSchema = (JSchema)schema.ExtensionData["definitions"]["baz"];
Assert.AreEqual(JSchemaType.Number, bazSchema.Properties["value"].Type);
}
public void Test()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://example.com/schema1.json"), Schema1);
resolver.Add(new Uri("http://example.com/schema2.json"), Schema2);
JSchema schema = JSchema.Parse(Schema1, resolver);
JSchema fooSchema = schema.Properties["foo"];
Assert.AreEqual(JSchemaType.String, fooSchema.Properties["value"].Type);
// because the root schema has no BaseUri this schema won't be set back
ExceptionAssert.Throws<JSchemaException>(() =>
{
JSchema bazSchema = (JSchema)schema.ExtensionData["definitions"]["baz"];
Assert.IsNotNull(bazSchema);
}, "Cannot convert JToken to JSchema. No schema is associated with this token.");
Console.WriteLine(schema.ToString());
}
public JSchema ReadJsonSchema()
{
// We have the fibers report schema defined in FibersReport.json
// This in-turn has ref to FibersReportItem.json
// Whenever we have a ref, we must read the referred json firt (Parsing as schema not required, just read the text)
// And add the referred objects json schema text to the resolver
// And then use this resolver to parse the original schema
var fibersReportItemJsonSchemaAsText = File.ReadAllText(@"FibersReportItem.json");
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
//var fibersReportItemSchema = JSchema.Parse(fibersReportItemJsonSchemaAsText, resolver); // Not required here (See A)
resolver.Add(new Uri("FibersReportItem.json", UriKind.RelativeOrAbsolute), fibersReportItemJsonSchemaAsText);
var fibersReportJsonSchemaAsText = File.ReadAllText(@"FibersReport.json");
var fibersReportSchema = JSchema.Parse(fibersReportJsonSchemaAsText, resolver); // (A) This would then parse the referred object as well
return(fibersReportSchema);
// However, the resulting schema has referred object completely embedded inline (not cool)
}
public void Test()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://example.com/schema1.json"), Schema1);
resolver.Add(new Uri("http://example.com/schema2.json"), Schema2);
JSchema schema = JSchema.Parse(Schema1, resolver);
JSchema fooSchema = schema.Properties["foo"];
Assert.AreEqual(JSchemaType.String, fooSchema.Properties["value"].Type);
// because the root schema has no BaseUri this schema won't be set back
ExceptionAssert.Throws <JSchemaException>(() =>
{
JSchema bazSchema = (JSchema)schema.ExtensionData["definitions"]["baz"];
Assert.IsNotNull(bazSchema);
}, "Cannot convert JToken to JSchema. No schema is associated with this token.");
Console.WriteLine(schema.ToString());
}
public void WriteSpecTest(SchemaSpecTest schemaSpecTest)
{
Console.WriteLine("Running writer JSON Schema {0} test {1}: {2}", schemaSpecTest.Version, schemaSpecTest.TestNumber, schemaSpecTest);
IList <string> errorMessages = new List <string>();
JSchemaPreloadedResolver resolver = GetResolver();
var schemaToken = schemaSpecTest.Schema.DeepClone();
if (schemaToken.Type == JTokenType.Object)
{
schemaToken["$schema"] = GetSchemaUri(schemaSpecTest.Version);
}
JSchema s = JSchema.Load(schemaToken.CreateReader(), resolver);
s.SchemaVersion = GetSchemaUri(schemaSpecTest.Version);
JsonReader jsonReader = schemaSpecTest.Data.CreateReader();
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
using (JSchemaValidatingWriter validatingWriter = new JSchemaValidatingWriter(writer))
{
validatingWriter.Schema = s;
validatingWriter.ValidationEventHandler += (sender, args) => errorMessages.Add(args.Message);
while (jsonReader.Read())
{
validatingWriter.WriteToken(jsonReader.TokenType, jsonReader.Value);
}
}
bool isValid = (errorMessages.Count == 0);
Assert.AreEqual(schemaSpecTest.IsValid, isValid, schemaSpecTest.TestCaseDescription + " - " + schemaSpecTest.TestDescription + " - errors: " + StringHelpers.Join(", ", errorMessages));
}
public void Test()
{
string swaggerJson = TestHelpers.OpenFileText("Resources/Schemas/swagger-2.0.json");
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(
new Uri("http://json-schema.org/draft-04/schema"),
Encoding.UTF8.GetBytes(TestHelpers.OpenFileText("Resources/Schemas/schema-draft-v4.json")));
JSchema swagger = JSchema.Parse(swaggerJson, resolver);
// resolve the nested schema
JSchema infoSchema = resolver.GetSubschema(new SchemaReference
{
BaseUri = new Uri("#", UriKind.RelativeOrAbsolute),
SubschemaId = new Uri("#/definitions/info", UriKind.RelativeOrAbsolute)
}, swagger);
Assert.AreEqual("General information about the API.", infoSchema.Description);
Console.WriteLine(infoSchema.ToString());
}
public void GeoJson()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://json-schema.org/geojson/crs.json"), TestHelpers.OpenFile(@"resources\schemas\geojson\crs.json"));
resolver.Add(new Uri("http://json-schema.org/geojson/bbox.json"), TestHelpers.OpenFile(@"resources\schemas\geojson\bbox.json"));
resolver.Add(new Uri("http://json-schema.org/geojson/geometry.json"), TestHelpers.OpenFile(@"resources\schemas\geojson\geometry.json"));
JSchema schema = OpenSchemaFile(@"resources\schemas\geojson\geojson.json", resolver, new Uri("http://json-schema.org/geojson/geojson.json"));
JObject o = JObject.Parse(@"{
""type"": ""Feature"",
""geometry"": {
""type"": ""Point"",
""coordinates"": [125.6, 10.1]
},
""properties"": {
""name"": ""Dinagat Islands""
}
}");
bool isValid1 = o.IsValid(schema);
Assert.IsTrue(isValid1);
JObject o2 = JObject.Parse(@"{
""type"": ""Feature"",
""geometry"": {
""type"": ""Point"",
""coordinates"": [true, 10.1]
},
""bbox"": [1, 2.1, ""string?!""],
""properties"": {
""name"": ""Dinagat Islands""
}
}");
IList<ValidationError> errors;
bool isValid2 = o2.IsValid(schema, out errors);
Assert.IsFalse(isValid2);
Assert.AreEqual(new Uri("http://json-schema.org/geojson/bbox.json"), errors[0].SchemaBaseUri);
Assert.AreEqual(new Uri("http://json-schema.org/geojson/geojson.json"), errors[1].SchemaBaseUri);
PrintErrorsRecursive(errors, 0);
}
public void Reference_UnusedInnerSchemaOfExternalSchema()
{
string schemaJson = @"{
""definitions"": {
""unused"": {
""not"": {
""$ref"": ""#/definitions/used_by_unused""
}
},
""used_by_unused"": {
""title"": ""used by unused""
}
}
}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://localhost/base"), schemaJson);
string json = @"{
""not"": {
""$ref"": ""http://localhost/base#/definitions/unused""
}
}";
JSchemaReader schemaReader = new JSchemaReader(resolver);
JSchema refSchema = schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
Assert.IsNotNull(refSchema.Not);
Assert.AreEqual("used by unused", refSchema.Not.Not.Title);
}
public void ErrorInExternalSchema()
{
string schemaJson = @"{
""definitions"": {
""unused"": {
""not"": {
""$ref"": ""#/definitions/used_by_unused""
}
},
""used_by_unused"": {
""$ref"": ""#/definitions/invalid""
}
}
}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://localhost/base"), schemaJson);
string json = @"{
""not"": {
""$ref"": ""http://localhost/base#/definitions/unused""
}
}";
try
{
JSchemaReader schemaReader = new JSchemaReader(resolver);
schemaReader.ReadRoot(new JsonTextReader(new StringReader(json)));
}
catch (JSchemaReaderException ex)
{
Assert.AreEqual("Error when resolving schema reference 'http://localhost/base#/definitions/unused'. Path 'not', line 2, position 11.", ex.Message);
Assert.AreEqual(null, ex.BaseUri);
JSchemaReaderException inner = (JSchemaReaderException)ex.InnerException;
Assert.AreEqual("Could not resolve schema reference '#/definitions/invalid'. Path 'definitions.used_by_unused', line 8, position 24.", inner.Message);
Assert.AreEqual(new Uri("http://localhost/base"), inner.BaseUri);
}
}
public void RefToExternalRef()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
JSchema subSchema = JSchema.Parse(@"{
""integer"": {
""type"": ""integer""
},
""refToInteger"": {
""$ref"": ""#/integer""
}
}");
resolver.Add(new Uri("http://*****:*****@"{
""$ref"": ""http://localhost:1234/subSchemas.json#/refToInteger""
}", resolver);
Assert.AreEqual(JSchemaType.Integer, schema.Type);
}
public void InvalidPatternInDeferredResolvedSchema()
{
string schemaJson = @"{
""title"": ""JSON schema for DNX project.json files"",
""$schema"": ""http://json-schema.org/draft-04/schema#"",
""type"": ""object"",
""properties"": {
""authors"": {
""$ref"": ""http://test#/definitions/authors""
},
""authors2"": {
""pattern"":""[]""
}
}
}";
string resolvedSchemaJson = @"{
""id"": ""http://test#"",
""$schema"": ""http://json-schema.org/draft-04/schema#"",
""definitions"": {
""authors"": {
""type"": ""array"",
""items"": {
""type"": ""string"",
""uniqueItems"": true,
""pattern"":""[]""
}
}
}
}";
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://test"), resolvedSchemaJson);
List<ValidationError> errors = new List<ValidationError>();
JSchemaReaderSettings settings = new JSchemaReaderSettings();
settings.Resolver = resolver;
settings.ValidationEventHandler += (o, e) => errors.Add(e.ValidationError);
JSchema s = JSchema.Parse(schemaJson, settings);
Assert.AreEqual(2, errors.Count);
Assert.AreEqual(@"Could not parse regex pattern '[]'. Regex parser error: parsing ""[]"" - Unterminated [] set.", errors[0].Message);
Assert.AreEqual(ErrorType.Pattern, errors[0].ErrorType);
Assert.AreEqual("http://test/#/definitions/authors/items/0", errors[0].SchemaId.OriginalString);
Assert.AreEqual(s.Properties["authors"].Items[0], errors[0].Schema);
Assert.AreEqual("http://test", errors[0].Schema.BaseUri.OriginalString);
Assert.AreEqual(null, errors[1].Schema.BaseUri);
}
public void Swagger()
{
JSchemaPreloadedResolver resolver = new JSchemaPreloadedResolver();
resolver.Add(new Uri("http://json-schema.org/draft-04/schema"), TestHelpers.OpenFileText(@"resources\schemas\schema-draft-v4.json"));
string schemaJson = TestHelpers.OpenFileText(@"resources\schemas\swagger-2.0.json");
JSchema swaggerSchema = JSchema.Parse(schemaJson, resolver);
string json = TestHelpers.OpenFileText(@"resources\json\swagger-petstore.json");
JObject o = JObject.Parse(json);
IList<string> messages;
bool valid = o.IsValid(swaggerSchema, out messages);
Assert.IsFalse(valid);
Assert.AreEqual(1, messages.Count);
Assert.AreEqual(@"String 'http://petstore.swagger.io' does not match regex pattern '^[^{}/ :\\]+(?::\d+)?$'. Path 'host', line 16, position 41.", messages[0]);
Console.WriteLine(swaggerSchema.ToString());
}
