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