Introduce PH2160 v1

Author: bcollamore

Documentation/Diagnostics/PH2160.md

@@ -0,0 +1,108 @@
+# PH2160: Mock<T> of disposable concrete class should configure protected Dispose
+
+| Property | Value  |
+|--|--|
+| Package | [Philips.CodeAnalysis.MoqAnalyzers](https://www.nuget.org/packages/Philips.CodeAnalysis.MoqAnalyzers) |
+| Diagnostic ID | PH2160 |
+| Category  | [RuntimeFailure](../RuntimeFailure.md) |
+| Analyzer | [MockDisposableClassesShouldSetupDisposeAnalyzer](https://github.com/philips-software/roslyn-analyzers/blob/main/Philips.CodeAnalysis.MoqAnalyzers/MockDisposableClassesShouldSetupDisposeAnalyzer.cs) |
+| CodeFix  | No |
+| Severity | Error |
+| Enabled By Default | Yes |
+
+## Introduction
+
+This rule identifies uses of `Mock<T>` where `T` is a disposable concrete class that appears to follow the standard virtual `Dispose(bool)` pattern.
+
+## Reason
+
+When Moq mocks a concrete class, virtual members are intercepted. By default, Moq does not call base implementations.
+
+If the mocked type performs its cleanup in a virtual `Dispose(bool)` method, calling `Dispose()` on the mocked object may not execute the real cleanup logic. This can result in leaked resources, background threads not stopping, or other cleanup not occurring during tests.
+
+## How to fix violations
+
+Configure the mock’s protected `Dispose` method explicitly, or use a project-specific helper or wrapper that ensures the base `Dispose(bool)` implementation is executed.
+
+Example:
+
+```csharp
+mock.Protected().Setup("Dispose", ItExpr.IsAny<bool>()).CallBase();
+```
+
+Any explicit protected setup of `Dispose` is considered acceptable for this rule.
+
+## Examples
+
+### Incorrect
+
+```csharp
+using Moq;
+
+public class Worker : IDisposable
+{
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        // real cleanup
+    }
+}
+
+public class TestClass
+{
+    public void TestMethod()
+    {
+        var mock = new Mock<Worker>();
+    }
+}
+```
+
+### Correct
+
+```csharp
+using Moq;
+using Moq.Protected;
+
+public class Worker : IDisposable
+{
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        // real cleanup
+    }
+}
+
+public class TestClass
+{
+    public void TestMethod()
+    {
+        var mock = new Mock<Worker>();
+        mock.Protected().Setup("Dispose", ItExpr.IsAny<bool>()).CallBase();
+    }
+}
+```
+
+## Limitations
+
+This analyzer currently focuses on direct `new Mock<T>(...)` constructions and same-member setup patterns. It may not detect disposal configuration performed indirectly through helper methods, factory abstractions, or other layers of indirection.
+
+## Suppression
+
+```csharp
+[SuppressMessage("Philips.CodeAnalysis.MoqAnalyzers", "PH2160:Mock<T> of disposable concrete class should configure protected Dispose", Justification = "Reviewed.")]
+```
+
+## References
+
+- [Moq](https://github.com/devlooped/moq)
+- [Castle DynamicProxy](https://www.castleproject.org/projects/dynamicproxy/)

Philips.CodeAnalysis.Common/DiagnosticId.cs

@@ -145,5 +145,6 @@ public enum DiagnosticId
 		AvoidUnlicensedPackages = 2155,
 		AvoidPkcsPaddingWithRsaEncryption = 2158,
 		AvoidUnnecessaryAttributeParentheses = 2159,
+		MockDisposableObjectsShouldSetupDispose = 2160
 	}
 }