Propagate test method name and harden tracing

TorreyBetts · TorreyBetts · commit 3402af600774 · 2026-04-10T14:40:48.000-04:00
Add TestMethodNameContext to carry the active test method name across async flows. TestExecutionService now sets/clears the context around test invocation so MotusTestBase (MSTest/NUnit/xUnit) and BrowserContextFixture can resolve per-method PerformanceBudget attributes when framework TestContext/MethodInfo is not available. Update sample PerformanceTests to use real navigations, add extra assertions and an integration category. Harden Tracing by cancelling lingering pumps, using a local TaskCompletionSource for tracingComplete, adding a 30s timeout, and ensuring pumps are cancelled to avoid races and hangs.
diff --git a/samples/Motus.Samples/Tests/PerformanceTests.cs b/samples/Motus.Samples/Tests/PerformanceTests.cs
@@ -1,32 +1,25 @@
 namespace Motus.Samples.Tests;
 
 /// <summary>
-/// Performance testing showcase: budget assertions, individual metric assertions,
-/// the [PerformanceBudget] attribute, and .Not negation. Uses inline HTML fixtures
-/// that trigger real navigations so the performance metrics collector fires.
+/// Performance testing showcase demonstrating Phase 2 features:
+/// budget assertions, individual metric assertions (LCP, FCP, TTFB, CLS),
+/// the [PerformanceBudget] attribute with class/method override, and .Not negation.
+///
+/// Uses real HTTP navigations so the PerformanceObserver collects actual web vitals.
+/// When run in the visual runner, navigate steps appear as annotated timeline markers
+/// with LCP, FCP, and CLS values, and the step detail panel shows a Performance section.
 /// </summary>
 [TestClass]
+[TestCategory("Integration")]
 [PerformanceBudget(Lcp = 5000, Fcp = 5000, Cls = 1.0)]
 public class PerformanceTests : MotusTestBase
 {
-    private const string SimplePage = """
-        <!DOCTYPE html>
-        <html lang="en">
-        <head><title>Performance Sample</title></head>
-        <body>
-            <main>
-                <h1>Performance Test Page</h1>
-                <p>A lightweight page for budget validation.</p>
-                <img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" alt="pixel" />
-            </main>
-        </body>
-        </html>
-        """;
+    private const string ExampleUrl = "https://example.com";
 
     [TestMethod]
-    public async Task SimplePage_MeetsPerformanceBudget()
+    public async Task ExampleDotCom_MeetsPerformanceBudget()
     {
-        await Fixtures.SetPageContentAsync(Page, SimplePage);
+        await Page.GotoAsync(ExampleUrl);
         await Expect.That(Page).ToMeetPerformanceBudgetAsync();
     }
 
@@ -35,36 +28,55 @@ public async Task SimplePage_MeetsPerformanceBudget()
     public async Task MethodAttribute_OverridesClassBudget()
     {
         // The method-level budget (LCP = 10000ms) overrides the class-level budget.
-        await Fixtures.SetPageContentAsync(Page, SimplePage);
+        await Page.GotoAsync(ExampleUrl);
         await Expect.That(Page).ToMeetPerformanceBudgetAsync();
     }
 
     [TestMethod]
     public async Task LcpBelow_IndividualMetricAssertion()
     {
-        await Fixtures.SetPageContentAsync(Page, SimplePage);
+        await Page.GotoAsync(ExampleUrl);
         await Expect.That(Page).ToHaveLcpBelowAsync(5000);
     }
 
     [TestMethod]
     public async Task FcpBelow_IndividualMetricAssertion()
     {
-        await Fixtures.SetPageContentAsync(Page, SimplePage);
+        await Page.GotoAsync(ExampleUrl);
         await Expect.That(Page).ToHaveFcpBelowAsync(5000);
     }
 
+    [TestMethod]
+    public async Task TtfbBelow_ServerResponseTime()
+    {
+        await Page.GotoAsync(ExampleUrl);
+        await Expect.That(Page).ToHaveTtfbBelowAsync(3000);
+    }
+
     [TestMethod]
     public async Task ClsBelow_NoLayoutShift()
     {
-        await Fixtures.SetPageContentAsync(Page, SimplePage);
+        await Page.GotoAsync(ExampleUrl);
         await Expect.That(Page).ToHaveClsBelowAsync(0.5);
     }
 
     [TestMethod]
     public async Task Not_LcpBelow_NegationAssertsThatLcpIsAtLeastThreshold()
     {
-        await Fixtures.SetPageContentAsync(Page, SimplePage);
-        // A 1x1 inline page will have LCP well above 0ms
+        await Page.GotoAsync(ExampleUrl);
+        // A real page will have LCP well above 0ms
         await Expect.That(Page).Not.ToHaveLcpBelowAsync(0);
     }
+
+    [TestMethod]
+    public async Task MultipleNavigations_EachProducesTimelineMetrics()
+    {
+        // Each GotoAsync fires the PerformanceMetricsCollector, creating a
+        // separate annotated navigate marker on the visual runner timeline.
+        await Page.GotoAsync(ExampleUrl);
+        await Expect.That(Page).ToHaveLcpBelowAsync(5000);
+
+        await Page.GotoAsync("https://www.iana.org/domains/reserved");
+        await Expect.That(Page).ToMeetPerformanceBudgetAsync();
+    }
 }
