Migrate Microsoft.TemplateEngine.Cli.UnitTests to MSTest.Sdk on MTP

eng/Packages.props

@@ -7,6 +7,7 @@
     <PackageVersion Update="DiffPlex" Condition="'$(DiffPlexVersion)' != ''" Version="$(DiffPlexVersion)" />
     <PackageVersion Update="FakeItEasy" Condition="'$(FakeItEasyVersion)' != ''" Version="$(FakeItEasyVersion)" />
     <PackageVersion Update="Verify.DiffPlex" Condition="'$(VerifyDiffPlexVersion)' != ''" Version="$(VerifyDiffPlexVersion)" />
+    <PackageVersion Update="Verify.MSTest" Condition="'$(VerifyMSTestVersion)' != ''" Version="$(VerifyMSTestVersion)" />
     <PackageVersion Update="Verify.XunitV3" Condition="'$(VerifyXunitV3Version)' != ''" Version="$(VerifyXunitV3Version)" />
     <PackageVersion Update="Wcwidth.Sources" Condition="'$(WcwidthSourcesVersion)' != ''" Version="$(WcwidthSourcesVersion)" />
   </ItemGroup>

eng/Signing.props

@@ -94,6 +94,7 @@
     <FileSignInfo Include="SimpleInfoName.dll" CertificateName="$(ExternalCertificateId)" />
     <FileSignInfo Include="Verify.dll" CertificateName="$(ExternalCertificateId)" />
     <FileSignInfo Include="Verify.DiffPlex.dll" CertificateName="$(ExternalCertificateId)" />
+    <FileSignInfo Include="Verify.MSTest.dll" CertificateName="$(ExternalCertificateId)" />
     <FileSignInfo Include="Verify.XunitV3.dll" CertificateName="$(ExternalCertificateId)" />
     <FileSignInfo Include="FluentAssertions.dll" CertificateName="$(ExternalCertificateId)" />
   </ItemGroup>

eng/dependabot/Packages.props

@@ -8,6 +8,7 @@
     <PackageVersion Include="DiffPlex" Version="1.8.0" />
     <PackageVersion Include="FakeItEasy" Version="8.0.0" />
     <PackageVersion Include="Verify.DiffPlex" Version="3.1.2" />
+    <PackageVersion Include="Verify.MSTest" Version="28.12.0" />
     <PackageVersion Include="Verify.XunitV3" Version="28.12.0" />
     <PackageVersion Include="Wcwidth.Sources" Version="2.0.0" />
   </ItemGroup>

test/Microsoft.TemplateEngine.Cli.UnitTests/AliasAssignmentTests.cs

