コード例 #1
8
        public void Example()
        {
            #region Usage
            // person.json, has a relative external schema reference 'address.json'
            // --------
            // {
            //   'type': 'object',
            //   'properties': {
            //     'name': {'type':'string'},
            //     'addresses': {
            //       'type': 'array',
            //       'items': {'$ref': 'address.json'}
            //     }
            //   }
            // }
            // --------

            using (StreamReader file = File.OpenText(@"c:\person.json"))
            using (JsonTextReader reader = new JsonTextReader(file))
            {
                JSchemaUrlResolver resolver = new JSchemaUrlResolver();

                JSchema schema = JSchema.Load(reader, new JSchemaReaderSettings
                {
                    Resolver = resolver,
                    // where the schema is being loaded from
                    // referenced 'address.json' schema will be loaded from disk at 'c:\address.json'
                    BaseUri = new Uri(@"c:\person.json")
                });

                // validate JSON
            }
            #endregion
        }
コード例 #2
0
        public void Example()
        {
            #region Usage
            // resolver will fetch 'http://schema.org/address.json' with a web request as the parent schema is loaded
            JSchemaUrlResolver resolver = new JSchemaUrlResolver();

            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

            Assert.IsTrue(isValid);
        }
コード例 #3
0
        public void HandleError()
        {
            JSchemaUrlResolver resolver = new JSchemaUrlResolver();
            resolver.SetDownloader(new MockDownloader());

            ExceptionAssert.Throws<JSchemaReaderException>(() => { JSchema.Parse(@"{
    'allOf': [
        {'$ref':'http://google.com#'}
    ]
}", resolver); },
                "Error when resolving schema reference 'http://google.com/#'. Path 'allOf[0]', line 3, position 9.");
        }
コード例 #4
0
        public async Task openapiv3___specific_version_json_validate_success()
        {
            base.SetupEnvironment();


            var request = @$ "
GET https://{host}/openapi/v3/doc?version=3 HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {applicationJson}
";

            using var httpContext = new MockHttpContext(this.ServiceProvider, request);
            var apiContext = await Invoke(httpContext).ConfigureAwait(false);

            var response = httpContext.Response;

            base.AssertResponse(
                apiContext: apiContext,
                response: response,
                expectedHttpStatus: 200,
                expectedContentType: applicationJson,
                shouldHaveResponse: true,
                expectedValidationState: ApiValidationState.Succeeded,
                extendedHeaders: new NameValuePairs <string, string>
            {
            });

            var data = await base.GetResponseDataString(response).ConfigureAwait(false);

            //System.Diagnostics.Debug.Write(data);

            data.Should().NotBeNull();
            data.Should().NotBeEmpty();
            data.Should().StartWith("{");
            data.Should().EndWith("}");

            var rawSchema = Encoding.UTF8.GetString(TestResources.openapi_v3);
            var resolver  = new JSchemaUrlResolver();

            var schema = JSchema.Parse(rawSchema, resolver);
            var json   = JObject.Parse(data);

            IList <ValidationError> errors = null;
            bool valid = json.IsValid(schema, out errors);

            valid.Should().BeTrue();
        }
コード例 #5
0
        private static bool Validate(JToken obj, string path, string schemaPath)
        {
            JSchemaUrlResolver resolver = new JSchemaUrlResolver();

            IList<ValidationError> errors;
            bool valid = true;

            using (StreamReader file = File.OpenText(schemaPath))
            using (JsonTextReader reader = new JsonTextReader(file))
            {
                JSchema schema = JSchema.Load(reader, new JSchemaReaderSettings { Resolver = resolver, BaseUri = new Uri(schemaPath) });
                try
                {
                    valid = obj.IsValid(schema, out errors);
                }
                catch (JSchemaException e)
                {
                    errors = new List<ValidationError>();
                    if (e.Message.Contains("free-quota limit"))
                    {
                        valid = true;
                    }
                    else
                    {
                        valid = false;
                    }
                }

                if (valid)
                {
                    return true;
                }
                else
                {
                    foreach (var error in errors)
                    {
                        Console.Error.WriteLine(error.ToString());
                    }
                    throw new InvalidDataException("Could not validate " + path);
                }
            }
        }
コード例 #6
0
ファイル: ItemCollection.cs プロジェクト: Terradue/DotNetStac
        private static JSchema GetSchema(Uri schemaUri)
        {
            JSchemaUrlResolver jSchemaResolver = new JSchemaUrlResolver();
            Stream             stream          = null;

            try
            {
                stream = jSchemaResolver.GetSchemaResource(null, new SchemaReference()
                {
                    BaseUri = schemaUri
                });
            }
            catch (Exception e)
            {
                throw new Stac.Exceptions.InvalidStacSchemaException(string.Format("Error getting schema at Uri '{0}'", schemaUri), e);
            }
            var sr = new StreamReader(stream);

            return(JSchema.Parse(sr.ReadToEnd(), jSchemaResolver));
        }
コード例 #7
0
        public async Task openapiv3___json_validate_success()
        {
            base.SetupEnvironment();


            var request = @$ "
GET https://{host}/openapi/v3/doc HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {applicationJson}";

            using var httpContext = new MockHttpContext(base.serviceProvider, request);
            var apiContext = await Invoke(httpContext).ConfigureAwait(false);

            var response = httpContext.Response;

            response.Should().NotBeNull();

            var data = await base.GetResponseDataString(response).ConfigureAwait(false);

            //System.Diagnostics.Debug.Write(data);

            data.Should().NotBeNullOrWhiteSpace();
            data.Should().NotBeEmpty();
            data.Should().StartWith("{");
            data.Should().EndWith("}");

            var rawSchema = Encoding.UTF8.GetString(TestResources.openapi_v3);
            var resolver  = new JSchemaUrlResolver();

            var schema = JSchema.Parse(rawSchema, resolver);
            var json   = JObject.Parse(data);

            IList <ValidationError> errors = null;
            bool valid = json.IsValid(schema, out errors);

            valid.Should().BeTrue();
        }
コード例 #8
0
        public IList <string> Validate()
        {
            if (string.IsNullOrEmpty(SchemaPath) || string.IsNullOrEmpty(jsonFullFileName))
            {
                return(null);
            }

            IList <string> errors = new List <string>();
            //  using (StreamReader reader = File.OpenText(@"C:\Users\dhedayati\Documents\Visual Studio 2017\Projects\Repos\JsonValid\JsonValid\BDPSchema\business.json"))
            var parentSchema = Path.Combine(SchemaPath, "business.json");

            if (!File.Exists(parentSchema))
            {
                //System.Windows.MessageBox.Show("Schema file cannot be found.","Error");
                errors.Add("Schema file cannot be found");
                return(errors);
            }

            using (StreamReader reader = File.OpenText(@"C:\Users\dhedayati\Documents\Visual Studio 2017\Projects\Repos\JsonValid\JsonValid\BDPSchema\business.json"))
            {
                using (JsonTextReader jsonReader = new JsonTextReader(reader))
                {
                    JSchemaUrlResolver resolver = new JSchemaUrlResolver();
                    JSchema            schema   = JSchema.Load(jsonReader, new JSchemaReaderSettings()
                    {
                        Resolver = resolver,

                        //BaseUri = new Uri(@"file://C:/Users/dhedayati/Documents/Visual Studio 2017/Projects/Repos/JsonValid/JsonValid/BDPSchema/")

                        BaseUri = new Uri(SchemaPath)
                    });

                    string data = ReadJsonFile();
                    var    jTok = JToken.Parse(data);
                    jTok.IsValid(schema, out errors);
                }
            }
            return(errors);
        }
コード例 #9
0
        public void ResolveRelativeFilePaths_InvalidNestedRef()
        {
            ExceptionAssert.Throws<JSchemaReaderException>(
                () =>
                {
                    JSchemaUrlResolver resolver = new JSchemaUrlResolver();

                    TestHelpers.OpenSchemaFile(@"resources\schemas\custom\root_invalidnestedref.json", resolver);
                },
                "Could not resolve schema reference 'sub/sub2.json#/definitions/invalid'. Path 'properties.property2', line 7, position 23.");
        }
コード例 #10
0
        public void ResolveRelativeFilePaths()
        {
            JSchemaUrlResolver resolver = new JSchemaUrlResolver();

            JSchema rootSchema = TestHelpers.OpenSchemaFile(@"resources\schemas\custom\root.json", resolver);

            Assert.AreEqual("Root", rootSchema.Title);
            Assert.IsTrue(rootSchema.BaseUri.OriginalString.EndsWith("root.json"));

            JSchema sub1 = rootSchema.Properties["property1"];
            Assert.AreEqual("Sub1", sub1.Title);
            Assert.IsTrue(sub1.BaseUri.OriginalString.EndsWith("sub1.json"));

            JSchema sub2 = rootSchema.Properties["property2"];
            Assert.AreEqual("Sub2", sub2.Title);
            Assert.IsTrue(sub2.BaseUri.OriginalString.EndsWith("sub/sub2.json"));

            JSchema nestedSub3 = sub2.Properties["property1"];

            JSchema sub2Def1 = rootSchema.Properties["property3"];
            Assert.AreEqual("Def1", sub2Def1.Title);
            Assert.IsTrue(sub2Def1.BaseUri.OriginalString.EndsWith("sub/sub2.json"));

            JSchema sub3 = rootSchema.Properties["property4"];
            Assert.AreEqual("Sub3", sub3.Title);
            Assert.IsTrue(sub3.BaseUri.OriginalString.EndsWith("sub3.json"));

            Assert.AreEqual(nestedSub3, sub3);
        }
コード例 #11
0
        public void Reference_InnerSchemaOfExternalSchema()
        {
            JSchemaUrlResolver resolver = new JSchemaUrlResolver();

            JSchema cleanSchema = TestHelpers.OpenSchemaFile(@"resources\schemas\grunt-clean-task.json", resolver);

            JSchema fileFormatSchema = cleanSchema.AdditionalProperties.AnyOf[0];

            Assert.NotNull(fileFormatSchema.BaseUri);
            Assert.AreEqual(true, fileFormatSchema.Properties.ContainsKey("files"));
        }