chore: update-discriminator-mapping

Michael-Wamae · Michael-Wamae · commit f9a529bec2cb · 2025-03-20T16:28:11.000+03:00
diff --git a/src/Microsoft.OpenApi/Models/OpenApiDiscriminator.cs b/src/Microsoft.OpenApi/Models/OpenApiDiscriminator.cs
@@ -1,8 +1,10 @@
 ﻿// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
+using System;
 using System.Collections.Generic;
 using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Writers;
 
 namespace Microsoft.OpenApi.Models
@@ -20,7 +22,7 @@ public class OpenApiDiscriminator : IOpenApiSerializable, IOpenApiExtensible
         /// <summary>
         /// An object to hold mappings between payload values and schema names or references.
         /// </summary>
-        public IDictionary<string, string>? Mapping { get; set; } = new Dictionary<string, string>();
+        public IDictionary<string, OpenApiSchemaReference>? Mapping { get; set; } = new Dictionary<string, OpenApiSchemaReference>();
 
         /// <summary>
         /// This object MAY be extended with Specification Extensions.
@@ -38,7 +40,7 @@ public OpenApiDiscriminator() { }
         public OpenApiDiscriminator(OpenApiDiscriminator discriminator)
         {
             PropertyName = discriminator?.PropertyName ?? PropertyName;
-            Mapping = discriminator?.Mapping != null ? new Dictionary<string, string>(discriminator.Mapping) : null;
+            Mapping = discriminator?.Mapping != null ? new Dictionary<string, OpenApiSchemaReference>(discriminator.Mapping) : null;
             Extensions = discriminator?.Extensions != null ? new Dictionary<string, IOpenApiExtension>(discriminator.Extensions) : null;
         }
 
@@ -48,7 +50,8 @@ public OpenApiDiscriminator(OpenApiDiscriminator discriminator)
         /// <param name="writer"></param>
         public void SerializeAsV31(IOpenApiWriter writer)
         {
-            SerializeInternal(writer);
+            SerializeInternal(writer,
+               (writer, referenceElement) => referenceElement.SerializeAsV31(writer));
 
             // extensions
             writer.WriteExtensions(Extensions, OpenApiSpecVersion.OpenApi3_1);
@@ -61,16 +64,16 @@ public void SerializeAsV31(IOpenApiWriter writer)
         /// </summary>
         public void SerializeAsV3(IOpenApiWriter writer)
         {
-            SerializeInternal(writer);
+            SerializeInternal(writer,
+                (writer, referenceElement) => referenceElement.SerializeAsV3(writer));
 
             writer.WriteEndObject();
         }
 
         /// <summary>
         /// Serialize <see cref="OpenApiDiscriminator"/> to Open Api v3.0
         /// </summary>
-        /// <param name="writer"></param>
-        private void SerializeInternal(IOpenApiWriter writer)
+        private void SerializeInternal(IOpenApiWriter writer, Action<IOpenApiWriter, IOpenApiReferenceHolder> action)
         {
             Utils.CheckArgumentNull(writer);
 
@@ -80,7 +83,7 @@ private void SerializeInternal(IOpenApiWriter writer)
             writer.WriteProperty(OpenApiConstants.PropertyName, PropertyName);
 
             // mapping
-            writer.WriteOptionalMap(OpenApiConstants.Mapping, Mapping, (w, s) => w.WriteValue(s));
+            writer.WriteOptionalMap(OpenApiConstants.Mapping, Mapping, (w, key, reference) => action(w, reference));
         }
 
         /// <summary>
diff --git a/src/Microsoft.OpenApi/Reader/V3/OpenApiDiscriminatorDeserializer.cs b/src/Microsoft.OpenApi/Reader/V3/OpenApiDiscriminatorDeserializer.cs
@@ -1,8 +1,10 @@
 ﻿// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
+using System.Collections.Generic;
 using System.Linq;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Reader.ParseNodes;
 
 namespace Microsoft.OpenApi.Reader.V3
@@ -22,7 +24,7 @@ internal static partial class OpenApiV3Deserializer
                 },
                 {
                     "mapping",
-                    (o, n, _) => o.Mapping = n.CreateSimpleMap(LoadString).Where(kv => kv.Value is not null).ToDictionary(kv => kv.Key, kv => kv.Value!)
+                    (o, n, doc) => o.Mapping = n.CreateMap(LoadMapping, doc)
                 }
             };
 