@@ -13,6 +13,7 @@
 
 namespace Microsoft.TemplateEngine.Cli.UnitTests
 {
+    [TestClass]
     public class AliasAssignmentTests
     {
         private static HashSet<string> InitiallyTakenAliases
@@ -46,7 +47,7 @@ private static HashSet<string> InitiallyTakenAliases
         }
 
         // also asserts that "--param:<name>" is used if <name> is taken
-        [Fact(DisplayName = nameof(LongNameOverrideTakesPrecendence))]
+        [TestMethod]
         public void LongNameOverrideTakesPrecendence()
         {
             IReadOnlyList<CliTemplateParameter> paramList = new List<CliTemplateParameter>()
@@ -61,10 +62,10 @@ public void LongNameOverrideTakesPrecendence()
             Assert.Contains("-f", result["foo"].Aliases);
             Assert.Contains("--foo", result["bar"].Aliases);
             Assert.Contains("-fo", result["bar"].Aliases); // the short name is based on the long name override if it exists
-            Assert.DoesNotContain(result, r => r.Value.Errors.Any());
+            Assert.IsFalse(result.Any(r => r.Value.Errors.Any()));
         }
 
-        [Fact(DisplayName = nameof(ShortNameOverrideTakesPrecedence))]
+        [TestMethod]
         public void ShortNameOverrideTakesPrecedence()
         {
             IReadOnlyList<CliTemplateParameter> paramList = new List<CliTemplateParameter>()
@@ -79,10 +80,10 @@ public void ShortNameOverrideTakesPrecedence()
             Assert.Contains("-fo", result["foo"].Aliases);
             Assert.Contains("--bar", result["bar"].Aliases);
             Assert.Contains("-f", result["bar"].Aliases);
-            Assert.DoesNotContain(result, r => r.Value.Errors.Any());
+            Assert.IsFalse(result.Any(r => r.Value.Errors.Any()));
         }
 
-        [Fact(DisplayName = nameof(ShortNameExcludedWithEmptyStringOverride))]
+        [TestMethod]
         public void ShortNameExcludedWithEmptyStringOverride()
         {
             IReadOnlyList<CliTemplateParameter> paramList = new List<CliTemplateParameter>()
@@ -96,11 +97,11 @@ public void ShortNameExcludedWithEmptyStringOverride()
             Assert.Contains("--foo", result["foo"].Aliases);
             Assert.Contains("-f", result["foo"].Aliases);
             Assert.Contains("--bar", result["bar"].Aliases);
-            Assert.Single(result["bar"].Aliases);
-            Assert.DoesNotContain(result, r => r.Value.Errors.Any());
+            Assert.HasCount(1, result["bar"].Aliases);
+            Assert.IsFalse(result.Any(r => r.Value.Errors.Any()));
         }
 
-        [Fact(DisplayName = nameof(ParameterNameCannotContainColon))]
+        [TestMethod]
         public void ParameterNameCannotContainColon()
         {
             IReadOnlyList<CliTemplateParameter> paramList = new List<CliTemplateParameter>()
@@ -109,12 +110,12 @@ public void ParameterNameCannotContainColon()
             };
 
             var result = AliasAssignmentCoordinator.AssignAliasesForParameter(paramList, InitiallyTakenAliases).ToDictionary(r => r.Parameter.Name, r => r);
-            Assert.Empty(result["foo:bar"].Aliases);
-            Assert.Single(result["foo:bar"].Errors);
+            Assert.IsFalse(result["foo:bar"].Aliases.Any());
+            Assert.HasCount(1, result["foo:bar"].Errors);
             Assert.Contains("Parameter name 'foo:bar' contains colon, which is forbidden.", result["foo:bar"].Errors);
         }
 
-        [Fact(DisplayName = nameof(ShortNameGetPrependedPColonIfNeeded))]
+        [TestMethod]
         public void ShortNameGetPrependedPColonIfNeeded()
         {
             IReadOnlyList<CliTemplateParameter> paramList = new List<CliTemplateParameter>()
@@ -129,10 +130,10 @@ public void ShortNameGetPrependedPColonIfNeeded()
             Assert.Contains("-f", result["bar"].Aliases);
             Assert.Contains("--f", result["f"].Aliases);
             Assert.Contains("-p:f", result["f"].Aliases);
-            Assert.DoesNotContain(result, r => r.Value.Errors.Any());
+            Assert.IsFalse(result.Any(r => r.Value.Errors.Any()));
         }
 
-        [Fact]
+        [TestMethod]
         public void ShortNameGenerationShouldNotProduceDuplicates()
         {
             List<CliTemplateParameter> paramList = new();
@@ -147,7 +148,7 @@ public void ShortNameGenerationShouldNotProduceDuplicates()
                 .BeFalse("Duplicate option aliases should not be generated.");
         }
 
-        [Fact]
+        [TestMethod]
         public void ShortNameSkippedAfter4Reps()
         {
             List<CliTemplateParameter> paramList = new();
@@ -169,7 +170,7 @@ public void ShortNameSkippedAfter4Reps()
         }
 
         // This reflects the MVC 2.0 tempalte as of May 24, 2017
