fix: support reinitializing OpenApiOperation.Tags to null and custom comparers (#3116) (#3142)

* fix: preserve custom tag comparers and sorted sets in OpenApiOperation copy constructor

Align the OpenApiOperation copy constructor with OpenApiOperation.Tags setter to preserve custom equality comparers, sorted sets, and immutable sorted sets, and add corresponding copy constructor unit tests.

* refactor: deduplicate tag normalization logic into static helper

Extract CopyTags static method to deduplicate tag normalization logic between OpenApiOperation.Tags setter and the copy constructor as requested in review.

Co-authored-by: Austin Aviv <abhikr6714@gmail.com>

Author: baywet

src/Microsoft.OpenApi/Models/OpenApiOperation.cs

@@ -28,21 +28,22 @@ public ISet<OpenApiTagReference>? Tags
             }
             set
             {
-                if (value is null)
-                {
-                    _tags = null;
-                    return;
-                }
-                _tags = value switch
-                {
-                    HashSet<OpenApiTagReference> tags when !ReferenceEquals(tags.Comparer, EqualityComparer<OpenApiTagReference>.Default) => value,
-                    SortedSet<OpenApiTagReference> => value,
+                _tags = CopyTags(value);
+            }
+        }
+
+        private static ISet<OpenApiTagReference>? CopyTags(ISet<OpenApiTagReference>? tags, bool copy = false)
+        {
+            return tags switch
+            {
+                null => null,
+                HashSet<OpenApiTagReference> hashSet when !ReferenceEquals(hashSet.Comparer, EqualityComparer<OpenApiTagReference>.Default) => copy ? new HashSet<OpenApiTagReference>(hashSet, hashSet.Comparer) : hashSet,
+                SortedSet<OpenApiTagReference> sorted => copy ? new SortedSet<OpenApiTagReference>(sorted, sorted.Comparer) : sorted,
 #if NET
-                    ImmutableSortedSet<OpenApiTagReference> => value,
+                ImmutableSortedSet<OpenApiTagReference> => tags,
 #endif
-                    _ => new HashSet<OpenApiTagReference>(value, OpenApiTagComparer.Instance),
-                };
-            }
+                _ => new HashSet<OpenApiTagReference>(tags, OpenApiTagComparer.Instance),
+            };
         }
 
         /// <summary>
@@ -139,7 +140,7 @@ public OpenApiOperation() { }
         public OpenApiOperation(OpenApiOperation operation)
         {
             Utils.CheckArgumentNull(operation);
-            Tags = operation.Tags != null ? new HashSet<OpenApiTagReference>(operation.Tags) : null;
+            Tags = CopyTags(operation.Tags, copy: true);
             Summary = operation.Summary ?? Summary;
             Description = operation.Description ?? Description;
             ExternalDocs = operation.ExternalDocs != null ? new(operation.ExternalDocs) : null;

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

@@ -939,5 +939,61 @@ public void TagsSupportsImmutableSortedSets()
             Assert.Equal(["tagC", "tagB", "tagA"], names);
             Assert.IsType<ImmutableSortedSet<OpenApiTagReference>>(operation.Tags);
         }
+
+        [Fact]
+        public void OpenApiOperationCopyConstructorPreservesCustomComparer()
+        {
+            var operation = new OpenApiOperation
+            {
+                Tags = new HashSet<OpenApiTagReference>(new CaseInsensitiveOpenApiTagReferenceEqualityComparer())
+                {
+                    new("Tag1")
+                }
+            };
+
+            var copy = new OpenApiOperation(operation);
+            Assert.NotNull(copy.Tags);
+            Assert.False(copy.Tags.Add(new OpenApiTagReference("tag1")));
+            Assert.Single(copy.Tags);
+        }
+
+        [Fact]
+        public void OpenApiOperationCopyConstructorPreservesSortedSet()
+        {
+            var operation = new OpenApiOperation
+            {
+                Tags = new SortedSet<OpenApiTagReference>(new DescendingOpenApiTagReferenceComparer())
+                {
+                    new("tagB"),
+                    new("tagA"),
+                    new("tagC"),
+                }
+            };
+
+            var copy = new OpenApiOperation(operation);
+            Assert.IsType<SortedSet<OpenApiTagReference>>(copy.Tags);
+            var copyNames = copy.Tags.Select(t => t.Name);
+            Assert.Equal(["tagC", "tagB", "tagA"], copyNames);
+        }
+
+        [Fact]
+        public void OpenApiOperationCopyConstructorPreservesImmutableSortedSet()
+        {
+            var operation = new OpenApiOperation
+            {
+                Tags = ImmutableSortedSet.Create(
+                    new DescendingOpenApiTagReferenceComparer(),
+                    [
+                        new OpenApiTagReference("tagB"),
+                        new OpenApiTagReference("tagA"),
+                        new OpenApiTagReference("tagC"),
+                    ]),
+            };
+
+            var copy = new OpenApiOperation(operation);
+            Assert.IsType<ImmutableSortedSet<OpenApiTagReference>>(copy.Tags);
+            var copyNames = copy.Tags.Select(t => t.Name);
+            Assert.Equal(["tagC", "tagB", "tagA"], copyNames);
+        }
     }
 }