Harden OpenApi comparer implementations

captainsafia · captainsafia · commit 623fa19e5cf8 · 2024-06-14T18:58:32.000-07:00
diff --git a/src/OpenApi/src/Comparers/OpenApiAnyComparer.cs b/src/OpenApi/src/Comparers/OpenApiAnyComparer.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Linq;
 using Microsoft.OpenApi.Any;
 
 namespace Microsoft.AspNetCore.OpenApi;
@@ -24,7 +25,25 @@ public bool Equals(IOpenApiAny? x, IOpenApiAny? y)
             return true;
         }
 
-        return GetHashCode(x) == GetHashCode(y);
+        return x.AnyType == y.AnyType &&
+            (x switch
+            {
+                OpenApiNull _ => y is OpenApiNull,
+                OpenApiArray arrayX => y is OpenApiArray arrayY && arrayX.SequenceEqual(arrayY, Instance),
+                OpenApiObject objectX => y is OpenApiObject objectY && objectX.Keys.Count == objectY.Keys.Count && objectX.Keys.All(key => objectY.ContainsKey(key) && Equals(objectX[key], objectY[key])),
+                OpenApiBinary binaryX => y is OpenApiBinary binaryY && binaryX.Value.SequenceEqual(binaryY.Value),
+                OpenApiInteger integerX => y is OpenApiInteger integerY && integerX.Value == integerY.Value,
+                OpenApiLong longX => y is OpenApiLong longY && longX.Value == longY.Value,
+                OpenApiDouble doubleX => y is OpenApiDouble doubleY && doubleX.Value == doubleY.Value,
+                OpenApiFloat floatX => y is OpenApiFloat floatY && floatX.Value == floatY.Value,
+                OpenApiBoolean booleanX => y is OpenApiBoolean booleanY && booleanX.Value == booleanY.Value,
+                OpenApiString stringX => y is OpenApiString stringY && stringX.Value == stringY.Value,
+                OpenApiPassword passwordX => y is OpenApiPassword passwordY && passwordX.Value == passwordY.Value,
+                OpenApiByte byteX => y is OpenApiByte byteY && byteX.Value.SequenceEqual(byteY.Value),
+                OpenApiDate dateX => y is OpenApiDate dateY && dateX.Value == dateY.Value,
+                OpenApiDateTime dateTimeX => y is OpenApiDateTime dateTimeY && dateTimeX.Value == dateTimeY.Value,
+                _ => x.Equals(y)
+            });
     }
 
     public int GetHashCode(IOpenApiAny obj)
@@ -35,22 +54,8 @@ public int GetHashCode(IOpenApiAny obj)
         {
             hashCode.Add(primitive.PrimitiveType);
         }
-        if (obj is OpenApiArray array)
-        {
-            foreach (var item in array)
-            {
-                hashCode.Add(item, Instance);
-            }
-        }
-        if (obj is OpenApiObject openApiObject)
+        hashCode.Add<object?>(obj switch
         {
-            foreach (var item in openApiObject)
-            {
-                hashCode.Add(item.Key);
-                hashCode.Add(item.Value, Instance);
-            }
-        }
-        hashCode.Add<object?>(obj switch {
             OpenApiBinary binary => binary.Value,
             OpenApiInteger integer => integer.Value,
             OpenApiLong @long => @long.Value,
diff --git a/src/OpenApi/src/Comparers/OpenApiDiscriminatorComparer.cs b/src/OpenApi/src/Comparers/OpenApiDiscriminatorComparer.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Linq;
 using Microsoft.OpenApi.Models;
 
 namespace Microsoft.AspNetCore.OpenApi;
@@ -24,18 +25,16 @@ public bool Equals(OpenApiDiscriminator? x, OpenApiDiscriminator? y)
             return true;
         }
 
-        return GetHashCode(x) == GetHashCode(y);
+        return x.PropertyName == y.PropertyName &&
+            x.Mapping.Count == y.Mapping.Count &&
+            x.Mapping.Keys.All(key => y.Mapping.ContainsKey(key) && x.Mapping[key] == y.Mapping[key]);
     }
 
     public int GetHashCode(OpenApiDiscriminator obj)
     {
         var hashCode = new HashCode();
         hashCode.Add(obj.PropertyName);
-        foreach (var item in obj.Mapping)
-        {
-            hashCode.Add(item.Key);
-            hashCode.Add(item.Value);
-        }
+        hashCode.Add(obj.Mapping.Count);
         return hashCode.ToHashCode();
     }
 }
