feat: add nunit assert.that empty assertions (#339)

Author: Meir017

docs/NunitAnalyzer.md

@@ -174,6 +174,7 @@ var collection = new List<int>();
 
 // old assertion:
 Assert.IsEmpty(collection);
+Assert.That(collection, Is.Empty);
 
 // new assertion:
 collection.Should().BeEmpty();
@@ -188,6 +189,9 @@ var collection = new List<int> { 1, 2, 3 };
 Assert.IsEmpty(collection); /* fail message:   Expected: <empty>
   But was:  < 1, 2, 3 >
  */
+Assert.That(collection, Is.Empty); /* fail message:   Expected: <empty>
+  But was:  < 1, 2, 3 >
+ */
 
 // new assertion:
 collection.Should().BeEmpty(); /* fail message: Expected collection to be empty, but found {1, 2, 3}. */
@@ -201,6 +205,7 @@ var collection = new List<int> { 1, 2, 3 };
 
 // old assertion:
 Assert.IsNotEmpty(collection);
+Assert.That(collection, Is.Not.Empty);
 
 // new assertion:
 collection.Should().NotBeEmpty();
@@ -215,6 +220,9 @@ var collection = new List<int>();
 Assert.IsNotEmpty(collection); /* fail message:   Expected: not <empty>
   But was:  <empty>
  */
+Assert.That(collection, Is.Not.Empty); /* fail message:   Expected: not <empty>
+  But was:  <empty>
+ */
 
 // new assertion:
 collection.Should().NotBeEmpty(); /* fail message: Expected collection not to be empty. */

src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs/NunitAnalyzerTests.cs

@@ -270,13 +270,14 @@ public void AssertIsEmpty()
 
         // old assertion:
         Assert.IsEmpty(collection);
+        Assert.That(collection, Is.Empty);
 
         // new assertion:
         collection.Should().BeEmpty();
     }
 
     [TestMethod, ExpectedTestFrameworkException]
-    public void AssertIsEmpty_Failure_OldAssertion()
+    public void AssertIsEmpty_Failure_OldAssertion_0()
     {
         // arrange
         var collection = new List<int> { 1, 2, 3 };
@@ -285,6 +286,16 @@ public void AssertIsEmpty_Failure_OldAssertion()
         Assert.IsEmpty(collection);
     }
 
+    [TestMethod, ExpectedTestFrameworkException]
+    public void AssertIsEmpty_Failure_OldAssertion_1()
+    {
+        // arrange
+        var collection = new List<int> { 1, 2, 3 };
+
+        // old assertion:
+        Assert.That(collection, Is.Empty);
+    }
+
     [TestMethod, ExpectedTestFrameworkException]
     public void AssertIsEmpty_Failure_NewAssertion()
     {
@@ -303,13 +314,14 @@ public void AssertIsNotEmpty()
 
         // old assertion:
         Assert.IsNotEmpty(collection);
+        Assert.That(collection, Is.Not.Empty);
 
         // new assertion:
         collection.Should().NotBeEmpty();
     }
 
     [TestMethod, ExpectedTestFrameworkException]
-    public void AssertIsNotEmpty_Failure_OldAssertion()
+    public void AssertIsNotEmpty_Failure_OldAssertion_0()
     {
         // arrange
         var collection = new List<int>();
@@ -318,6 +330,16 @@ public void AssertIsNotEmpty_Failure_OldAssertion()
         Assert.IsNotEmpty(collection);
     }
 
