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