Merge pull request #844 from RSuter/master

Release v9.13.3

src/NJsonSchema.CodeGeneration.CSharp.Tests/InheritanceTests.cs

@@ -1,7 +1,11 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Serialization;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 using NJsonSchema.CodeGeneration.CSharp;
+using NJsonSchema.Converters;
 using Xunit;
 
 namespace NJsonSchema.CodeGeneration.Tests.CSharp
@@ -38,5 +42,39 @@ public async Task When_empty_class_inherits_from_dictionary_then_allOf_inheritan
             Assert.Contains("public EmptyClassInheritingDictionary CustomDictionary", code);
             Assert.Contains("public partial class EmptyClassInheritingDictionary : System.Collections.Generic.Dictionary<string, object>", code);
         }
+
+        [KnownType(typeof(MyException))]
+        [JsonConverter(typeof(JsonInheritanceConverter), "kind")]
+        public class ExceptionBase : Exception
+        {
+            public string Foo { get; set; }
+        }
+
+        public class MyException : ExceptionBase
+        {
+            public string Bar { get; set; }
+        }
+
+        public class ExceptionContainer
+        {
+            public ExceptionBase Exception { get; set; }
+        }
+
+        [Fact]
+        public async Task When_class_with_discriminator_has_base_class_then_csharp_is_generated_correctly()
+        {
+            //// Arrange
+            var schema = await JsonSchema4.FromTypeAsync<ExceptionContainer>();
+            var data = schema.ToJson();
+
+            var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco });
+
+            //// Act
+            var code = generator.GenerateFile();
+
+            //// Assert
+            Assert.Contains("class ExceptionBase : Exception", code);
+            Assert.Contains("class MyException : ExceptionBase", code);
+        }
     }
 }

src/NJsonSchema.CodeGeneration.CSharp/Models/ClassTemplateModel.cs

@@ -89,10 +89,10 @@ public ClassTemplateModel(string typeName, CSharpGeneratorSettings settings,
         public bool GenerateJsonMethods => _settings.GenerateJsonMethods;
 
         /// <summary>Gets a value indicating whether the class has discriminator property.</summary>
-        public bool HasDiscriminator => !string.IsNullOrEmpty(_schema.Discriminator);
+        public bool HasDiscriminator => !string.IsNullOrEmpty(_schema.ActualDiscriminator);
 
         /// <summary>Gets the discriminator property name.</summary>
-        public string Discriminator => _schema.Discriminator;
+        public string Discriminator => _schema.ActualDiscriminator;
 
         /// <summary>Gets a value indicating whether the class has a parent class.</summary>
         public bool HasInheritance => _schema.InheritedTypeSchema != null;

src/NJsonSchema.CodeGeneration.CSharp/NJsonSchema.CodeGeneration.CSharp.csproj

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard1.3;netstandard2.0;net451</TargetFrameworks>
     <Description>JSON Schema reader, generator and validator for .NET</Description>
-    <Version>9.13.2</Version>
+    <Version>9.13.3</Version>
     <PackageTags>json schema validation generator .net</PackageTags>
-    <Copyright>Copyright © Rico Suter, 2017</Copyright>
+    <Copyright>Copyright © Rico Suter, 2018</Copyright>
     <PackageLicenseUrl>https://github.com/rsuter/NJsonSchema/blob/master/LICENSE.md</PackageLicenseUrl>
     <PackageProjectUrl>http://NJsonSchema.org</PackageProjectUrl>
     <SignAssembly>True</SignAssembly>

src/NJsonSchema.CodeGeneration.Tests/InheritanceSerializationTests.cs

@@ -208,7 +208,7 @@ public async Task When_JsonInheritanceConverter_is_set_then_discriminator_field_
 
             //// Act
             var baseSchema = schema.Properties["Animal"].ActualTypeSchema.ActualSchema;
-            var discriminator = baseSchema.Discriminator;
+            var discriminator = baseSchema.ActualDiscriminator;
             var property = baseSchema.Properties["discriminator"];
 
             var json = schema.ToJson();
@@ -230,10 +230,10 @@ public async Task When_JsonInheritanceConverter_is_set_then_discriminator_mappin
             var baseSchema = schema.Definitions["SubClass"].ActualSchema;
 
             //// Assert
-            Assert.Equal(3, baseSchema.DiscriminatorObject.Mapping.Count);
-            Assert.True(baseSchema.DiscriminatorObject.Mapping.ContainsKey("SubClass1"));
-            Assert.True(baseSchema.DiscriminatorObject.Mapping.ContainsKey("SubClass2"));
-            Assert.True(baseSchema.DiscriminatorObject.Mapping.ContainsKey("SubClass3"));
+            Assert.Equal(3, baseSchema.ActualDiscriminatorObject.Mapping.Count);
+            Assert.True(baseSchema.ActualDiscriminatorObject.Mapping.ContainsKey("SubClass1"));
+            Assert.True(baseSchema.ActualDiscriminatorObject.Mapping.ContainsKey("SubClass2"));
+            Assert.True(baseSchema.ActualDiscriminatorObject.Mapping.ContainsKey("SubClass3"));
         }
 
         [Fact]

