Add rule to explicitly pick MockBehavior

docs/rules/Moq1400.md

@@ -0,0 +1,48 @@
+# Moq1400: Explicitly choose a mocking behavior instead of relying on the default (Loose) behavior
+
+| Item | Value |
+| --- | --- |
+| Enabled | True |
+| Severity | Warning |
+| CodeFix | False |
+---
+
+Mocks use the `MockBehavior.Loose` by default. Some people find this default behavior undesirable, as it can lead to
+unexpected behavior if the mock is improperly set up. To fix, specify either `MockBehavior.Loose` or
+`MockBehavior.Strict` to signify acknowledgement of the mock's behavior.
+
+## Examples of patterns that are flagged by this analyzer
+
+```csharp
+interface ISample
+{
+    int Calculate() => 0;
+}
+
+var mock = new Mock<ISample>(); // Moq1400: Moq: Explicitly choose a mock behavior
+var mock2 = Mock.Of<ISample>();  // Moq1400: Moq: Explicitly choose a mock behavior
+```
+
+```csharp
+interface ISample
+{
+    int Calculate() => 0;
+}
+
+var mock = new Mock<ISample>(MockBehavior.Default); // Moq1400: Moq: Explicitly choose a mock behavior
+var mock2 = Mock.Of<ISample>(MockBehavior.Default); // Moq1400: Moq: Explicitly choose a mock behavior
+var repo = new MockRepository(MockBehavior.Default); // Moq1400: Moq: Explicitly choose a mock behavior
+```
+
+## Solution
+
+```csharp
+interface ISample
+{
+    int Calculate() => 0;
+}
+
+var mock = new Mock<ISample>(MockBehavior.Strict); // Or `MockBehavior.Loose`
+var mock2 = new Mock.Of<ISample>(MockBehavior.Strict); // Or `MockBehavior.Loose`
+var repo = new MockRepository(MockBehavior.Strict); // Or `MockBehavior.Loose`
+```

src/Moq.Analyzers/AnalyzerReleases.Unshipped.md

@@ -1,2 +1,8 @@
 ; Unshipped analyzer release
 ; https://github.com/dotnet/roslyn-analyzers/blob/main/src/Microsoft.CodeAnalysis.Analyzers/ReleaseTrackingAnalyzers.Help.md
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+Moq1400 | Moq      | Warning  | SetExplicitMockBehaviorAnalyzer, [Documentation](https://github.com/rjmurillo/moq.analyzers/blob/main/docs/rules/Moq1400.md)

src/Moq.Analyzers/AsShouldBeUsedOnlyForInterfaceAnalyzer.cs

@@ -68,12 +68,10 @@ private static void Analyze(OperationAnalysisContext context, ImmutableArray<IMe
         }
 
         IMethodSymbol targetMethod = invocationOperation.TargetMethod;
-#pragma warning disable ECS0900 // Minimize boxing and unboxing
         if (!targetMethod.IsInstanceOf(wellKnownAsMethods))
         {
             return;
         }
-#pragma warning restore ECS0900 // Minimize boxing and unboxing
 
         ImmutableArray<ITypeSymbol> typeArguments = targetMethod.TypeArguments;
         if (typeArguments.Length != 1)

src/Moq.Analyzers/Common/DiagnosticIds.cs

@@ -12,4 +12,5 @@ internal static class DiagnosticIds
     internal const string SetupOnlyUsedForOverridableMembers = "Moq1200";
     internal const string AsyncUsesReturnsAsyncInsteadOfResult = "Moq1201";
     internal const string AsShouldOnlyBeUsedForInterfacesRuleId = "Moq1300";
+    internal const string SetExplicitMockBehavior = "Moq1400";
 }

src/Moq.Analyzers/Common/ISymbolExtensions.cs

