feat: nunit null assertions (#293)

Meir017 · web-flow · commit 548166863f78 · 2024-01-17T14:18:26.000+02:00
* feat: add nunit null assertions
diff --git a/src/FluentAssertions.Analyzers.TestUtils/GenerateCode.cs b/src/FluentAssertions.Analyzers.TestUtils/GenerateCode.cs
@@ -254,5 +254,26 @@ public static string GenericIListExpressionBodyAssertion(string assertion) => Ge
             .AppendLine("    }")
             .AppendLine("}")
             .ToString();
+
+        public static string Nunit4Assertion(string methodArguments, string assertion) => new StringBuilder()
+            .AppendLine("using System;")
+            .AppendLine("using System.Collections.Generic;")
+            .AppendLine("using System.Collections.Immutable;")
+            .AppendLine("using System.Text.RegularExpressions;")
+            .AppendLine("using FluentAssertions;")
+            .AppendLine("using FluentAssertions.Extensions;")
+            .AppendLine("using NUnit.Framework; using NUnit.Framework.Legacy;")
+            .AppendLine("using System.Threading.Tasks;")
+            .AppendLine("namespace TestNamespace")
+            .AppendLine("{")
+            .AppendLine("    class TestClass")
+            .AppendLine("    {")
+            .AppendLine($"        void TestMethod({methodArguments})")
+            .AppendLine("        {")
+            .AppendLine($"            {assertion}")
+            .AppendLine("        }")
+            .AppendLine("    }")
+            .AppendLine("}")
+            .ToString();
     }
 }
diff --git a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs
@@ -14,7 +14,15 @@ public class NunitTests
     [AssertionDiagnostic("Assert.IsTrue(actual{0});")]
     [AssertionDiagnostic("Assert.IsTrue(bool.Parse(\"true\"){0});")]
     [Implemented]
-    public void AssertTrue_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic("bool actual", assertion);
+    public void Nunit3_AssertTrue_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("bool actual", assertion);
+
+    [DataTestMethod]
+    [AssertionDiagnostic("ClassicAssert.True(actual{0});")]
+    [AssertionDiagnostic("ClassicAssert.True(bool.Parse(\"true\"){0});")]
+    [AssertionDiagnostic("ClassicAssert.IsTrue(actual{0});")]
+    [AssertionDiagnostic("ClassicAssert.IsTrue(bool.Parse(\"true\"){0});")]
+    [Implemented]
+    public void Nunit4_AssertTrue_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("bool actual", assertion);
 
     [DataTestMethod]
     [AssertionCodeFix(
@@ -42,16 +50,51 @@ public class NunitTests
         oldAssertion: "Assert.IsTrue(actual == false{0});",
         newAssertion: "(actual == false).Should().BeTrue({0});")]
     [Implemented]
-    public void AssertTrue_TestCodeFix(string oldAssertion, string newAssertion)
-        => VerifyCSharpFix("bool actual", oldAssertion, newAssertion);
+    public void Nunit3_AssertTrue_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("bool actual", oldAssertion, newAssertion);
+
+    [DataTestMethod]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.True(actual{0});",
+        newAssertion: "actual.Should().BeTrue({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.True(bool.Parse(\"true\"){0});",
+        newAssertion: "bool.Parse(\"true\").Should().BeTrue({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.True(!actual{0});",
+        newAssertion: "(!actual).Should().BeTrue({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.True(actual == false{0});",
+        newAssertion: "(actual == false).Should().BeTrue({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsTrue(actual{0});",
+        newAssertion: "actual.Should().BeTrue({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsTrue(bool.Parse(\"true\"){0});",
+        newAssertion: "bool.Parse(\"true\").Should().BeTrue({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsTrue(!actual{0});",
+        newAssertion: "(!actual).Should().BeTrue({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsTrue(actual == false{0});",
+        newAssertion: "(actual == false).Should().BeTrue({0});")]
+    [Implemented]
+    public void Nunit4_AssertTrue_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("bool actual", oldAssertion, newAssertion);
 
     [DataTestMethod]
     [AssertionDiagnostic("Assert.False(actual{0});")]
     [AssertionDiagnostic("Assert.False(bool.Parse(\"false\"){0});")]
     [AssertionDiagnostic("Assert.IsFalse(actual{0});")]
     [AssertionDiagnostic("Assert.IsFalse(bool.Parse(\"false\"){0});")]
     [Implemented]