@@ -40,5 +42,13 @@ public static OpenApiDiscriminator LoadDiscriminator(ParseNode node, OpenApiDocu
 
             return discriminator;
         }
+        public static OpenApiSchemaReference LoadMapping(ParseNode node, OpenApiDocument hostDocument)
+        {
+            var mapNode = node.CheckMapNode("mapping");
+
+            var pointer = mapNode.GetReferencePointer();
+            var reference = GetReferenceIdAndExternalResource(pointer!);
+            return new OpenApiSchemaReference(reference.Item1, hostDocument, reference.Item2);
+        }
     }
 }
diff --git a/src/Microsoft.OpenApi/Reader/V3/OpenApiV3VersionService.cs b/src/Microsoft.OpenApi/Reader/V3/OpenApiV3VersionService.cs
@@ -9,6 +9,7 @@
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Properties;
 using Microsoft.OpenApi.Reader.ParseNodes;
 
@@ -62,7 +63,8 @@ public OpenApiV3VersionService(OpenApiDiagnostic diagnostic)
             [typeof(OpenApiServer)] = OpenApiV3Deserializer.LoadServer,
             [typeof(OpenApiServerVariable)] = OpenApiV3Deserializer.LoadServerVariable,
             [typeof(OpenApiTag)] = OpenApiV3Deserializer.LoadTag,
-            [typeof(OpenApiXml)] = OpenApiV3Deserializer.LoadXml
+            [typeof(OpenApiXml)] = OpenApiV3Deserializer.LoadXml,
+            [typeof(OpenApiSchemaReference)] = OpenApiV3Deserializer.LoadMapping
         };
 
         public OpenApiDocument LoadDocument(RootNode rootNode)
diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiDiscriminatorDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiDiscriminatorDeserializer.cs
@@ -1,7 +1,9 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.Linq;
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Reader.ParseNodes;
 
 namespace Microsoft.OpenApi.Reader.V31
@@ -22,9 +24,9 @@ internal static partial class OpenApiV31Deserializer
                     }
                 },
                 {
-                    "mapping", (o, n, _) =>
+                    "mapping", (o, n, doc) =>
                     {
-                        o.Mapping = n.CreateSimpleMap(LoadString).Where(kv => kv.Value is not null).ToDictionary(kv => kv.Key, kv => kv.Value!);
+                        o.Mapping = n.CreateMap(LoadMapping, doc);
                     }
                 }
             };
@@ -47,5 +49,14 @@ public static OpenApiDiscriminator LoadDiscriminator(ParseNode node, OpenApiDocu
 
             return discriminator;
         }
+
+        public static OpenApiSchemaReference LoadMapping(ParseNode node, OpenApiDocument hostDocument)
+        {
+            var mapNode = node.CheckMapNode("mapping");
+
+            var pointer = mapNode.GetReferencePointer();
+            var reference = GetReferenceIdAndExternalResource(pointer!);
+            return new OpenApiSchemaReference(reference.Item1, hostDocument, reference.Item2);
+        }
     }
 }
diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiV31VersionService.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiV31VersionService.cs
@@ -9,6 +9,7 @@
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Properties;
 using Microsoft.OpenApi.Reader.ParseNodes;
 using Microsoft.OpenApi.Reader.V3;
@@ -61,7 +62,8 @@ public OpenApiV31VersionService(OpenApiDiagnostic diagnostic)
             [typeof(OpenApiServer)] = OpenApiV31Deserializer.LoadServer,
             [typeof(OpenApiServerVariable)] = OpenApiV31Deserializer.LoadServerVariable,
             [typeof(OpenApiTag)] = OpenApiV31Deserializer.LoadTag,
