feat: Remove AwesomeAssertions, use TUnit built-in assertions (#49)

TUnit ships its own async fluent assertion API so AwesomeAssertions is
an unnecessary dependency that can be dropped.

## What changed

- Removed `AwesomeAssertions` from `Directory.Packages.props` and
`TrxLib.Tests.csproj`.
- Migrated all three test files to TUnit's native assertions:
  - `x.Should().Be(y)` -> `await Assert.That(x).IsEqualTo(y)`
  - `x.Should().Contain(y)` -> `await Assert.That(x).Contains(y)`
  - `x.Should().HaveCount(n)` -> `await Assert.That(x).HasCount(n)`
- `x.Should().ContainSingle(pred)` -> `await
Assert.That(x).HasSingleItem(pred)`
- `x.Should().NotBeNull()` / `.BeNull()` -> `await
Assert.That(x).IsNotNull()` / `.IsNull()`
- `act.Should().NotThrow<T>()` -> direct invocation (TUnit surfaces
exceptions automatically)
  - `AssertionScope` blocks -> sequential `await Assert.That(...)` calls
- All `void` test methods that now use `await` were updated to `async
Task`.

All 65 tests pass after the migration.

Author: BenjaminMichaelis

Directory.Packages.props

@@ -17,7 +17,6 @@
   This would typically list all NuGet packages used within this solution.
   -->
   <ItemGroup>
-    <PackageVersion Include="AwesomeAssertions" Version="9.4.0" />
     <PackageVersion Include="IntelliTect.Multitool" Version="2.0.0" />
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="10.0.203" />
     <PackageVersion Include="Moq" Version="4.20.70" />

TrxLib.Tests/TestResultTests.cs

@@ -1,5 +1,4 @@
-using AwesomeAssertions;
-using AwesomeAssertions.Execution;
+using TUnit.Assertions;
 
 namespace TrxLib.Tests;
 
@@ -9,77 +8,76 @@ public class TestResultTests
     [Arguments("namespace.class.test", "namespace")]
     [Arguments("deeper.namespace.class.test", "deeper.namespace")]
     [Arguments("still.deeper.namespace.class.test", "still.deeper.namespace")]
-    public void Namespace_is_parsed_correctly(
+    public async Task Namespace_is_parsed_correctly(
         string fullyQualifiedTestName,
         string expectedNamespace)
     {
         var testResult = new TestResult(fullyQualifiedTestName, TestOutcome.NotExecuted);
-        testResult.Namespace.Should().Be(expectedNamespace);
+        await Assert.That(testResult.Namespace).IsEqualTo(expectedNamespace);
     }
 
     [Test]
     [Arguments("namespace.class.test")]
     [Arguments("deeper.namespace.class.test")]
     [Arguments("still.deeper.namespace.class.test")]
-    public void TestName_is_parsed_correctly(
+    public async Task TestName_is_parsed_correctly(
         string fullyQualifiedTestName)
     {
         var testResult = new TestResult(fullyQualifiedTestName, TestOutcome.NotExecuted);
-        testResult.TestName.Should().Be("test");
+        await Assert.That(testResult.TestName).IsEqualTo("test");
     }
 
     [Test]
     [Arguments("namespace.class.test")]
     [Arguments("deeper.namespace.class.test")]
     [Arguments("still.deeper.namespace.class.test")]
-    public void ClassName_is_parsed_correctly(
+    public async Task ClassName_is_parsed_correctly(
         string fullyQualifiedTestName)
     {
         var testResult = new TestResult(fullyQualifiedTestName, TestOutcome.NotExecuted);
-        testResult.ClassName.Should().Be("class");
+        await Assert.That(testResult.ClassName).IsEqualTo("class");
     }
 
     [Test]
     [Arguments("namespace.class.test", "namespace.class")]
     [Arguments("deeper.namespace.class.test", "deeper.namespace.class")]
     [Arguments("still.deeper.namespace.class.test", "still.deeper.namespace.class")]
     [Arguments("deeper.namespace.class.theorytest(command: \"build\")", "deeper.namespace.class")]
-    public void FullyQualifiedClassName_is_parsed_correctly(
+    public async Task FullyQualifiedClassName_is_parsed_correctly(
         string fullyQualifiedTestName,
         string expected)
     {
         var testResult = new TestResult(fullyQualifiedTestName, TestOutcome.NotExecuted);
-        testResult.FullyQualifiedClassName.Should().Be(expected);
+        await Assert.That(testResult.FullyQualifiedClassName).IsEqualTo(expected);
     }
 
     [Test]
-    public void Theory_test_is_parsed_correctly()
+    public async Task Theory_test_is_parsed_correctly()
     {
         var testResult = new TestResult(
             "Microsoft.DotNet.Cli.MSBuild.IntegrationTests.GivenDotnetInvokesMSBuild.When_dotnet_command_invokes_msbuild_Then_env_vars_and_m_are_passed(command: \"build\")",
             outcome: TestOutcome.Passed);
 
-        using var _ = new AssertionScope();
-        testResult.TestName.Should().Be("When_dotnet_command_invokes_msbuild_Then_env_vars_and_m_are_passed(command: \"build\")");
-        testResult.Namespace.Should().Be("Microsoft.DotNet.Cli.MSBuild.IntegrationTests");
-        testResult.ClassName.Should().Be("GivenDotnetInvokesMSBuild");
+        await Assert.That(testResult.TestName).IsEqualTo("When_dotnet_command_invokes_msbuild_Then_env_vars_and_m_are_passed(command: \"build\")");
+        await Assert.That(testResult.Namespace).IsEqualTo("Microsoft.DotNet.Cli.MSBuild.IntegrationTests");
+        await Assert.That(testResult.ClassName).IsEqualTo("GivenDotnetInvokesMSBuild");
     }
 
     [Test]
     [Arguments("Cell 1: #r \"nuget:TRexLib\"")]
     [Arguments("Cell 1: Console.Write(\"Hello world.\";")]
-    public void Inferred_properties_are_not_inferred_from_fully_qualified_test_name_if_they_do_not_match_dotnet_standards(
+    public async Task Inferred_properties_are_not_inferred_from_fully_qualified_test_name_if_they_do_not_match_dotnet_standards(
         string fullyQualifiedTestName)
     {
         var testResult = new TestResult(fullyQualifiedTestName, TestOutcome.NotExecuted);
-        testResult.ClassName.Should().BeNull();
-        testResult.FullyQualifiedClassName.Should().BeNull();
-        testResult.Namespace.Should().BeNull();
-        testResult.TestName.Should().Be(fullyQualifiedTestName);
+        await Assert.That(testResult.ClassName).IsNull();
+        await Assert.That(testResult.FullyQualifiedClassName).IsNull();
+        await Assert.That(testResult.Namespace).IsNull();
+        await Assert.That(testResult.TestName).IsEqualTo(fullyQualifiedTestName);
     }
 
     [Test]
-    public void Theory_test_with_dotted_param_is_parsed_correctly_when_testMethod_provided()
+    public async Task Theory_test_with_dotted_param_is_parsed_correctly_when_testMethod_provided()
     {
         // When testMethod is supplied the constructor must use testMethod.ClassName
         // directly instead of splitting the FQTN on '.'.  Without the fix, a param
@@ -91,22 +89,20 @@ public void Theory_test_with_dotted_param_is_parsed_correctly_when_testMethod_pr
         var testResult = new TestResult(fqtn, TestOutcome.Passed,
             testMethod: new TestMethod { ClassName = className, Name = methodName });
 
-        using var _ = new AssertionScope();
-        testResult.FullyQualifiedTestName.Should().Be(fqtn);
-        testResult.FullyQualifiedClassName.Should().Be(className);
-        testResult.ClassName.Should().Be("ParserTests");
-        testResult.Namespace.Should().Be("System.CommandLine.Tests");
-        testResult.TestName.Should().Be($"{methodName}(param: \"foo.bar\")");
+        await Assert.That(testResult.FullyQualifiedTestName).IsEqualTo(fqtn);
+        await Assert.That(testResult.FullyQualifiedClassName).IsEqualTo(className);
+        await Assert.That(testResult.ClassName).IsEqualTo("ParserTests");
+        await Assert.That(testResult.Namespace).IsEqualTo("System.CommandLine.Tests");
+        await Assert.That(testResult.TestName).IsEqualTo($"{methodName}(param: \"foo.bar\")");
     }
 
     [Test]
-    public void ToString_DoesNotThrow_ForOutcomeValueNotInEnum()
+    public async Task ToString_DoesNotThrow_ForOutcomeValueNotInEnum()
     {
         // TestResult.ToString() has a _ => throw arm that crashes on any enum value
         // not listed in its switch expression (e.g. future additions to TestOutcome, or
         // values written by vstest that TrxLib doesn't yet map, such as "Completed").
         var testResult = new TestResult("some.namespace.SomeClass.SomeTest", (TestOutcome)99);
-        var act = () => testResult.ToString();
-        act.Should().NotThrow<ArgumentOutOfRangeException>();
+        await Assert.That(() => testResult.ToString()).ThrowsNothing();
     }
-}
+}

TrxLib.Tests/TrxLib.Tests.csproj

@@ -10,7 +10,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AwesomeAssertions" />
     <PackageReference Include="IntelliTect.Multitool" />
     <PackageReference Include="TUnit" />
   </ItemGroup>

TrxLib.Tests/TrxParserRegressionTests.cs

@@ -1,6 +1,6 @@
 using System.IO;
 
-using AwesomeAssertions;
+using TUnit.Assertions;
 
 namespace TrxLib.Tests;
 
@@ -17,11 +17,11 @@ public class TrxParserRegressionTests
     [Arguments("Aborted",     TestOutcome.Aborted)]
     [Arguments("NotRunnable", TestOutcome.NotRunnable)]
     [Arguments(null,          TestOutcome.Error)] // absent attribute = Error
-    public void Parse_OutcomeAttribute_RoundTrips(string? outcomeAttr, TestOutcome expected)
+    public async Task Parse_OutcomeAttribute_RoundTrips(string? outcomeAttr, TestOutcome expected)
     {
         using var trxFile = new TempTrxFile(MinimalTrx(outcome: outcomeAttr));
         var results = TrxParser.Parse(trxFile.FileInfo);
-        results.Single().Outcome.Should().Be(expected);
+        await Assert.That(results.Single().Outcome).IsEqualTo(expected);
     }
 
     // TestProjectDirectory must resolve to the project root for all standard .NET SDK
@@ -34,14 +34,14 @@ public void Parse_OutcomeAttribute_RoundTrips(string? outcomeAttr, TestOutcome e
     ];
 
     [Test, MethodDataSource(nameof(DirectoryLayouts))]
-    public void Parse_TestProjectDirectory_ResolvesFromBinAnchor(string subfolder, string[] segments)
+    public async Task Parse_TestProjectDirectory_ResolvesFromBinAnchor(string subfolder, string[] segments)
     {
         var projectRoot = Path.GetFullPath(Path.Combine(Path.GetTempPath(), subfolder));
         var codebase = Path.Combine(new[] { projectRoot }.Concat(segments).ToArray());
         using var trxFile = new TempTrxFile(MinimalTrx(codeBase: codebase));
         var results = TrxParser.Parse(trxFile.FileInfo);
-        results.Single().TestProjectDirectory!.FullName.TrimEnd(Path.DirectorySeparatorChar)
-            .Should().Be(projectRoot.TrimEnd(Path.DirectorySeparatorChar));
+        await Assert.That(results.Single().TestProjectDirectory!.FullName.TrimEnd(Path.DirectorySeparatorChar))
+            .IsEqualTo(projectRoot.TrimEnd(Path.DirectorySeparatorChar));
     }
 
     // -------------------------------------------------------------------------