diff --git a/src/OpenApi/src/Comparers/OpenApiExternalDocsComparer.cs b/src/OpenApi/src/Comparers/OpenApiExternalDocsComparer.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.OpenApi.Any;
+using System.Linq;
 using Microsoft.OpenApi.Models;
 
 namespace Microsoft.AspNetCore.OpenApi;
@@ -25,26 +25,18 @@ public bool Equals(OpenApiExternalDocs? x, OpenApiExternalDocs? y)
             return true;
         }
 
-        return GetHashCode(x) == GetHashCode(y);
+        return x.Description == y.Description &&
+            x.Url == y.Url &&
+            x.Extensions.Count == y.Extensions.Count
+            && x.Extensions.Keys.All(k => y.Extensions.ContainsKey(k) && y.Extensions[k] == x.Extensions[k]);
     }
 
     public int GetHashCode(OpenApiExternalDocs obj)
     {
         var hashCode = new HashCode();
         hashCode.Add(obj.Description);
         hashCode.Add(obj.Url);
-        foreach (var item in obj.Extensions)
-        {
-            hashCode.Add(item.Key, StringComparer.Ordinal);
-            if (item.Value is IOpenApiAny openApiAny)
-            {
-                hashCode.Add(openApiAny, OpenApiAnyComparer.Instance);
-            }
-            else
-            {
-                hashCode.Add(item.Value);
-            }
-        }
+        hashCode.Add(obj.Extensions.Count);
         return hashCode.ToHashCode();
     }
 }
diff --git a/src/OpenApi/src/Comparers/OpenApiReferenceComparer.cs b/src/OpenApi/src/Comparers/OpenApiReferenceComparer.cs
@@ -24,20 +24,16 @@ public bool Equals(OpenApiReference? x, OpenApiReference? y)
             return true;
         }
 