+    [TestMethod, ExpectedTestFrameworkException]
+    public void AssertIsNotEmpty_Failure_OldAssertion_1()
+    {
+        // arrange
+        var collection = new List<int>();
+
+        // old assertion:
+        Assert.That(collection, Is.Not.Empty);
+    }
+
     [TestMethod, ExpectedTestFrameworkException]
     public void AssertIsNotEmpty_Failure_NewAssertion()
     {

src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs

@@ -243,6 +243,7 @@ public void Nunit4_AssertIsNaN_TestAnalyzer(string assertion)
     // IsEmpty
     [DataTestMethod]
     [AssertionDiagnostic("Assert.IsEmpty(actual{0});")]
+    [AssertionDiagnostic("Assert.That(actual, Is.Empty{0});")]
     [Implemented]
     public void Nunit3_AssertIsEmpty_TestAnalyzer(string assertion)
     {
@@ -267,6 +268,9 @@ public void Nunit4_AssertIsEmpty_TestAnalyzer(string assertion)
     [AssertionCodeFix(
         oldAssertion: "Assert.IsEmpty(actual{0});",
         newAssertion: "actual.Should().BeEmpty({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "Assert.That(actual, Is.Empty{0});",
+        newAssertion: "actual.Should().BeEmpty({0});")]
     [Implemented]
     public void Nunit3_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAssertion)
     {
@@ -292,6 +296,7 @@ public void Nunit4_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAsse
     // IsNotEmpty
     [DataTestMethod]
     [AssertionDiagnostic("Assert.IsNotEmpty(actual{0});")]
+    [AssertionDiagnostic("Assert.That(actual, Is.Not.Empty{0});")]
     [Implemented]
     public void Nunit3_AssertIsNotEmpty_TestAnalyzer(string assertion)
     {
@@ -316,6 +321,9 @@ public void Nunit4_AssertIsNotEmpty_TestAnalyzer(string assertion)
     [AssertionCodeFix(
         oldAssertion: "Assert.IsNotEmpty(actual{0});",
         newAssertion: "actual.Should().NotBeEmpty({0});")]
+    [AssertionCodeFix(
+        oldAssertion: "Assert.That(actual, Is.Not.Empty{0});",
+        newAssertion: "actual.Should().NotBeEmpty({0});")]
     [Implemented]
     public void Nunit3_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newAssertion)
     {

src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs

@@ -240,27 +240,38 @@ private CreateChangedDocument TryComputeFixForNunitThat(IInvocationOperation inv
         }
 
         if (invocation.Arguments[1].Value.UnwrapConversion() is not IPropertyReferenceOperation constraint) return null;
+        var subject = invocation.Arguments[0].Value;
 
-        switch (constraint.Property.Name)
+        if (IsPropertyOfSymbol(constraint, "True", t.Is) // Assert.That(subject, Is.True)
+            || IsPropertyOfSymbol(constraint, "Not", "False", t.Is)) // Assert.That(subject, Is.False)
+            return RenameAssertThatAssertionToSubjectShouldAssertion("BeTrue");
+        else if (IsPropertyOfSymbol(constraint, "False", t.Is) // Assert.That(subject, Is.False)
+            || IsPropertyOfSymbol(constraint, "Not", "True", t.Is)) // Assert.That(subject, Is.Not.True)
+            return RenameAssertThatAssertionToSubjectShouldAssertion("BeFalse");
+        else if (IsPropertyOfSymbol(constraint, "Null", t.Is)) // Assert.That(subject, Is.Null)
+            return RenameAssertThatAssertionToSubjectShouldAssertion("BeNull");
+        else if (IsPropertyOfSymbol(constraint, "Not", "Null", t.Is)) // Assert.That(subject, Is.Not.Null)
+            return RenameAssertThatAssertionToSubjectShouldAssertion("NotBeNull");
+        else if (subject.Type.SpecialType is not SpecialType.System_Collections_IEnumerable)
         {
-            case "True" when constraint.Property.ContainingType.EqualsSymbol(t.Is): // Assert.That(subject, Is.True)
-            case "False" when constraint.Instance is IPropertyReferenceOperation { Property.Name: "Not" } chainedReference && PropertyReferencedFromType(chainedReference, t.Is): // Assert.That(subject, Is.Not.False)
-                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeTrue", subjectIndex: 0, argumentsToRemove: [1]);
-            case "True" when constraint.Instance is IPropertyReferenceOperation { Property.Name: "Not" } chainedReference && PropertyReferencedFromType(chainedReference, t.Is): // Assert.That(subject, Is.Not.True)
-            case "False" when PropertyReferencedFromType(constraint, t.Is): // Assert.That(subject, Is.False)
-                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeFalse", subjectIndex: 0, argumentsToRemove: [1]);
-            case "Null" when PropertyReferencedFromType(constraint, t.Is): // Assert.That(subject, Is.Null)
-                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeNull", subjectIndex: 0, argumentsToRemove: [1]);
-            case "Null" when constraint.Instance is IPropertyReferenceOperation { Property.Name: "Not" } chainedReference && PropertyReferencedFromType(chainedReference, t.Is): // Assert.That(subject, Is.Not.Null)
-                return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "NotBeNull", subjectIndex: 0, argumentsToRemove: [1]);
-
-            default:
-                return null;
+            if (IsPropertyOfSymbol(constraint, "Empty", t.Is)) // Assert.That(subject, Is.Empty)
+                return RenameAssertThatAssertionToSubjectShouldAssertion("BeEmpty");
+            else if (IsPropertyOfSymbol(constraint, "Not", "Empty", t.Is)) // Assert.That(subject, Is.Not.Empty)
+                return RenameAssertThatAssertionToSubjectShouldAssertion("NotBeEmpty");
         }
 
+        return null;
+
+        CreateChangedDocument RenameAssertThatAssertionToSubjectShouldAssertion(string assertionName)
+            => DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, assertionName, subjectIndex: 0, argumentsToRemove: [1]);
     }
 
-    private static bool PropertyReferencedFromType(IPropertyReferenceOperation propertyReference, INamedTypeSymbol type) => propertyReference.Property.ContainingType.EqualsSymbol(type);
+    private static bool IsPropertyReferencedFromType(IPropertyReferenceOperation propertyReference, INamedTypeSymbol type)
+        => propertyReference.Property.ContainingType.EqualsSymbol(type);
+    private static bool IsPropertyOfSymbol(IPropertyReferenceOperation propertyReference, string firstProperty, string secondProperty, INamedTypeSymbol type)
+        => propertyReference.Property.Name == secondProperty && IsPropertyOfSymbol(propertyReference.Instance, firstProperty, type);
+    private static bool IsPropertyOfSymbol(IOperation operation, string property, INamedTypeSymbol type)
+        => operation is IPropertyReferenceOperation propertyReference && propertyReference.Property.Name == property && IsPropertyReferencedFromType(propertyReference, type);
 
     public class NunitCodeFixContext(Compilation compilation) : TestingFrameworkCodeFixProvider.TestingFrameworkCodeFixContext(compilation)
     {