feat: add xunit Null assertions (#191)

Author: Meir017

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

@@ -312,6 +312,33 @@ public void AssertObjectNotStrictEqual_TestAnalyzer(string assertion) =>
         public void AssertObjectNotStrictEqual_TestCodeFix(string oldAssertion, string newAssertion)
             => VerifyCSharpFix<AssertNotStrictEqualCodeFix, AssertNotStrictEqualAnalyzer>("object actual, object expected", oldAssertion, newAssertion);
 
+        [DataTestMethod]
+        [DataRow("Assert.Null(actual);")]
+        [Implemented]
+        public void AssertNull_TestAnalyzer(string assertion) =>
+            VerifyCSharpDiagnostic<AssertNullAnalyzer>("object actual", assertion);
+
+        [DataTestMethod]
+        [DataRow(
+            /* oldAssertion: */ "Assert.Null(actual);",
+            /* newAssertion: */ "actual.Should().BeNull();")]
+        [Implemented]
+        public void AssertNull_TestCodeFix(string oldAssertion, string newAssertion)
+            => VerifyCSharpFix<AssertNullCodeFix, AssertNullAnalyzer>("object actual", oldAssertion, newAssertion);
+
+        [DataTestMethod]
+        [DataRow("Assert.NotNull(actual);")]
+        [Implemented]
+        public void AssertNotNull_TestAnalyzer(string assertion) =>
+            VerifyCSharpDiagnostic<AssertNotNullAnalyzer>("object actual", assertion);
+
+        [DataTestMethod]
+        [DataRow(
+            /* oldAssertion: */ "Assert.NotNull(actual);",
+            /* newAssertion: */ "actual.Should().NotBeNull();")]
+        [Implemented]
+        public void AssertNotNull_TestCodeFix(string oldAssertion, string newAssertion)
+            => VerifyCSharpFix<AssertNotNullCodeFix, AssertNotNullAnalyzer>("object actual", oldAssertion, newAssertion);
 
         private void VerifyCSharpDiagnostic<TDiagnosticAnalyzer>(string methodArguments, string assertion) where TDiagnosticAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer, new()
         {

src/FluentAssertions.Analyzers/Constants.cs

@@ -127,6 +127,8 @@ public static class Xunit
                 public const string AssertStrictEqual = $"{DiagnosticProperties.IdPrefix}0705";
                 public const string AssertNotEqual = $"{DiagnosticProperties.IdPrefix}0706";
                 public const string AssertNotStrictEqual = $"{DiagnosticProperties.IdPrefix}0707";
+                public const string AssertNull = $"{DiagnosticProperties.IdPrefix}0708";
+                public const string AssertNotNull = $"{DiagnosticProperties.IdPrefix}0709";
             }
         }
 

src/FluentAssertions.Analyzers/Tips/Xunit/AssertNotNull.cs

@@ -0,0 +1,46 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+
+namespace FluentAssertions.Analyzers.Xunit
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class AssertNotNullAnalyzer : XunitAnalyzer
+    {
+        public const string DiagnosticId = Constants.Tips.Xunit.AssertNotNull;
+        public const string Category = Constants.Tips.Category;
+
+        public const string Message = "Use .Should().NotBeNull() instead.";
+
+        protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);
+        protected override IEnumerable<FluentAssertionsCSharpSyntaxVisitor> Visitors
+        {
+            get
+            {
+                yield return new AssertNotNullSyntaxVisitor();
+            }
+        }
+
+		public class AssertNotNullSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
+		{
+			public AssertNotNullSyntaxVisitor() : base(new MemberValidator("NotNull"))
+            {
+            }
+		}
+    }
+
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(AssertNotNullCodeFix)), Shared]
+    public class AssertNotNullCodeFix : XunitCodeFixProvider
+    {
+        public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(AssertNotNullAnalyzer.DiagnosticId);
+
+        protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
+        {
+            return RenameMethodAndReplaceWithSubjectShould(expression, "NotNull", "NotBeNull");
+		}
+    }
+}

src/FluentAssertions.Analyzers/Tips/Xunit/AssertNull.cs

@@ -0,0 +1,46 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+
+namespace FluentAssertions.Analyzers.Xunit
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class AssertNullAnalyzer : XunitAnalyzer
+    {
+        public const string DiagnosticId = Constants.Tips.Xunit.AssertNull;
+        public const string Category = Constants.Tips.Category;
+
+        public const string Message = "Use .Should().BeNull() instead.";
+
+        protected override DiagnosticDescriptor Rule => new DiagnosticDescriptor(DiagnosticId, Title, Message, Category, DiagnosticSeverity.Info, true);
+        protected override IEnumerable<FluentAssertionsCSharpSyntaxVisitor> Visitors
+        {
+            get
+            {
+                yield return new AssertNullSyntaxVisitor();
+            }
+        }
+
+		public class AssertNullSyntaxVisitor : FluentAssertionsCSharpSyntaxVisitor
+		{
+			public AssertNullSyntaxVisitor() : base(new MemberValidator("Null"))
+            {
+            }
+		}
+    }
+
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(AssertNullCodeFix)), Shared]
+    public class AssertNullCodeFix : XunitCodeFixProvider
+    {
+        public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(AssertNullAnalyzer.DiagnosticId);
+
+        protected override ExpressionSyntax GetNewExpression(ExpressionSyntax expression, FluentAssertionsDiagnosticProperties properties)
+        {
+            return RenameMethodAndReplaceWithSubjectShould(expression, "Null", "BeNull");
+		}
+    }
+}