diff --git a/src/Motus.Runner/Services/TestExecutionService.cs b/src/Motus.Runner/Services/TestExecutionService.cs
@@ -208,6 +208,10 @@ private static async Task<TestNodeState> ExecuteTestAsync(DiscoveredTest test, I
         {
             instance = Activator.CreateInstance(test.TestClass)!;
 
+            // Publish the test method name so MotusTestBase can resolve
+            // per-method attributes (e.g. [PerformanceBudget]) without TestContext
+            TestMethodNameContext.Set(test.TestMethod.Name);
+
             // Run [TestInitialize] methods
             await ExecuteLifecycleMethodAsync(instance, test.TestClass, "TestInitializeAttribute");
             // Also support NUnit [SetUp]
@@ -252,6 +256,8 @@ private static async Task<TestNodeState> ExecuteTestAsync(DiscoveredTest test, I
                 else if (instance is IDisposable disposable)
                     disposable.Dispose();
             }
+
+            TestMethodNameContext.Clear();
         }
     }
 }
diff --git a/src/Motus.Testing.MSTest/MotusTestBase.cs b/src/Motus.Testing.MSTest/MotusTestBase.cs
@@ -75,7 +75,7 @@ public async Task MotusTestInitialize()
         _failureTracing = new FailureTracing();
         await _failureTracing.StartIfEnabledAsync(_context).ConfigureAwait(false);
 
-        var testMethodName = TestContext?.TestName;
+        var testMethodName = TestContext?.TestName ?? TestMethodNameContext.Current;
         var methodInfo = testMethodName is not null
             ? GetType().GetMethod(testMethodName, BindingFlags.Public | BindingFlags.Instance)
             : null;
diff --git a/src/Motus.Testing.NUnit/MotusTestBase.cs b/src/Motus.Testing.NUnit/MotusTestBase.cs
@@ -68,7 +68,10 @@ public async Task SetUp()
         _failureTracing = new FailureTracing();
         await _failureTracing.StartIfEnabledAsync(_context);
 
-        var methodInfo = TestContext.CurrentContext.Test.Method?.MethodInfo;
+        var testMethodName = TestMethodNameContext.Current;
+        var methodInfo = testMethodName is not null
+            ? GetType().GetMethod(testMethodName, BindingFlags.Public | BindingFlags.Instance)
+            : TestContext.CurrentContext.Test.Method?.MethodInfo;
         var methodAttr = methodInfo?.GetCustomAttribute<PerformanceBudgetAttribute>();
         var classAttr = GetType().GetCustomAttribute<PerformanceBudgetAttribute>();
         var activeAttr = methodAttr ?? classAttr;
diff --git a/src/Motus.Testing.xUnit/BrowserContextFixture.cs b/src/Motus.Testing.xUnit/BrowserContextFixture.cs
@@ -44,8 +44,14 @@ public async Task InitializeAsync()
         _context = await _browserFixture.NewContextAsync(ContextOptions);
         _page = await _context.NewPageAsync();
 
+        var testMethodName = TestMethodNameContext.Current;
+        var methodInfo = testMethodName is not null
+            ? GetType().GetMethod(testMethodName, BindingFlags.Public | BindingFlags.Instance)
+            : null;
+        var methodAttr = methodInfo?.GetCustomAttribute<PerformanceBudgetAttribute>();
         var classAttr = GetType().GetCustomAttribute<PerformanceBudgetAttribute>();
-        var budget = classAttr?.ToBudget();
+        var activeAttr = methodAttr ?? classAttr;
+        var budget = activeAttr?.ToBudget();
         PerformanceBudgetContext.Push(budget);
         PerformanceBudgetContext.SetBudget(_page, budget);
     }
diff --git a/src/Motus/Context/Tracing.cs b/src/Motus/Context/Tracing.cs
@@ -48,19 +48,24 @@ public async Task StartAsync(TracingStartOptions? options = null)
             categories.Add("disabled-by-default-devtools.timeline.picture");
         }
 
+        // Cancel any lingering pumps from a previous run before starting new ones
+        _pumpCts?.Cancel();
+
         // Drain any leftover data from a previous run
         while (_dataChannel.Reader.TryRead(out _)) { }
 