-        [Fact(DisplayName = nameof(CheckAliasAssignmentsMvc20))]
+        [TestMethod]
         public void CheckAliasAssignmentsMvc20()
         {
             IReadOnlyList<CliTemplateParameter> paramList = new List<CliTemplateParameter>()
@@ -201,23 +202,23 @@ public void CheckAliasAssignmentsMvc20()
 
             Assert.Contains("-au", result["auth"].Aliases);
             Assert.Contains("--auth", result["auth"].Aliases);
-            Assert.Single(result["AAdB2CInstance"].Aliases);
+            Assert.HasCount(1, result["AAdB2CInstance"].Aliases);
             Assert.Contains("--aad-b2c-instance", result["AAdB2CInstance"].Aliases);
             Assert.Contains("-ssp", result["SignUpSignInPolicyId"].Aliases);
             Assert.Contains("--susi-policy-id", result["SignUpSignInPolicyId"].Aliases);
             Assert.Contains("-rp", result["ResetPasswordPolicyId"].Aliases);
             Assert.Contains("--reset-password-policy-id", result["ResetPasswordPolicyId"].Aliases);
             Assert.Contains("-ep", result["EditProfilePolicyId"].Aliases);
             Assert.Contains("--edit-profile-policy-id", result["EditProfilePolicyId"].Aliases);
-            Assert.Single(result["AADInstance"].Aliases);
+            Assert.HasCount(1, result["AADInstance"].Aliases);
             Assert.Contains("--aad-instance", result["AADInstance"].Aliases);
-            Assert.Single(result["ClientId"].Aliases);
+            Assert.HasCount(1, result["ClientId"].Aliases);
             Assert.Contains("--client-id", result["ClientId"].Aliases);
-            Assert.Single(result["Domain"].Aliases);
+            Assert.HasCount(1, result["Domain"].Aliases);
             Assert.Contains("--domain", result["Domain"].Aliases);
-            Assert.Single(result["TenantId"].Aliases);
+            Assert.HasCount(1, result["TenantId"].Aliases);
             Assert.Contains("--tenant-id", result["TenantId"].Aliases);
-            Assert.Single(result["CallbackPath"].Aliases);
+            Assert.HasCount(1, result["CallbackPath"].Aliases);
             Assert.Contains("--callback-path", result["CallbackPath"].Aliases);
             Assert.Contains("-r", result["OrgReadAccess"].Aliases);
             Assert.Contains("--org-read-access", result["OrgReadAccess"].Aliases);
@@ -233,21 +234,21 @@ public void CheckAliasAssignmentsMvc20()
             Assert.Contains("--IISExpressPort", result["IISExpressPort"].Aliases);
             Assert.Contains("-uld", result["UseLocalDB"].Aliases);
             Assert.Contains("--use-local-db", result["UseLocalDB"].Aliases);
-            Assert.Single(result["TargetFrameworkOverride"].Aliases);
+            Assert.HasCount(1, result["TargetFrameworkOverride"].Aliases);
             Assert.Contains("--target-framework-override", result["TargetFrameworkOverride"].Aliases);
             Assert.Contains("-f", result["Framework"].Aliases);
             Assert.Contains("--framework", result["Framework"].Aliases);
             Assert.Contains("-nt", result["NoTools"].Aliases);
             Assert.Contains("--no-tools", result["NoTools"].Aliases);
-            Assert.Single(result["skipRestore"].Aliases);
+            Assert.HasCount(1, result["skipRestore"].Aliases);
             Assert.Contains("--no-restore", result["skipRestore"].Aliases);
-            Assert.DoesNotContain(result, r => r.Value.Errors.Any());
+            Assert.IsFalse(result.Any(r => r.Value.Errors.Any()));
         }
 