-            [typeof(OpenApiXml)] = OpenApiV31Deserializer.LoadXml
+            [typeof(OpenApiXml)] = OpenApiV31Deserializer.LoadXml,
+            [typeof(OpenApiSchemaReference)] = OpenApiV31Deserializer.LoadMapping
         };
 
         public OpenApiDocument LoadDocument(RootNode rootNode)
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/Samples/OpenApiDocument/docWithExample.yaml b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/Samples/OpenApiDocument/docWithExample.yaml
@@ -75,8 +75,10 @@ components: # Reusable components for the API
       discriminator: # The discriminator for resolving the concrete schema type
         propertyName: petType
         mapping:
-          cat: '#/components/schemas/Cat'
-          dog: '#/components/schemas/Dog'
+          cat:
+            $ref: '#/components/schemas/Cat'
+          dog:
+            $ref: '#/components/schemas/Dog'
     Cat: # A schema for a cat object
       allOf:
         - $ref: '#/components/schemas/Pet'
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiDiscriminatorTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiDiscriminatorTests.cs
@@ -1,10 +1,15 @@
 ﻿// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
+using System;
+using System.Diagnostics;
 using System.IO;
 using System.Threading.Tasks;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Reader;
+using Microsoft.VisualStudio.TestPlatform.Utilities;
+using Newtonsoft.Json;
 using Xunit;
 
 namespace Microsoft.OpenApi.Readers.Tests.V3Tests
@@ -25,19 +30,20 @@ public async Task ParseBasicDiscriminatorShouldSucceed()
             memoryStream.Position = 0;
 
             // Act
-            var discriminator = OpenApiModelFactory.Load<OpenApiDiscriminator>(memoryStream, OpenApiSpecVersion.OpenApi3_0, OpenApiConstants.Yaml, new(), out var diagnostic, SettingsFixture.ReaderSettings);
+            var openApiDocument = new OpenApiDocument();
+            var discriminator = OpenApiModelFactory.Load<OpenApiDiscriminator>(memoryStream, OpenApiSpecVersion.OpenApi3_0, OpenApiConstants.Yaml, openApiDocument, out var diagnostic, SettingsFixture.ReaderSettings);
 
             // Assert
             Assert.Equivalent(
-                new OpenApiDiscriminator
-                {
-                    PropertyName = "pet_type",
-                    Mapping =
+               new OpenApiDiscriminator
+               {
+                   PropertyName = "pet_type",
+                   Mapping =
                     {
-                            ["puppy"] = "#/components/schemas/Dog",
-                            ["kitten"] = "Cat"
+                            ["puppy"] = new OpenApiSchemaReference("Dog", openApiDocument),
+                            ["kitten"] = new OpenApiSchemaReference("Cat", openApiDocument)
                     }
-                }, discriminator);
+               }, discriminator);
         }
     }
 }
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V3Tests/Samples/OpenApiDiscriminator/basicDiscriminator.yaml b/test/Microsoft.OpenApi.Readers.Tests/V3Tests/Samples/OpenApiDiscriminator/basicDiscriminator.yaml
@@ -1,4 +1,6 @@
 ﻿propertyName: pet_type
 mapping:
-    puppy: '#/components/schemas/Dog'
-    kitten: Cat
+    puppy: 
+      $ref: '#/components/schemas/Dog'
+    kitten: 
+      $ref: '#/components/schemas/Cat'
diff --git a/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt b/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt
@@ -699,7 +699,7 @@ namespace Microsoft.OpenApi.Models
         public OpenApiDiscriminator() { }
         public OpenApiDiscriminator(Microsoft.OpenApi.Models.OpenApiDiscriminator discriminator) { }
         public System.Collections.Generic.IDictionary<string, Microsoft.OpenApi.Interfaces.IOpenApiExtension>? Extensions { get; set; }
-        public System.Collections.Generic.IDictionary<string, string>? Mapping { get; set; }
+        public System.Collections.Generic.IDictionary<string, Microsoft.OpenApi.Models.References.OpenApiSchemaReference>? Mapping { get; set; }
         public string? PropertyName { get; set; }
         public void SerializeAsV2(Microsoft.OpenApi.Writers.IOpenApiWriter writer) { }
         public void SerializeAsV3(Microsoft.OpenApi.Writers.IOpenApiWriter writer) { }

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,10 @@`
`1`	`1`	`// Copyright (c) Microsoft Corporation. All rights reserved.`
`2`	`2`	`// Licensed under the MIT license.`
`3`	`3`
	`4`	`+using System.Collections.Generic;`
