Fix AreEqual conversion on Assembly types (#32)

meziantou · Jan 23, 2024 · 35c2718 · 35c2718
1 parent 902f300
commit 35c2718
Show file tree

Hide file tree

Showing 3 changed files with 72 additions and 1 deletion.
diff --git a/Meziantou.FluentAssertionsAnalyzers.Tests/NUnit4ToFluentAssertionsAnalyzerUnitTests.cs b/Meziantou.FluentAssertionsAnalyzers.Tests/NUnit4ToFluentAssertionsAnalyzerUnitTests.cs
@@ -847,4 +847,66 @@ public void MyTest()
             }
             """);
     }
+
+    [Fact]
+    public Task Assert_AreEqual_on_assemblies()
+    {
+        return Assert(
+            """
+            using NUnit.Framework.Legacy;
+            using System.Reflection;
+
+            class Test
+            {
+                public void MyTest(Assembly assembly1, Assembly assembly2)
+                {
+                    [|ClassicAssert.AreEqual(assembly1, assembly2)|];
+                }
+            }
+            """,
+            """
+            using System.Reflection;
+            using FluentAssertions;
+            using NUnit.Framework.Legacy;
+
+            class Test
+            {
+                public void MyTest(Assembly assembly1, Assembly assembly2)
+                {
+                    assembly2.Should().BeSameAs(assembly1);
+                }
+            }
+            """);
+    }
+
+    [Fact]
+    public Task Assert_AreNotEqual_on_assemblies()
+    {
+        return Assert(
+            """
+            using NUnit.Framework.Legacy;
+            using System.Reflection;
+
+            class Test
+            {
+                public void MyTest(Assembly assembly1, Assembly assembly2)
+                {
+                    [|ClassicAssert.AreNotEqual(assembly1, assembly2)|];
+                }
+            }
+            """,
+            """
+            using System.Reflection;
+            using FluentAssertions;
+            using NUnit.Framework.Legacy;
+
+            class Test
+            {
+                public void MyTest(Assembly assembly1, Assembly assembly2)
+                {
+                    assembly2.Should().NotBeSameAs(assembly1);
+                }
+            }
+            """);
+    }
 }
diff --git a/Meziantou.FluentAssertionsAnalyzers/Meziantou.FluentAssertionsAnalyzers.csproj b/Meziantou.FluentAssertionsAnalyzers/Meziantou.FluentAssertionsAnalyzers.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
-    <Version>1.0.20</Version>
+    <Version>1.0.21</Version>
     <IncludeBuildOutput>false</IncludeBuildOutput>
     <developmentDependency>true</developmentDependency>
     <Description>A Roslyn analyzer to help migrate from Xunit / NUnit assertions to FluentAssertions</Description>

diff --git a/Meziantou.FluentAssertionsAnalyzers/NunitAssertAnalyzerCodeFixProvider.cs b/Meziantou.FluentAssertionsAnalyzers/NunitAssertAnalyzerCodeFixProvider.cs
@@ -167,6 +167,7 @@ private static async Task<Document> Rewrite(Document document, SyntaxNode nodeTo
         var exceptionSymbol = compilation.GetTypeByMetadataName("System.Exception");
         var typeSymbol = compilation.GetTypeByMetadataName("System.Type");
         var resolveConstraintSymbol = compilation.GetTypeByMetadataName("NUnit.Framework.Constraints.IResolveConstraint");
+        var assemblySymbol = compilation.GetTypeByMetadataName("System.Reflection.Assembly");
 
         var isDynamic = semanticModel.GetOperation(invocationExpression, cancellationToken)?.Type is IDynamicTypeSymbol;
         var rewrite = new Rewriter(isDynamic);
@@ -192,6 +193,10 @@ private static async Task<Document> Rewrite(Document document, SyntaxNode nodeTo
                 {
                     result = rewrite.UsingShould(right, "Equal", ArgumentList(left, arguments.Skip(2)));
                 }
+                else if (leftType.Equals(assemblySymbol, SymbolEqualityComparer.Default))
+                {
+                    result = rewrite.UsingShould(right, "BeSameAs", ArgumentList(left, arguments.Skip(2)));
+                }
                 else
                 {
                     var useBeApproximately = leftType.SpecialType is SpecialType.System_Double or SpecialType.System_Single
@@ -216,6 +221,10 @@ private static async Task<Document> Rewrite(Document document, SyntaxNode nodeTo
                 {
                     result = rewrite.UsingShould(right, "NotEqual", ArgumentList(left, arguments.Skip(2)));
                 }
+                else if (leftType.Equals(assemblySymbol, SymbolEqualityComparer.Default))
+                {
+                    result = rewrite.UsingShould(right, "NotBeSameAs", ArgumentList(left, arguments.Skip(2)));
+                }
                 else
                 {
                     result = rewrite.UsingShould(right, "NotBe", ArgumentList(left, arguments.Skip(2)));