src/NJsonSchema.CodeGeneration.TypeScript.Tests/InheritanceTests.cs

@@ -1,4 +1,8 @@
-using System.Collections.Generic;
+using Newtonsoft.Json;
+using NJsonSchema.Converters;
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -35,5 +39,39 @@ public async Task When_empty_class_inherits_from_dictionary_then_allOf_inheritan
             Assert.DoesNotContain("EmptyClassInheritingDictionary", code);
             Assert.Contains("customDictionary: { [key: string] : any; } | undefined;", code);
         }
+
+        [KnownType(typeof(MyException))]
+        [JsonConverter(typeof(JsonInheritanceConverter), "kind")]
+        public class ExceptionBase : Exception
+        {
+            public string Foo { get; set; }
+        }
+
+        public class MyException : ExceptionBase
+        {
+            public string Bar { get; set; }
+        }
+
+        public class ExceptionContainer
+        {
+            public ExceptionBase Exception { get; set; }
+        }
+
+        [Fact]
+        public async Task When_class_with_discriminator_has_base_class_then_csharp_is_generated_correctly()
+        {
+            //// Arrange
+            var schema = await JsonSchema4.FromTypeAsync<ExceptionContainer>();
+            var data = schema.ToJson();
+
+            var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings { TypeScriptVersion = 2.0m });
+
+            //// Act
+            var code = generator.GenerateFile();
+
+            //// Assert
+            Assert.Contains("class ExceptionBase extends Exception", code);
+            Assert.Contains("class MyException extends ExceptionBase", code);
+        }
     }
 }

src/NJsonSchema.CodeGeneration.TypeScript/Models/ClassTemplateModel.cs

@@ -46,13 +46,13 @@ public ClassTemplateModel(string typeName, string discriminatorName,
         public string DiscriminatorName { get; }
 
         /// <summary>Gets a value indicating whether the class has a discriminator property.</summary>
-        public bool HasDiscriminator => !string.IsNullOrEmpty(_schema.Discriminator);
+        public bool HasDiscriminator => !string.IsNullOrEmpty(_schema.ActualDiscriminator);
 
         /// <summary>Gets a value indicating whether the class or an inherited class has a discriminator property.</summary>
-        public bool HasBaseDiscriminator => _schema.BaseDiscriminator != null;
+        public bool HasBaseDiscriminator => _schema.ResponsibleDiscriminatorObject != null;
 
         /// <summary>Gets the class discriminator property name (may be defined in a inherited class).</summary>
-        public string BaseDiscriminator => _schema.BaseDiscriminator?.PropertyName;
+        public string BaseDiscriminator => _schema.ResponsibleDiscriminatorObject?.PropertyName;
 
         /// <summary>Gets a value indicating whether the class has description.</summary>
         public bool HasDescription => !(_schema is JsonProperty) && !string.IsNullOrEmpty(_schema.Description);

src/NJsonSchema.CodeGeneration.TypeScript/NJsonSchema.CodeGeneration.TypeScript.csproj

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard1.3;netstandard2.0;net451</TargetFrameworks>
     <Description>JSON Schema reader, generator and validator for .NET</Description>
-    <Version>9.13.2</Version>
+    <Version>9.13.3</Version>
     <PackageTags>json schema validation generator .net</PackageTags>
-    <Copyright>Copyright © Rico Suter, 2017</Copyright>
+    <Copyright>Copyright © Rico Suter, 2018</Copyright>
     <PackageLicenseUrl>https://github.com/rsuter/NJsonSchema/blob/master/LICENSE.md</PackageLicenseUrl>
     <PackageProjectUrl>http://NJsonSchema.org</PackageProjectUrl>
     <SignAssembly>True</SignAssembly>

src/NJsonSchema.CodeGeneration.TypeScript/TypeScriptTypeResolver.cs

@@ -55,7 +55,7 @@ public override string Resolve(JsonSchema4 schema, bool isNullable, string typeN
         /// <returns>The result.</returns>
         public bool SupportsConstructorConversion(JsonSchema4 schema)
         {
-            return schema?.ActualSchema.BaseDiscriminator == null;
+            return schema?.ActualSchema.ResponsibleDiscriminatorObject == null;
         }
 
         private string Resolve(JsonSchema4 schema, string typeNameHint, bool addInterfacePrefix)

src/NJsonSchema.CodeGeneration/Models/ClassTemplateModelBase.cs

@@ -41,7 +41,7 @@ protected ClassTemplateModelBase(TypeResolverBase resolver, JsonSchema4 schema,
         /// <summary>Gets the derived class names (discriminator key/type name).</summary>
         public ICollection<DerivedClassModel> DerivedClasses => _schema
             .GetDerivedSchemas(_rootObject)
-            .Select(p => new DerivedClassModel(p.Value, p.Key, _schema.ActualSchema.BaseDiscriminator, _resolver))
+            .Select(p => new DerivedClassModel(p.Value, p.Key, _schema.ActualSchema.ResponsibleDiscriminatorObject, _resolver))
             .ToList();
 
         /// <summary>The model of a derived class.</summary>

src/NJsonSchema.CodeGeneration/NJsonSchema.CodeGeneration.csproj

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard1.3;netstandard2.0;net451</TargetFrameworks>
     <Description>JSON Schema reader, generator and validator for .NET</Description>
-    <Version>9.13.2</Version>
+    <Version>9.13.3</Version>
     <PackageTags>json schema validation generator .net</PackageTags>
-    <Copyright>Copyright © Rico Suter, 2017</Copyright>
+    <Copyright>Copyright © Rico Suter, 2018</Copyright>
     <PackageLicenseUrl>https://github.com/rsuter/NJsonSchema/blob/master/LICENSE.md</PackageLicenseUrl>
     <PackageProjectUrl>http://NJsonSchema.org</PackageProjectUrl>
     <SignAssembly>True</SignAssembly>

src/NJsonSchema.Tests/Generation/InheritanceTests.cs

@@ -211,7 +211,7 @@ public async Task When_discriminator_is_externally_defined_then_it_is_generated(
             Assert.True(schema.Definitions.ContainsKey(nameof(BCommonThing)));
 
             var baseSchema = schema.Definitions[nameof(CommonThingBase)];
-            Assert.Equal("discriminator", baseSchema.Discriminator);
+            Assert.Equal("discriminator", baseSchema.ActualDiscriminator);
         }
 
         [Fact]
@@ -339,5 +339,43 @@ public async Task When_class_inherits_from_dictionary_then_allOf_contains_base_d
             Assert.True(bar.AllOf.First().IsDictionary); // base class (dictionary)
             Assert.True(bar.AllOf.Last().ActualProperties.Any()); // actual class
         }
+
+        [KnownType(typeof(MyException))]
+        [JsonConverter(typeof(JsonInheritanceConverter), "kind")]
+        public class ExceptionBase : Exception
+        {
+            public string Foo { get; set; }
+        }
+
+        public class MyException : ExceptionBase
+        {
+            public string Bar { get; set; }
+        }
+
+        public class ExceptionContainer
+        {
+            public ExceptionBase Exception { get; set; }
+        }
+
+        [Fact]
+        public async Task When_class_with_discriminator_has_base_class_then_mapping_is_placed_in_type_schema_and_not_root()
+        {
+            //// Arrange
+            var settings = new JsonSchemaGeneratorSettings
+            {
+                SchemaType = SchemaType.OpenApi3
+            };
+
+            //// Act
+            var schema = await JsonSchema4.FromTypeAsync<ExceptionContainer>(settings);
+            var json = schema.ToJson();
+
+            //// Assert
+            var exceptionBase = schema.Definitions["ExceptionBase"];
+
+            Assert.Null(exceptionBase.DiscriminatorObject);
+            Assert.NotNull(exceptionBase.ActualTypeSchema.DiscriminatorObject);
+            Assert.True(exceptionBase.ActualTypeSchema.DiscriminatorObject.Mapping.ContainsKey("MyException"));
+        }
     }
 }