@@ -15,19 +15,33 @@ internal static class ISymbolExtensions
     /// <see langword="true"/> if <paramref name="symbol"/> is an instance of <paramref name="other"/>, either as a direct match,
     /// or as a specialaization; otherwise, <see langword="false"/>.
     /// </returns>
-    /// <remarks>
-    /// As an example, <c>Type.Method&lt;int&gt;()</c> is an instance of <c>Type.Method&lt;T&gt;()</c>.
-    /// </remarks>
+    /// <example>
+    /// <c>MyType.MyMethod&lt;int&gt;()</c> is an instance of <c>MyType.MyMethod&lt;T&gt;()</c>.
+    /// </example>
+    /// <example>
+    /// <c>MyType&lt;int&gt;()</c> is an instance of <c>MyType&lt;T&gt;()</c>.
+    /// </example>
     public static bool IsInstanceOf<TSymbol>(this ISymbol symbol, TSymbol other, SymbolEqualityComparer? symbolEqualityComparer = null)
         where TSymbol : class, ISymbol
     {
         symbolEqualityComparer ??= SymbolEqualityComparer.Default;
 
-        return symbol switch
+        if (symbol is IMethodSymbol methodSymbol)
         {
-            IMethodSymbol methodSymbol => symbolEqualityComparer.Equals(methodSymbol.OriginalDefinition, other),
-            _ => symbolEqualityComparer.Equals(symbol, other),
-        };
+            return symbolEqualityComparer.Equals(methodSymbol.OriginalDefinition, other);
+        }
+
+        if (symbol is INamedTypeSymbol namedTypeSymbol)
+        {
+            if (namedTypeSymbol.IsGenericType)
+            {
+                namedTypeSymbol = namedTypeSymbol.ConstructedFrom;
+            }
+
+            return symbolEqualityComparer.Equals(namedTypeSymbol, other);
+        }
+
+        return symbolEqualityComparer.Equals(symbol, other);
     }
 
     /// <inheritdoc cref="IsInstanceOf{TSymbol}(ISymbol, TSymbol, SymbolEqualityComparer?)"/>
