Merge pull request #22 from fluentassertions/feature/null-conditional-assertion

[Feature] null conditional assertion

Author: Meir017

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

@@ -0,0 +1,50 @@
+using FluentAssertions.Analyzers.Tips;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Text;
+
+namespace FluentAssertions.Analyzers.Tests.Tips
+{
+    [TestClass]
+    public class NullConditionalAssertionTests
+    {
+        [AssertionDataTestMethod]
+        [AssertionDiagnostic("actual?.Should().Be(expected{0});")]
+        [Implemented]
+        public void TestAnalyzer(string assertion) => VerifyCSharpDiagnostic(assertion);
+
+        private void VerifyCSharpDiagnostic(string assertion)
+        {
+            var code = new StringBuilder()
+                .AppendLine("using System;")
+                .AppendLine("using FluentAssertions;")
+                .AppendLine("namespace TestNamespace")
+                .AppendLine("{")
+                .AppendLine("    class TestClass")
+                .AppendLine("    {")
+                .AppendLine("        void TestMethod(int? actual, int expected)")
+                .AppendLine("        {")
+                .AppendLine($"            {assertion}")
+                .AppendLine("        }")
+                .AppendLine("    }")
+                .AppendLine("    class Program")
+                .AppendLine("    {")
+                .AppendLine("        public static void Main()")
+                .AppendLine("        {")
+                .AppendLine("        }")
+                .AppendLine("    }")
+                .AppendLine("}")
+                .ToString();
+
+            DiagnosticVerifier.VerifyCSharpDiagnostic<NullConditionalAssertionAnalyzer>(code, new DiagnosticResult
+            {
+                Id = NullConditionalAssertionAnalyzer.DiagnosticId,
+                Message = NullConditionalAssertionAnalyzer.Message,
+                Severity = Microsoft.CodeAnalysis.DiagnosticSeverity.Warning,
+                Locations = new DiagnosticResultLocation[]
+                {
+                    new DiagnosticResultLocation("Test0.cs", 9, 13)
+                }
+            });
+        }
+    }
+}

src/FluentAssertions.Analyzers/Constants.cs

@@ -58,7 +58,13 @@ public static class Dictionaries
                 public const string DictionaryShouldNotContainKey = nameof(DictionaryShouldNotContainKey);
                 public const string DictionaryShouldNotContainValue = nameof(DictionaryShouldNotContainValue);
 
-            }
+            }            
+        }
+        public static class CodeSmell
+        {
+            public const string Category = "FluentAssertionCodeSmell";
+
+            public const string NullConditionalAssertion = nameof(NullConditionalAssertion);
         }
     }
 }

src/FluentAssertions.Analyzers/FluentAssertions.Analyzers.nuspec

@@ -3,7 +3,7 @@
   <metadata>
     <id>FluentAssertions.Analyzers</id>
     <title>Fluent Assertions Analyzers</title>
-    <version>0.7.0</version>
+    <version>0.8.0</version>
     <owners>Meir Blachman</owners>
     <authors>Meir Blachman</authors>
     <summary>

src/FluentAssertions.Analyzers/Tips/NullConditionalAssertionAnalyzer.cs

@@ -0,0 +1,84 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace FluentAssertions.Analyzers.Tips
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class NullConditionalAssertionAnalyzer : DiagnosticAnalyzer
+    {
+        public const string DiagnosticId = Constants.CodeSmell.NullConditionalAssertion;
+        public const string Title = "Code Smell";
+        public const string Message = "The assertions might not be executed when using ?.Should()";
+
+        public static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(DiagnosticId, Title, Message, Constants.CodeSmell.Category, DiagnosticSeverity.Warning, true);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public sealed override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.RegisterCodeBlockAction(AnalyzeCodeBlock);
+        }
+
+        private void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
+        {
+            var method = context.CodeBlock as MethodDeclarationSyntax;
+            if (method == null) return;
+
+            if (method.Body != null)
+            {
+                foreach (var statement in method.Body.Statements.OfType<ExpressionStatementSyntax>())
+                {
+                    var diagnostic = AnalyzeExpression(statement.Expression);
+                    if (diagnostic != null)
+                    {
+                        context.ReportDiagnostic(diagnostic);
+                    }
+                }
+                return;
+            }
+            if (method.ExpressionBody != null)
+            {
+                var diagnostic = AnalyzeExpression(method.ExpressionBody.Expression);
+                if (diagnostic != null)
+                {
+                    context.ReportDiagnostic(diagnostic);
+                }
+            }
+        }
+
+        protected virtual Diagnostic AnalyzeExpression(ExpressionSyntax expression)
+        {
+            var visitor = new ConditionalAccessExpressionVisitor();
+            expression.Accept(visitor);
+
+            return visitor.CodeSmells ? Diagnostic.Create(descriptor: Rule, location: expression.GetLocation()) : null;
+        }
+
+        private class ConditionalAccessExpressionVisitor : CSharpSyntaxWalker
+        {
+            public bool CodeSmells { get; private set; }
+            public Location ConditionalAccess { get; private set; }
+
+            public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
+            {
+                if (CodeSmells) return;
+
+                CodeSmells = node.WhenNotNull is InvocationExpressionSyntax invocation
+                    && invocation.Expression is MemberAccessExpressionSyntax memberAccess && memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression)
+                    && memberAccess.Expression is InvocationExpressionSyntax shouldInvocation
+                    && shouldInvocation.Expression is MemberBindingExpressionSyntax memberBinding
+                    && memberBinding.Name.Identifier.ValueText == "Should";
+                if (CodeSmells)
+                {
+                    ConditionalAccess = node.GetLocation();
+                }
+            }
+        }
+    }
+}