`4`	`5`	`using System.Linq;`
`5`	`6`	`using Microsoft.OpenApi.Models;`
	`7`	`+using Microsoft.OpenApi.Models.References;`
`6`	`8`	`using Microsoft.OpenApi.Reader.ParseNodes;`
`7`	`9`
`8`	`10`	`namespace Microsoft.OpenApi.Reader.V3`
`@@ -22,7 +24,7 @@ internal static partial class OpenApiV3Deserializer`
`22`	`24`	`},`
`23`	`25`	`{`
`24`	`26`	`"mapping",`
`25`		`- (o, n, _) => o.Mapping = n.CreateSimpleMap(LoadString).Where(kv => kv.Value is not null).ToDictionary(kv => kv.Key, kv => kv.Value!)`
	`27`	`+ (o, n, doc) => o.Mapping = n.CreateMap(LoadMapping, doc)`
`26`	`28`	`}`
`27`	`29`	`};`
`28`	`30`
`@@ -40,5 +42,13 @@ public static OpenApiDiscriminator LoadDiscriminator(ParseNode node, OpenApiDocu`
`40`	`42`
`41`	`43`	`return discriminator;`
`42`	`44`	`}`
	`45`	`+ public static OpenApiSchemaReference LoadMapping(ParseNode node, OpenApiDocument hostDocument)`
	`46`	`+ {`
	`47`	`+ var mapNode = node.CheckMapNode("mapping");`
	`48`	`+`
	`49`	`+ var pointer = mapNode.GetReferencePointer();`
	`50`	`+ var reference = GetReferenceIdAndExternalResource(pointer!);`
	`51`	`+ return new OpenApiSchemaReference(reference.Item1, hostDocument, reference.Item2);`
	`52`	`+ }`
`43`	`53`	`}`
`44`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,9 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Collections.Generic;`
`2`	`3`	`using System.Linq;`
`3`	`4`	`using Microsoft.OpenApi.Extensions;`
`4`	`5`	`using Microsoft.OpenApi.Models;`
	`6`	`+using Microsoft.OpenApi.Models.References;`
`5`	`7`	`using Microsoft.OpenApi.Reader.ParseNodes;`
`6`	`8`
`7`	`9`	`namespace Microsoft.OpenApi.Reader.V31`
`@@ -22,9 +24,9 @@ internal static partial class OpenApiV31Deserializer`
`22`	`24`	`}`
`23`	`25`	`},`
`24`	`26`	`{`
`25`		`- "mapping", (o, n, _) =>`
	`27`	`+ "mapping", (o, n, doc) =>`
`26`	`28`	`{`
`27`		`- o.Mapping = n.CreateSimpleMap(LoadString).Where(kv => kv.Value is not null).ToDictionary(kv => kv.Key, kv => kv.Value!);`
	`29`	`+ o.Mapping = n.CreateMap(LoadMapping, doc);`
`28`	`30`	`}`
`29`	`31`	`}`
`30`	`32`	`};`
`@@ -47,5 +49,14 @@ public static OpenApiDiscriminator LoadDiscriminator(ParseNode node, OpenApiDocu`
`47`	`49`
`48`	`50`	`return discriminator;`
`49`	`51`	`}`
	`52`	`+`
	`53`	`+ public static OpenApiSchemaReference LoadMapping(ParseNode node, OpenApiDocument hostDocument)`
	`54`	`+ {`
	`55`	`+ var mapNode = node.CheckMapNode("mapping");`
	`56`	`+`
	`57`	`+ var pointer = mapNode.GetReferencePointer();`
	`58`	`+ var reference = GetReferenceIdAndExternalResource(pointer!);`
	`59`	`+ return new OpenApiSchemaReference(reference.Item1, hostDocument, reference.Item2);`
	`60`	`+ }`
`50`	`61`	`}`
`51`	`62`	`}`