feat: verify assertion type and module (#186)

* reproduce issue #163

* update test

* remove unused ShouldAnalyzeMethod

* verify assertion type and module

Author: Meir017

src/FluentAssertions.Analyzers.Tests/DiagnosticVerifier.cs

@@ -450,6 +450,13 @@ public static void VerifyCSharpDiagnosticUsingAllAnalyzers(string source, params
             VerifyDiagnosticResults(diagnostics, analyzers, expected);
         }
 
+        public static void VerifyCSharpDiagnosticUsingAllAnalyzers(string[] sources, params DiagnosticResult[] expected)
+        {
+            var analyzers = CreateAllAnalyzers();
+            var diagnostics = GetSortedDiagnostics(sources, LanguageNames.CSharp, analyzers);
+            VerifyDiagnosticResults(diagnostics, analyzers, expected);
+        }
+
         /// <summary>
         /// General method that gets a collection of actual diagnostics found in the source after the analyzer is run,
         /// then verifies each of them.

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

@@ -1,4 +1,9 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using FluentAssertions.Analyzers.Xunit;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace FluentAssertions.Analyzers.Tests
 {
@@ -302,5 +307,37 @@ public static void Main()
 
             DiagnosticVerifier.VerifyCSharpFix<AssertAreEqualCodeFix, AssertAreEqualAnalyzer>(oldSource, newSource);
         }
+
+        [TestMethod]
+        [Implemented(Reason = "https://github.com/fluentassertions/fluentassertions.analyzers/issues/163")]
+        public void GlobalUsingsWithAssert()
+        {
+            const string globalUsings = @"
+global using Xunit;
+global using FluentAssertions;
+global using FluentAssertions.Extensions;";
+            const string source = @"
+public class TestClass
+{
+    public static void Main()
+    {
+        var x = false;
+        Assert.True(x);
+        TestClass.True(x);
+    }
+
+    public static void True(bool input)
+    {
+    }
+}";
+
+            DiagnosticVerifier.VerifyCSharpDiagnosticUsingAllAnalyzers(new[] { source, globalUsings }, new DiagnosticResult()
+            {
+                Id = AssertTrueAnalyzer.DiagnosticId,
+                Message = AssertTrueAnalyzer.Message,
+                Severity = DiagnosticSeverity.Info,
+                Locations = new[] { new DiagnosticResultLocation("Test0.cs", 7, 9) }
+            });
+        }
     }
 }

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

@@ -2,6 +2,8 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using FluentAssertions.Analyzers.Xunit;
 
