v1.2.0 (#5)

* Add the PosInfoMoq2001 to check the member is overridable. #4
* Add the PosInfoMoq2002 rule to check the Mock instances is not a sealed class.

Author: GillesTourreau

PosInformatique.Moq.Analyzers.sln

@@ -40,6 +40,8 @@ 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
 	EndProjectSection
 EndProject
 Global

README.md

@@ -38,3 +38,6 @@ All the rules of this category should not be disabled (or changed their severity
 | Rule | Description |
 | - | - |
 | [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. |
+

build/azure-pipelines-release.yaml

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

docs/Compilation/PosInfoMoq2000.md

@@ -1,11 +1,11 @@
 # PosInfoMoq2000: The `Returns()` or `ReturnsAsync()` methods must be call for Strict mocks
 
-| Property                            | Value                                                                                      |
-|-------------------------------------|--------------------------------------------------------------------------------------------|
-| **Rule ID**                         | PosInfoMoq2000                                                                                    |
-| **Title**                           | The `Returns()` or `ReturnsAsync()` methods must be call for Strict mocks                |
-| **Category**                        | Compilation																			       |
-| **Default severity**				  | Error																				       |
+| Property                            | Value                                                                       |
+|-------------------------------------|-----------------------------------------------------------------------------|
+| **Rule ID**                         | PosInfoMoq2000                                                              |
+| **Title**                           | The `Returns()` or `ReturnsAsync()` methods must be call for Strict mocks   |
+| **Category**                        | Compilation																	|
+| **Default severity**				  | Error																		|
 
 ## Cause
 

docs/Compilation/PosInfoMoq2001.md

@@ -0,0 +1,61 @@
+# PosInfoMoq2001: The `Setup()` method must be used only on overridable members
+
+| Property                            | Value                                                         |
+|-------------------------------------|---------------------------------------------------------------|
+| **Rule ID**                         | PosInfoMoq2001                                                |
+| **Title**                           | The `Setup()` method must be used only on overridable members |
+| **Category**                        | Compilation													  |
+| **Default severity**				  | Error														  |
+
+## Cause
+
+The `Setup()` method must be applied only for overridable members.
+An overridable member is a **methode** or **property** which is in:
+- An `interface`.
+- A non-`sealed` `class`. In this case, the member must be:
+    - Defines as `abstract`.
+	- Or defined as `virtual`
+
+## Rule description
+
+The `Setup()` method must be applied only for overridable members.
+
+For example, the following methods and properties can be mock and used in the `Setup()` method:
+- `IService.MethodCanBeMocked()`
+- `IService.PropertyCanBeMocked`
+- `Service.VirtualMethodCanBeMocked`
+- `Service.VirtualPropertyCanBeMocked`
+- `Service.AbstractMethodCanBeMocked`
+- `Service.AbstractPropertyCanBeMocked`
+
+```csharp
+public interface IService
+{
+	void MethodCanBeMocked();
+
+	string PropertyCanBeMocked { get; set; }
+}
+
+public abstract class Service
+{
+	public virtual void VirtualMethodCanBeMocked() { ... }
+
+	public virtual void VirtualPropertyCanBeMocked() { ... }
+
+	public abstract void AbstractMethodCanBeMocked();
+
+	public abstract void AbstractPropertyCanBeMocked();
+}
+```
+
+> **NOTE**: The extension methods can not be overriden. The C# syntax looks like a member method an interface or class, but the extension method are just simple
+static methods which can not be overriden.
+
+## How to fix violations
+
+To fix a violation of this rule, be sure to mock a member in the `Setup()` method which can be overriden.
+
+## 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 *"Extensions methods may not be used in setup/verification expressions"* message.

docs/Compilation/PosInfoMoq2002.md

@@ -0,0 +1,42 @@
+# PosInfoMoq2002: `Mock<T>` class can be used only to mock non-sealed class
+
+| Property                            | Value                                                         |
+|-------------------------------------|---------------------------------------------------------------|
+| **Rule ID**                         | PosInfoMoq2002                                                |
+| **Title**                           | `Mock<T>` class can be used only to mock non-sealed class     |
+| **Category**                        | Compilation													  |
+| **Default severity**				  | Error														  |
+
+## Cause
+
+The `Mock<T>` can mock only interfaces or non-`sealed` classes.
+
+## Rule description
+
+The `Mock<T>` method must be use only on the interfaces or non-`sealed` classes.
+
+For example, the following code can not mock the `Service` class because it is `sealed`.
+
+```csharp
+[Fact]
+public void Test()
+{
+	var service = new Mock<Service>();		// The Service can not be mocked, because it is a sealed class.
+	service.Setup(s => s.GetData())
+		.Returns(10);
+}
+
+public class Service
+{
+	public virtual int GetData() { }
+}
+```
+
+## How to fix violations
+
+To fix a violation of this rule, be sure to mock interfaces or non-sealed classes.
+
+## 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 *"Type to mock (xxx) must be an interface, a delegate, or a non-selead, non-static class"* message.

src/Moq.Analyzers/AnalyzerReleases.Shipped.md

@@ -1,16 +1,25 @@
-## Release 1.1.0
+## Release 1.2.0
 
 ### New Rules
 
 Rule ID | Category | Severity | Notes
 --------|----------|----------|--------------------
-PosInfoMoq2000  | Compilation | Error  | The `Returns()` or `ReturnsAsync()` method must be called for Strict mocks
+PosInfoMoq2001  | Compilation | Error  | The `Setup()` method can be used only on overridable members.
+PosInfoMoq2002  | Compilation | Error  | `Mock<T>` class can be used only to mock non-sealed class.
+
+## Release 1.1.0
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|--------------------
+PosInfoMoq2000  | Compilation | Error  | The `Returns()` or `ReturnsAsync()` method must be called for Strict mocks.
 
 ## Release 1.0.0
 
 ### New Rules
 
 Rule ID | Category | Severity | Notes
 --------|----------|----------|--------------------
-PosInfoMoq1000  | Design   | Warning  | `Verify()` and `VerifyAll()` methods should be called when instantiate a Mock<T> instances
-PosInfoMoq1001  | Design   | Warning  | The `Mock<T>` instance behavior should be defined to Strict mode
+PosInfoMoq1000  | Design   | Warning  | `Verify()` and `VerifyAll()` methods should be called when instantiate a Mock<T> instances.
+PosInfoMoq1001  | Design   | Warning  | The `Mock<T>` instance behavior should be defined to Strict mode.

src/Moq.Analyzers/Analyzers/MockInstanceShouldBeStrictBehaviorAnalyzer.cs

@@ -47,13 +47,15 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
                 return;
             }
 
+            var moqExpressionAnalyzer = new MoqExpressionAnalyzer(context.SemanticModel);
+
             // Check there is "new Mock<I>()" statement.
-            if (!MockExpressionHelper.IsMockCreation(moqSymbols, context.SemanticModel, objectCreation))
+            if (!moqExpressionAnalyzer.IsMockCreation(moqSymbols, objectCreation))
             {
                 return;
             }
 
-            if (!MockExpressionHelper.IsStrictBehavior(moqSymbols, context.SemanticModel, objectCreation))
+            if (!moqExpressionAnalyzer.IsStrictBehavior(moqSymbols, objectCreation))
             {
                 var diagnostic = Diagnostic.Create(Rule, objectCreation.GetLocation());
                 context.ReportDiagnostic(diagnostic);

src/Moq.Analyzers/Analyzers/NoSealedClassAnalyzer.cs

@@ -0,0 +1,78 @@
+//-----------------------------------------------------------------------
+// <copyright file="NoSealedClassAnalyzer.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 NoSealedClassAnalyzer : DiagnosticAnalyzer
+    {
+        private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
+            "PosInfoMoq2002",
+            "Mock<T> class can be used only to mock non-sealed class",
+            "Mock<T> class can be used only to mock non-sealed class",
+            "Compilation",
+            DiagnosticSeverity.Error,
+            isEnabledByDefault: true,
+            description: "Mock<T> class can be used only to mock non-sealed class.");
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+
+            context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.ObjectCreationExpression);
+        }
+
+        private static void Analyze(SyntaxNodeAnalysisContext context)
+        {
+            var objectCreationExpression = (ObjectCreationExpressionSyntax)context.Node;
+
+            var moqSymbols = MoqSymbols.FromCompilation(context.Compilation);
+
+            if (moqSymbols is null)
+            {
+                return;
+            }
+
+            var moqExpressionAnalyzer = new MoqExpressionAnalyzer(context.SemanticModel);
+
+            // Check the expression is a Mock<T> instance creation.
+            var mockedType = moqExpressionAnalyzer.GetMockedType(moqSymbols, objectCreationExpression, out var typeExpression);
+
+            if (mockedType is null)
+            {
+                return;
+            }
+
+            if (mockedType.TypeKind == TypeKind.Interface)
+            {
+                return;
+            }
+
+            if (mockedType.IsAbstract)
+            {
+                return;
+            }
+
+            if (!mockedType.IsSealed)
+            {
+                return;
+            }
+
+            // No returns method has been specified with Strict mode. Report the diagnostic issue.
+            var diagnostic = Diagnostic.Create(Rule, typeExpression!.GetLocation());
+            context.ReportDiagnostic(diagnostic);
+        }
+    }
+}