-    public void AssertFalse_TestAnalyzer(string assertion) => VerifyCSharpDiagnostic("bool actual", assertion);
+    public void Nunit3_AssertFalse_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("bool actual", assertion);
+
+    [DataTestMethod]
+    [AssertionDiagnostic("ClassicAssert.False(actual{0});")]
+    [AssertionDiagnostic("ClassicAssert.False(bool.Parse(\"false\"){0});")]
+    [AssertionDiagnostic("ClassicAssert.IsFalse(actual{0});")]
+    [AssertionDiagnostic("ClassicAssert.IsFalse(bool.Parse(\"false\"){0});")]
+    [Implemented]
+    public void Nunit4_AssertFalse_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("bool actual", assertion);
 
     [DataTestMethod]
     [AssertionCodeFix(
@@ -67,16 +110,104 @@ public void AssertTrue_TestCodeFix(string oldAssertion, string newAssertion)
         oldAssertion: "Assert.IsFalse(bool.Parse(\"false\"){0});",
         newAssertion: "bool.Parse(\"false\").Should().BeFalse({0});")]
     [Implemented]
-    public void AssertFalse_TestCodeFix(string oldAssertion, string newAssertion)
-        => VerifyCSharpFix("bool actual", oldAssertion, newAssertion);
+    public void Nunit3_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("bool actual", oldAssertion, newAssertion);
+
+    [DataTestMethod]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.False(actual{0});",
+        newAssertion: "actual.Should().BeFalse({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.False(bool.Parse(\"false\"){0});",
+        newAssertion: "bool.Parse(\"false\").Should().BeFalse({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsFalse(actual{0});",
+        newAssertion: "actual.Should().BeFalse({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsFalse(bool.Parse(\"false\"){0});",
+        newAssertion: "bool.Parse(\"false\").Should().BeFalse({0});")]
+    [Implemented]
+    public void Nunit4_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("bool actual", oldAssertion, newAssertion);
 
