From 201c4c9257e8774c315d16d7e5c73f0b2ce32885 Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 13:32:09 +0300 Subject: [PATCH 1/8] feat: add nunit assert.that zero assertions --- docs/NunitAnalyzer.md | 64 +++++ .../NunitAnalyzerTests.cs | 88 +++++++ .../Tips/NunitTests.cs | 220 +++++++++++++++--- .../Tips/Editing/EditAction.cs | 8 + .../Tips/NunitCodeFixProvider.cs | 10 + 5 files changed, 354 insertions(+), 36 deletions(-) diff --git a/docs/NunitAnalyzer.md b/docs/NunitAnalyzer.md index 805b6f1a..09a239ee 100644 --- a/docs/NunitAnalyzer.md +++ b/docs/NunitAnalyzer.md @@ -10,6 +10,8 @@ This is a generated file, please edit src\FluentAssertions.Analyzers.FluentAsser - [AssertNotNull](#scenario-assertnotnull) - `obj.Should().NotBeNull();` - [AssertIsEmpty](#scenario-assertisempty) - `collection.Should().BeEmpty();` - [AssertIsNotEmpty](#scenario-assertisnotempty) - `collection.Should().NotBeEmpty();` +- [AssertZero](#scenario-assertzero) - `number.Should().Be(0);` +- [AssertNotZero](#scenario-assertnotzero) - `number.Should().NotBe(0);` ## Scenarios @@ -228,4 +230,66 @@ Assert.That(collection, Is.Not.Empty); /* fail message: Expected: not collection.Should().NotBeEmpty(); /* fail message: Expected collection not to be empty. */ ``` +### scenario: AssertZero + +```cs +// arrange +var number = 0; + +// old assertion: +Assert.Zero(number); +Assert.That(number, Is.Zero); + +// new assertion: +number.Should().Be(0); +``` + +#### Failure messages + +```cs +var number = 1; + +// old assertion: +Assert.Zero(number); /* fail message: Expected: 0 + But was: 1 + */ +Assert.That(number, Is.Zero); /* fail message: Expected: 0 + But was: 1 + */ + +// new assertion: +number.Should().Be(0); /* fail message: Expected number to be 0, but found 1 (difference of 1). */ +``` + +### scenario: AssertNotZero + +```cs +// arrange +var number = 1; + +// old assertion: +Assert.NotZero(number); +Assert.That(number, Is.Not.Zero); + +// new assertion: +number.Should().NotBe(0); +``` + +#### Failure messages + +```cs +var number = 0; + +// old assertion: +Assert.NotZero(number); /* fail message: Expected: not equal to 0 + But was: 0 + */ +Assert.That(number, Is.Not.Zero); /* fail message: Expected: not equal to 0 + But was: 0 + */ + +// new assertion: +number.Should().NotBe(0); /* fail message: Did not expect number to be 0. */ +``` + diff --git a/src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs/NunitAnalyzerTests.cs b/src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs/NunitAnalyzerTests.cs index 01a02fbe..166edd9d 100644 --- a/src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs/NunitAnalyzerTests.cs +++ b/src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs/NunitAnalyzerTests.cs @@ -349,4 +349,92 @@ public void AssertIsNotEmpty_Failure_NewAssertion() // new assertion: collection.Should().NotBeEmpty(); } + + [TestMethod] + public void AssertZero() + { + // arrange + var number = 0; + + // old assertion: + Assert.Zero(number); + Assert.That(number, Is.Zero); + + // new assertion: + number.Should().Be(0); + } + + [TestMethod, ExpectedTestFrameworkException] + public void AssertZero_Failure_OldAssertion_0() + { + // arrange + var number = 1; + + // old assertion: + Assert.Zero(number); + } + + [TestMethod, ExpectedTestFrameworkException] + public void AssertZero_Failure_OldAssertion_1() + { + // arrange + var number = 1; + + // old assertion: + Assert.That(number, Is.Zero); + } + + [TestMethod, ExpectedTestFrameworkException] + public void AssertZero_Failure_NewAssertion() + { + // arrange + var number = 1; + + // new assertion: + number.Should().Be(0); + } + + [TestMethod] + public void AssertNotZero() + { + // arrange + var number = 1; + + // old assertion: + Assert.NotZero(number); + Assert.That(number, Is.Not.Zero); + + // new assertion: + number.Should().NotBe(0); + } + + [TestMethod, ExpectedTestFrameworkException] + public void AssertNotZero_Failure_OldAssertion_0() + { + // arrange + var number = 0; + + // old assertion: + Assert.NotZero(number); + } + + [TestMethod, ExpectedTestFrameworkException] + public void AssertNotZero_Failure_OldAssertion_1() + { + // arrange + var number = 0; + + // old assertion: + Assert.That(number, Is.Not.Zero); + } + + [TestMethod, ExpectedTestFrameworkException] + public void AssertNotZero_Failure_NewAssertion() + { + // arrange + var number = 0; + + // new assertion: + number.Should().NotBe(0); + } } diff --git a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs index 750a6bd5..defa8222 100644 --- a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs +++ b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs @@ -15,9 +15,6 @@ public class NunitTests [AssertionDiagnostic("Assert.True(bool.Parse(\"true\"){0});")] [AssertionDiagnostic("Assert.IsTrue(actual{0});")] [AssertionDiagnostic("Assert.IsTrue(bool.Parse(\"true\"){0});")] - [AssertionDiagnostic("Assert.That(actual{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.True{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.Not.False{0});")] [Implemented] public void Nunit3_AssertTrue_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("bool actual", assertion); @@ -29,6 +26,13 @@ public class NunitTests [Implemented] public void Nunit4_AssertTrue_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("bool actual", assertion); + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.True{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.False{0});")] + [Implemented] + public void Nunit_AssertTrue_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("bool actual", assertion); + [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.True(actual{0});", @@ -54,15 +58,6 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsTrue(actual == false{0});", newAssertion: "(actual == false).Should().BeTrue({0});")] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual{0});", - newAssertion: "actual.Should().BeTrue({0});")] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.True{0});", - newAssertion: "actual.Should().BeTrue({0});")] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.False{0});", - newAssertion: "actual.Should().BeTrue({0});")] [Implemented] public void Nunit3_AssertTrue_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("bool actual", oldAssertion, newAssertion); @@ -94,13 +89,24 @@ public class NunitTests [Implemented] public void Nunit4_AssertTrue_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("bool actual", oldAssertion, newAssertion); + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual{0});", + newAssertion: "actual.Should().BeTrue({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.True{0});", + newAssertion: "actual.Should().BeTrue({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.False{0});", + newAssertion: "actual.Should().BeTrue({0});")] + [Implemented] + public void Nunit_AssertTrue_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("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});")] - [AssertionDiagnostic("Assert.That(actual, Is.False{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.Not.True{0});")] [Implemented] public void Nunit3_AssertFalse_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("bool actual", assertion); @@ -112,6 +118,12 @@ public class NunitTests [Implemented] public void Nunit4_AssertFalse_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("bool actual", assertion); + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual, Is.False{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.True{0});")] + [Implemented] + public void Nunit_AssertFalse_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("bool actual", assertion); + [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.False(actual{0});", @@ -125,12 +137,6 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsFalse(bool.Parse(\"false\"){0});", newAssertion: "bool.Parse(\"false\").Should().BeFalse({0});")] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.False{0});", - newAssertion: "actual.Should().BeFalse({0});")] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.True{0});", - newAssertion: "actual.Should().BeFalse({0});")] [Implemented] public void Nunit3_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("bool actual", oldAssertion, newAssertion); @@ -150,10 +156,19 @@ public class NunitTests [Implemented] public void Nunit4_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("bool actual", oldAssertion, newAssertion); + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.False{0});", + newAssertion: "actual.Should().BeFalse({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.True{0});", + newAssertion: "actual.Should().BeFalse({0});")] + [Implemented] + public void Nunit_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("bool actual", oldAssertion, newAssertion); + [DataTestMethod] [AssertionDiagnostic("Assert.Null(actual{0});")] [AssertionDiagnostic("Assert.IsNull(actual{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.Null{0});")] [Implemented] public void Nunit3_AssertNull_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("object actual", assertion); @@ -163,6 +178,11 @@ public class NunitTests [Implemented] public void Nunit4_AssertNull_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("object actual", assertion); + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual, Is.Null{0});")] + [Implemented] + public void Nunit_AssertNull_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("object actual", assertion); + [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.Null(actual{0});", @@ -170,9 +190,6 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsNull(actual{0});", newAssertion: "actual.Should().BeNull({0});")] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Null{0});", - newAssertion: "actual.Should().BeNull({0});")] [Implemented] public void Nunit3_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("object actual", oldAssertion, newAssertion); @@ -186,10 +203,16 @@ public class NunitTests [Implemented] public void Nunit4_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("object actual", oldAssertion, newAssertion); + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Null{0});", + newAssertion: "actual.Should().BeNull({0});")] + [Implemented] + public void Nunit_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("object actual", oldAssertion, newAssertion); + [DataTestMethod] [AssertionDiagnostic("Assert.NotNull(actual{0});")] [AssertionDiagnostic("Assert.IsNotNull(actual{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.Not.Null{0});")] [Implemented] public void Nunit3_AssertNotNull_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("object actual", assertion); @@ -199,6 +222,11 @@ public class NunitTests [Implemented] public void Nunit4_AssertNotNull_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("object actual", assertion); + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Null{0});")] + [Implemented] + public void Nunit_AssertNotNull_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("object actual", assertion); + [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.NotNull(actual{0});", @@ -206,9 +234,6 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsNotNull(actual{0});", newAssertion: "actual.Should().NotBeNull({0});")] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.Null{0});", - newAssertion: "actual.Should().NotBeNull({0});")] [Implemented] public void Nunit3_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("object actual", oldAssertion, newAssertion); @@ -222,6 +247,13 @@ public class NunitTests [Implemented] public void Nunit4_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("object actual", oldAssertion, newAssertion); + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.Null{0});", + newAssertion: "actual.Should().NotBeNull({0});")] + [Implemented] + public void Nunit_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("object actual", oldAssertion, newAssertion); + [DataTestMethod] [AssertionDiagnostic("Assert.IsNaN(actual{0});")] [Implemented] @@ -243,7 +275,6 @@ 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) { @@ -264,13 +295,21 @@ public void Nunit4_AssertIsEmpty_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("string actual", assertion); } + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual, Is.Empty{0});")] + [Implemented] + public void Nunit_AssertIsEmpty_TestAnalyzer(string assertion) + { + NunitVerifyDiagnostic("object[] actual", assertion); + NunitVerifyDiagnostic("IEnumerable actual", assertion); + NunitVerifyDiagnostic("IEnumerable actual", assertion); + NunitVerifyDiagnostic("string actual", assertion); + } + [DataTestMethod] [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) { @@ -293,10 +332,22 @@ public void Nunit4_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAsse Nunit4VerifyFix("string actual", oldAssertion, newAssertion); } + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Empty{0});", + newAssertion: "actual.Should().BeEmpty({0});")] + [Implemented] + public void Nunit_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAssertion) + { + NunitVerifyFix("object[] actual", oldAssertion, newAssertion); + NunitVerifyFix("IEnumerable actual", oldAssertion, newAssertion); + NunitVerifyNoFix("IEnumerable actual", oldAssertion); + NunitVerifyFix("string actual", oldAssertion, newAssertion); + } + // IsNotEmpty [DataTestMethod] [AssertionDiagnostic("Assert.IsNotEmpty(actual{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.Not.Empty{0});")] [Implemented] public void Nunit3_AssertIsNotEmpty_TestAnalyzer(string assertion) { @@ -316,14 +367,22 @@ public void Nunit4_AssertIsNotEmpty_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("IEnumerable actual", assertion); Nunit4VerifyDiagnostic("string actual", assertion); } + + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Empty{0});")] + [Implemented] + public void Nunit_AssertIsNotEmpty_TestAnalyzer(string assertion) + { + NunitVerifyDiagnostic("object[] actual", assertion); + NunitVerifyDiagnostic("IEnumerable actual", assertion); + NunitVerifyDiagnostic("IEnumerable actual", assertion); + NunitVerifyDiagnostic("string actual", assertion); + } [DataTestMethod] [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) { @@ -346,6 +405,19 @@ public void Nunit4_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newA Nunit4VerifyFix("string actual", oldAssertion, newAssertion); } + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.Empty{0});", + newAssertion: "actual.Should().NotBeEmpty({0});")] + [Implemented] + public void Nunit_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newAssertion) + { + NunitVerifyFix("object[] actual", oldAssertion, newAssertion); + NunitVerifyFix("IEnumerable actual", oldAssertion, newAssertion); + NunitVerifyNoFix("IEnumerable actual", oldAssertion); + NunitVerifyFix("string actual", oldAssertion, newAssertion); + } + [DataTestMethod] [AssertionDiagnostic("Assert.Zero(actual{0});")] [Implemented] @@ -374,6 +446,20 @@ public void Nunit4_AssertZero_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("decimal actual", assertion); } + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual, Is.Zero{0});")] + [Implemented] + public void Nunit_AssertZero_TestAnalyzer(string assertion) + { + NunitVerifyDiagnostic("int actual", assertion); + NunitVerifyDiagnostic("uint actual", assertion); + NunitVerifyDiagnostic("long actual", assertion); + NunitVerifyDiagnostic("ulong actual", assertion); + NunitVerifyDiagnostic("float actual", assertion); + NunitVerifyDiagnostic("double actual", assertion); + NunitVerifyDiagnostic("decimal actual", assertion); + } + [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.Zero(actual{0});", @@ -406,6 +492,22 @@ public void Nunit4_AssertZero_TestCodeFix(string oldAssertion, string newAsserti Nunit4VerifyFix("decimal actual", oldAssertion, newAssertion); } + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Zero{0});", + newAssertion: "actual.Should().Be(0{0});")] + [Implemented] + public void Nunit_AssertZero_TestCodeFix(string oldAssertion, string newAssertion) + { + NunitVerifyFix("int actual", oldAssertion, newAssertion); + NunitVerifyFix("uint actual", oldAssertion, newAssertion); + NunitVerifyFix("long actual", oldAssertion, newAssertion); + NunitVerifyFix("ulong actual", oldAssertion, newAssertion); + NunitVerifyFix("float actual", oldAssertion, newAssertion); + NunitVerifyFix("double actual", oldAssertion, newAssertion); + NunitVerifyFix("decimal actual", oldAssertion, newAssertion); + } + [DataTestMethod] [AssertionDiagnostic("Assert.NotZero(actual{0});")] [Implemented] @@ -434,6 +536,20 @@ public void Nunit4_AssertNotZero_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("decimal actual", assertion); } + [DataTestMethod] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Zero{0});")] + [Implemented] + public void Nunit_AssertNotZero_TestAnalyzer(string assertion) + { + NunitVerifyDiagnostic("int actual", assertion); + NunitVerifyDiagnostic("uint actual", assertion); + NunitVerifyDiagnostic("long actual", assertion); + NunitVerifyDiagnostic("ulong actual", assertion); + NunitVerifyDiagnostic("float actual", assertion); + NunitVerifyDiagnostic("double actual", assertion); + NunitVerifyDiagnostic("decimal actual", assertion); + } + [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.NotZero(actual{0});", @@ -466,6 +582,22 @@ public void Nunit4_AssertNotZero_TestCodeFix(string oldAssertion, string newAsse Nunit4VerifyFix("decimal actual", oldAssertion, newAssertion); } + [DataTestMethod] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.Zero{0});", + newAssertion: "actual.Should().NotBe(0{0});")] + [Implemented] + public void Nunit_AssertNotZero_TestCodeFix(string oldAssertion, string newAssertion) + { + NunitVerifyFix("int actual", oldAssertion, newAssertion); + NunitVerifyFix("uint actual", oldAssertion, newAssertion); + NunitVerifyFix("long actual", oldAssertion, newAssertion); + NunitVerifyFix("ulong actual", oldAssertion, newAssertion); + NunitVerifyFix("float actual", oldAssertion, newAssertion); + NunitVerifyFix("double actual", oldAssertion, newAssertion); + NunitVerifyFix("decimal actual", oldAssertion, newAssertion); + } + // Positive [DataTestMethod] [AssertionDiagnostic("Assert.Positive(actual{0});")] @@ -1129,6 +1261,22 @@ public void Nunit4_AssertContains_WithCasting_TestCodeFix(string methodArguments #endregion + private void NunitVerifyDiagnostic(string methodArguments, string assertion) + { + Nunit3VerifyDiagnostic(methodArguments, assertion); + Nunit4VerifyDiagnostic(methodArguments, assertion); + } + private void NunitVerifyFix(string methodArguments, string oldAssertion, string newAssertion) + { + Nunit3VerifyFix(methodArguments, oldAssertion, newAssertion); + Nunit4VerifyFix(methodArguments, oldAssertion, newAssertion); + } + private void NunitVerifyNoFix(string methodArguments, string assertion) + { + Nunit3VerifyNoFix(methodArguments, assertion); + Nunit4VerifyNoFix(methodArguments, assertion); + } + 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) diff --git a/src/FluentAssertions.Analyzers/Tips/Editing/EditAction.cs b/src/FluentAssertions.Analyzers/Tips/Editing/EditAction.cs index 869fe0cf..f455c2d7 100644 --- a/src/FluentAssertions.Analyzers/Tips/Editing/EditAction.cs +++ b/src/FluentAssertions.Analyzers/Tips/Editing/EditAction.cs @@ -17,6 +17,14 @@ public static Action RemoveInvocationArgument(int argumentInd public static Action SubjectShouldAssertion(int argumentIndex, string assertion) => context => new SubjectShouldAssertionAction(argumentIndex, assertion).Apply(context); + public static Action ReplaceAssertionArgument(int index, Func expressionFactory) + => context => + { + var argument = context.InvocationExpression.ArgumentList.Arguments[index]; + var newArgumentExpression = (ExpressionSyntax)expressionFactory(context.Editor.Generator); + context.Editor.ReplaceNode(argument.Expression, newArgumentExpression); + }; + public static Action SubjectShouldGenericAssertion(int argumentIndex, string assertion, ImmutableArray genericTypes) => context => new SubjectShouldGenericAssertionAction(argumentIndex, assertion, genericTypes).Apply(context); diff --git a/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs b/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs index f684f5b2..86e314fb 100644 --- a/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs +++ b/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs @@ -259,6 +259,16 @@ private CreateChangedDocument TryComputeFixForNunitThat(IInvocationOperation inv else if (IsPropertyOfSymbol(constraint, "Not", "Empty", t.Is)) // Assert.That(subject, Is.Not.Empty) return RenameAssertThatAssertionToSubjectShouldAssertion("NotBeEmpty"); } + else if (IsPropertyOfSymbol(constraint, "Zero", t.Is)) + return DocumentEditorUtils.RewriteExpression(invocation, [ + EditAction.ReplaceAssertionArgument(index: 1, generator => generator.LiteralExpression(0)), + EditAction.SubjectShouldAssertion(argumentIndex: 0, "Be"), + ], context); + else if (IsPropertyOfSymbol(constraint, "Not", "Zero", t.Is)) + return DocumentEditorUtils.RewriteExpression(invocation, [ + EditAction.ReplaceAssertionArgument(index: 1, generator => generator.LiteralExpression(0)), + EditAction.SubjectShouldAssertion(argumentIndex: 0, "NotBe"), + ], context); return null; From 516ee982f51db5b5c1dbf7ef0119c33bdb43d947 Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 15:00:21 +0300 Subject: [PATCH 2/8] feat: add nunit assert.that zero assertions --- src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs b/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs index 86e314fb..feaa8f2e 100644 --- a/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs +++ b/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs @@ -259,7 +259,7 @@ private CreateChangedDocument TryComputeFixForNunitThat(IInvocationOperation inv else if (IsPropertyOfSymbol(constraint, "Not", "Empty", t.Is)) // Assert.That(subject, Is.Not.Empty) return RenameAssertThatAssertionToSubjectShouldAssertion("NotBeEmpty"); } - else if (IsPropertyOfSymbol(constraint, "Zero", t.Is)) + if (IsPropertyOfSymbol(constraint, "Zero", t.Is)) return DocumentEditorUtils.RewriteExpression(invocation, [ EditAction.ReplaceAssertionArgument(index: 1, generator => generator.LiteralExpression(0)), EditAction.SubjectShouldAssertion(argumentIndex: 0, "Be"), From c9e2087c1df14a5eb00023cfff040ba745b78249 Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 15:21:07 +0300 Subject: [PATCH 3/8] feat: add nunit assert.that zero assertions --- .../Tips/NunitTests.cs | 244 ++++++------------ 1 file changed, 82 insertions(+), 162 deletions(-) diff --git a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs index defa8222..019b69cd 100644 --- a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs +++ b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs @@ -15,6 +15,9 @@ public class NunitTests [AssertionDiagnostic("Assert.True(bool.Parse(\"true\"){0});")] [AssertionDiagnostic("Assert.IsTrue(actual{0});")] [AssertionDiagnostic("Assert.IsTrue(bool.Parse(\"true\"){0});")] + [AssertionDiagnostic("Assert.That(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.True{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.False{0});")] [Implemented] public void Nunit3_AssertTrue_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("bool actual", assertion); @@ -23,16 +26,12 @@ public class NunitTests [AssertionDiagnostic("ClassicAssert.True(bool.Parse(\"true\"){0});")] [AssertionDiagnostic("ClassicAssert.IsTrue(actual{0});")] [AssertionDiagnostic("ClassicAssert.IsTrue(bool.Parse(\"true\"){0});")] + [AssertionDiagnostic("Assert.That(actual);")] + [AssertionDiagnostic("Assert.That(actual, Is.True);")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.False);")] [Implemented] public void Nunit4_AssertTrue_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("bool actual", assertion); - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.True{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.Not.False{0});")] - [Implemented] - public void Nunit_AssertTrue_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("bool actual", assertion); - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.True(actual{0});", @@ -58,6 +57,15 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsTrue(actual == false{0});", newAssertion: "(actual == false).Should().BeTrue({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual{0});", + newAssertion: "actual.Should().BeTrue({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.True{0});", + newAssertion: "actual.Should().BeTrue({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.False{0});", + newAssertion: "actual.Should().BeTrue({0});")] [Implemented] public void Nunit3_AssertTrue_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("bool actual", oldAssertion, newAssertion); @@ -86,27 +94,25 @@ public class NunitTests [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] [AssertionCodeFix( - oldAssertion: "Assert.That(actual{0});", - newAssertion: "actual.Should().BeTrue({0});")] + oldAssertion: "Assert.That(actual);", + newAssertion: "actual.Should().BeTrue();")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.True{0});", - newAssertion: "actual.Should().BeTrue({0});")] + oldAssertion: "Assert.That(actual, Is.True);", + newAssertion: "actual.Should().BeTrue();")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.False{0});", - newAssertion: "actual.Should().BeTrue({0});")] + oldAssertion: "Assert.That(actual, Is.Not.False);", + newAssertion: "actual.Should().BeTrue();")] [Implemented] - public void Nunit_AssertTrue_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("bool actual", oldAssertion, newAssertion); + 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});")] + [AssertionDiagnostic("Assert.That(actual, Is.False{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.True{0});")] [Implemented] public void Nunit3_AssertFalse_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("bool actual", assertion); @@ -115,15 +121,11 @@ public class NunitTests [AssertionDiagnostic("ClassicAssert.False(bool.Parse(\"false\"){0});")] [AssertionDiagnostic("ClassicAssert.IsFalse(actual{0});")] [AssertionDiagnostic("ClassicAssert.IsFalse(bool.Parse(\"false\"){0});")] + [AssertionDiagnostic("Assert.That(actual, Is.False);")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.True);")] [Implemented] public void Nunit4_AssertFalse_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("bool actual", assertion); - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual, Is.False{0});")] - [AssertionDiagnostic("Assert.That(actual, Is.Not.True{0});")] - [Implemented] - public void Nunit_AssertFalse_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("bool actual", assertion); - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.False(actual{0});", @@ -137,6 +139,12 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsFalse(bool.Parse(\"false\"){0});", newAssertion: "bool.Parse(\"false\").Should().BeFalse({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.False{0});", + newAssertion: "actual.Should().BeFalse({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.True{0});", + newAssertion: "actual.Should().BeFalse({0});")] [Implemented] public void Nunit3_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("bool actual", oldAssertion, newAssertion); @@ -153,36 +161,29 @@ public class NunitTests [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); - - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.That(actual, Is.False{0});", - newAssertion: "actual.Should().BeFalse({0});")] + newAssertion: "actual.Should().BeFalse();")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.True{0});", - newAssertion: "actual.Should().BeFalse({0});")] + oldAssertion: "Assert.That(actual, Is.Not.True);", + newAssertion: "actual.Should().BeFalse();")] [Implemented] - public void Nunit_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("bool actual", oldAssertion, newAssertion); + public void Nunit4_AssertFalse_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("bool actual", oldAssertion, newAssertion); [DataTestMethod] [AssertionDiagnostic("Assert.Null(actual{0});")] [AssertionDiagnostic("Assert.IsNull(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Null{0});")] [Implemented] public void Nunit3_AssertNull_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("object actual", assertion); [DataTestMethod] [AssertionDiagnostic("ClassicAssert.Null(actual{0});")] [AssertionDiagnostic("ClassicAssert.IsNull(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Null);")] [Implemented] public void Nunit4_AssertNull_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("object actual", assertion); - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual, Is.Null{0});")] - [Implemented] - public void Nunit_AssertNull_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("object actual", assertion); - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.Null(actual{0});", @@ -190,6 +191,9 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsNull(actual{0});", newAssertion: "actual.Should().BeNull({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Null{0});", + newAssertion: "actual.Should().BeNull({0});")] [Implemented] public void Nunit3_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("object actual", oldAssertion, newAssertion); @@ -200,33 +204,26 @@ public class NunitTests [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] [AssertionCodeFix( oldAssertion: "Assert.That(actual, Is.Null{0});", - newAssertion: "actual.Should().BeNull({0});")] + newAssertion: "actual.Should().BeNull();")] [Implemented] - public void Nunit_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("object actual", oldAssertion, newAssertion); + 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});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Null{0});")] [Implemented] public void Nunit3_AssertNotNull_TestAnalyzer(string assertion) => Nunit3VerifyDiagnostic("object actual", assertion); [DataTestMethod] [AssertionDiagnostic("ClassicAssert.NotNull(actual{0});")] [AssertionDiagnostic("ClassicAssert.IsNotNull(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Null);")] [Implemented] public void Nunit4_AssertNotNull_TestAnalyzer(string assertion) => Nunit4VerifyDiagnostic("object actual", assertion); - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual, Is.Not.Null{0});")] - [Implemented] - public void Nunit_AssertNotNull_TestAnalyzer(string assertion) => NunitVerifyDiagnostic("object actual", assertion); - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.NotNull(actual{0});", @@ -234,6 +231,9 @@ public class NunitTests [AssertionCodeFix( oldAssertion: "Assert.IsNotNull(actual{0});", newAssertion: "actual.Should().NotBeNull({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.Null{0});", + newAssertion: "actual.Should().NotBeNull({0});")] [Implemented] public void Nunit3_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit3VerifyFix("object actual", oldAssertion, newAssertion); @@ -244,15 +244,11 @@ public class NunitTests [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); - - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.That(actual, Is.Not.Null{0});", - newAssertion: "actual.Should().NotBeNull({0});")] + newAssertion: "actual.Should().NotBeNull();")] [Implemented] - public void Nunit_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => NunitVerifyFix("object actual", oldAssertion, newAssertion); + public void Nunit4_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("object actual", oldAssertion, newAssertion); [DataTestMethod] [AssertionDiagnostic("Assert.IsNaN(actual{0});")] @@ -275,6 +271,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) { @@ -286,6 +283,7 @@ public void Nunit3_AssertIsEmpty_TestAnalyzer(string assertion) [DataTestMethod] [AssertionDiagnostic("ClassicAssert.IsEmpty(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Empty);")] [Implemented] public void Nunit4_AssertIsEmpty_TestAnalyzer(string assertion) { @@ -295,21 +293,13 @@ public void Nunit4_AssertIsEmpty_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("string actual", assertion); } - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual, Is.Empty{0});")] - [Implemented] - public void Nunit_AssertIsEmpty_TestAnalyzer(string assertion) - { - NunitVerifyDiagnostic("object[] actual", assertion); - NunitVerifyDiagnostic("IEnumerable actual", assertion); - NunitVerifyDiagnostic("IEnumerable actual", assertion); - NunitVerifyDiagnostic("string actual", assertion); - } - [DataTestMethod] [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) { @@ -323,6 +313,9 @@ public void Nunit3_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAsse [AssertionCodeFix( oldAssertion: "ClassicAssert.IsEmpty(actual{0});", newAssertion: "actual.Should().BeEmpty({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Empty{0});", + newAssertion: "actual.Should().BeEmpty();")] [Implemented] public void Nunit4_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAssertion) { @@ -332,22 +325,10 @@ public void Nunit4_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAsse Nunit4VerifyFix("string actual", oldAssertion, newAssertion); } - [DataTestMethod] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Empty{0});", - newAssertion: "actual.Should().BeEmpty({0});")] - [Implemented] - public void Nunit_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAssertion) - { - NunitVerifyFix("object[] actual", oldAssertion, newAssertion); - NunitVerifyFix("IEnumerable actual", oldAssertion, newAssertion); - NunitVerifyNoFix("IEnumerable actual", oldAssertion); - NunitVerifyFix("string actual", oldAssertion, newAssertion); - } - // IsNotEmpty [DataTestMethod] [AssertionDiagnostic("Assert.IsNotEmpty(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Empty{0});")] [Implemented] public void Nunit3_AssertIsNotEmpty_TestAnalyzer(string assertion) { @@ -359,6 +340,7 @@ public void Nunit3_AssertIsNotEmpty_TestAnalyzer(string assertion) [DataTestMethod] [AssertionDiagnostic("ClassicAssert.IsNotEmpty(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Empty);")] [Implemented] public void Nunit4_AssertIsNotEmpty_TestAnalyzer(string assertion) { @@ -367,22 +349,14 @@ public void Nunit4_AssertIsNotEmpty_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("IEnumerable actual", assertion); Nunit4VerifyDiagnostic("string actual", assertion); } - - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual, Is.Not.Empty{0});")] - [Implemented] - public void Nunit_AssertIsNotEmpty_TestAnalyzer(string assertion) - { - NunitVerifyDiagnostic("object[] actual", assertion); - NunitVerifyDiagnostic("IEnumerable actual", assertion); - NunitVerifyDiagnostic("IEnumerable actual", assertion); - NunitVerifyDiagnostic("string actual", assertion); - } [DataTestMethod] [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) { @@ -396,6 +370,9 @@ public void Nunit3_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newA [AssertionCodeFix( oldAssertion: "ClassicAssert.IsNotEmpty(actual{0});", newAssertion: "actual.Should().NotBeEmpty({0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.Empty{0});", + newAssertion: "actual.Should().NotBeEmpty();")] [Implemented] public void Nunit4_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newAssertion) { @@ -405,21 +382,9 @@ public void Nunit4_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newA Nunit4VerifyFix("string actual", oldAssertion, newAssertion); } - [DataTestMethod] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.Empty{0});", - newAssertion: "actual.Should().NotBeEmpty({0});")] - [Implemented] - public void Nunit_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newAssertion) - { - NunitVerifyFix("object[] actual", oldAssertion, newAssertion); - NunitVerifyFix("IEnumerable actual", oldAssertion, newAssertion); - NunitVerifyNoFix("IEnumerable actual", oldAssertion); - NunitVerifyFix("string actual", oldAssertion, newAssertion); - } - [DataTestMethod] [AssertionDiagnostic("Assert.Zero(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Zero{0});")] [Implemented] public void Nunit3_AssertZero_TestAnalyzer(string assertion) { @@ -434,6 +399,7 @@ public void Nunit3_AssertZero_TestAnalyzer(string assertion) [DataTestMethod] [AssertionDiagnostic("ClassicAssert.Zero(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Zero);")] [Implemented] public void Nunit4_AssertZero_TestAnalyzer(string assertion) { @@ -446,24 +412,13 @@ public void Nunit4_AssertZero_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("decimal actual", assertion); } - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual, Is.Zero{0});")] - [Implemented] - public void Nunit_AssertZero_TestAnalyzer(string assertion) - { - NunitVerifyDiagnostic("int actual", assertion); - NunitVerifyDiagnostic("uint actual", assertion); - NunitVerifyDiagnostic("long actual", assertion); - NunitVerifyDiagnostic("ulong actual", assertion); - NunitVerifyDiagnostic("float actual", assertion); - NunitVerifyDiagnostic("double actual", assertion); - NunitVerifyDiagnostic("decimal actual", assertion); - } - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.Zero(actual{0});", newAssertion: "actual.Should().Be(0{0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Zero{0});", + newAssertion: "actual.Should().Be(0{0});")] [Implemented] public void Nunit3_AssertZero_TestCodeFix(string oldAssertion, string newAssertion) { @@ -480,6 +435,9 @@ public void Nunit3_AssertZero_TestCodeFix(string oldAssertion, string newAsserti [AssertionCodeFix( oldAssertion: "ClassicAssert.Zero(actual{0});", newAssertion: "actual.Should().Be(0{0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Zero{0});", + newAssertion: "actual.Should().Be(0);")] [Implemented] public void Nunit4_AssertZero_TestCodeFix(string oldAssertion, string newAssertion) { @@ -492,24 +450,9 @@ public void Nunit4_AssertZero_TestCodeFix(string oldAssertion, string newAsserti Nunit4VerifyFix("decimal actual", oldAssertion, newAssertion); } - [DataTestMethod] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Zero{0});", - newAssertion: "actual.Should().Be(0{0});")] - [Implemented] - public void Nunit_AssertZero_TestCodeFix(string oldAssertion, string newAssertion) - { - NunitVerifyFix("int actual", oldAssertion, newAssertion); - NunitVerifyFix("uint actual", oldAssertion, newAssertion); - NunitVerifyFix("long actual", oldAssertion, newAssertion); - NunitVerifyFix("ulong actual", oldAssertion, newAssertion); - NunitVerifyFix("float actual", oldAssertion, newAssertion); - NunitVerifyFix("double actual", oldAssertion, newAssertion); - NunitVerifyFix("decimal actual", oldAssertion, newAssertion); - } - [DataTestMethod] [AssertionDiagnostic("Assert.NotZero(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Zero{0});")] [Implemented] public void Nunit3_AssertNotZero_TestAnalyzer(string assertion) { @@ -524,6 +467,7 @@ public void Nunit3_AssertNotZero_TestAnalyzer(string assertion) [DataTestMethod] [AssertionDiagnostic("ClassicAssert.NotZero(actual{0});")] + [AssertionDiagnostic("Assert.That(actual, Is.Not.Zero);")] [Implemented] public void Nunit4_AssertNotZero_TestAnalyzer(string assertion) { @@ -536,24 +480,13 @@ public void Nunit4_AssertNotZero_TestAnalyzer(string assertion) Nunit4VerifyDiagnostic("decimal actual", assertion); } - [DataTestMethod] - [AssertionDiagnostic("Assert.That(actual, Is.Not.Zero{0});")] - [Implemented] - public void Nunit_AssertNotZero_TestAnalyzer(string assertion) - { - NunitVerifyDiagnostic("int actual", assertion); - NunitVerifyDiagnostic("uint actual", assertion); - NunitVerifyDiagnostic("long actual", assertion); - NunitVerifyDiagnostic("ulong actual", assertion); - NunitVerifyDiagnostic("float actual", assertion); - NunitVerifyDiagnostic("double actual", assertion); - NunitVerifyDiagnostic("decimal actual", assertion); - } - [DataTestMethod] [AssertionCodeFix( oldAssertion: "Assert.NotZero(actual{0});", newAssertion: "actual.Should().NotBe(0{0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.Zero{0});", + newAssertion: "actual.Should().NotBe(0{0});")] [Implemented] public void Nunit3_AssertNotZero_TestCodeFix(string oldAssertion, string newAssertion) { @@ -570,6 +503,9 @@ public void Nunit3_AssertNotZero_TestCodeFix(string oldAssertion, string newAsse [AssertionCodeFix( oldAssertion: "ClassicAssert.NotZero(actual{0});", newAssertion: "actual.Should().NotBe(0{0});")] + [AssertionCodeFix( + oldAssertion: "Assert.That(actual, Is.Not.Zero{0});", + newAssertion: "actual.Should().NotBe(0);")] [Implemented] public void Nunit4_AssertNotZero_TestCodeFix(string oldAssertion, string newAssertion) { @@ -582,22 +518,6 @@ public void Nunit4_AssertNotZero_TestCodeFix(string oldAssertion, string newAsse Nunit4VerifyFix("decimal actual", oldAssertion, newAssertion); } - [DataTestMethod] - [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.Zero{0});", - newAssertion: "actual.Should().NotBe(0{0});")] - [Implemented] - public void Nunit_AssertNotZero_TestCodeFix(string oldAssertion, string newAssertion) - { - NunitVerifyFix("int actual", oldAssertion, newAssertion); - NunitVerifyFix("uint actual", oldAssertion, newAssertion); - NunitVerifyFix("long actual", oldAssertion, newAssertion); - NunitVerifyFix("ulong actual", oldAssertion, newAssertion); - NunitVerifyFix("float actual", oldAssertion, newAssertion); - NunitVerifyFix("double actual", oldAssertion, newAssertion); - NunitVerifyFix("decimal actual", oldAssertion, newAssertion); - } - // Positive [DataTestMethod] [AssertionDiagnostic("Assert.Positive(actual{0});")] From 02ff90f5a8f95e48da7456ea2ab184727b05d1a5 Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 15:22:31 +0300 Subject: [PATCH 4/8] feat: add nunit assert.that zero assertions --- .../Tips/NunitTests.cs | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-) diff --git a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs index 019b69cd..36de7303 100644 --- a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs +++ b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs @@ -162,7 +162,7 @@ public class NunitTests oldAssertion: "ClassicAssert.IsFalse(bool.Parse(\"false\"){0});", newAssertion: "bool.Parse(\"false\").Should().BeFalse({0});")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.False{0});", + oldAssertion: "Assert.That(actual, Is.False);", newAssertion: "actual.Should().BeFalse();")] [AssertionCodeFix( oldAssertion: "Assert.That(actual, Is.Not.True);", @@ -1181,22 +1181,6 @@ public void Nunit4_AssertContains_WithCasting_TestCodeFix(string methodArguments #endregion - private void NunitVerifyDiagnostic(string methodArguments, string assertion) - { - Nunit3VerifyDiagnostic(methodArguments, assertion); - Nunit4VerifyDiagnostic(methodArguments, assertion); - } - private void NunitVerifyFix(string methodArguments, string oldAssertion, string newAssertion) - { - Nunit3VerifyFix(methodArguments, oldAssertion, newAssertion); - Nunit4VerifyFix(methodArguments, oldAssertion, newAssertion); - } - private void NunitVerifyNoFix(string methodArguments, string assertion) - { - Nunit3VerifyNoFix(methodArguments, assertion); - Nunit4VerifyNoFix(methodArguments, assertion); - } - 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) From 0cafb7e32c045d17343d93709c98d406754e9311 Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 15:37:36 +0300 Subject: [PATCH 5/8] feat: add nunit assert.that zero assertions --- .../TestAttributes.cs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/FluentAssertions.Analyzers.Tests/TestAttributes.cs b/src/FluentAssertions.Analyzers.Tests/TestAttributes.cs index 5b238528..31ad162b 100644 --- a/src/FluentAssertions.Analyzers.Tests/TestAttributes.cs +++ b/src/FluentAssertions.Analyzers.Tests/TestAttributes.cs @@ -73,12 +73,24 @@ public static class TestCasesInputUtils private static readonly string FormattedBecause = "\"because message with {0} placeholders {1} at {2}\", 3, \"is awesome\", DateTime.Now.Add(2.Seconds())"; public static IEnumerable GetTestCases(string assertion) { + if (!assertion.Contains("{0}")) + { + yield return assertion; + yield break; + } + yield return SafeFormat(assertion, Empty); yield return SafeFormat(assertion, Because); yield return SafeFormat(assertion, FormattedBecause); } public static IEnumerable<(string oldAssertion, string newAssertion)> GetTestCases(string oldAssertion, string newAssertion) { + if (!oldAssertion.Contains("{0}") && !newAssertion.Contains("{0}")) + { + yield return (oldAssertion, newAssertion); + yield break; + } + yield return (SafeFormat(oldAssertion, Empty), SafeFormat(newAssertion, Empty)); yield return (SafeFormat(oldAssertion, Because), SafeFormat(newAssertion, Because)); yield return (SafeFormat(oldAssertion, FormattedBecause), SafeFormat(newAssertion, FormattedBecause)); From ab151a62879293dd412af1ddcbb60d035f91d20c Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 15:41:37 +0300 Subject: [PATCH 6/8] feat: add nunit assert.that zero assertions --- src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs index 36de7303..d2c870b3 100644 --- a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs +++ b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs @@ -314,7 +314,7 @@ public void Nunit3_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAsse oldAssertion: "ClassicAssert.IsEmpty(actual{0});", newAssertion: "actual.Should().BeEmpty({0});")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Empty{0});", + oldAssertion: "Assert.That(actual, Is.Empty);", newAssertion: "actual.Should().BeEmpty();")] [Implemented] public void Nunit4_AssertIsEmpty_TestCodeFix(string oldAssertion, string newAssertion) @@ -371,7 +371,7 @@ public void Nunit3_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newA oldAssertion: "ClassicAssert.IsNotEmpty(actual{0});", newAssertion: "actual.Should().NotBeEmpty({0});")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.Empty{0});", + oldAssertion: "Assert.That(actual, Is.Not.Empty);", newAssertion: "actual.Should().NotBeEmpty();")] [Implemented] public void Nunit4_AssertIsNotEmpty_TestCodeFix(string oldAssertion, string newAssertion) @@ -504,7 +504,7 @@ public void Nunit3_AssertNotZero_TestCodeFix(string oldAssertion, string newAsse oldAssertion: "ClassicAssert.NotZero(actual{0});", newAssertion: "actual.Should().NotBe(0{0});")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.Zero{0});", + oldAssertion: "Assert.That(actual, Is.Not.Zero);", newAssertion: "actual.Should().NotBe(0);")] [Implemented] public void Nunit4_AssertNotZero_TestCodeFix(string oldAssertion, string newAssertion) From 4374764480f767c76d36eca1312d016c033f3101 Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 15:43:10 +0300 Subject: [PATCH 7/8] feat: add nunit assert.that zero assertions --- src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs index d2c870b3..e469442d 100644 --- a/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs +++ b/src/FluentAssertions.Analyzers.Tests/Tips/NunitTests.cs @@ -205,7 +205,7 @@ public class NunitTests oldAssertion: "ClassicAssert.IsNull(actual{0});", newAssertion: "actual.Should().BeNull({0});")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Null{0});", + oldAssertion: "Assert.That(actual, Is.Null);", newAssertion: "actual.Should().BeNull();")] [Implemented] public void Nunit4_AssertNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("object actual", oldAssertion, newAssertion); @@ -245,7 +245,7 @@ public class NunitTests oldAssertion: "ClassicAssert.IsNotNull(actual{0});", newAssertion: "actual.Should().NotBeNull({0});")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Not.Null{0});", + oldAssertion: "Assert.That(actual, Is.Not.Null);", newAssertion: "actual.Should().NotBeNull();")] [Implemented] public void Nunit4_AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion) => Nunit4VerifyFix("object actual", oldAssertion, newAssertion); @@ -436,7 +436,7 @@ public void Nunit3_AssertZero_TestCodeFix(string oldAssertion, string newAsserti oldAssertion: "ClassicAssert.Zero(actual{0});", newAssertion: "actual.Should().Be(0{0});")] [AssertionCodeFix( - oldAssertion: "Assert.That(actual, Is.Zero{0});", + oldAssertion: "Assert.That(actual, Is.Zero);", newAssertion: "actual.Should().Be(0);")] [Implemented] public void Nunit4_AssertZero_TestCodeFix(string oldAssertion, string newAssertion) From 983486d94bf6a323b1864291d1784a2a82a43a50 Mon Sep 17 00:00:00 2001 From: Meir Blachman Date: Fri, 17 May 2024 15:56:38 +0300 Subject: [PATCH 8/8] feat: add nunit assert.that zero assertions --- .../Tips/NunitCodeFixProvider.cs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs b/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs index feaa8f2e..e04e4ba7 100644 --- a/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs +++ b/src/FluentAssertions.Analyzers/Tips/NunitCodeFixProvider.cs @@ -233,8 +233,15 @@ private CreateChangedDocument TryComputeFixForNunitClassicAssert(IInvocationOper private CreateChangedDocument TryComputeFixForNunitThat(IInvocationOperation invocation, CodeFixContext context, NunitCodeFixContext t) { - if (invocation.Arguments.Length is 1 && invocation.Arguments[0].Value.Type.EqualsSymbol(t.Boolean) // Assert.That(subject) - || invocation.Arguments.Length > 2 && invocation.Arguments[0].Value.Type.EqualsSymbol(t.Boolean) && invocation.Arguments[1].Value.Type.EqualsSymbol(t.String)) // Assert.That(subject, message) + // Assert.That(condition) + if (invocation.Arguments[0].Value.Type.EqualsSymbol(t.Boolean) + && (invocation.Arguments.Length is 1 + || (invocation.Arguments.Length >= 2 + && (invocation.Arguments[1].Value.Type.EqualsSymbol(t.NUnitString) + || invocation.Arguments[1].Value.Type.EqualsSymbol(t.String)) + ) + ) + ) { return DocumentEditorUtils.RenameMethodToSubjectShouldAssertion(invocation, context, "BeTrue", subjectIndex: 0, argumentsToRemove: []); } @@ -291,5 +298,6 @@ public class NunitCodeFixContext(Compilation compilation) : TestingFrameworkCode public INamedTypeSymbol Contains { get; } = compilation.GetTypeByMetadataName("NUnit.Framework.Contains"); public INamedTypeSymbol Throws { get; } = compilation.GetTypeByMetadataName("NUnit.Framework.Throws"); public INamedTypeSymbol ConstraintExpression { get; } = compilation.GetTypeByMetadataName("NUnit.Framework.Constraints.ConstraintExpression"); + public INamedTypeSymbol NUnitString { get; } = compilation.GetTypeByMetadataName("NUnit.Framework.NUnitString"); } } \ No newline at end of file