-        return GetHashCode(x) == GetHashCode(y);
+        return x.ExternalResource == y.ExternalResource &&
+            x.HostDocument?.HashCode == y.HostDocument?.HashCode &&
+            x.Id == y.Id &&
+            x.Type == y.Type;
     }
 
     public int GetHashCode(OpenApiReference obj)
     {
         var hashCode = new HashCode();
         hashCode.Add(obj.ExternalResource);
-        if (obj.HostDocument is not null)
-        {
-            // Microsoft.OpenApi provides a HashCode property for
-            // the OpenAPI document that we can use to uniquely identify
-            // the host document that is referenced here.
-            hashCode.Add(obj.HostDocument.HashCode);
-        };
         hashCode.Add(obj.Id);
         if (obj.Type is not null)
         {
diff --git a/src/OpenApi/src/Comparers/OpenApiSchemaComparer.cs b/src/OpenApi/src/Comparers/OpenApiSchemaComparer.cs
@@ -26,46 +26,65 @@ public bool Equals(OpenApiSchema? x, OpenApiSchema? y)
             return true;
         }
 
-        return GetHashCode(x) == GetHashCode(y);
+        return Instance.Equals(x.AdditionalProperties, y.AdditionalProperties) &&
+            x.AdditionalPropertiesAllowed == y.AdditionalPropertiesAllowed &&
+            x.AllOf.SequenceEqual(y.AllOf, Instance) &&
+            x.AnyOf.SequenceEqual(y.AnyOf, Instance) &&
+            x.Deprecated == y.Deprecated &&
+            OpenApiAnyComparer.Instance.Equals(x.Default, y.Default) &&
+            x.Description == y.Description &&
+            OpenApiDiscriminatorComparer.Instance.Equals(x.Discriminator, y.Discriminator) &&
+            OpenApiAnyComparer.Instance.Equals(x.Example, y.Example) &&
+            x.ExclusiveMaximum == y.ExclusiveMaximum &&
+            x.ExclusiveMinimum == y.ExclusiveMinimum &&
+            x.Extensions.Count == y.Extensions.Count
+            && x.Extensions.Keys.All(k => y.Extensions.ContainsKey(k) && x.Extensions[k] is IOpenApiAny anyX && y.Extensions[k] is IOpenApiAny anyY && OpenApiAnyComparer.Instance.Equals(anyX, anyY)) &&
+            OpenApiExternalDocsComparer.Instance.Equals(x.ExternalDocs, y.ExternalDocs) &&
+            x.Enum.SequenceEqual(y.Enum, OpenApiAnyComparer.Instance) &&
+            x.Format == y.Format &&
+            Instance.Equals(x.Items, y.Items) &&
+            x.Title == y.Title &&
+            x.Type == y.Type &&
+            x.Maximum == y.Maximum &&
+            x.MaxItems == y.MaxItems &&
+            x.MaxLength == y.MaxLength &&
+            x.MaxProperties == y.MaxProperties &&
+            x.Minimum == y.Minimum &&
+            x.MinItems == y.MinItems &&
+            x.MinLength == y.MinLength &&
+            x.MinProperties == y.MinProperties &&
+            x.MultipleOf == y.MultipleOf &&
+            x.OneOf.SequenceEqual(y.OneOf, Instance) &&
+            Instance.Equals(x.Not, y.Not) &&
+            x.Nullable == y.Nullable &&
+            x.Pattern == y.Pattern &&
+            x.Properties.Keys.All(k => y.Properties.ContainsKey(k) && Instance.Equals(x.Properties[k], y.Properties[k])) &&
+            x.ReadOnly == y.ReadOnly &&
+            x.Required.Order().SequenceEqual(y.Required.Order()) &&
+            OpenApiReferenceComparer.Instance.Equals(x.Reference, y.Reference) &&
+            x.UniqueItems == y.UniqueItems &&
+            x.UnresolvedReference == y.UnresolvedReference &&
+            x.WriteOnly == y.WriteOnly &&
+            OpenApiXmlComparer.Instance.Equals(x.Xml, y.Xml);
     }
 
     public int GetHashCode(OpenApiSchema obj)
     {
         var hashCode = new HashCode();
         hashCode.Add(obj.AdditionalProperties, Instance);
         hashCode.Add(obj.AdditionalPropertiesAllowed);
-        foreach (var item in obj.AllOf)
-        {
-            hashCode.Add(item, Instance);
-        }
-        foreach (var item in obj.AnyOf)
-        {
-            hashCode.Add(item, Instance);
-        }
+        hashCode.Add(obj.AllOf.Count);
+        hashCode.Add(obj.AnyOf.Count);
         hashCode.Add(obj.Deprecated);
         hashCode.Add(obj.Default, OpenApiAnyComparer.Instance);
         hashCode.Add(obj.Description);
         hashCode.Add(obj.Discriminator, OpenApiDiscriminatorComparer.Instance);
         hashCode.Add(obj.Example, OpenApiAnyComparer.Instance);
         hashCode.Add(obj.ExclusiveMaximum);
         hashCode.Add(obj.ExclusiveMinimum);
-        foreach ((var key, var value) in obj.Extensions)
-        {
-            hashCode.Add(key);
-            if (value is IOpenApiAny any)
-            {
-                hashCode.Add(any, OpenApiAnyComparer.Instance);
-            }
-            else
-            {
-                hashCode.Add(value);
-            }
-        }
+        hashCode.Add(obj.Extensions.Count);
         hashCode.Add(obj.ExternalDocs, OpenApiExternalDocsComparer.Instance);
-        foreach (var item in obj.Enum)
-        {
-            hashCode.Add(item, OpenApiAnyComparer.Instance);
-        }
+        hashCode.Add(obj.Enum.Count);
         hashCode.Add(obj.Format);
         hashCode.Add(obj.Items, Instance);
         hashCode.Add(obj.Title);
@@ -79,23 +98,13 @@ public int GetHashCode(OpenApiSchema obj)
         hashCode.Add(obj.MinLength);
         hashCode.Add(obj.MinProperties);
         hashCode.Add(obj.MultipleOf);
-        foreach (var item in obj.OneOf)
-        {
-            hashCode.Add(item, Instance);
-        }
+        hashCode.Add(obj.OneOf.Count);
         hashCode.Add(obj.Not, Instance);
         hashCode.Add(obj.Nullable);
         hashCode.Add(obj.Pattern);
-        foreach ((var key, var value) in obj.Properties)
-        {
-            hashCode.Add(key);
-            hashCode.Add(value, Instance);
-        }
+        hashCode.Add(obj.Properties.Count);
         hashCode.Add(obj.ReadOnly);
-        foreach (var item in obj.Required.Order())
-        {
-            hashCode.Add(item);
-        }
+        hashCode.Add(obj.Required.Count);
         hashCode.Add(obj.Reference, OpenApiReferenceComparer.Instance);
         hashCode.Add(obj.UniqueItems);
         hashCode.Add(obj.UnresolvedReference);
diff --git a/src/OpenApi/src/Comparers/OpenApiXmlComparer.cs b/src/OpenApi/src/Comparers/OpenApiXmlComparer.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.OpenApi.Any;
+using System.Linq;
 using Microsoft.OpenApi.Models;
 
 namespace Microsoft.AspNetCore.OpenApi;
@@ -25,7 +25,13 @@ public bool Equals(OpenApiXml? x, OpenApiXml? y)
             return true;
         }
 
