Refactor unit tests: data driven tests and leverage Microsoft.CodeAnalysis.Testing patterns

Source/Moq.Analyzers.Test/AsAcceptOnlyInterfaceAnalyzerTests.cs

@@ -1,40 +1,29 @@
+using Verifier = Moq.Analyzers.Test.Helpers.AnalyzerVerifier<Moq.Analyzers.AsShouldBeUsedOnlyForInterfaceAnalyzer>;
+
 namespace Moq.Analyzers.Test;
 
-public class AsAcceptOnlyInterfaceAnalyzerTests : DiagnosticVerifier<AsShouldBeUsedOnlyForInterfaceAnalyzer>
+public class AsAcceptOnlyInterfaceAnalyzerTests
 {
-    [Fact]
-    public async Task ShouldFailWhenUsingAsWithAbstractClass()
+    public static IEnumerable<object[]> TestData()
     {
-        await VerifyCSharpDiagnostic(
-                """
-                using Moq;
-
-                namespace AsAcceptOnlyInterface.TestBadAsForAbstractClass;
-
-                public abstract class BaseSampleClass
-                {
-                    public int Calculate() => 0;
-                }
-
-                internal class MyUnitTests
-                {
-                    private void TestBadAsForAbstractClass()
-                    {
-                        var mock = new Mock<BaseSampleClass>();
-                        mock.As<{|Moq1300:BaseSampleClass|}>();
-                    }
-                }
-                """);
+        foreach (var @namespace in new[] { string.Empty, "namespace MyNamespace;" })
+        {
+            // TODO: .As<BaseSampleClass> and .As<SampleClass> feels redundant
+            yield return [@namespace, """new Mock<BaseSampleClass>().As<{|Moq1300:BaseSampleClass|}>();"""];
+            yield return [@namespace, """new Mock<BaseSampleClass>().As<{|Moq1300:SampleClass|}>();"""];
+            yield return [@namespace, """new Mock<SampleClass>().As<ISampleInterface>();"""];
+            // TODO: Testing with .Setup() and .Returns() seems unnecessary.
+            yield return [@namespace, """new Mock<SampleClass>().As<ISampleInterface>().Setup(x => x.Calculate(It.IsAny<int>(), It.IsAny<int>())).Returns(10);"""];
+        }
     }
 
-    [Fact]
-    public async Task ShouldFailWhenUsingAsWithConcreteClass()
+    [Theory]
+    [MemberData(nameof(TestData))]
+    public async Task ShouldAnalyzeAs(string @namespace, string mock)
     {
-        await VerifyCSharpDiagnostic(
-                """
-                using Moq;
-
-                namespace AsAcceptOnlyInterface.TestBadAsForNonAbstractClass;
+        await Verifier.VerifyAnalyzerAsync(
+                $$"""
+                {{@namespace}}
 
                 public interface ISampleInterface
                 {
@@ -46,80 +35,17 @@ public abstract class BaseSampleClass
                     public int Calculate() => 0;
                 }
 
-                public class OtherClass
-                {
-
-                    public int Calculate() => 0;
-                }
-
-                internal class MyUnitTests
-                {
-                    private void TestBadAsForNonAbstractClass()
-                    {
-                        var mock = new Mock<BaseSampleClass>();
-                        mock.As<{|Moq1300:OtherClass|}>();
-                    }
-                }
-                """);
-    }
-
-    [Fact]
-    public async Task ShouldPassWhenUsingAsWithInterface()
-    {
-        await VerifyCSharpDiagnostic(
-                """
-                using Moq;
-
-                namespace AsAcceptOnlyInterface.TestOkAsForInterface;
-
-                public interface ISampleInterface
-                {
-                    int Calculate(int a, int b);
-                }
-
                 public class SampleClass
                 {
-                    public int Calculate() => 0;
-                }
-
-                internal class MyUnitTests
-                {
-                    private void TestOkAsForInterface()
-                    {
-                        var mock = new Mock<SampleClass>();
-                        mock.As<ISampleInterface>();
-                    }
-                }
-                """);
-    }
-
-    [Fact]
-    public async Task ShouldPassWhenUsingAsWithInterfaceWithSetup()
-    {
-        await VerifyCSharpDiagnostic(
-                """
-                using Moq;
-
-                namespace AsAcceptOnlyInterface.TestOkAsForInterfaceWithConfiguration;
-
-                public interface ISampleInterface
-                {
-                    int Calculate(int a, int b);
-                }
 
-                public class SampleClass
-                {
                     public int Calculate() => 0;
                 }
 
-                internal class MyUnitTests
+                internal class UnitTest
                 {
-                    private void TestOkAsForInterfaceWithConfiguration()
+                    private void Test()
                     {
-                        var mock = new Mock<SampleClass>();
-                        mock.As<ISampleInterface>()
-                            .Setup(x => x.Calculate(It.IsAny<int>(), It.IsAny<int>()))
-                            .Returns(10);
+                        {{mock}}
                     }
                 }
                 """);