-        [Theory]
-        [InlineData("package", "--param:package")]
-        [InlineData("u", "-p:u")]
-        [InlineData("notreserved", "--notreserved")]
+        [TestMethod]
+        [DataRow("package", "--param:package")]
+        [DataRow("u", "-p:u")]
+        [DataRow("notreserved", "--notreserved")]
         public void CanAssignAliasForParameterWithReservedAlias(string parameterName, string expectedContainedAlias)
         {
             string command = "foo";
@@ -266,13 +267,13 @@ public void CanAssignAliasForParameterWithReservedAlias(string parameterName, st
                 .FromTemplateList(CliTemplateInfo.FromTemplateInfo(templates, A.Fake<IHostSpecificDataLoader>()))
                 .Single();
             var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
-            Assert.Single(templateCommands);
+            Assert.HasCount(1, templateCommands);
             var templateOption = templateCommands.Single().TemplateOptions[parameterName];
             Assert.Contains(expectedContainedAlias, templateOption.Aliases);
         }
 
-        [Theory]
-        [MemberData(nameof(GetTemplateData))]
+        [TestMethod]
+        [DynamicData(nameof(GetTemplateData))]
         public void CanOverrideAliasesForParameterWithHostData(string hostJsonData, string expectedJsonResult)
         {
             var hostData = new HostSpecificTemplateData(string.IsNullOrEmpty(hostJsonData) ? null : JsonNode.Parse(hostJsonData)?.AsObject());
@@ -294,25 +295,25 @@ public void CanOverrideAliasesForParameterWithHostData(string hostJsonData, stri
             ParseResult parseResult = myCommand.Parse(" new foo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, templatePackageManager, templateGroup);
-            Assert.Single(templateCommands);
+            Assert.HasCount(1, templateCommands);
             foreach (var expectedResult in expectedResults)
             {
                 var expectedArr = expectedResult.Value!.AsArray();
                 var expectedLongAlias = expectedArr[0]?.GetValue<string>();
                 var expectedShortAlias = expectedArr[1]?.GetValue<string>();
                 var expectedIsHidden = expectedArr[2]?.GetValue<bool>() ?? false;
                 var templateOptions = templateCommands.Single().TemplateOptions;
-                Assert.NotNull(templateOptions);
+                Assert.IsNotNull(templateOptions);
                 Assert.Contains(expectedResult.Key, templateOptions.Keys);
                 var templateOption = templateOptions[expectedResult.Key];
-                Assert.NotNull(templateOption);
-                Assert.True(templateOption.Aliases.Count > 0);
+                Assert.IsNotNull(templateOption);
+                Assert.IsTrue(templateOption.Aliases.Count > 0);
                 var longAlias = templateOption.Aliases.ElementAt(0);
                 var shortAlias = templateOption.Aliases.Count > 1 ? templateOption.Aliases.ElementAt(1) : null;
                 var isHidden = templateOption.Option.Hidden;
-                Assert.Equal(expectedLongAlias, longAlias);
-                Assert.Equal(expectedShortAlias, shortAlias);
-                Assert.Equal(expectedIsHidden, isHidden);
+                Assert.AreEqual(expectedLongAlias, longAlias);
+                Assert.AreEqual(expectedShortAlias, shortAlias);
+                Assert.AreEqual(expectedIsHidden, isHidden);
             }
         }
 

test/Microsoft.TemplateEngine.Cli.UnitTests/AllComponents.cs

@@ -1,21 +1,22 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.TemplateEngine.TestHelper;
 
 namespace Microsoft.TemplateEngine.Cli.UnitTests
 {
+    [TestClass]
     public class AllComponents
     {
-        [Fact]
+        [TestMethod]
         public void TestAllComponents()
         {
             var assemblyCatalog = new AssemblyComponentCatalog(new[] { typeof(Components).Assembly });
 
             var expectedTypeNames = assemblyCatalog.Select(pair => pair.Item1.FullName + ";" + pair.Item2.GetType().FullName).OrderBy(name => name);
             var actualTypeNames = Components.AllComponents.Select(t => t.Type.FullName + ";" + t.Instance.GetType().FullName).OrderBy(name => name);
 
-            Assert.Equal(expectedTypeNames, actualTypeNames);
+            Assert.AreSequenceEqual(expectedTypeNames, actualTypeNames);
         }
     }
 }

test/Microsoft.TemplateEngine.Cli.UnitTests/BaseTest.cs

@@ -3,7 +3,7 @@
 
 namespace Microsoft.TemplateEngine.Cli.UnitTests
 {
-    public abstract class BaseTest
+    public abstract class BaseTest : VerifyBase
     {
         /// <summary>
         /// Gets a path to the folder with dotnet new test assets.

test/Microsoft.TemplateEngine.Cli.UnitTests/GlobalUsings.cs

@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Microsoft.TemplateEngine.TestHelper still references xunit.v3.extensibility.core
+// (it is consumed by other in-tree xUnit projects and is not part of this migration).
+// EnvironmentSettingsHelper's constructor takes an Xunit.Sdk.IMessageSink. We surface
+// it here with a short alias so the tests below can construct a no-op sink without
+// pulling in xUnit's global usings (which would conflict with MSTest's Assert).
+global using IMessageSink = Xunit.Sdk.IMessageSink;
+global using IMessageSinkMessage = Xunit.Sdk.IMessageSinkMessage;
+
+// Verify.MSTest's VerifyBase is used by snapshot test classes (HelpTests,
+// TabCompletionTests via BaseTest).
+global using VerifyMSTest;
+
+// The xUnit-only Directory.Build.targets adds these as global usings for VSTest
+// projects. MSTest.Sdk projects do not get them automatically.
+global using Microsoft.NET.TestFramework;
+global using Microsoft.NET.TestFramework.Utilities;
+
+// Some test methods (e.g. in InstantiateTests) take parameters of internal types
+// from Microsoft.TemplateEngine.Cli. Discover them via DiscoverInternals to keep
+// the existing method accessibility.
+[assembly: Microsoft.VisualStudio.TestTools.UnitTesting.DiscoverInternals]