-        _completeTcs = new TaskCompletionSource<TracingTracingCompleteEvent>(
+        var completeTcs = new TaskCompletionSource<TracingTracingCompleteEvent>(
             TaskCreationOptions.RunContinuationsAsynchronously);
+        _completeTcs = completeTcs;
 
         _pumpCts = new CancellationTokenSource();
 
         // Start background pump for dataCollected events
         _ = PumpDataCollectedAsync(_pumpCts.Token);
 
-        // Subscribe to tracingComplete
-        _ = PumpTracingCompleteAsync(_pumpCts.Token);
+        // Subscribe to tracingComplete; capture the local TCS so cancellation
+        // of an old pump cannot poison a newer TCS via the shared field.
+        _ = PumpTracingCompleteAsync(completeTcs, _pumpCts.Token);
 
         await _browserSession.SendAsync(
             "Tracing.start",
@@ -79,15 +84,33 @@ public async Task StopAsync(TracingStopOptions? options = null)
             return;
 
         var completeTcs = _completeTcs!;
+        var pumpCts = _pumpCts;
 
         // Send Tracing.end
         await _browserSession.SendAsync(
             "Tracing.end",
             CdpJsonContext.Default.TracingEndResult,
             CancellationToken.None).ConfigureAwait(false);
 
-        // Wait for tracingComplete event
-        var completeEvent = await completeTcs.Task.ConfigureAwait(false);
+        // Wait for tracingComplete event with a timeout to prevent indefinite hangs
+        using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        using var reg = timeoutCts.Token.Register(() => completeTcs.TrySetCanceled());
+
+        TracingTracingCompleteEvent completeEvent;
+        try
+        {
+            completeEvent = await completeTcs.Task.ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) when (timeoutCts.IsCancellationRequested)
+        {
+            throw new TimeoutException(
+                "Timed out waiting for Tracing.tracingComplete event after 30 seconds.");
+        }
+        finally
+        {
+            // Cancel background pumps immediately so they don't race with future runs
+            pumpCts?.Cancel();
+        }
 
         // Collect all accumulated data chunks
         var allEvents = new List<JsonElement>();
@@ -104,9 +127,6 @@ await _browserSession.SendAsync(
             allEvents.AddRange(streamEvents);
         }
 
-        // Cancel background pumps
-        _pumpCts?.Cancel();
-
         // Extract screenshots from trace events
         var screenshots = ExtractScreenshots(allEvents);
 
@@ -139,7 +159,9 @@ private async Task PumpDataCollectedAsync(CancellationToken ct)
         catch (OperationCanceledException) { }
     }
 
-    private async Task PumpTracingCompleteAsync(CancellationToken ct)
+    private async Task PumpTracingCompleteAsync(
+        TaskCompletionSource<TracingTracingCompleteEvent> completeTcs,
+        CancellationToken ct)
     {
         try
         {
@@ -148,13 +170,13 @@ private async Task PumpTracingCompleteAsync(CancellationToken ct)
                 CdpJsonContext.Default.TracingTracingCompleteEvent,
                 ct).ConfigureAwait(false))
             {
-                _completeTcs?.TrySetResult(evt);
+                completeTcs.TrySetResult(evt);
                 break;
             }
         }
         catch (OperationCanceledException)
         {
-            _completeTcs?.TrySetCanceled();
+            completeTcs.TrySetCanceled();
         }
     }
 
diff --git a/src/Motus/Performance/TestMethodNameContext.cs b/src/Motus/Performance/TestMethodNameContext.cs
@@ -0,0 +1,21 @@
+namespace Motus;
+
+/// <summary>
+/// Carries the current test method name across async boundaries.
+/// The visual runner sets this before invoking test lifecycle methods so that
+/// <c>MotusTestBase</c> can resolve per-method attributes (e.g. <c>[PerformanceBudget]</c>)
+/// without requiring a framework-specific <c>TestContext</c>.
+/// </summary>
+public static class TestMethodNameContext
+{
+    private static readonly AsyncLocal<string?> s_name = new();
+
+    /// <summary>Sets the active test method name for the current async flow.</summary>
+    public static void Set(string? methodName) => s_name.Value = methodName;
+
+    /// <summary>Clears the active test method name.</summary>
+    public static void Clear() => s_name.Value = null;
+
+    /// <summary>The active test method name, or null if not set.</summary>
+    public static string? Current => s_name.Value;
+}

Original file line number	Diff line number	Diff line change
`@@ -208,6 +208,10 @@ private static async Task<TestNodeState> ExecuteTestAsync(DiscoveredTest test, I`
`208`	`208`	`{`
`209`	`209`	`instance = Activator.CreateInstance(test.TestClass)!;`
`210`	`210`
	`211`	`+ // Publish the test method name so MotusTestBase can resolve`
	`212`	`+ // per-method attributes (e.g. [PerformanceBudget]) without TestContext`
	`213`	`+ TestMethodNameContext.Set(test.TestMethod.Name);`
	`214`	`+`
`211`	`215`	`// Run [TestInitialize] methods`
`212`	`216`	`await ExecuteLifecycleMethodAsync(instance, test.TestClass, "TestInitializeAttribute");`
`213`	`217`	`// Also support NUnit [SetUp]`
`@@ -252,6 +256,8 @@ private static async Task<TestNodeState> ExecuteTestAsync(DiscoveredTest test, I`
`252`	`256`	`else if (instance is IDisposable disposable)`
`253`	`257`	`disposable.Dispose();`
`254`	`258`	`}`
	`259`	`+`
	`260`	`+ TestMethodNameContext.Clear();`
`255`	`261`	`}`
`256`	`262`	`}`
`257`	`263`	`}`