test(models): verify copy constructors preserve custom tag collections

Author: hardikkaurani

test/Microsoft.OpenApi.Tests/Models/OpenApiDocumentTests.cs

@@ -2214,6 +2214,64 @@ public void TagsSupportsImmutableSortedSets()
             Assert.IsType<ImmutableSortedSet<OpenApiTag>>(document.Tags);
         }
 
+        [Fact]
+        public void EnsureOpenApiDocumentCopyConstructorPreservesCustomTagCollections()
+        {
+            var sortedDocument = new OpenApiDocument
+            {
+                Tags = new SortedSet<OpenApiTag>(new DescendingOpenApiTagComparer())
+                {
+                    new() { Name = "tagB" },
+                    new() { Name = "tagA" },
+                    new() { Name = "tagC" },
+                }
+            };
+
+            var copiedSorted = new OpenApiDocument(sortedDocument);
+            Assert.NotNull(copiedSorted.Tags);
+            Assert.IsType<SortedSet<OpenApiTag>>(copiedSorted.Tags);
+            Assert.Equal(["tagC", "tagB", "tagA"], copiedSorted.Tags.Select(t => t.Name));
+
+            // Ensure modifying copied set does not affect original
+            copiedSorted.Tags.Add(new OpenApiTag { Name = "tagD" });
+            Assert.Equal(3, sortedDocument.Tags.Count);
+            Assert.Equal(4, copiedSorted.Tags.Count);
+
+            var customHashDocument = new OpenApiDocument
+            {
+                Tags = new HashSet<OpenApiTag>(new CaseInsensitiveOpenApiTagEqualityComparer())
+                {
+                    new() { Name = "tag1" },
+                }
+            };
+
+            var copiedHash = new OpenApiDocument(customHashDocument);
+            Assert.NotNull(copiedHash.Tags);
+            Assert.IsType<HashSet<OpenApiTag>>(copiedHash.Tags);
+            Assert.False(copiedHash.Tags.Add(new OpenApiTag { Name = "TAG1" }));
+            Assert.True(copiedHash.Tags.Add(new OpenApiTag { Name = "tag2" }));
+            Assert.Equal(1, customHashDocument.Tags.Count);
+            Assert.Equal(2, copiedHash.Tags.Count);
+
+#if NET
+            var immutableDocument = new OpenApiDocument
+            {
+                Tags = ImmutableSortedSet.Create(
+                    new DescendingOpenApiTagComparer(),
+                    [
+                        new OpenApiTag { Name = "tagB" },
+                        new OpenApiTag { Name = "tagA" },
+                        new OpenApiTag { Name = "tagC" },
+                    ]),
+            };
+
+            var copiedImmutable = new OpenApiDocument(immutableDocument);
+            Assert.NotNull(copiedImmutable.Tags);
+            Assert.IsType<ImmutableSortedSet<OpenApiTag>>(copiedImmutable.Tags);
+            Assert.Equal(["tagC", "tagB", "tagA"], copiedImmutable.Tags.Select(t => t.Name));
+#endif
+        }
+
         public static TheoryData<OpenApiSpecVersion> OpenApiSpecVersions()
         {
             var values = new TheoryData<OpenApiSpecVersion>();

test/Microsoft.OpenApi.Tests/Models/OpenApiOperationTests.cs

@@ -939,5 +939,63 @@ public void TagsSupportsImmutableSortedSets()
             Assert.Equal(["tagC", "tagB", "tagA"], names);
             Assert.IsType<ImmutableSortedSet<OpenApiTagReference>>(operation.Tags);
         }
+
+        [Fact]
+        public void EnsureOpenApiOperationCopyConstructorPreservesCustomTagCollections()
+        {
+            var sortedOperation = new OpenApiOperation
+            {
+                Tags = new SortedSet<OpenApiTagReference>(new DescendingOpenApiTagReferenceComparer())
+                {
+                    new("tagB"),
+                    new("tagA"),
+                    new("tagC"),
+                }
+            };
+
+            var copiedSorted = new OpenApiOperation(sortedOperation);
+            Assert.NotNull(copiedSorted.Tags);
+            Assert.IsType<SortedSet<OpenApiTagReference>>(copiedSorted.Tags);
+            Assert.Equal(["tagC", "tagB", "tagA"], copiedSorted.Tags.Select(t => t.Name));
+
+            // Ensure modifying copied set does not affect original
+            copiedSorted.Tags.Add(new OpenApiTagReference("tagD"));
+            Assert.Equal(3, sortedOperation.Tags.Count);
+            Assert.Equal(4, copiedSorted.Tags.Count);
+
+            var customHashOperation = new OpenApiOperation
+            {
+                Tags = new HashSet<OpenApiTagReference>(new CaseInsensitiveOpenApiTagReferenceEqualityComparer())
+                {
+                    new("tag1"),
+                }
+            };
+
+            var copiedHash = new OpenApiOperation(customHashOperation);
+            Assert.NotNull(copiedHash.Tags);
+            Assert.IsType<HashSet<OpenApiTagReference>>(copiedHash.Tags);
+            Assert.False(copiedHash.Tags.Add(new OpenApiTagReference("TAG1")));
+            Assert.True(copiedHash.Tags.Add(new OpenApiTagReference("tag2")));
+            Assert.Equal(1, customHashOperation.Tags.Count);
+            Assert.Equal(2, copiedHash.Tags.Count);
+
+#if NET
+            var immutableOperation = new OpenApiOperation
+            {
+                Tags = ImmutableSortedSet.Create(
+                    new DescendingOpenApiTagReferenceComparer(),
+                    [
+                        new OpenApiTagReference("tagB"),
+                        new OpenApiTagReference("tagA"),
+                        new OpenApiTagReference("tagC"),
+                    ]),
+            };
+
+            var copiedImmutable = new OpenApiOperation(immutableOperation);
+            Assert.NotNull(copiedImmutable.Tags);
+            Assert.IsType<ImmutableSortedSet<OpenApiTagReference>>(copiedImmutable.Tags);
+            Assert.Equal(["tagC", "tagB", "tagA"], copiedImmutable.Tags.Select(t => t.Name));
+#endif
+        }
     }
 }