Support migrating from MSTest v4

Author: cbersch

src/AwesomeAssertions.Analyzers.TestUtils/PackageReference.cs

@@ -18,8 +18,9 @@ private PackageReference(string name, string version, string path)
         _allDependencies.Add(this);
     }
 
-    public static PackageReference AwesomeAssertions_latest { get; } = new("AwesomeAssertions", "9.0.0", "lib/netstandard2.0/");
-    public static PackageReference MSTestTestFramework_3_1_1 { get; } = new("MSTest.TestFramework", "3.1.1", "lib/netstandard2.0/");
+    public static PackageReference AwesomeAssertions_latest { get; } = new("AwesomeAssertions", "9.3.0", "lib/netstandard2.0/");
+    public static PackageReference MSTestTestFramework_3_11_0 { get; } = new("MSTest.TestFramework", "3.11.0", "lib/netstandard2.0/");
+    public static PackageReference MSTestTestFramework_4_0_1 { get; } = new("MSTest.TestFramework", "4.0.1", "lib/netstandard2.0/");
     public static PackageReference XunitAssert_2_5_1 { get; } = new("xunit.assert", "2.5.1", "lib/netstandard1.1/");
     public static PackageReference Xunit3Assert_3_0_0 { get; } = new("xunit.v3.assert", "3.0.0", "lib/netstandard2.0/");
     public static PackageReference Nunit_3_14_0 { get; } = new("NUnit", "3.14.0", "lib/netstandard2.0/");

src/AwesomeAssertions.Analyzers.Tests/AwesomeAssertions.Analyzers.Tests.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" >
+    <PackageReference Include="coverlet.msbuild">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

src/AwesomeAssertions.Analyzers.Tests/TestAttributes.cs

@@ -11,66 +11,64 @@ public class NotImplementedAttribute : TestCategoryBaseAttribute
 {
     public string Reason { get; set; }
 
-    public override IList<string> TestCategories => new[] { "NotImplemented" };
+    public override IList<string> TestCategories { get; } = ["NotImplemented"];
 }
 
 [AttributeUsage(AttributeTargets.Method)]
 public class ImplementedAttribute : TestCategoryBaseAttribute
 {
     public string Reason { get; set; }
 
-    public override IList<string> TestCategories => new[] { "Completed" };
+    public override IList<string> TestCategories { get; } = ["Completed"];
 }
 
 [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
-public class AssertionDiagnosticAttribute : Attribute, ITestDataSource
+public abstract class AssertionDiagnosticBaseAttribute(string assertion, params string[] additionalParameters) : Attribute, ITestDataSource
 {
-    public string Assertion { get; }
+    public string Assertion { get; } = assertion;
 
-    public string[] AdditionalParameters { get; }
+    public string[] AdditionalParameters { get; } = additionalParameters ?? [];
 
-    public AssertionDiagnosticAttribute(string assertion, params string[] additionalParameters)
-    {
-        Assertion = assertion;
-        AdditionalParameters = additionalParameters ?? Array.Empty<string>();
-    }
+    private protected abstract IEnumerable<string> GetTestCases();
 
     public IEnumerable<object[]> GetData(MethodInfo methodInfo)
     {
-        foreach (var assertion in TestCasesInputUtils.GetTestCases(Assertion))
+        foreach (var assertion in GetTestCases())
         {
             yield return new object[] { assertion }.Concat(AdditionalParameters).ToArray();
         }
     }
 
-    public string GetDisplayName(MethodInfo methodInfo, object[] data) => $"{methodInfo.Name}(\"{string.Join("\", \"", data)}\")";
+    public string GetDisplayName(MethodInfo methodInfo, object[] data)
+        => $"{methodInfo.Name}(\"{string.Join("\", \"", data)}\")";
 }
 