src/Moq.Analyzers/Analyzers/SetupMethodMustReturnValueWithStrictBehaviorAnalyzer.cs

@@ -45,14 +45,16 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
                 return;
             }
 
+            var moqExpressionAnalyzer = new MoqExpressionAnalyzer(context.SemanticModel);
+
             // Check is Setup() method.
-            if (!MockExpressionHelper.IsMockSetupMethod(moqSymbols, context.SemanticModel, invocationExpression, out var localVariableExpression))
+            if (!moqExpressionAnalyzer.IsMockSetupMethod(moqSymbols, invocationExpression, out var localVariableExpression))
             {
                 return;
             }
 
             // Check the mocked method return type (if "void", we skip the analysis, because no Returns() is required).
-            var mockedMethodReturnTypeSymbol = MockExpressionHelper.GetSetupMethodReturnSymbol(moqSymbols, context.SemanticModel, invocationExpression);
+            var mockedMethodReturnTypeSymbol = moqExpressionAnalyzer.GetSetupMethodReturnSymbol(moqSymbols, invocationExpression);
             if (mockedMethodReturnTypeSymbol is null)
             {
                 return;
@@ -64,7 +66,7 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
             }
 
             // Check the behavior of the mock instance is Strict.
-            if (!MockExpressionHelper.IsStrictBehavior(moqSymbols, context.SemanticModel, localVariableExpression!))
+            if (!moqExpressionAnalyzer.IsStrictBehavior(moqSymbols, localVariableExpression!))
             {
                 return;
             }