-        return GetHashCode(x) == GetHashCode(y);
+        return x.Name == y.Name &&
+            x.Namespace == y.Namespace &&
+            x.Prefix == y.Prefix &&
+            x.Attribute == y.Attribute &&
+            x.Wrapped == y.Wrapped &&
+            x.Extensions.Count == y.Extensions.Count
+            && x.Extensions.Keys.All(k => y.Extensions.ContainsKey(k) && y.Extensions[k] == x.Extensions[k]);
     }
 
     public int GetHashCode(OpenApiXml obj)
@@ -36,17 +42,7 @@ public int GetHashCode(OpenApiXml obj)
         hashCode.Add(obj.Prefix);
         hashCode.Add(obj.Attribute);
         hashCode.Add(obj.Wrapped);
-        foreach (var item in obj.Extensions)
-        {
-            hashCode.Add(item.Key);
-            if (item.Value is IOpenApiAny any)
-            {
-                hashCode.Add(any, OpenApiAnyComparer.Instance);
-            }
-            {
-                hashCode.Add(item.Value);
-            }
-        }
+        hashCode.Add(obj.Extensions.Count);
         return hashCode.ToHashCode();
     }
 }
diff --git a/src/OpenApi/test/Comparers/OpenApiAnyComparerTests.cs b/src/OpenApi/test/Comparers/OpenApiAnyComparerTests.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Text;
 using Microsoft.AspNetCore.OpenApi;
 using Microsoft.OpenApi.Any;
 