@@ -36,7 +50,7 @@ public static bool IsInstanceOf<TSymbol>(this ISymbol symbol, TSymbol other, Sym
     /// The symbols to compare to. Returns <see langword="true"/> if <paramref name="symbol"/> matches any of others.
     /// </param>
     /// <param name="symbolEqualityComparer">The <see cref="SymbolEqualityComparer"/> to use for equality.</param>
-    public static bool IsInstanceOf<TSymbol>(this ISymbol symbol, IEnumerable<TSymbol> others, SymbolEqualityComparer? symbolEqualityComparer = null)
+    public static bool IsInstanceOf<TSymbol>(this ISymbol symbol, ImmutableArray<TSymbol> others, SymbolEqualityComparer? symbolEqualityComparer = null)
         where TSymbol : class, ISymbol
     {
         symbolEqualityComparer ??= SymbolEqualityComparer.Default;

src/Moq.Analyzers/SetExplicitMockBehaviorAnalyzer.cs

@@ -0,0 +1,136 @@
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Moq.Analyzers;
+
+/// <summary>
+/// Mock should explicitly specify a behavior and not rely on the default.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class SetExplicitMockBehaviorAnalyzer : DiagnosticAnalyzer
+{
+    private static readonly LocalizableString Title = "Moq: Explicitly choose a mock behavior";
+    private static readonly LocalizableString Message = "Explicitly choose a mocking behavior instead of relying on the default (Loose) behavior";
+
+    private static readonly DiagnosticDescriptor Rule = new(
+        DiagnosticIds.SetExplicitMockBehavior,
+        Title,
+        Message,
+        DiagnosticCategory.Moq,
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        helpLinkUri: $"https://github.com/rjmurillo/moq.analyzers/blob/{ThisAssembly.GitCommitId}/docs/rules/{DiagnosticIds.SetExplicitMockBehavior}.md");
+
+    /// <inheritdoc />
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);
+
+    /// <inheritdoc />
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+
+        context.RegisterCompilationStartAction(RegisterCompilationStartAction);
+    }
+
+    private static void RegisterCompilationStartAction(CompilationStartAnalysisContext context)
+    {
+        // Ensure Moq is referenced in the compilation
+        ImmutableArray<INamedTypeSymbol> mockTypes = context.Compilation.GetMoqMock();
+        if (mockTypes.IsEmpty)
+        {
+            return;
+        }
+
+        // Look for the MockBehavior type and provide it to Analyze to avoid looking it up multiple times.
+        INamedTypeSymbol? mockBehaviorSymbol = context.Compilation.GetTypeByMetadataName(WellKnownTypeNames.MoqBehavior);
+        if (mockBehaviorSymbol is null)
+        {
+            return;
+        }
+
+        // Look for the Mock.Of() method and provide it to Analyze to avoid looking it up multiple times.
+#pragma warning disable ECS0900 // Minimize boxing and unboxing
+        ImmutableArray<IMethodSymbol> ofMethods = mockTypes
+            .SelectMany(mockType => mockType.GetMembers(WellKnownTypeNames.Of))
+            .OfType<IMethodSymbol>()
+            .Where(method => method.IsGenericMethod)
+            .ToImmutableArray();
+#pragma warning restore ECS0900 // Minimize boxing and unboxing
+
+        context.RegisterOperationAction(
+            context => AnalyzeNewObject(context, mockTypes, mockBehaviorSymbol),
+            OperationKind.ObjectCreation);
+
+        if (!ofMethods.IsEmpty)
+        {
+            context.RegisterOperationAction(
+                context => AnalyzeInvocation(context, ofMethods, mockBehaviorSymbol),
+                OperationKind.Invocation);
+        }
+    }
+
+    private static void AnalyzeNewObject(OperationAnalysisContext context, ImmutableArray<INamedTypeSymbol> mockTypes, INamedTypeSymbol mockBehaviorSymbol)
+    {
+        if (context.Operation is not IObjectCreationOperation creationOperation)
+        {
+            return;
+        }
+
+        if (creationOperation.Type is not INamedTypeSymbol namedType)
+        {
+            return;
+        }
+
+        if (!namedType.IsInstanceOf(mockTypes))
+        {
+            return;
+        }
+
+        foreach (IArgumentOperation argument in creationOperation.Arguments)
+        {
+            if (argument.Value is IFieldReferenceOperation fieldReferenceOperation)
+            {
+                ISymbol field = fieldReferenceOperation.Member;
+                if (field.ContainingType.IsInstanceOf(mockBehaviorSymbol) && IsExplicitBehavior(field.Name))
+                {
+                    return;
+                }
+            }
+        }
+
+        context.ReportDiagnostic(creationOperation.Syntax.GetLocation().CreateDiagnostic(Rule));
+    }
+
+    private static void AnalyzeInvocation(OperationAnalysisContext context, ImmutableArray<IMethodSymbol> wellKnownOfMethods, INamedTypeSymbol mockBehaviorSymbol)
+    {
+        if (context.Operation is not IInvocationOperation invocationOperation)
+        {
+            return;
+        }
+
+        IMethodSymbol targetMethod = invocationOperation.TargetMethod;
+        if (!targetMethod.IsInstanceOf(wellKnownOfMethods))
+        {
+            return;
+        }
+
+        foreach (IArgumentOperation argument in invocationOperation.Arguments)
+        {
+            if (argument.Value is IFieldReferenceOperation fieldReferenceOperation)
+            {
+                ISymbol field = fieldReferenceOperation.Member;
+                if (field.ContainingType.IsInstanceOf(mockBehaviorSymbol) && IsExplicitBehavior(field.Name))
+                {
+                    return;
+                }
+            }
+        }
+
+        context.ReportDiagnostic(invocationOperation.Syntax.GetLocation().CreateDiagnostic(Rule));
+    }
+
+    private static bool IsExplicitBehavior(string symbolName)
+    {
+        return string.Equals(symbolName, "Loose", StringComparison.Ordinal) || string.Equals(symbolName, "Strict", StringComparison.Ordinal);
+    }
+}

