Add the PosInfoMoq1010 rule to check there is "+= null" when set the event to raise (fixes #52).

Author: GillesTourreau

PosInformatique.Moq.Analyzers.sln

@@ -38,6 +38,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Design", "Design", "{815BE8
 		docs\Design\PosInfoMoq1007.md = docs\Design\PosInfoMoq1007.md
 		docs\Design\PosInfoMoq1008.md = docs\Design\PosInfoMoq1008.md
 		docs\Design\PosInfoMoq1009.md = docs\Design\PosInfoMoq1009.md
+		docs\Design\PosInfoMoq1010.md = docs\Design\PosInfoMoq1010.md
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Compilation", "Compilation", "{D9C84D36-7F9C-4EFB-BE6F-9F7A05FE957D}"

README.md

@@ -48,7 +48,8 @@ Design rules used to make your unit tests more strongly strict.
 | [PosInfoMoq1006: The `It.IsAny<T>()` or `It.Is<T>()` arguments must match the parameters of the mocked method.](docs/Design/PosInfoMoq1006.md) | When setting up a method using `It.IsAny<T>()` or `It.Is<T>()` as arguments, the type `T` must exactly match the parameters of the configured method. |
 | [PosInfoMoq1007: The `Verify()` method must specify the `Times` argument.](docs/Design/PosInfoMoq1007.md) | When calling the `Verify()` method, if the `Times` argument is not specified, Moq will assume `Times.AtLeastOnce()` by default. |
 | [PosInfoMoq1008: The `Mock.Verify()` and `Mock.VerifyAll()` methods must specify at least one mock.](docs/Design/PosInfoMoq1008.md) | When calling the static methods `Mock.Verify()` or `Mock.VerifyAll()` without providing any `Mock<T>` instances, no verification is performed. |
-| [PosInfoMoq1009: Avoid using `Verifiable()` method](docs/Design/PosInfoMoq1008.md) | A `Verify()` of an `Mock<T>` instance has not been called in the *Assert* phase of an unit test for `Verifiable()` setups. |
+| [PosInfoMoq1009: Avoid using `Verifiable()` method](docs/Design/PosInfoMoq1009.md) | A `Verify()` of an `Mock<T>` instance has not been called in the *Assert* phase of an unit test for `Verifiable()` setups. |
+| [PosInfoMoq1010: Use `+= null` syntax when raising events with `Raise()`/`RaiseAsync()`](docs/Design/PosInfoMoq1010.md) | When using `Mock<T>.Raise()` or `Mock<T>.RaiseAsync()`, the lambda expression used to identify the event should consistently use the `+= null` syntax. |
 
 ### Compilation
 

docs/Design/PosInfoMoq1010.md

@@ -0,0 +1,77 @@
+# PosInfoMoq1010: Use `+= null` syntax when raising events with `Raise()`/`RaiseAsync()`
+
+| Property              | Value                                                                 |
+|-----------------------|----------------------------------------------------------------------|
+| **Rule ID**           | PosInfoMoq1010                                                       |
+| **Title**             | Use `+= null` syntax when raising events with `Raise()`/`RaiseAsync()` |
+| **Category**          | Design                                                               |
+| **Default severity**  | Warning                                                              |
+
+## Cause
+
+When using `Mock<T>.Raise()` or `Mock<T>.RaiseAsync()`, the lambda expression used to identify the event should consistently use the `+= null` syntax.
+
+## Rule description
+
+While Moq is flexible and can identify the event even with `+= SomeMethod`, using `+= null` is the conventional and clearest way to indicate that you are merely referencing the event for Moq's internal use, not actually subscribing a handler. This improves code readability and intent.
+
+### Example
+
+```csharp
+public class Service
+{
+    public event EventHandler Changed;
+
+    public void DoSomething()
+    {
+        this.Changed?.Invoke(this, EventArgs.Empty);
+    }
+}
+```
+
+#### Correct usage (`+= null`)
+
+```csharp
+var serviceMock = new Mock<Service>();
+
+// Clear intent: referencing the event for Moq
+serviceMock.Raise(s => s.Changed += null, EventArgs.Empty);
+```
+
+#### Incorrect usage (`+= SomeMethod`)
+
+```csharp
+public class MyTests
+{
+    private void MyEventHandler(object sender, EventArgs e) { /* ... */ }
+
+    [Fact]
+    public void Test()
+    {
+        var serviceMock = new Mock<Service>();
+
+        // While functional, less clear intent
+        serviceMock.Raise(s => s.Changed += MyEventHandler, EventArgs.Empty); // ⚠️
+    }
+}
+```
+
+## How to fix violations
+
+Change the lambda expression to use `+= null` when identifying the event for `Raise()` or `RaiseAsync()`.
+
+Correct:
+
+```csharp
+serviceMock.Raise(s => s.Changed += null, EventArgs.Empty);
+```
+
+Incorrect:
+
+```csharp
+serviceMock.Raise(s => s.Changed += MyEventHandler, EventArgs.Empty);
+```
+
+## When to suppress warnings
+
+This is a design guideline for code readability. While suppressing it won't cause runtime errors, it's generally recommended to follow for consistent and clear code.

src/Moq.Analyzers/AnalyzerReleases.Shipped.md

@@ -3,6 +3,7 @@
 ### New Rules
 Rule ID | Category | Severity | Notes
 --------|----------|----------|-------
+PosInfoMoq1010 | Design | Warning | RaiseMethodsAnalyzer, [Documentation](https://posinformatique.github.io/PosInformatique.Moq.Analyzers/docs/Design/PosInfoMoq1010.html)
 PosInfoMoq2017 | Compilation | Error | RaiseMethodsAnalyzer, [Documentation](https://posinformatique.github.io/PosInformatique.Moq.Analyzers/docs/Compilation/PosInfoMoq2017.html)
 PosInfoMoq2018 | Compilation | Error | RaiseMethodsAnalyzer, [Documentation](https://posinformatique.github.io/PosInformatique.Moq.Analyzers/docs/Compilation/PosInfoMoq2018.html)
 

src/Moq.Analyzers/Analyzers/RaiseMethodsAnalyzer.cs

@@ -35,9 +35,20 @@ public class RaiseMethodsAnalyzer : DiagnosticAnalyzer
             description: "The first parameter of Raise()/RaiseAsync() must be an event.",
             helpLinkUri: "https://posinformatique.github.io/PosInformatique.Moq.Analyzers/docs/Compilation/PosInfoMoq2018.html");
 
+        internal static readonly DiagnosticDescriptor EventExpressionMustBeEventAddWithNull = new DiagnosticDescriptor(
+            "PosInfoMoq1010",
+            "Use '+= null' syntax when raising events with Raise()/RaiseAsync()",
+            "Use '+= null' syntax when raising events with Raise()/RaiseAsync()",
+            "Design",
+            DiagnosticSeverity.Warning,
+            isEnabledByDefault: true,
+            description: "Use '+= null' syntax when raising events with Raise()/RaiseAsync().",
+            helpLinkUri: "https://posinformatique.github.io/PosInformatique.Moq.Analyzers/docs/Design/PosInfoMoq1010.html");
+
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
             ParametersMustMatchSignature,
-            FirstParameterMustBeEvent);
+            FirstParameterMustBeEvent,
+            EventExpressionMustBeEventAddWithNull);
 
         public override void Initialize(AnalysisContext context)
         {
@@ -74,6 +85,12 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
                 return;
             }
 
+            if (invalidEventExpression is not null)
+            {
+                // Raise a warning to indicate that the expression after the "+=" is not "null".
+                context.ReportDiagnostic(EventExpressionMustBeEventAddWithNull, invalidEventExpression.GetLocation());
+            }
+
             var eventParameters = raiseMethod.EventParameters.ToList();
 
             // Check the overload of the Raise() method called.

src/Moq.Analyzers/Moq.Analyzers.csproj

@@ -19,8 +19,9 @@
     <PackageReleaseNotes>
       2.0.0
       - Add new rules:
+        - PosInfoMoq1010: Use '+= null' syntax when raising events with Raise()/RaiseAsync()
         - PosInfoMoq2017: Mock&lt;T&gt;.Raise()/RaiseAsync() must use parameters matching the event signature.
-        - PosInfoMoq2018: The first parameter of `Raise()`/`RaiseAsync()` must be an event.
+        - PosInfoMoq2018: The first parameter of Raise()/RaiseAsync() must be an event.
 
       1.13.0
       - Add new rules:

src/Moq.Analyzers/MoqExpressionAnalyzer.cs

@@ -7,6 +7,7 @@
 namespace PosInformatique.Moq.Analyzers
 {
     using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
 
     internal class MoqExpressionAnalyzer
@@ -544,7 +545,22 @@ public bool IsStrictBehavior(IdentifierNameSyntax localVariableExpression, Cance
                 parameterSymbols.Add(parameterSymbol.Type);
             }
 
-            invalidEventExpression = null;
+            // Check the right assignement expression is "null".
+            if (assignmentExpressionSyntax.Right is not LiteralExpressionSyntax literalExpressionSyntax)
+            {
+                invalidEventExpression = assignmentExpressionSyntax.Right;
+            }
+            else
+            {
+                if (literalExpressionSyntax.Kind() != SyntaxKind.NullLiteralExpression)
+                {
+                    invalidEventExpression = assignmentExpressionSyntax.Right;
+                }
+                else
+                {
+                    invalidEventExpression = null;
+                }
+            }
 
             return new RaiseMethodCall((IMethodSymbol)methodSymbol.Symbol, parameterSymbols, arguments, eventSymbol);
         }

tests/Moq.Analyzers.Tests/Analyzers/RaiseMethodsAnalyzerTest.cs

@@ -268,6 +268,47 @@ public interface I
             await Verifier.VerifyAnalyzerAsync(source);
         }
 
+        [Theory]
+        [InlineData("Raise", "void")]
+        [InlineData("RaiseAsync", "Task")]
+        public async Task Raise_WithNotNullDelegate_NoDiagnosticReported(string method, string eventReturnType)
+        {
+            var source = @"
+                namespace ConsoleApplication1
+                {
+                    using Moq;
+                    using System;
+                    using System.Threading.Tasks;
+
+                    public class TestClass
+                    {
+                        public void TestMethod()
+                        {
+                            var mock1 = new Mock<I>(MockBehavior.Strict);
+
+                            mock1." + method + @"(m => m.TheEvent += {|PosInfoMoq1010:MethodMatchEventSignature|}, ""OK"", 1, null);
+                            mock1." + method + @"(m => m.TheEvent += {|PosInfoMoq1010:MethodMatchEventSignature|}, ""OK"", 1, 10);
+                            mock1." + method + @"(m => m.TheEvent += {|PosInfoMoq1010:MethodMatchEventSignature|}, ""OK"", 1, new object());
+
+                            mock1." + method + @"(m => m.TheEvent += {|PosInfoMoq1010:(a, b, c) => throw new NotSupportedException()|}, ""OK"", 1, null);
+                            mock1." + method + @"(m => m.TheEvent += {|PosInfoMoq1010:(a, b, c) => throw new NotSupportedException()|}, ""OK"", 1, 10);
+                            mock1." + method + @"(m => m.TheEvent += {|PosInfoMoq1010:(a, b, c) => throw new NotSupportedException()|}, ""OK"", 1, new object());
+                        }
+
+                        public static " + eventReturnType + @" MethodMatchEventSignature(string a, int b, object c) { throw new NotSupportedException(); }
+                    }
+
+                    public interface I
+                    {
+                        event CustomEventHandler TheEvent;
+                    }
+
+                    public delegate " + eventReturnType + @" CustomEventHandler(string a, int b, object c);
+                }";
+
+            await Verifier.VerifyAnalyzerAsync(source);
+        }
+
         [Fact]
         public async Task NoMoqLibrary()
         {