feat(test): DumpCapture that captures memory dump on test failure

clean up ci

dumpcapture code docs

Author: egil

.config/dotnet-tools.json

@@ -6,13 +6,22 @@
       "version": "1.10.175",
       "commands": [
         "dotnet-serve"
-      ]
+      ],
+      "rollForward": false
     },
     "docfx": {
       "version": "2.76.0",
       "commands": [
         "docfx"
-      ]
+      ],
+      "rollForward": false
+    },
+    "dotnet-dump": {
+      "version": "8.0.532401",
+      "commands": [
+        "dotnet-dump"
+      ],
+      "rollForward": false
     }
   }
 }

.github/workflows/ci.yml

@@ -136,15 +136,15 @@ jobs:
             8.0.x
             9.0.x
 
-      - name: ⚙️ Setup GIT versioning
+      - name: ⚙️ Restore packages and tools
         run: |
           dotnet restore
           dotnet tool restore
 
       - name: 🧪 Run unit tests
         run: dotnet test -c release --no-restore -p:VSTestUseMSBuildOutput=false --logger "trx"
 
-      - name: Test Report
+      - name: 🛒 Test Report
         uses: dorny/test-reporter@v1
         if: success() || failure()
         with:

tests/bunit.testassets/DumpCapture.cs

@@ -0,0 +1,92 @@
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using Xunit.Abstractions;
+
+namespace Bunit.TestAssets;
+
+/// <summary>
+/// Wrap a test action or function in a try-catch block that captures a dump file if the test fails.
+/// </summary>
+/// <remarks>
+/// This requires the <c>dotnet-dump</c> tool to be installed as a local dotnet tool.
+/// </remarks>
+public static class DumpCapture
+{
+
+	public static async Task OnFailureAsync(
+		Action testAction,
+		ITestOutputHelper outputHelper,
+		[CallerMemberName] string testName = "",
+		[CallerFilePath] string testFilePath = "")
+	{
+		try
+		{
+			testAction();
+		}
+		catch
+		{
+			await CaptureDump(testName, testFilePath, outputHelper);
+			throw;
+		}
+	}
+
+	public static async Task OnFailureAsync(
+		Func<Task> testAction,
+		ITestOutputHelper outputHelper,
+		[CallerMemberName] string testName = "",
+		[CallerFilePath] string testFilePath = "")
+	{
+		try
+		{
+			await testAction();
+		}
+		catch
+		{
+			await CaptureDump(testName, testFilePath, outputHelper);
+			throw;
+		}
+	}
+
+	private static async Task CaptureDump(string testName, string testFilePath, ITestOutputHelper outputHelper)
+	{
+#if NETSTANDARD2_1
+		var processId = Process.GetCurrentProcess().Id;
+#else
+		var processId = Environment.ProcessId;
+#endif
+		var dumpFilePath = Path.Combine(Directory.GetCurrentDirectory(), $"{Path.GetFileNameWithoutExtension(testFilePath)}-{testName}-wait-failed-{Guid.NewGuid()}.dmp");
+		// Attempt to start the dotnet-dump process
+		var startInfo = new ProcessStartInfo
+		{
+			FileName = "dotnet",
+			Arguments = $"dotnet-dump collect -p {processId} -o {dumpFilePath}",
+			RedirectStandardOutput = true,
+			RedirectStandardError = true,
+			UseShellExecute = false,
+			CreateNoWindow = true
+		};
+		using var process = Process.Start(startInfo);
+		if (process is null)
+		{
+			outputHelper.WriteLine(" Failed to start dotnet-dump process.");
+			return;
+		}
+
+#if NETSTANDARD2_1
+		process.WaitForExit();
+#else
+		await process.WaitForExitAsync();
+#endif
+		var output = await process.StandardOutput.ReadToEndAsync();
+		var error = await process.StandardError.ReadToEndAsync();
+		outputHelper.WriteLine($"Dump status: {{process.ExitCode}}. Dump file: {dumpFilePath}");
+		if (!string.IsNullOrWhiteSpace(output))
+		{
+			outputHelper.WriteLine($"Dump output: {output}");
+		}
+		if (!string.IsNullOrWhiteSpace(error))
+		{
+			outputHelper.WriteLine($"Dump error: {error}");
+		}
+	}
+}

tests/bunit.web.tests/Asserting/MarkupMatchesTests.razor

@@ -1,35 +1,47 @@
+@using Bunit.TestAssets
 @using Bunit.TestAssets.SampleComponents
 @inherits TestContext
-
 @code {
+    private readonly ITestOutputHelper outputHelper;
+
+    public MarkupMatchesTests(ITestOutputHelper outputHelper)
+    {
+        this.outputHelper = outputHelper;
+    }
 
-	[Fact]
-	public void MarkupMatchesShouldNotBeBlockedByRenderer()
-	{
-		var tcs = new TaskCompletionSource<object?>();
+    [Fact]
+    public async Task MarkupMatchesShouldNotBeBlockedByRenderer()
+    {
+        await DumpCapture.OnFailureAsync(() =>
+        {
+            var tcs = new TaskCompletionSource<object?>();
 
-		var cut = Render(@<LoadingComponent Task="@tcs.Task"/> );
+            var cut = Render(@<LoadingComponent Task="@tcs.Task" />    );
 
-		cut.MarkupMatches(@<span>loading</span>);
+            cut.MarkupMatches(@<span>loading</span>  );
 
-		tcs.SetResult(true);
+            tcs.SetResult(true);
 
-		cut.WaitForAssertion(() => cut.MarkupMatches(@<span>done</span>));
-	}
+            cut.WaitForAssertion(() => cut.MarkupMatches(@<span>done</span>));
+        },
+        outputHelper);
+    }
 
-	[SuppressMessage("Usage", "xUnit1026:Theory method does not use parameter")]
-	[Theory]
-	[Repeat(2)]
-	public void MarkupMatchesShouldNotBeBlockedByRendererComplex(int repeatCount)
-	{
-		var tcs = new TaskCompletionSource<object?>();
+    [Fact]
+    public async Task MarkupMatchesShouldNotBeBlockedByRendererComplex()
+    {
+        await DumpCapture.OnFailureAsync(() =>
+        {
+            var tcs = new TaskCompletionSource<object?>();
 
-		var cut = Render(@<InvokeAsyncInsideContinueWith Task="@tcs.Task"/> );
+            var cut = Render(@<InvokeAsyncInsideContinueWith Task="@tcs.Task" /> );
 
-		cut.MarkupMatches(@<span>waiting</span>);
+            cut.MarkupMatches(@<span>waiting</span>);
 
-		tcs.SetResult(true);
+            tcs.SetResult(true);
 
-		cut.WaitForAssertion(() => cut.MarkupMatches(@<span>done</span>));
-	}
+            cut.WaitForAssertion(() => cut.MarkupMatches(@<span>done</span>));
+        },
+        outputHelper);
+    }
 }