public async Task When_deserializing_schema_then_it_should_be_read_correctly() { //// Arrange var data = @"{ ""title"": ""Example Schema"", ""type"": ""object"", ""properties"": { ""firstName"": { ""type"": ""string"" }, ""lastName"": { ""type"": ""string"" }, ""age"": { ""description"": ""Age in years"", ""type"": ""integer"", ""minimum"": 0 } }, ""required"": [""firstName"", ""lastName""] }"; //// Act var schema = await JsonSchema4.FromJsonAsync(data); var x = schema.ToJson(); //// Assert Assert.AreEqual(3, schema.Properties.Count); Assert.AreEqual(JsonObjectType.Object, schema.Type); }
public async Task When_definition_contains_maximum_a_range_attribute_is_not_added_for_anything_but_type_number_or_integer() { //// Arrange var json = @"{ ""type"": ""object"", ""properties"": { ""foo"": { ""type"": ""string"", ""maximum"": ""10"" } } }"; var schema = await JsonSchema4.FromJsonAsync(json); //// Act var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco, NullHandling = NullHandling.Swagger }); var code = generator.GenerateFile("MyClass"); //// Assert Assert.IsFalse(code.Contains("System.ComponentModel.DataAnnotations.Range")); }
public async Task When_definition_contains_min_length_a_string_length_attribute_is_added() { //// Arrange var json = @"{ ""type"": ""object"", ""properties"": { ""foo"": { ""type"": ""string"", ""minLength"": ""10"" } } }"; var schema = await JsonSchema4.FromJsonAsync(json); //// Act var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco, NullHandling = NullHandling.Swagger }); var code = generator.GenerateFile("MyClass"); //// Assert Assert.IsTrue(code.Contains("[System.ComponentModel.DataAnnotations.StringLength(int.MaxValue, MinimumLength = 10)]")); }
public async Task When_definition_contains_both_minimum_and_maximum_a_range_attribute_is_added() { //// Arrange var json = @"{ ""type"": ""object"", ""properties"": { ""foo"": { ""type"": ""integer"", ""minimum"": ""1"", ""maximum"": ""10"" } } }"; var schema = await JsonSchema4.FromJsonAsync(json); //// Act var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco, NullHandling = NullHandling.Swagger }); var code = generator.GenerateFile("MyClass"); //// Assert Assert.IsTrue(code.Contains("[System.ComponentModel.DataAnnotations.Range(1.0, 10.0)]")); }
public async Task When_Swagger2_enum_property_is_not_required_then_it_is_nullable() { var json = @"{ ""properties"": { ""sex"": { ""$ref"": ""#/definitions/Sex"" } }, ""definitions"": { ""Sex"": { ""type"": ""string"", ""enum"": [ ""male"", ""female"" ] } } }"; var schema = await JsonSchema4.FromJsonAsync(json); var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings { SchemaType = SchemaType.Swagger2, ClassStyle = CSharpClassStyle.Poco }); //// Act var code = generator.GenerateFile("MyClass"); //// Assert Assert.Contains(@"public Sex? Sex", code); }
public async Task When_schema_is_loaded_then_all_refs_are_resolved() { //// Arrange var json = @"{ ""$schema"": ""http://json-schema.org/draft-04/schema#"", ""type"": ""object"", ""allOf"": [ { ""$ref"": ""http://json-schema.org/draft-04/schema#"" }, { ""type"": ""object"", ""properties"": { ""simpleRef"": { ""type"": ""string"" } } } ], ""properties"": { ""simpleRef2"": { ""type"": ""string"" } } }"; //// Act var schema = await JsonSchema4.FromJsonAsync(json); var data = schema.ToJson(); //// Assert Assert.IsNotNull(schema.AllOf.First().SchemaReference); }
public async System.Threading.Tasks.Task asyncJsonSchemaTestAsync() { string path = Path.Combine(Directory.GetCurrentDirectory(), "..", "..", "..", "..", "cogsburger"); string subdir = Path.GetFileNameWithoutExtension(Path.GetTempFileName()); string outputPath = Path.Combine(Path.GetTempPath(), subdir); var directoryReader = new CogsDirectoryReader(); var cogsDtoModel = directoryReader.Load(path); var modelBuilder = new CogsModelBuilder(); var cogsModel = modelBuilder.Build(cogsDtoModel); var jsonPublisher = new JsonPublisher(); jsonPublisher.TargetDirectory = outputPath; jsonPublisher.Publish(cogsModel); JsonConvert.DefaultSettings = () => new JsonSerializerSettings { MetadataPropertyHandling = MetadataPropertyHandling.Ignore }; var schemaData = File.ReadAllText(Path.Combine(outputPath, "jsonSchema" + ".json")); var schema = await JsonSchema4.FromJsonAsync(schemaData); string[] tests = new string[] { "testing1_reference_reusable.json", "testing2_reference_Object.json", "test3_SimpleType.json", "test4_invalid_json.json", "ToDo.json", "testing5_more.json", "jsonOut.json" }; foreach (var test in tests) { using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Cogs.Tests." + test)) { StringBuilder lines = new StringBuilder(); using (StreamReader reader = new StreamReader(stream)) { string line; while ((line = reader.ReadLine()) != null) { lines.Append(line); } } if (!test.Contains("invalid")) { Assert.Empty(schema.Validate(lines.ToString())); } else { Assert.NotEmpty(schema.Validate(lines.ToString())); } } } }
public async Task When_has_more_than_one_of_then_it_is_invalid() { var schema = await JsonSchema4.FromJsonAsync(example_schema); var errors = schema.Validate(@"{ ""A"": ""string"", ""B"": 1, ""C"": 2 }"); Assert.Equal(1, errors.Count); }
public async Task When_does_not_have_one_of_then_it_is_invalid() { var schema = await JsonSchema4.FromJsonAsync(example_schema); var errors = schema.Validate(@"{ ""A"": ""string"" }"); Assert.Equal(1, errors.Count); }
public static Link WithParams(this Link link, object from) { var jsonString = JsonConvert.SerializeObject(from); var schema = Task.Run(async() => await JsonSchema4.FromJsonAsync(jsonString)); link.ParamSchema = schema.Result; return(link); }
/// <summary> /// Initializes a new instance of the <see cref="ButtplugJsonMessageParser"/> class. /// </summary> /// <param name="aLogManager">Log manager</param> public ButtplugJsonMessageParser(IButtplugLogManager aLogManager = null) { _bpLogger = aLogManager.GetLogger(GetType()); _bpLogger?.Info($"Setting up {GetType().Name}"); _serializer = new JsonSerializer { MissingMemberHandling = MissingMemberHandling.Error }; IEnumerable <Type> allTypes; // Some classes in the library may not load on certain platforms due to missing symbols. // If this is the case, we should still find messages even though an exception was thrown. try { allTypes = Assembly.GetAssembly(typeof(ButtplugMessage)).GetTypes(); } catch (ReflectionTypeLoadException e) { allTypes = e.Types; } var messageClasses = allTypes.Where(t => t != null && t.IsClass && t.Namespace == "B******g.Core.Messages" && typeof(ButtplugMessage).IsAssignableFrom(t)); var enumerable = messageClasses as Type[] ?? messageClasses.ToArray(); _bpLogger?.Debug($"Message type count: {enumerable.Length}"); _messageTypes = new Dictionary <string, Type>(); enumerable.ToList().ForEach(aMessageType => { _bpLogger?.Debug($"- {aMessageType.Name}"); _messageTypes.Add(aMessageType.Name, aMessageType); }); // Load the schema for validation var assembly = Assembly.GetExecutingAssembly(); const string resourceName = "B******g.Core.b******g-schema.json"; Stream stream = null; try { stream = assembly.GetManifestResourceStream(resourceName); using (var reader = new StreamReader(stream)) { stream = null; var result = reader.ReadToEnd(); _schema = JsonSchema4.FromJsonAsync(result).GetAwaiter().GetResult(); } } catch (Exception e) { _bpLogger.LogException(e); throw e; } finally { stream?.Dispose(); } }
public async Task When_all_of_has_multiple_refs_then_the_properties_should_expand_to_single_class() { //// Arrange var json = @"{ '$schema': 'http://json-schema.org/draft-04/schema#', 'id': 'http://some.domain.com/foo.json', 'type': 'object', 'additionalProperties': false, 'definitions': { 'tRef1': { 'properties': { 'val1': { 'type': 'string', } } }, 'tRef2': { 'properties': { 'val2': { 'type': 'string', } } }, 'tRef3': { 'properties': { 'val3': { 'type': 'string', } } } }, 'properties' : { 'tAgg': { 'allOf': [ {'$ref': '#/definitions/tRef1'}, {'$ref': '#/definitions/tRef2'}, {'$ref': '#/definitions/tRef3'} ] } } }"; //// Act var schema = await JsonSchema4.FromJsonAsync(json); var settings = new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco, Namespace = "ns" }; var generator = new CSharpGenerator(schema, settings); var output = generator.GenerateFile("Foo"); //// Assert Assert.Contains("public partial class TAgg", output); Assert.Contains("public string Val1 { get; set; }", output); Assert.Contains("public string Val2 { get; set; }", output); Assert.Contains("public string Val3 { get; set; }", output); }
public async Task When_tuple_types_has_ints_then_it_is_generated_correctly() { //// Arrange var json = @" { ""$schema"": ""http://json-schema.org/draft-04/schema#"", ""title"": ""MySchema"", ""type"": ""object"", ""required"": [ ""OuterList"" ], ""properties"": { ""OuterList"": { ""$ref"": ""#/definitions/OuterList"" } }, ""additionalProperties"": false, ""definitions"": { ""InnerList"": { ""description"": ""Only ever has 2 items"", ""type"": ""array"", ""minItems"": 2, ""maxItems"": 2, ""items"": [ { ""type"": ""integer"" }, { ""type"": ""integer"" } ], ""additionalItems"": false }, ""OuterList"": { ""type"": ""array"", ""items"": { ""$ref"": ""#/definitions/InnerList"" } } } }"; var schema = await JsonSchema4.FromJsonAsync(json); //// Act var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco, SchemaType = SchemaType.Swagger2, DateType = "System.DateTime" }); var code = generator.GenerateFile("MyClass"); //// Assert Assert.DoesNotContain("System.Linq.Enumerable+SelectIListIterator", code); Assert.Contains("ObservableCollection<System.Tuple<int, int>>", code); }
public async Task <SwaggerDocument> RunAsync() { var schema = await JsonSchema4.FromJsonAsync(Schema).ConfigureAwait(false); var document = new SwaggerDocument(); var rootSchemaName = string.IsNullOrEmpty(Name) && Regex.IsMatch(schema.Title, "^[a-zA-Z0-9_]*$") ? schema.Title : Name; document.Definitions[rootSchemaName] = schema; return(document); }
public async void test(string path) { string schemaData = System.IO.File.ReadAllText(path); var schema = await JsonSchema4.FromJsonAsync(schemaData); var generator = new CSharpGenerator(schema); var file = generator.GenerateFile(); System.IO.File.WriteAllText("D:/Result.cs", file); }
public async Task InitAsync() { Schema = await JsonSchema4.FromJsonAsync(@"{ ""type"": ""object"", ""required"": [""prop1"", ""prop3""], ""additionalProperties"": false, ""properties"": { ""prop1"": { ""type"": ""string"" }, ""prop2"": { ""type"": ""number"", ""enum"": [""this"", ""that""] }, ""prop3"": {}, ""prop4"": {} }, ""oneOf"": [ { ""properties"": { ""prop4"": { ""uniqueItems"": true } } }, { ""properties"": { ""prop2"": { ""minLength"": 123 } } }, { ""properties"": { ""prop1"": { ""maximum"": 10 } } } ], ""allOf"": [ { ""properties"": { ""prop1"": { ""minimum"": 22 } } }, { ""properties"": { ""prop2"": { ""pattern"": ""anything"" } } } ] }"); Json = @"{ ""prop1"": 12, ""prop2"": ""something"", ""prop4"": [1,2,3,1], ""prop5"": null }"; }
public async Task When_json_is_array_then_validate_should_not_throw_an_exception() { //// Act var svc = await JsonSchema4.FromJsonAsync(@"{ ""type"": ""array"", ""items"": { ""type"":""string"" } }"); //// Assert Assert.AreEqual(0, svc.Validate(JToken.Parse("[]")).Count); Assert.AreEqual(0, svc.Validate(JToken.Parse(@"[""test""]")).Count); Assert.AreEqual(0, svc.Validate("[]").Count); Assert.AreEqual(0, svc.Validate(@"[""test""]").Count); }
/// <summary>Creates a new <see cref="JsonDocumentModel"/> based on a given schema file path. </summary> /// <param name="schemaPath">The schema file path. </param> /// <param name="dispatcher">The UI dispatcher. </param> /// <returns>The <see cref="JsonDocumentModel"/>. </returns> public static Task <JsonDocumentModel> CreateAsync(string schemaPath, IDispatcher dispatcher) { return(Task.Run(() => { var schema = JsonSchema4.FromJsonAsync(File.ReadAllText(schemaPath, Encoding.UTF8)).GetAwaiter().GetResult(); var data = JsonObjectModel.FromSchema(schema); var document = new JsonDocumentModel(); document.Initialize(data, dispatcher); return document; })); }
/// <summary>Deserializes a JSON string to a <see cref="JsonSchema4" />.</summary> /// <param name="data">The JSON string.</param> /// <param name="documentPath">The document path (URL or file path) for resolving relative document references.</param> /// <param name="referenceResolverFactory">The JSON reference resolver factory.</param> /// <returns>The JSON Schema.</returns> public static async Task <JsonSchema4> FromYamlAsync(string data, string documentPath, Func <JsonSchema4, JsonReferenceResolver> referenceResolverFactory) { var deserializer = new DeserializerBuilder().Build(); var yamlObject = deserializer.Deserialize(new StringReader(data)); var serializer = new SerializerBuilder() .JsonCompatible() .Build(); var json = serializer.Serialize(yamlObject); return(await JsonSchema4.FromJsonAsync(json, documentPath, referenceResolverFactory).ConfigureAwait(false)); }
public async Task When_schema_has_metadata_properties_it_can_still_be_read() { //// Arrange var json = @"{ ""type"": ""object"", ""additionalProperties"": false, ""properties"": { ""$type"": { ""type"": ""string"", ""enum"": [ ""file"" ] }, ""Id"": { ""type"": ""string"", ""format"": ""guid"" }, ""Name"": { ""type"": ""string"" } }, ""required"": [ ""$type"", ""Id"", ""Name"" ] }"; //// Act var schema = await JsonSchema4.FromJsonAsync(json); //// Assert // No exception }
public async Task <IEnumerable <T> > GenerateAsync(Stream schemaStream, int count) { schemaStream.Seek(0, SeekOrigin.Begin); JsonSchema4 schema = null; using (var streamReader = new StreamReader(schemaStream)) { schema = await JsonSchema4.FromJsonAsync(streamReader.ReadToEnd()); } return(Enumerable .Range(1, count) .Select(number => Generate(schema))); }
public async Task Start(string consumerGroup, string messageJsonSchema) { var schema = await JsonSchema4.FromJsonAsync(messageJsonSchema); var runtimeInfo = await eventHubClient.GetRuntimeInformationAsync(); var d2cPartitions = runtimeInfo.PartitionIds; foreach (string partition in d2cPartitions) { tasks.Add(Task.Run(() => ReceiveMessagesFromDeviceAsync(consumerGroup, partition, schema, cts.Token))); } }
public async Task When_multiple_types_fail_with_errors_take_the_best_group() { //// Arrange var schemaJson = @"{ ""$schema"": ""http://json-schema.org/schema#"", ""type"": ""object"", ""properties"": { ""name"": { ""type"": ""string"", ""maxLength"": 40 }, ""settings"": { ""type"": [ ""object"", ""null"" ], ""properties"": { ""security"": { ""type"": [ ""object"", ""null"" ], ""properties"": { ""timeout"": { ""type"": [ ""integer"", ""null"" ], ""minimum"": 1, ""maximum"": 10 } }, ""additionalProperties"": false } }, ""additionalProperties"": false } }, ""required"": [ ""name"" ], ""additionalProperties"": false }"; var json = @"{ ""name"":""abc"", ""settings"": { ""security"":{ ""timeout"": 0 } } }"; //// Act var schema = await JsonSchema4.FromJsonAsync(schemaJson); var errors = schema.Validate(json); //// Assert Assert.Equal(1, errors.Count); Assert.Contains(errors, e => e.Kind == ValidationErrorKind.NoTypeValidates); }
/// <summary> /// Create a json schema from all discovered config object types. /// </summary> /// <returns>The json schema as a string.</returns> public async Task <String> CreateSchema() { var settings = new JsonSchemaGeneratorSettings() { FlattenInheritanceHierarchy = true, DefaultEnumHandling = EnumHandling.String }; var generator = new JsonSchemaGenerator(settings); var mergeSettings = new JsonMergeSettings() { MergeArrayHandling = MergeArrayHandling.Union }; var schema = new JsonSchema4(); foreach (var itemKey in configObjects.Keys) { var property = new JsonProperty(); JObject itemSchema = new JObject(); foreach (var item in configObjects[itemKey]) { if (item != typeof(Object)) { var jsonSchema = await generator.GenerateAsync(item); var jObjSchema = JObject.Parse(jsonSchema.ToJson()); jObjSchema["$schema"]?.Parent?.Remove(); //Remove any $schema properties itemSchema.Merge(jObjSchema, mergeSettings); } else { //If the type is ever object, set the type to object and stop itemSchema = new JObject(); property = new JsonProperty() { Type = JsonObjectType.Null | JsonObjectType.Object }; break; } } schema.Properties.Add(itemKey, property); if (itemSchema.Count > 0) { var jsonSchema = await JsonSchema4.FromJsonAsync(itemSchema.ToString()); property.Reference = jsonSchema; schema.Definitions.Add(itemKey, jsonSchema); } } return(schema.ToJson()); }
public async Task When_no_extension_data_is_available_then_property_is_null() { //// Arrange var json = @"{ ""$schema"": ""http://json-schema.org/draft-04/schema#"", }"; //// Act var schema = await JsonSchema4.FromJsonAsync(json); //// Assert Assert.IsNull(schema.ExtensionData); }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var inputJson = await GetInputJsonAsync().ConfigureAwait(false); var schema = await JsonSchema4.FromJsonAsync(inputJson).ConfigureAwait(false); var generator = new TypeScriptGenerator(schema); var code = generator.GenerateFile(Name); await TryWriteFileOutputAsync(host, () => code).ConfigureAwait(false); return(Task.FromResult <object>(code)); }
public async Task When_allOf_has_one_schema_then_it_is_inherited() { //// Arrange var json = @"{ ""type"": ""object"", ""discriminator"": ""type"", ""required"": [ ""prop"", ""type"" ], ""properties"": { ""prop"": { ""type"": ""string"", ""minLength"": 1, ""maxLength"": 30 }, ""prop2"": { ""type"": ""string"" }, ""type"": { ""type"": ""string"" } }, ""allOf"": [ { ""$ref"": ""#/definitions/B"" } ], ""definitions"": { ""B"": { ""type"": ""object"", ""properties"": { ""foo"": { ""type"": ""string"" } } } } }"; var schema = await JsonSchema4.FromJsonAsync(json); //// Act var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings()); var code = generator.GenerateFile("A"); //// Assert Assert.DoesNotContain("Anonymous", code); Assert.Contains("A : B", code); }
public async Task When_definition_entry_is_null_then_it_is_deserialized_correctly() { //// Arrange var json = @"{ ""definitions"": { ""abc"": null } }"; //// Act var schema = await JsonSchema4.FromJsonAsync(json); var json2 = schema.ToJson(); //// Assert Assert.False(schema.Definitions.ContainsKey("abc")); Assert.DoesNotContain("abc", json2); }
public async Task When_has_one_of_then_it_is_validated_correctly() { var schema = await JsonSchema4.FromJsonAsync(example_schema); var matches = new string[] { @"{ ""A"": ""string"", ""B"": 3 }", @"{ ""A"": ""string"", ""C"": 2 }" }; foreach (var match in matches) { var errors = schema.Validate(match); Assert.Equal(0, errors.Count); } }
public async Task When_deserializing_single_type_then_flags_should_be_set_correctly() { //// Arrange var data = @"{ ""type"": ""string"" }"; //// Act var schema = await JsonSchema4.FromJsonAsync(data); //// Assert Assert.IsTrue(schema.Type.HasFlag(JsonObjectType.String)); Assert.AreEqual(JsonObjectType.String, schema.Type); }