+using XunitAssert = Xunit.Assert;
+
 namespace FluentAssertions.Analyzers.Tests.Tips
 {
     [TestClass]

src/FluentAssertions.Analyzers/Tips/MsTest/MsTestBase.cs

@@ -7,23 +7,22 @@ namespace FluentAssertions.Analyzers
 {
     public abstract class MsTestAnalyzer : TestingLibraryAnalyzerBase
     {
-        private static readonly string MsTestNamespace = "Microsoft.VisualStudio.TestTools.UnitTesting";
-        protected override string TestingLibraryNamespace => MsTestNamespace;
+        protected override string TestingLibraryModule => "Microsoft.VisualStudio.TestPlatform.TestFramework";
     }
 
     public abstract class MsTestAssertAnalyzer : MsTestAnalyzer
     {
-        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => type.Name == "Assert";
+        override protected string TestingLibraryAssertionType => "Assert";
     }
 
     public abstract class MsTestStringAssertAnalyzer : MsTestAnalyzer
     {
-        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => type.Name == "StringAssert";
+        override protected string TestingLibraryAssertionType => "StringAssert";
     }
 
     public abstract class MsTestCollectionAssertAnalyzer : MsTestAnalyzer
     {
-        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => type.Name == "CollectionAssert";
+        override protected string TestingLibraryAssertionType => "CollectionAssert";
     }
 
     public abstract class MsTestAssertCodeFixProvider : TestingLibraryCodeFixBase

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

@@ -6,8 +6,8 @@ namespace FluentAssertions.Analyzers.Xunit
 {
     public abstract class XunitAnalyzer : TestingLibraryAnalyzerBase
     {
-        private static readonly string XunitNamespace = "Xunit";
-        protected override string TestingLibraryNamespace => XunitNamespace;
+        protected override string TestingLibraryModule => "xunit.assert";
+        protected override string TestingLibraryAssertionType => "Assert";
 
         protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => type.Name == "Assert";
     }

src/FluentAssertions.Analyzers/Utilities/FluentAssertionsAnalyzer.cs

@@ -5,8 +5,6 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Linq;
-using SF = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
 namespace FluentAssertions.Analyzers
 {
@@ -46,8 +44,6 @@ private void AnalyzeExpressionStatementSyntax(SyntaxNodeAnalysisContext context)
             }
         }
 
-        protected virtual bool ShouldAnalyzeMethod(MethodDeclarationSyntax method) => true;
-
         protected virtual bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => true;
 
         protected virtual Diagnostic AnalyzeExpression(ExpressionSyntax expression, SemanticModel semanticModel)
@@ -77,7 +73,7 @@ protected virtual Diagnostic CreateDiagnostic(TCSharpSyntaxVisitor visitor, Expr
         {
             var properties = visitor.ToDiagnosticProperties()
                 .Add(Constants.DiagnosticProperties.Title, Title);
-            var newRule = new DiagnosticDescriptor(Rule.Id, Rule.Title, Rule.MessageFormat, Rule.Category, Rule.DefaultSeverity, true, 
+            var newRule = new DiagnosticDescriptor(Rule.Id, Rule.Title, Rule.MessageFormat, Rule.Category, Rule.DefaultSeverity, true,
                 helpLinkUri: properties.GetValueOrDefault(Constants.DiagnosticProperties.HelpLink));
             return Diagnostic.Create(
                 descriptor: newRule,
@@ -105,44 +101,10 @@ public abstract class FluentAssertionsAnalyzer : FluentAssertionsAnalyzer<Fluent
 
     public abstract class TestingLibraryAnalyzerBase : FluentAssertionsAnalyzer
     {
-        protected abstract string TestingLibraryNamespace { get; }
-
-        protected override bool ShouldAnalyzeMethod(MethodDeclarationSyntax method)
-        {
-            var compilation = method.FirstAncestorOrSelf<CompilationUnitSyntax>();
-
-            if (compilation == null) return false;
-
-            foreach (var @using in compilation.Usings)
-            {
-                if (@using.Name.NormalizeWhitespace().ToString().Equals(TestingLibraryNamespace)) return true;
-            }
-
-            var parentNamespace = method.FirstAncestorOrSelf<NamespaceDeclarationSyntax>();
-            if (parentNamespace != null)
-            {
-                var namespaces = new List<NamespaceDeclarationSyntax>();
-                while(parentNamespace != null)
-                {
-                    namespaces.Add(parentNamespace);
-                    parentNamespace = parentNamespace.Parent as NamespaceDeclarationSyntax;
-                }
-                namespaces.Reverse();
-
-                for (int i = 0; i < namespaces.Count; i++)
-                {
-                    var baseNamespace = string.Join(".", namespaces.Take(i+1).Select(ns => ns.Name));
-                    foreach (var @using in namespaces[i].Usings)
-                    {
-                        if (@using.Name.NormalizeWhitespace().ToString().Equals(TestingLibraryNamespace)) return true;
-
-                        var fullUsing = SF.ParseName($"{baseNamespace}.{@using.Name}").NormalizeWhitespace().ToString();
-                        if (fullUsing.Equals(TestingLibraryNamespace)) return true;
-                    }
-                }
-            }
+        protected abstract string TestingLibraryModule { get; }
+        protected abstract string TestingLibraryAssertionType { get; }
 
-            return false;
-        }
+        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel)
+            => type.Name == TestingLibraryAssertionType && type.ContainingModule.Name == TestingLibraryModule + ".dll";
     }
 }