public void When_string_and_integer_enum_used_then_two_refs_are_generated()
{
//// Arrange
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.Integer
});
var data = schema.ToJson();
//// Assert
Assert.IsNotNull(schema.Properties["Bar"].ActualPropertySchema);
Assert.IsNotNull(schema.Properties["Bar2"].ActualPropertySchema); // must not be a reference but second enum declaration
Assert.AreNotEqual(schema.Properties["Bar"].ActualPropertySchema, schema.Properties["Bar2"].ActualPropertySchema);
}
public void When_property_is_not_required_then_required_attribute_is_not_rendered()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithoutRequiredObject>();
var schemaData = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco
});
var code = generator.GenerateFile();
//// Assert
Assert.IsFalse(code.Contains("[Required]"));
Assert.IsTrue(code.Contains("public string Property { get; set; }"));
}
public void When_property_is_nullable_then_property_schema_type_is_also_null()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassRoom>();
//// Act
var json = schema.ToJson();
//// Assert
Assert.IsFalse(schema.Properties["Id"].IsRequired);
Assert.IsFalse(schema.Properties["Name"].IsRequired);
Assert.IsFalse(schema.Properties["Size"].IsRequired);
Assert.IsFalse(schema.Properties["Id"].Type.HasFlag(JsonObjectType.Null));
Assert.IsTrue(schema.Properties["Name"].Type.HasFlag(JsonObjectType.Null));
Assert.IsTrue(schema.Properties["Size"].Type.HasFlag(JsonObjectType.Null));
}
public void When_property_has_default_attribute_then_default_value_is_set_in_generated_Poco_CSharp_code()
{
//// Arrange
var schema = JsonSchema4.FromType <DefaultPropertyGenerationClass>(new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.Integer
});
//// Act
var generator = new CSharpGenerator(schema);
generator.Settings.ClassStyle = CSharpClassStyle.Poco;
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.IsTrue(code.Contains("public string Test { get; set; } = \"foo\";"));
}
public void When_property_is_required_then_required_attribute_is_rendered()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithRequiredObject>();
var schemaData = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.IsTrue(code.Contains("[System.ComponentModel.DataAnnotations.Required]"));
Assert.IsTrue(code.Contains("public object Property { get; set; }"));
}
public void When_class_has_array_item_type_defined_then_schema_has_this_item_type()
{
//// Arrange
var schema = JsonSchema4.FromType <ArrayModel>();
//// Act
var json = schema.ToJson();
//// Assert
Assert.AreEqual(@"{
""$schema"": ""http://json-schema.org/draft-04/schema#"",
""type"": ""array"",
""items"": {
""type"": ""string""
}
}", json);
}
public void When_JsonInheritanceConverter_is_set_then_discriminator_field_is_set()
{
//// Arrange
var schema = JsonSchema4.FromType <Container>();
//// Act
var baseSchema = schema.Properties["Animal"].ActualPropertySchema.ActualSchema;
var discriminator = baseSchema.Discriminator;
var property = baseSchema.Properties["discriminator"];
var json = schema.ToJson();
//// Assert
Assert.IsNotNull(property);
Assert.IsTrue(property.IsRequired);
Assert.AreEqual("discriminator", discriminator);
}
public void When_enum_property_has_default_and_string_serialization_then_correct_csharp_code_generated()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithDefaultEnumProperty>(new JsonSchemaGeneratorSettings {
DefaultEnumHandling = EnumHandling.String
});
var schemaJson = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings {
ClassStyle = CSharpClassStyle.Poco
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("public ConstructionCode ConstructionCode { get; set; } = ConstructionCode.NON_CBST;"));
}
public void When_enum_is_generated_then_names_are_set()
{
//// Arrange
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.Integer
});
//// Assert
Assert.AreEqual(3, schema.Properties["Bar"].EnumerationNames.Count);
Assert.AreEqual("A", schema.Properties["Bar"].EnumerationNames.ElementAt(0));
Assert.AreEqual("B", schema.Properties["Bar"].EnumerationNames.ElementAt(1));
Assert.AreEqual("C", schema.Properties["Bar"].EnumerationNames.ElementAt(2));
}
public void When_FlattenInheritanceHierarchy_is_enabled_then_all_properties_are_in_one_schema()
{
//// Arrange
var settings = new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.String,
FlattenInheritanceHierarchy = true
};
//// Act
var schema = JsonSchema4.FromType(typeof(Teacher), settings);
var data = schema.ToJson();
//// Assert
Assert.IsTrue(schema.Properties.ContainsKey("Name"));
Assert.IsTrue(schema.Properties.ContainsKey("Class"));
}
public void When_date_handling_is_date_then_date_property_are_generated_in_class()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithDateProperty>();
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class,
//DateTimeType = TypeScriptDateTimeType.Date
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("myDateTime: Date"));
Assert.IsTrue(code.Contains("this.myDateTime = data[\"MyDateTime\"] ? new Date(data[\"MyDateTime\"].toString()) : null;"));
Assert.IsTrue(code.Contains("data[\"MyDateTime\"] = this.myDateTime ? this.myDateTime.toISOString() : null;"));
}
public void When_date_handling_is_string_then_string_property_are_generated_in_class()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithDateProperty>();
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class,
DateTimeType = TypeScriptDateTimeType.String
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("myDateTime: string"));
Assert.IsTrue(code.Contains("this.myDateTime = data[\"MyDateTime\"] !== undefined ? data[\"MyDateTime\"] : null;"));
Assert.IsTrue(code.Contains("data[\"MyDateTime\"] = this.myDateTime !== undefined ? this.myDateTime : null;"));
}
private static JsonSchema4 GetSchema(Type type)
{
return(JsonSchema4.FromType(type, new JsonSchemaGeneratorSettings {
DefaultEnumHandling = EnumHandling.String
}));
// JSchemaGenerator generator = new JSchemaGenerator();
//
// JSchema schema = generator.Generate(type);
//
// // I didn't find the way how to disallow JSchemaGenerator to use nullable types, swagger doesn't work with them
//
// string tmp = schema.ToString();
// string s = @"\""type\"":[\s\n\r]*\[[\s\n\r]*\""(\w+)\"",[\s\n\r]*\""null\""[\s\n\r]*\]";
// tmp = Regex.Replace(tmp, s, "\"type\": \"$1\"");
//
// return JSchema.Parse(tmp);
}
public void When_property_name_is_camel_then_schema_has_camel_names()
{
//// Arrange
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
DefaultPropertyNameHandling = PropertyNameHandling.CamelCase
});
var data = schema.ToJson();
//// Assert
Assert.IsTrue(schema.Properties.ContainsKey("barBar1"));
Assert.AreEqual("barBar1", schema.Properties["barBar1"].Name);
Assert.IsTrue(schema.Properties.ContainsKey("barBar2"));
Assert.AreEqual("barBar2", schema.Properties["barBar2"].Name);
}
public void When_property_name_is_default_then_schema_has_reflected_names()
{
//// Arrange
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
DefaultPropertyNameHandling = PropertyNameHandling.Default
});
var data = schema.ToJson();
//// Assert
Assert.IsTrue(schema.Properties.ContainsKey("BarBar1JsonProperty"));
Assert.AreEqual("BarBar1JsonProperty", schema.Properties["BarBar1JsonProperty"].Name);
Assert.IsTrue(schema.Properties.ContainsKey("BarBar2DataMember"));
Assert.AreEqual("BarBar2DataMember", schema.Properties["BarBar2DataMember"].Name);
}
public void When_string_and_integer_enum_used_then_one_enum_is_generated_in_CSharp()
{
//// Arrange
var schema = JsonSchema4.FromType <StringAndIntegerEnumTestClass>(new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.Integer
});
var data = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema);
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains(" B = 5,")); // B must be 5 even if B = 1 is first defined
Assert.AreEqual(3, code.Split(new[] { "public enum " }, StringSplitOptions.None).Count()); // two found (one string and one integer based enum)
Assert.AreEqual(3, code.Split(new[] { "[JsonConverter(typeof(StringEnumConverter))]" }, StringSplitOptions.None).Count()); // two found
}
public void When_converting_not_nullable_properties_then_they_should_have_null_type()
{
//// Act
var schema = JsonSchema4.FromType <MyType>();
//// Assert
Assert.IsFalse(schema.Properties["Integer"].IsRequired);
Assert.IsFalse(schema.Properties["Decimal"].IsRequired);
Assert.IsFalse(schema.Properties["Double"].IsRequired);
Assert.IsFalse(schema.Properties["Boolean"].IsRequired);
Assert.IsFalse(schema.Properties["String"].IsRequired);
Assert.IsFalse(schema.Properties["Integer"].Type.HasFlag(JsonObjectType.Null));
Assert.IsFalse(schema.Properties["Decimal"].Type.HasFlag(JsonObjectType.Null));
Assert.IsFalse(schema.Properties["Double"].Type.HasFlag(JsonObjectType.Null));
Assert.IsFalse(schema.Properties["Boolean"].Type.HasFlag(JsonObjectType.Null));
Assert.IsTrue(schema.Properties["String"].Type.HasFlag(JsonObjectType.Null));
}
public void When_primitive_type_mapping_is_available_for_type_then_it_is_called()
{
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
TypeMappers =
{
new PrimitiveTypeMapper(typeof(Bar), s => s.Type = JsonObjectType.String)
}
});
//// Assert
var json = schema.ToJson();
var property = schema.Properties["Bar1"].ActualPropertySchema;
Assert.IsTrue(property.Type.HasFlag(JsonObjectType.String));
Assert.IsFalse(json.Contains("$ref"));
}
public void When_property_is_string_enum_then_schema_has_enum()
{
//// Arrange
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.String
});
//// Assert
Assert.AreEqual(JsonObjectType.String, schema.Properties["Bar"].Type);
Assert.AreEqual(3, schema.Properties["Bar"].ActualSchema.Enumeration.Count);
Assert.AreEqual("A", schema.Properties["Bar"].ActualSchema.Enumeration.ElementAt(0));
Assert.AreEqual("B", schema.Properties["Bar"].ActualSchema.Enumeration.ElementAt(1));
Assert.AreEqual("C", schema.Properties["Bar"].ActualSchema.Enumeration.ElementAt(2));
}
public void When_dictionary_value_is_null_then_string_values_are_allowed()
{
//// Arrange
var schema = JsonSchema4.FromType <DictTest>();
var schemaData = schema.ToJson();
var data = @"{
""values"": {
""key"": ""value"",
}
}";
//// Act
var errors = schema.Validate(data);
//// Assert
Assert.AreEqual(0, errors.Count);
}
public void When_property_is_required_then_CSharp_code_is_correct()
{
//// Arrange
var schema = JsonSchema4.FromType <Person2>();
var schemaJson = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings {
ClassStyle = CSharpClassStyle.Poco
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(schemaJson.Contains(
@" ""required"": [
""FirstName"",
""Age""
],
""properties"": {
""FirstName"": {
""type"": ""string""
},
""MiddleName"": {
""type"": ""string""
},
""Age"": {
""type"": [
""integer"",
""null""
]
}
}"));
Assert.IsTrue(code.Contains(
@" [JsonProperty(""FirstName"", Required = Required.Always)]
[Required]
public string FirstName { get; set; }
[JsonProperty(""MiddleName"", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)]
public string MiddleName { get; set; }
[JsonProperty(""Age"", Required = Required.AllowNull)]
public int? Age { get; set; }"));
}
private static SwaggerService CreateService()
{
var service = new SwaggerService();
service.Paths["/Person"] = new SwaggerOperations();
service.Paths["/Person"][SwaggerOperationMethod.Get] = new SwaggerOperation
{
Responses = new Dictionary <string, SwaggerResponse>
{
{
"200", new SwaggerResponse
{
Schema = JsonSchema4.FromType(typeof(Person))
}
}
}
};
return(service);
}
public void When_property_is_integer_enum_then_schmea_has_enum()
{
//// Arrange
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
DefaultEnumHandling = EnumHandling.Integer
});
var data = schema.ToJson();
//// Assert
Assert.AreEqual(JsonObjectType.Integer, schema.Properties["Bar"].Type);
Assert.AreEqual(3, schema.Properties["Bar"].ActualSchema.Enumeration.Count);
Assert.AreEqual(0, schema.Properties["Bar"].ActualSchema.Enumeration.ElementAt(0));
Assert.AreEqual(5, schema.Properties["Bar"].ActualSchema.Enumeration.ElementAt(1));
Assert.AreEqual(6, schema.Properties["Bar"].ActualSchema.Enumeration.ElementAt(2));
}
public void When_property_is_required_then_required_attribute_is_rendered_in_Swagger_mode()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithRequiredObject>(new JsonSchemaGeneratorSettings
{
NullHandling = NullHandling.Swagger
});
var schemaData = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
NullHandling = NullHandling.Swagger
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("[Required]"));
Assert.IsTrue(code.Contains("public object Property { get; set; }"));
}
public void When_property_name_is_created_by_custom_fun_then_attribute_is_correct()
{
//// Arrange
var schema = JsonSchema4.FromType <Teacher>();
var schemaData = schema.ToJson();
var settings = new CSharpGeneratorSettings();
settings.TypeNameGenerator = new CustomTypeNameGenerator();
settings.PropertyNameGenerator = new CustomPropertyNameGenerator();
var generator = new CSharpGenerator(schema, settings);
//// Act
var output = generator.GenerateFile();
Console.WriteLine(output);
//// Assert
Assert.IsTrue(output.Contains(@"[JsonProperty(""lastName"""));
Assert.IsTrue(output.Contains(@"public string MyCustomLastName"));
Assert.IsTrue(output.Contains(@"public partial class MyCustomTypeTeacher"));
Assert.IsTrue(output.Contains(@"public partial class MyCustomTypePerson"));
}
static void Main(string[] args)
{
var lib = Assembly.GetExecutingAssembly();
foreach (Type type in lib.GetTypes().Where(t => t.Name != "Program" && t.Name.Contains("<>") == false))
{
Console.WriteLine(type.Name);
var schema = JsonSchema4.FromType(type, new JsonSchemaGeneratorSettings
{
DefaultPropertyNameHandling = PropertyNameHandling.CamelCase
});
var tsGenerator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Interface
});
var file = tsGenerator.GenerateFile();
Console.Write(file);
Console.WriteLine();
}
Console.ReadLine();
}
public static void Main(string[] args)
{
/* var restateClientFactory = new REstateClient.REstateClientFactory("http://localhost:5000/auth/apikey");
*/
/* var configClient = restateClientFactory.GetConfigurationClient("http://localhost:5000");
*
* var session = configClient.GetSessionAsync("E17705B5-D0FD-47F5-849F-F0881B954C58", CancellationToken.None).Result;
*
* var act = new Action(() =>
* {
*
* var instanceId = session.InstantiateAsync("Load-Test-Machine3", CancellationToken.None).Result;
*
* var resultState = session.FireTriggerAsync(instanceId, "GoPathA", null, null, null, CancellationToken.None).Result;
* });*/
//act.Invoke();
var schema = JsonSchema4.FromType <InstanceRecord>();
var schemaJson = schema.ToJson();
File.WriteAllText("D:\\InstanceRecord.json", schemaJson);
}
public void When_object_type_mapping_is_available_for_type_then_it_is_called()
{
//// Act
var schema = JsonSchema4.FromType <Foo>(new JsonSchemaGeneratorSettings
{
TypeMappers =
{
new ObjectTypeMapper(typeof(Bar), new JsonSchema4
{
Type = JsonObjectType.Object,
Properties =
{
{
"Prop",
new JsonProperty
{
IsRequired = true,
Type = JsonObjectType.String
}
}
}
}
)
}
});
//// Assert
var json = schema.ToJson();
var property1 = schema.Properties["Bar1"];
var property2 = schema.Properties["Bar2"];
Assert.IsTrue(property1.ActualPropertySchema.Properties.ContainsKey("Prop"));
Assert.IsTrue(property1.ActualPropertySchema == property2.ActualPropertySchema);
Assert.IsTrue(json.Contains("$ref"));
}
public void Demo()
{
var schema = JsonSchema4.FromType <Person>();
var schemaJsonData = schema.ToJson();
var errors = schema.Validate("...");
}
public static string testMnoSchema()
{
return(JsonSchema4.FromType <Mno>().ToJson());
}