-    private void VerifyCSharpDiagnostic(string methodArguments, string assertion)
+    [DataTestMethod]
+    [AssertionDiagnostic("Assert.Null(actual{0});")]
+    [AssertionDiagnostic("Assert.IsNull(actual{0});")]
+    [Implemented]
+    public void Nunit3_AssertNull_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("object actual", assertion);
+
+    [DataTestMethod]
+    [AssertionDiagnostic("ClassicAssert.Null(actual{0});")]
+    [AssertionDiagnostic("ClassicAssert.IsNull(actual{0});")]
+    [Implemented]
+    public void Nunit4_AssertNull_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("object actual", assertion);
+
+    [DataTestMethod]
+    [AssertionCodeFix(
+        oldAssertion: "Assert.Null(actual{0});",
+        newAssertion: "actual.Should().BeNull({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "Assert.IsNull(actual{0});",
+        newAssertion: "actual.Should().BeNull({0});")]
+    [Implemented]
+    public void Nunit3_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("object actual", oldAssertion, newAssertion);
+
+    [DataTestMethod]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.Null(actual{0});",
+        newAssertion: "actual.Should().BeNull({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsNull(actual{0});",
+        newAssertion: "actual.Should().BeNull({0});")]
+    [Implemented]
+    public void Nunit4_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("object actual", oldAssertion, newAssertion);
+
+    [DataTestMethod]
+    [AssertionDiagnostic("Assert.NotNull(actual{0});")]
+    [AssertionDiagnostic("Assert.IsNotNull(actual{0});")]
+    [Implemented]
+    public void Nunit3_AssertNotNull_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("object actual", assertion);
+
+    [DataTestMethod]
+    [AssertionDiagnostic("ClassicAssert.NotNull(actual{0});")]
+    [AssertionDiagnostic("ClassicAssert.IsNotNull(actual{0});")]
+    [Implemented]
+    public void Nunit4_AssertNotNull_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("object actual", assertion);
+
+    [DataTestMethod]
+    [AssertionCodeFix(
+        oldAssertion: "Assert.NotNull(actual{0});",
+        newAssertion: "actual.Should().NotBeNull({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "Assert.IsNotNull(actual{0});",
+        newAssertion: "actual.Should().NotBeNull({0});")]
+    [Implemented]
+    public void Nunit3_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("object actual", oldAssertion, newAssertion);
+
+    [DataTestMethod]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.NotNull(actual{0});",
+        newAssertion: "actual.Should().NotBeNull({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "ClassicAssert.IsNotNull(actual{0});",
+        newAssertion: "actual.Should().NotBeNull({0});")]
+    [Implemented]
+    public void Nunit4_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("object actual", oldAssertion, newAssertion);
+
+    private void Nunit3VerifyDiagnostic(string methodArguments, string assertion)
+        => VerifyDiagnostic(GenerateCode.Nunit3Assertion(methodArguments, assertion), PackageReference.Nunit_3_14_0);
+    private void Nunit3VerifyFix(string methodArguments, string oldAssertion, string newAssertion)
+        => VerifyFix(GenerateCode.Nunit3Assertion(methodArguments, oldAssertion), GenerateCode.Nunit3Assertion(methodArguments, newAssertion), PackageReference.Nunit_3_14_0);
+
+    private void Nunit4VerifyDiagnostic(string methodArguments, string assertion)
+        => VerifyDiagnostic(GenerateCode.Nunit4Assertion(methodArguments, assertion), PackageReference.Nunit_4_0_1);
+    private void Nunit4VerifyFix(string methodArguments, string oldAssertion, string newAssertion)
+        => VerifyFix(GenerateCode.Nunit4Assertion(methodArguments, oldAssertion), GenerateCode.Nunit4Assertion(methodArguments, newAssertion), PackageReference.Nunit_4_0_1);
+
+    private void VerifyDiagnostic(string source, PackageReference nunit)
     {
-        var source = GenerateCode.Nunit3Assertion(methodArguments, assertion);
         DiagnosticVerifier.VerifyDiagnostic(new DiagnosticVerifierArguments()
             .WithAllAnalyzers()
             .WithSources(source)
-            .WithPackageReferences(PackageReference.FluentAssertions_6_12_0, PackageReference.Nunit_3_14_0)
+            .WithPackageReferences(PackageReference.FluentAssertions_6_12_0, nunit)
             .WithExpectedDiagnostics(new DiagnosticResult
             {
                 Id = AssertAnalyzer.NUnitRule.Id,
@@ -90,17 +221,14 @@ private void VerifyCSharpDiagnostic(string methodArguments, string assertion)
         );
     }
 
-    private void VerifyCSharpFix(string methodArguments, string oldAssertion, string newAssertion)
+    private void VerifyFix(string oldSource, string newSource, PackageReference nunit)
     {
-        var oldSource = GenerateCode.Nunit3Assertion(methodArguments, oldAssertion);
-        var newSource = GenerateCode.Nunit3Assertion(methodArguments, newAssertion);
-
         DiagnosticVerifier.VerifyFix(new CodeFixVerifierArguments()
             .WithDiagnosticAnalyzer<AssertAnalyzer>()
             .WithCodeFixProvider<NunitCodeFixProvider>()
             .WithSources(oldSource)
             .WithFixedSources(newSource)
-            .WithPackageReferences(PackageReference.FluentAssertions_6_12_0, PackageReference.Nunit_3_14_0)
+            .WithPackageReferences(PackageReference.FluentAssertions_6_12_0, nunit)
         );
     }
 }
diff --git a/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs b/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs
@@ -15,26 +15,58 @@ public class NunitCodeFixProvider : TestingFrameworkCodeFixProvider
     protected override CreateChangedDocument TryComputeFixCore(IInvocationOperation invocation, CodeFixContext context, TestingFrameworkCodeFixContext t, Diagnostic diagnostic)
     {
         var assertType = invocation.TargetMethod.ContainingType;
+        var nunitVersion = assertType.ContainingAssembly.Identity.Version;
+        
+        var isNunit3 = nunitVersion >= new Version(3, 0, 0, 0) && nunitVersion < new Version(4, 0, 0, 0);
+        var isNunit4 = nunitVersion >= new Version(4, 0, 0, 0) && nunitVersion < new Version(5, 0, 0, 0);
+
         return assertType.Name switch
         {
-            "Assert" => TryComputeFixForAssert(invocation, context, t),
+            "Assert" when isNunit3 => TryComputeFixForNunit3Assert(invocation, context, t),
+            "ClassicAssert" when isNunit4 => TryComputeFixForNunit4ClassicAssert(invocation, context, t),
             //"StringAssert" => TryComputeFixForStringAssert(invocation, context, testContext),
             //"CollectionAssert" => TryComputeFixForCollectionAssert(invocation, context, testContext),
             _ => null
         };
     }
 
-    private CreateChangedDocument TryComputeFixForAssert(IInvocationOperation invocation, CodeFixContext context, TestingFrameworkCodeFixContext t)
+    private CreateChangedDocument TryComputeFixForNunit3Assert(IInvocationOperation invocation, CodeFixContext context, TestingFrameworkCodeFixContext t)
     {
         switch (invocation.TargetMethod.Name)
         {
-            case "True":
-            case "IsTrue":
+            case "True": // Assert.True(bool condition)
+            case "IsTrue": // Assert.IsTrue(bool condition)
                 return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeTrue", subjectIndex: 0, argumentsToRemove: []);
+            case "False": // Assert.False(bool condition)
+            case "IsFalse": // Assert.IsFalse(bool condition)
+                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeFalse", subjectIndex: 0, argumentsToRemove: []);
+            case "Null": // Assert.Null(object anObject)
+            case "IsNull": // Assert.IsNull(object anObject)
+                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeNull", subjectIndex: 0, argumentsToRemove: []);
+            case "NotNull": // Assert.NotNull(object anObject)
+            case "IsNotNull": // Assert.IsNotNull(object anObject)
+                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "NotBeNull", subjectIndex: 0, argumentsToRemove: []);
+        }
+
+        return null;
+    }
 
-            case "False":
-            case "IsFalse":
+    private CreateChangedDocument TryComputeFixForNunit4ClassicAssert(IInvocationOperation invocation, CodeFixContext context, TestingFrameworkCodeFixContext t)
+    {
+        switch (invocation.TargetMethod.Name)
+        {
+            case "True": // Assert.True(bool condition)
+            case "IsTrue": // Assert.IsTrue(bool condition)
+                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeTrue", subjectIndex: 0, argumentsToRemove: []);
+            case "False": // Assert.False(bool condition)
+            case "IsFalse": // Assert.IsFalse(bool condition)
                 return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeFalse", subjectIndex: 0, argumentsToRemove: []);
+            case "Null": // Assert.Null(object anObject)
+            case "IsNull": // Assert.IsNull(object anObject)
+                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeNull", subjectIndex: 0, argumentsToRemove: []);
+            case "NotNull": // Assert.NotNull(object anObject)
+            case "IsNotNull": // Assert.IsNotNull(object anObject)
+                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "NotBeNull", subjectIndex: 0, argumentsToRemove: []);
         }
 
         return null;