src/NJsonSchema.Tests/Infrastructure/ReflectionExtensionsTests.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NJsonSchema.Infrastructure;
+using Xunit;
+
+namespace NJsonSchema.Tests.Infrastructure
+{
+    public class ReflectionExtensionsTests
+    {
+        public class MyType : IEquatable<MyType>, IEnumerable<int>
+        {
+            public bool Equals(MyType other)
+            {
+                throw new NotImplementedException();
+            }
+
+            public IEnumerator<int> GetEnumerator()
+            {
+                throw new NotImplementedException();
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        [Fact]
+        public void When_type_implements_equatable_then_item_type_can_be_retrieved()
+        {
+            //// Act
+            var itemType = typeof(MyType).GetEnumerableItemType();
+
+            //// Assert
+            Assert.Equal(typeof(int), itemType);
+        }
+    }
+}

src/NJsonSchema.Tests/Serialization/DiscriminatorSerializationTests.cs

@@ -45,7 +45,7 @@ public async Task When_discriminator_object_is_set_then_schema_is_correctly_seri
 
             Assert.Equal(json, json2);
 
-            Assert.Equal(schema2.Definitions["Foo"], schema2.DiscriminatorObject.Mapping["Bar"].ActualSchema);
+            Assert.Equal(schema2.Definitions["Foo"], schema2.ActualDiscriminatorObject.Mapping["Bar"].ActualSchema);
         }
 
         [Fact]

src/NJsonSchema.Yaml/NJsonSchema.Yaml.csproj

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard1.3;netstandard2.0;net45</TargetFrameworks>
     <Description>JSON Schema reader, generator and validator for .NET</Description>
-    <Version>9.13.2</Version>
+    <Version>9.13.3</Version>
     <PackageTags>json schema validation generator .net</PackageTags>
-    <Copyright>Copyright © Rico Suter, 2017</Copyright>
+    <Copyright>Copyright © Rico Suter, 2018</Copyright>
     <PackageLicenseUrl>https://github.com/rsuter/NJsonSchema/blob/master/LICENSE.md</PackageLicenseUrl>
     <PackageProjectUrl>http://NJsonSchema.org</PackageProjectUrl>
     <SignAssembly>True</SignAssembly>