tests/Moq.Analyzers.Test/Helpers/ReferenceAssemblyCatalog.cs

@@ -24,6 +24,7 @@ internal static class ReferenceAssemblyCatalog
         // implementation of `.As<T>()` (see https://github.com/devlooped/moq/commit/b552aeddd82090ee0f4743a1ab70a16f3e6d2d11).
         { nameof(Net80WithOldMoq), ReferenceAssemblies.Net.Net80.AddPackages([new PackageIdentity("Moq", "4.8.2")]) },
 
+        // This must be 4.12.0 or later in order to have the new `Mock.Of<T>(MockBehavior)` method (see https://github.com/devlooped/moq/commit/1561c006c87a0894c5257a1e541da44e40e33dd3).
         // 4.18.4 is currently the most downloaded version of Moq.
         { nameof(Net80WithNewMoq), ReferenceAssemblies.Net.Net80.AddPackages([new PackageIdentity("Moq", "4.18.4")]) },
     };

tests/Moq.Analyzers.Test/SetExplicitMockBehaviorAnalyzerTests.cs

@@ -0,0 +1,58 @@
+using Verifier = Moq.Analyzers.Test.Helpers.AnalyzerVerifier<Moq.Analyzers.SetExplicitMockBehaviorAnalyzer>;
+
+namespace Moq.Analyzers.Test;
+
+public class SetExplicitMockBehaviorAnalyzerTests
+{
+    public static IEnumerable<object[]> TestData()
+    {
+        IEnumerable<object[]> mockConstructors = new object[][]
+        {
+            ["""{|Moq1400:new Mock<ISample>()|};"""],
+            ["""{|Moq1400:new Mock<ISample>(MockBehavior.Default)|};"""],
+            ["""new Mock<ISample>(MockBehavior.Loose);"""],
+            ["""new Mock<ISample>(MockBehavior.Strict);"""],
+        }.WithNamespaces().WithMoqReferenceAssemblyGroups();
+
+        IEnumerable<object[]> fluentBuilders = new object[][]
+        {
+            ["""{|Moq1400:Mock.Of<ISample>()|};"""],
+            ["""{|Moq1400:Mock.Of<ISample>(MockBehavior.Default)|};"""],
+            ["""Mock.Of<ISample>(MockBehavior.Loose);"""],
+            ["""Mock.Of<ISample>(MockBehavior.Strict);"""],
+        }.WithNamespaces().WithNewMoqReferenceAssemblyGroups();
+
+        IEnumerable<object[]> mockRepositories = new object[][]
+        {
+            ["""{|Moq1400:new MockRepository(MockBehavior.Default)|};"""],
+            ["""new MockRepository(MockBehavior.Loose);"""],
+            ["""new MockRepository(MockBehavior.Strict);"""],
+        }.WithNamespaces().WithNewMoqReferenceAssemblyGroups();
+
+        return mockConstructors.Union(fluentBuilders).Union(mockRepositories);
+    }
+
+    [Theory]
+    [MemberData(nameof(TestData))]
+    public async Task ShouldAnalyzeMocksWithoutExplictMockBehavior(string referenceAssemblyGroup, string @namespace, string mock)
+    {
+        await Verifier.VerifyAnalyzerAsync(
+                $$"""
+                {{@namespace}}
+
+                public interface ISample
+                {
+                    int Calculate(int a, int b);
+                }
+
+                internal class UnitTest
+                {
+                    private void Test()
+                    {
+                        {{mock}}
+                    }
+                }
+                """,
+                referenceAssemblyGroup);
+    }
+}