-[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
-public class IgnoreAssertionDiagnosticAttribute : Attribute
+public sealed class AssertionDiagnosticAttribute(string assertion, params string[] additionalParameters)
+    : AssertionDiagnosticBaseAttribute(assertion, additionalParameters)
 {
-    public string Assertion { get; }
+    private protected override IEnumerable<string> GetTestCases()
+        => TestCasesInputUtils.GetTestCases(Assertion, MessageFormat.Simple | MessageFormat.Because | MessageFormat.FormattedBecause);
+}
 
-    public IgnoreAssertionDiagnosticAttribute(string assertion) => Assertion = assertion;
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+public class IgnoreAssertionDiagnosticAttribute(string assertion) : Attribute
+{
+    public string Assertion { get; } = assertion;
 }
 
 [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
-public class AssertionCodeFixAttribute : Attribute, ITestDataSource
+public abstract class AssertionCodeFixBaseAttribute(string oldAssertion, string newAssertion, params string[] additionalParameters)
+    : Attribute, ITestDataSource
 {
-    public string OldAssertion { get; }
-    public string NewAssertion { get; }
-    public string[] AdditionalParameters { get; }
+    public string OldAssertion { get; } = oldAssertion;
+    public string NewAssertion { get; } = newAssertion;
+    public string[] AdditionalParameters { get; } = additionalParameters ?? [];
 
-    public AssertionCodeFixAttribute(string oldAssertion, string newAssertion, params string[] additionalParameters)
-    {
-        OldAssertion = oldAssertion;
-        NewAssertion = newAssertion;
-        AdditionalParameters = additionalParameters ?? Array.Empty<string>();
-    }
+    private protected abstract IEnumerable<(string oldAssertion, string newAssertion)> GetTestCases();
 
     public IEnumerable<object[]> GetData(MethodInfo methodInfo)
     {
-        foreach (var (oldAssertion, newAssertion) in TestCasesInputUtils.GetTestCases(OldAssertion, NewAssertion))
+        foreach (var (oldAssertion, newAssertion) in GetTestCases())
         {
             yield return new object[] { oldAssertion, newAssertion }.Concat(AdditionalParameters).ToArray();
         }
@@ -87,6 +85,13 @@ public string GetDisplayName(MethodInfo methodInfo, object[] data)
     }
 }
 
+public class AssertionCodeFixAttribute(string oldAssertion, string newAssertion, params string[] additionalParameters)
+    : AssertionCodeFixBaseAttribute(oldAssertion, newAssertion, additionalParameters)
+{
+    private protected override IEnumerable<(string oldAssertion, string newAssertion)> GetTestCases()
+        => TestCasesInputUtils.GetTestCases(OldAssertion, NewAssertion);
+}
+
 [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
 public class IgnoreAssertionCodeFixAttribute : Attribute
 {
@@ -128,34 +133,63 @@ public IgnoreAssertionMethodCodeFixAttribute(string methodArguments, string oldA
         => (MethodArguments, OldAssertion, NewAssertion) = (methodArguments, oldAssertion, newAssertion);
 }
 
-public static class TestCasesInputUtils
+[Flags]
+internal enum MessageFormat
 {
-    private static readonly string Empty = string.Empty;
-    private static readonly string Because = "\"because it's possible\"";
-    private static readonly string FormattedBecause = "\"because message with {0} placeholders {1} at {2}\", 3, \"is awesome\", DateTime.Now.Add(2.Seconds())";
-    public static IEnumerable<string> GetTestCases(string assertion)
+    Simple = 1,
+    Because = 2,
+    FormattedBecause = 4,
+    InterpolatedBecause = 8,
+    Default = Simple | Because | FormattedBecause,
+}
+
+internal static class TestCasesInputUtils
+{
+    private const string Empty = "";
+    private const string Because = "\"because it's possible\"";
+    private const string FormattedBecause = "\"because message with {0} placeholders {1} at {2}\", 3, \"is awesome\", DateTime.Now.Add(2.Seconds())";
+    private const string InterpolatedBecause = "$\"because message with {3} placeholders {DateTime.Now}\"";
+
+    public static IEnumerable<string> GetTestCases(string assertion, MessageFormat messageFormat = MessageFormat.Default)
     {
         if (!assertion.Contains("{0}"))
         {
             yield return assertion;
             yield break;
         }
 
-        yield return SafeFormat(assertion, Empty);
-        yield return SafeFormat(assertion, Because);
-        yield return SafeFormat(assertion, FormattedBecause);
+        if (messageFormat.HasFlag(MessageFormat.Simple))
+            yield return SafeFormat(assertion, Empty);
+
+        if (messageFormat.HasFlag(MessageFormat.Because))
+            yield return SafeFormat(assertion, Because);
+
+        if (messageFormat.HasFlag(MessageFormat.FormattedBecause))
+            yield return SafeFormat(assertion, FormattedBecause);
+
+        if (messageFormat.HasFlag(MessageFormat.InterpolatedBecause))
+            yield return SafeFormat(assertion, InterpolatedBecause);
     }
-    public static IEnumerable<(string oldAssertion, string newAssertion)> GetTestCases(string oldAssertion, string newAssertion)
+
+    public static IEnumerable<(string oldAssertion, string newAssertion)> GetTestCases(string oldAssertion, string newAssertion, MessageFormat messageFormat = MessageFormat.Default)
     {
         if (!oldAssertion.Contains("{0}") && !newAssertion.Contains("{0}"))
         {
             yield return (oldAssertion, newAssertion);
             yield break;
         }
 
-        yield return (SafeFormat(oldAssertion, Empty), SafeFormat(newAssertion, Empty));
-        yield return (SafeFormat(oldAssertion, Because), SafeFormat(newAssertion, Because));
-        yield return (SafeFormat(oldAssertion, FormattedBecause), SafeFormat(newAssertion, FormattedBecause));
+        if (messageFormat.HasFlag(MessageFormat.Simple))
+            yield return (SafeFormat(oldAssertion, Empty), SafeFormat(newAssertion, Empty));
+
+        if (messageFormat.HasFlag(MessageFormat.Because))
+            yield return (SafeFormat(oldAssertion, Because), SafeFormat(newAssertion, Because));
+
+        if (messageFormat.HasFlag(MessageFormat.FormattedBecause))
+            yield return (SafeFormat(oldAssertion, FormattedBecause), SafeFormat(newAssertion, FormattedBecause));
+
+        if (messageFormat.HasFlag(MessageFormat.InterpolatedBecause))
+            yield return (SafeFormat(oldAssertion, InterpolatedBecause), SafeFormat(newAssertion, InterpolatedBecause));
     }
 
     /// <summary>

src/AwesomeAssertions.Analyzers.Tests/Tips/AwesomeAssertionsTests.cs

@@ -76,17 +76,17 @@ public void ShouldNotAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsInAnyScope_
         [TestMethod]
         [Implemented]
         public void ShouldAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsNotInScope_ForMsTest()
-            => ShouldAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsNotInScope<MsTestCodeFixProvider>("IsTrue", "using Microsoft.VisualStudio.TestTools.UnitTesting;", PackageReference.MSTestTestFramework_3_1_1);
+            => ShouldAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsNotInScope<MsTestCodeFixProvider>("IsTrue", "using Microsoft.VisualStudio.TestTools.UnitTesting;", PackageReference.MSTestTestFramework_3_11_0);
 
         [TestMethod]
         [Implemented]
         public void ShouldNotAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsInGlobalScope_ForMsTest()
-            => ShouldNotAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsInGlobalScope<MsTestCodeFixProvider>("IsTrue", "using Microsoft.VisualStudio.TestTools.UnitTesting;", PackageReference.MSTestTestFramework_3_1_1);
+            => ShouldNotAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsInGlobalScope<MsTestCodeFixProvider>("IsTrue", "using Microsoft.VisualStudio.TestTools.UnitTesting;", PackageReference.MSTestTestFramework_3_11_0);
 
         [TestMethod]
         [Implemented]
         public void ShouldNotAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsInAnyScope_ForMsTest()
-            => ShouldNotAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsInAnyScope<MsTestCodeFixProvider>("IsTrue", "using Microsoft.VisualStudio.TestTools.UnitTesting;", PackageReference.MSTestTestFramework_3_1_1);
+            => ShouldNotAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsInAnyScope<MsTestCodeFixProvider>("IsTrue", "using Microsoft.VisualStudio.TestTools.UnitTesting;", PackageReference.MSTestTestFramework_3_11_0);
 
         private void ShouldAddAwesomeAssertionsUsing_WhenAwesomeAssertionIsNotInScope<TCodeFixProvider>(string assertTrue, string usingDirective, PackageReference testingLibraryReference) where TCodeFixProvider : CodeFixProvider, new()
         {