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 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 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() { 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()); }