v1.3.0 (#7)

* Fix the PosInfoMoq2000 rule to check the Returns() / ReturnsAsync() method has been called for the mocked properties. (fixes #6).
* Add the PosInfoMoq2003 rule to check the Callback() signature method (fixes #3).

Author: GillesTourreau

PosInformatique.Moq.Analyzers.sln

@@ -33,15 +33,16 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{3C20D95F-A
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Design", "Design", "{815BE8D0-C7D5-4B4E-82E0-DE29C11F258E}"
 	ProjectSection(SolutionItems) = preProject
-		docs\design\PosInfoMoq1001.md = docs\design\PosInfoMoq1001.md
 		docs\design\PosInfoMoq1000.md = docs\design\PosInfoMoq1000.md
+		docs\design\PosInfoMoq1001.md = docs\design\PosInfoMoq1001.md
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Compilation", "Compilation", "{D9C84D36-7F9C-4EFB-BE6F-9F7A05FE957D}"
 	ProjectSection(SolutionItems) = preProject
 		docs\Compilation\PosInfoMoq2000.md = docs\Compilation\PosInfoMoq2000.md
 		docs\Compilation\PosInfoMoq2001.md = docs\Compilation\PosInfoMoq2001.md
 		docs\Compilation\PosInfoMoq2002.md = docs\Compilation\PosInfoMoq2002.md
+		docs\Compilation\PosInfoMoq2003.md = docs\Compilation\PosInfoMoq2003.md
 	EndProjectSection
 EndProject
 Global

README.md

@@ -40,4 +40,5 @@ All the rules of this category should not be disabled (or changed their severity
 | [PosInfoMoq2000: The `Returns()` or `ReturnsAsync()` methods must be call for Strict mocks](docs/Compilation/PosInfoMoq2000.md) | When a `Mock<T>` has been defined with the `Strict` behavior, the `Returns()` or `ReturnsAsync()` method must be called when setup a method to mock which returns a value. |
 | [PosInfoMoq2001: The `Setup()` method must be used only on overridable members](docs/Compilation/PosInfoMoq2001.md)) | The `Setup()` method must be applied only for overridable members. |
 | [PosInfoMoq2002: `Mock<T>` class can be used only to mock non-sealed class](docs/Compilation/PosInfoMoq2002.md) | The `Mock<T>` can mock only interfaces or non-`sealed` classes. |
+| [PosInfoMoq2003: The `Callback()` delegate expression must match the signature of the mocked method](docs/Compilation/PosInfoMoq2003.md) | The delegate in the argument of the `Callback()` method must match the signature of the mocked method. |
 

build/azure-pipelines-release.yaml

@@ -2,7 +2,7 @@ parameters:
 - name: VersionPrefix
   displayName: The version of the library
   type: string
-  default: 1.2.0
+  default: 1.3.0
 - name: VersionSuffix
   displayName: The version suffix of the library (rc.1). Use a space ' ' if no suffix.
   type: string

docs/Compilation/PosInfoMoq2003.md

@@ -0,0 +1,47 @@
+# PosInfoMoq2003: The `Callback()` delegate expression must match the signature of the mocked method
+
+| Property                            | Value																					|
+|-------------------------------------|-----------------------------------------------------------------------------------------|
+| **Rule ID**                         | PosInfoMoq2003																			|
+| **Title**                           | The `Callback()` delegate expression must match the signature of the mocked method		|
+| **Category**                        | Compilation																				|
+| **Default severity**				  | Error																					|
+
+## Cause
+
+The delegate in the argument of the `Callback()` method must match the signature of the mocked method.
+
+## Rule description
+
+The lambda expression in the argument of the `Callback()` method must match the signature of the mocked method.
+
+For example, the `Callback()` have a lambda expression with the `(string, double)` signature
+which does not match the `GetData()` mocked method which have the `(string, int)` signature.
+
+```csharp
+[Fact]
+public void Test()
+{
+    var service = new Mock<Service>();
+    service.Setup(s => s.GetData("TOURREAU", 1234))
+        .Callback((string n, double age) =>		// Different signature of the GetData() method.
+        {
+        	// ...
+        })
+        .Returns(10);
+}
+
+public interface IService
+{
+	public int GetData(string name, int age) { }
+}
+```
+
+## How to fix violations
+
+To fix a violation of this rule, be sure to use the mocked method signature in the `Callback()` method.
+
+## When to suppress warnings
+
+Do not suppress an error from this rule. If bypassed, the execution of the unit test will be failed with a `MoqException`
+thrown with the *"Invalid callback. Setup on method with parameters (xxx) cannot invoke callback with parameters (yyy)."* message.

src/Moq.Analyzers/AnalyzerReleases.Shipped.md

@@ -1,4 +1,12 @@
-## Release 1.2.0
+## Release 1.3.0
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|--------------------
+PosInfoMoq2003  | Compilation | Error  | The `Callback()` delegate expression must match the signature of the mocked method.
+
+## Release 1.2.0
 
 ### New Rules
 

src/Moq.Analyzers/Analyzers/CallBackDelegateMustMatchMockedMethodAnalyzer.cs

@@ -0,0 +1,116 @@
+//-----------------------------------------------------------------------
+// <copyright file="CallBackDelegateMustMatchMockedMethodAnalyzer.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Moq.Analyzers
+{
+    using System.Collections.Immutable;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class CallBackDelegateMustMatchMockedMethodAnalyzer : DiagnosticAnalyzer
+    {
+        private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
+            "PosInfoMoq2003",
+            "The Callback() delegate expression must match the signature of the mocked method",
+            "The Callback() delegate expression must match the signature of the mocked method",
+            "Compilation",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true,
+            description: "The Callback() delegate expression must match the signature of the mocked method.");
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+
+            context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.InvocationExpression);
+        }
+
+        private static void Analyze(SyntaxNodeAnalysisContext context)
+        {
+            var invocationExpression = (InvocationExpressionSyntax)context.Node;
+
+            var moqSymbols = MoqSymbols.FromCompilation(context.Compilation);
+
+            if (moqSymbols is null)
+            {
+                return;
+            }
+
+            var moqExpressionAnalyzer = new MoqExpressionAnalyzer(context.SemanticModel);
+
+            // Try to determine if the invocation expression is a Callback() expression.
+            var methodSymbol = context.SemanticModel.GetSymbolInfo(invocationExpression);
+
+            if (!moqSymbols.IsCallback(methodSymbol.Symbol))
+            {
+                return;
+            }
+
+            // If yes, we extract the lambda expression of it.
+            var callBackLambdaExpressionSymbol = moqExpressionAnalyzer.ExtractCallBackLambdaExpressionMethod(invocationExpression, out var lambdaExpression);
+
+            if (callBackLambdaExpressionSymbol is null)
+            {
+                return;
+            }
+
+            // Check each CallBack() method for the following calls.
+            var followingMethods = invocationExpression.DescendantNodes().OfType<InvocationExpressionSyntax>();
+
+            foreach (var followingMethod in followingMethods)
+            {
+                // Find the symbol of the mocked method (if not symbol found, it is mean we Setup() method that not currently compile)
+                // so we skip the analysis.
+                var mockedMethod = moqExpressionAnalyzer.ExtractSetupMethod(followingMethod, out var _);
+
+                if (mockedMethod is null)
+                {
+                    continue;
+                }
+
+                // Compare the parameters between the mocked method and lambda expression in the CallBack() method.
+                // 1- Compare the number of the parameters
+                if (callBackLambdaExpressionSymbol.Parameters.Length != mockedMethod.Parameters.Length)
+                {
+                    var diagnostic = Diagnostic.Create(Rule, lambdaExpression!.ParameterList.GetLocation());
+                    context.ReportDiagnostic(diagnostic);
+
+                    continue;
+                }
+
+                // 2- Iterate for each parameter
+                for (var i = 0; i < callBackLambdaExpressionSymbol.Parameters.Length; i++)
+                {
+                    // Special case, if the argument is IsAnyType
+                    if (moqSymbols.IsAnyType(mockedMethod.Parameters[i].Type))
+                    {
+                        // The callback parameter associated must be an object.
+                        if (callBackLambdaExpressionSymbol.Parameters[i].Type.SpecialType != SpecialType.System_Object)
+                        {
+                            var diagnostic = Diagnostic.Create(Rule, lambdaExpression!.ParameterList.Parameters[i].GetLocation());
+                            context.ReportDiagnostic(diagnostic);
+
+                            continue;
+                        }
+                    }
+                    else if (!SymbolEqualityComparer.Default.Equals(callBackLambdaExpressionSymbol.Parameters[i].Type, mockedMethod.Parameters[i].Type))
+                    {
+                        var diagnostic = Diagnostic.Create(Rule, lambdaExpression!.ParameterList.Parameters[i].GetLocation());
+                        context.ReportDiagnostic(diagnostic);
+
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+}

src/Moq.Analyzers/Moq.Analyzers.csproj

@@ -33,16 +33,16 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.7.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.7.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.8.0" />
   </ItemGroup>
 
   <ItemGroup>
     <None Include="..\..\README.md" Pack="true" PackagePath="\" />
   </ItemGroup>
 
   <ItemGroup>
-    <None Include="Icon.png" Pack="true" PackagePath=""/>
+    <None Include="Icon.png" Pack="true" PackagePath="" />
   </ItemGroup>
 
   <Target Name="_AddAnalyzersToOutput">

src/Moq.Analyzers/MoqExpressionAnalyzer.cs

@@ -172,19 +172,31 @@ public bool IsStrictBehavior(MoqSymbols moqSymbols, IdentifierNameSyntax localVa
                 return null;
             }
 
-            if (lambdaExpression.Body is not InvocationExpressionSyntax methodExpression)
+            var methodSymbolInfo = this.semanticModel.GetSymbolInfo(lambdaExpression.Body);
+
+            if (methodSymbolInfo.Symbol is IMethodSymbol methodSymbol)
             {
-                return null;
+                return methodSymbol.ReturnType;
             }
 
-            var methodSymbolInfo = this.semanticModel.GetSymbolInfo(methodExpression);
+            if (methodSymbolInfo.Symbol is IPropertySymbol propertySymbol)
+            {
+                return propertySymbol.Type;
+            }
+
+            return null;
+        }
+
+        public IMethodSymbol? ExtractSetupMethod(InvocationExpressionSyntax invocationExpression, out NameSyntax? memberIdentifierName)
+        {
+            var symbol = this.ExtractSetupMember(invocationExpression, out memberIdentifierName);
 
-            if (methodSymbolInfo.Symbol is not IMethodSymbol methodSymbol)
+            if (symbol is not IMethodSymbol methodSymbol)
             {
                 return null;
             }
 
-            return methodSymbol.ReturnType;
+            return methodSymbol;
         }
 
         public ISymbol? ExtractSetupMember(InvocationExpressionSyntax invocationExpression, out NameSyntax? memberIdentifierName)
@@ -231,6 +243,32 @@ public bool IsStrictBehavior(MoqSymbols moqSymbols, IdentifierNameSyntax localVa
             return symbol.Symbol;
         }
 
+        public IMethodSymbol? ExtractCallBackLambdaExpressionMethod(InvocationExpressionSyntax invocationExpression, out ParenthesizedLambdaExpressionSyntax? lambdaExpression)
+        {
+            lambdaExpression = null;
+
+            if (invocationExpression.ArgumentList.Arguments.Count != 1)
+            {
+                return null;
+            }
+
+            if (invocationExpression.ArgumentList.Arguments[0].Expression is not ParenthesizedLambdaExpressionSyntax lambdaExpressionFound)
+            {
+                return null;
+            }
+
+            var symbol = this.semanticModel.GetSymbolInfo(lambdaExpressionFound);
+
+            if (symbol.Symbol is not IMethodSymbol methodSymbol)
+            {
+                return null;
+            }
+
+            lambdaExpression = lambdaExpressionFound;
+
+            return methodSymbol;
+        }
+
         private static ObjectCreationExpressionSyntax? FindMockCreation(BlockSyntax block, string variableName)
         {
             foreach (var statement in block.Statements.OfType<LocalDeclarationStatementSyntax>())

src/Moq.Analyzers/MoqSymbols.cs

@@ -18,10 +18,13 @@ internal sealed class MoqSymbols
 
         private readonly ISymbol mockBehaviorStrictField;
 
-        private MoqSymbols(INamedTypeSymbol mockClass, INamedTypeSymbol mockBehaviorEnum)
+        private readonly ISymbol isAnyTypeClass;
+
+        private MoqSymbols(INamedTypeSymbol mockClass, INamedTypeSymbol mockBehaviorEnum, ISymbol isAnyTypeClass)
         {
             this.mockClass = mockClass;
             this.mockBehaviorEnum = mockBehaviorEnum;
+            this.isAnyTypeClass = isAnyTypeClass;
 
             this.setupMethods = mockClass.GetMembers("Setup").OfType<IMethodSymbol>().ToArray();
             this.mockBehaviorStrictField = mockBehaviorEnum.GetMembers("Strict").First();
@@ -43,7 +46,24 @@ private MoqSymbols(INamedTypeSymbol mockClass, INamedTypeSymbol mockBehaviorEnum
                 return null;
             }
 
-            return new MoqSymbols(mockClass, mockBehaviorEnum);
+            var isAnyTypeClass = compilation.GetTypeByMetadataName("Moq.It+IsAnyType");
+
+            if (isAnyTypeClass is null)
+            {
+                return null;
+            }
+
+            return new MoqSymbols(mockClass, mockBehaviorEnum, isAnyTypeClass);
+        }
+
+        public bool IsAnyType(ITypeSymbol symbol)
+        {
+            if (!SymbolEqualityComparer.Default.Equals(symbol, this.isAnyTypeClass))
+            {
+                return false;
+            }
+
+            return true;
         }
 
         public bool IsMock(ISymbol? symbol)
@@ -81,6 +101,21 @@ public bool IsSetupMethod(ISymbol? symbol)
             return false;
         }
 
+        public bool IsCallback(ISymbol? symbol)
+        {
+            if (symbol is null)
+            {
+                return false;
+            }
+
+            if (symbol.Name != "Callback")
+            {
+                return false;
+            }
+
+            return true;
+        }
+
         public bool IsReturnsMethod(ISymbol? symbol)
         {
             if (symbol is null)