@@ -9,10 +10,15 @@ public class OpenApiAnyComparerTests
     public static object[][] Data => [
         [new OpenApiNull(), new OpenApiNull(), true],
         [new OpenApiNull(), new OpenApiBoolean(true), false],
+        [new OpenApiByte(1), new OpenApiByte(1), true],
+        [new OpenApiByte(1), new OpenApiByte(2), false],
+        [new OpenApiBinary(Encoding.UTF8.GetBytes("test")), new OpenApiBinary(Encoding.UTF8.GetBytes("test")), true],
+        [new OpenApiBinary(Encoding.UTF8.GetBytes("test2")), new OpenApiBinary(Encoding.UTF8.GetBytes("test")), false],
         [new OpenApiBoolean(true), new OpenApiBoolean(true), true],
         [new OpenApiBoolean(true), new OpenApiBoolean(false), false],
         [new OpenApiInteger(1), new OpenApiInteger(1), true],
         [new OpenApiInteger(1), new OpenApiInteger(2), false],
+        [new OpenApiInteger(1), new OpenApiLong(1), false],
         [new OpenApiLong(1), new OpenApiLong(1), true],
         [new OpenApiLong(1), new OpenApiLong(2), false],
         [new OpenApiFloat(1.1f), new OpenApiFloat(1.1f), true],
@@ -38,13 +44,6 @@ public class OpenApiAnyComparerTests
 
     [Theory]
     [MemberData(nameof(Data))]
-    public void ProducesCorrectHashCodeForAny(IOpenApiAny any, IOpenApiAny anotherAny, bool isEqual)
-    {
-        // Act
-        var hash = OpenApiAnyComparer.Instance.GetHashCode(any);
-        var anotherHash = OpenApiAnyComparer.Instance.GetHashCode(anotherAny);
-
-        // Assert
-        Assert.Equal(isEqual, hash.Equals(anotherHash));
-    }
+    public void ProducesCorrectEqualityForOpenApiAny(IOpenApiAny any, IOpenApiAny anotherAny, bool isEqual)
+        => Assert.Equal(isEqual, OpenApiAnyComparer.Instance.Equals(any, anotherAny));
 }
diff --git a/src/OpenApi/test/Comparers/OpenApiDiscriminatorComparerTests.cs b/src/OpenApi/test/Comparers/OpenApiDiscriminatorComparerTests.cs
@@ -18,13 +18,6 @@ public class OpenApiDiscriminatorComparerTests
 
     [Theory]
     [MemberData(nameof(Data))]
-    public void ProducesCorrectHashCodeForDiscriminator(OpenApiDiscriminator discriminator, OpenApiDiscriminator anotherDiscriminator, bool isEqual)
-    {
-        // Act
-        var hash = OpenApiDiscriminatorComparer.Instance.GetHashCode(discriminator);
-        var anotherHash = OpenApiDiscriminatorComparer.Instance.GetHashCode(anotherDiscriminator);
-
-        // Assert
-        Assert.Equal(isEqual, hash.Equals(anotherHash));
-    }
+    public void ProducesCorrectEqualityForOpenApiDiscriminator(OpenApiDiscriminator discriminator, OpenApiDiscriminator anotherDiscriminator, bool isEqual)
+        => Assert.Equal(isEqual, OpenApiDiscriminatorComparer.Instance.Equals(discriminator, anotherDiscriminator));
 }
diff --git a/src/OpenApi/test/Comparers/OpenApiExternalDocsComparerTests.cs b/src/OpenApi/test/Comparers/OpenApiExternalDocsComparerTests.cs
@@ -13,17 +13,11 @@ public class OpenApiExternalDocsComparerTests
         [new OpenApiExternalDocs { Description = "description" }, new OpenApiExternalDocs { Description = "description" }, true],
         [new OpenApiExternalDocs { Description = "description" }, new OpenApiExternalDocs { Description = "description", Url = new Uri("http://localhost") }, false],
         [new OpenApiExternalDocs { Description = "description", Url = new Uri("http://localhost") }, new OpenApiExternalDocs { Description = "description", Url = new Uri("http://localhost") }, true],
+        [new OpenApiExternalDocs { Description = "description", Url = new Uri("http://localhost") }, new OpenApiExternalDocs { Description = "description", Url = new Uri("http://localhost") }, true],
     ];
 
     [Theory]
     [MemberData(nameof(Data))]
-    public void ProducesCorrectHashCodeForAny(OpenApiExternalDocs externalDocs, OpenApiExternalDocs anotherExternalDocs, bool isEqual)
-    {
-        // Act
-        var hash = OpenApiExternalDocsComparer.Instance.GetHashCode(externalDocs);
-        var anotherHash = OpenApiExternalDocsComparer.Instance.GetHashCode(anotherExternalDocs);
-
-        // Assert
-        Assert.Equal(isEqual, hash.Equals(anotherHash));
-    }
+    public void ProducesCorrectEqualityForOpenApiExternalDocs(OpenApiExternalDocs externalDocs, OpenApiExternalDocs anotherExternalDocs, bool isEqual)
+        => Assert.Equal(isEqual, OpenApiExternalDocsComparer.Instance.Equals(externalDocs, anotherExternalDocs));
 }
diff --git a/src/OpenApi/test/Comparers/OpenApiReferenceComparerTests.cs b/src/OpenApi/test/Comparers/OpenApiReferenceComparerTests.cs
diff --git a/src/OpenApi/test/Comparers/OpenApiSchemaComparerTests.cs b/src/OpenApi/test/Comparers/OpenApiSchemaComparerTests.cs
diff --git a/src/OpenApi/test/Comparers/OpenApiXmlComparerTests.cs b/src/OpenApi/test/Comparers/OpenApiXmlComparerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
	`4`	`+using System.Linq;`
`4`	`5`	`using Microsoft.OpenApi.Models;`
`5`	`6`
`6`	`7`	`namespace Microsoft.AspNetCore.OpenApi;`
`@@ -24,18 +25,16 @@ public bool Equals(OpenApiDiscriminator? x, OpenApiDiscriminator? y)`
`24`	`25`	`return true;`
`25`	`26`	`}`
`26`	`27`
`27`		`- return GetHashCode(x) == GetHashCode(y);`
	`28`	`+ return x.PropertyName == y.PropertyName &&`
	`29`	`+ x.Mapping.Count == y.Mapping.Count &&`
	`30`	`+ x.Mapping.Keys.All(key => y.Mapping.ContainsKey(key) && x.Mapping[key] == y.Mapping[key]);`
`28`	`31`	`}`
`29`	`32`
`30`	`33`	`public int GetHashCode(OpenApiDiscriminator obj)`
`31`	`34`	`{`
`32`	`35`	`var hashCode = new HashCode();`
`33`	`36`	`hashCode.Add(obj.PropertyName);`
`34`		`- foreach (var item in obj.Mapping)`
`35`		`- {`
`36`		`- hashCode.Add(item.Key);`
`37`		`- hashCode.Add(item.Value);`
`38`		`- }`
	`37`	`+ hashCode.Add(obj.Mapping.Count);`
`39`	`38`	`return hashCode.ToHashCode();`
`40`	`39`	`}`
`41`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,20 +24,16 @@ public bool Equals(OpenApiReference? x, OpenApiReference? y)`
`24`	`24`	`return true;`
`25`	`25`	`}`
`26`	`26`
`27`		`- return GetHashCode(x) == GetHashCode(y);`
	`27`	`+ return x.ExternalResource == y.ExternalResource &&`
	`28`	`+ x.HostDocument?.HashCode == y.HostDocument?.HashCode &&`
	`29`	`+ x.Id == y.Id &&`
	`30`	`+ x.Type == y.Type;`
`28`	`31`	`}`
`29`	`32`
`30`	`33`	`public int GetHashCode(OpenApiReference obj)`
`31`	`34`	`{`
`32`	`35`	`var hashCode = new HashCode();`
`33`	`36`	`hashCode.Add(obj.ExternalResource);`
`34`		`- if (obj.HostDocument is not null)`
`35`		`- {`
`36`		`- // Microsoft.OpenApi provides a HashCode property for`
`37`		`- // the OpenAPI document that we can use to uniquely identify`
`38`		`- // the host document that is referenced here.`
`39`		`- hashCode.Add(obj.HostDocument.HashCode);`
`40`		`- };`
`41`	`37`	`hashCode.Add(obj.Id);`
`42`	`38`	`if (obj.Type is not null)`
`43`	`39`	`{`