Propagate performance budgets to Page and tests

Add page-level performance budget support and ensure test adapters set/clear it to work around AsyncLocal flow limitations. Introduce Page.ActivePerformanceBudget and PerformanceBudgetContext.SetBudget/ClearBudget; update MSTest, NUnit and xUnit test bases to Push resolved budgets, call SetBudget(_page, budget) when starting and ClearBudget(_page) during teardown. PageAssertions now prefers the page's active budget over the ambient context. Also enable performance collection in sample AssemblySetup and mark relevant sample tests as Integration.

Author: TorreyBetts

samples/Motus.Samples/AssemblySetup.cs

@@ -5,7 +5,11 @@ public class AssemblySetup
 {
     [AssemblyInitialize]
     public static async Task Initialize(TestContext _) =>
-        await MotusTestBase.LaunchBrowserAsync(new LaunchOptions { Headless = true });
+        await MotusTestBase.LaunchBrowserAsync(new LaunchOptions
+        {
+            Headless = true,
+            Performance = new PerformanceOptions { Enable = true },
+        });
 
     [AssemblyCleanup]
     public static async Task Cleanup() =>

samples/Motus.Samples/Tests/PerformanceTests.cs

@@ -40,20 +40,23 @@ public async Task MethodAttribute_OverridesClassBudget()
     }
 
     [TestMethod]
+    [TestCategory("Integration")]
     public async Task LcpBelow_IndividualMetricAssertion()
     {
         await Fixtures.SetPageContentAsync(Page, SimplePage);
         await Expect.That(Page).ToHaveLcpBelowAsync(5000);
     }
 
     [TestMethod]
+    [TestCategory("Integration")]
     public async Task FcpBelow_IndividualMetricAssertion()
     {
         await Fixtures.SetPageContentAsync(Page, SimplePage);
         await Expect.That(Page).ToHaveFcpBelowAsync(5000);
     }
 
     [TestMethod]
+    [TestCategory("Integration")]
     public async Task ClsBelow_NoLayoutShift()
     {
         await Fixtures.SetPageContentAsync(Page, SimplePage);

src/Motus.Testing.MSTest/MotusTestBase.cs

@@ -82,12 +82,18 @@ public async Task MotusTestInitialize()
         var methodAttr = methodInfo?.GetCustomAttribute<PerformanceBudgetAttribute>();
         var classAttr = GetType().GetCustomAttribute<PerformanceBudgetAttribute>();
         var activeAttr = methodAttr ?? classAttr;
-        PerformanceBudgetContext.Push(activeAttr?.ToBudget());
+        var budget = activeAttr?.ToBudget();
+        PerformanceBudgetContext.Push(budget);
+        PerformanceBudgetContext.SetBudget(_page, budget);
     }
 
     [TestCleanup]
     public async Task MotusTestCleanup()
     {
+        if (_page is not null)
+            PerformanceBudgetContext.ClearBudget(_page);
+        PerformanceBudgetContext.Clear();
+
         if (_context is not null)
         {
             var testFailed = TestContext?.CurrentTestOutcome != UnitTestOutcome.Passed;
@@ -98,7 +104,5 @@ public async Task MotusTestCleanup()
             _context = null;
             _page = null;
         }
-
-        PerformanceBudgetContext.Clear();
     }
 }

src/Motus.Testing.NUnit/MotusTestBase.cs

@@ -72,12 +72,18 @@ public async Task SetUp()
         var methodAttr = methodInfo?.GetCustomAttribute<PerformanceBudgetAttribute>();
         var classAttr = GetType().GetCustomAttribute<PerformanceBudgetAttribute>();
         var activeAttr = methodAttr ?? classAttr;
-        PerformanceBudgetContext.Push(activeAttr?.ToBudget());
+        var budget = activeAttr?.ToBudget();
+        PerformanceBudgetContext.Push(budget);
+        PerformanceBudgetContext.SetBudget(_page, budget);
     }
 
     [TearDown]
     public async Task TearDown()
     {
+        if (_page is not null)
+            PerformanceBudgetContext.ClearBudget(_page);
+        PerformanceBudgetContext.Clear();
+
         if (_context is not null)
         {
             var testFailed = TestContext.CurrentContext.Result.Outcome.Status == global::NUnit.Framework.Interfaces.TestStatus.Failed;
@@ -88,7 +94,5 @@ public async Task TearDown()
             _context = null;
             _page = null;
         }
-
-        PerformanceBudgetContext.Clear();
     }
 }

src/Motus.Testing.xUnit/BrowserContextFixture.cs

@@ -45,18 +45,22 @@ public async Task InitializeAsync()
         _page = await _context.NewPageAsync();
 
         var classAttr = GetType().GetCustomAttribute<PerformanceBudgetAttribute>();
-        PerformanceBudgetContext.Push(classAttr?.ToBudget());
+        var budget = classAttr?.ToBudget();
+        PerformanceBudgetContext.Push(budget);
+        PerformanceBudgetContext.SetBudget(_page, budget);
     }
 
     public async Task DisposeAsync()
     {
+        if (_page is not null)
+            PerformanceBudgetContext.ClearBudget(_page);
+        PerformanceBudgetContext.Clear();
+
         if (_context is not null)
         {
             await _context.CloseAsync();
             _context = null;
             _page = null;
         }
-
-        PerformanceBudgetContext.Clear();
     }
 }

src/Motus/Assertions/PageAssertions.cs

@@ -150,8 +150,11 @@ public Task ToHaveInpBelowAsync(double thresholdMs, AssertionOptions? options =
             return (actual <= thresholdMs, $"{actual:F1}ms");
         }, "ToHaveInpBelow", $"< {thresholdMs}ms", options);
 
-    private static PerformanceBudget ResolveBudget()
+    private PerformanceBudget ResolveBudget()
     {
+        if (_page.ActivePerformanceBudget is { } pageBudget)
+            return pageBudget;
+
         if (PerformanceBudgetContext.Current is { } ambient)
             return ambient;
 

src/Motus/Page/Page.Performance.cs

@@ -9,4 +9,10 @@ internal sealed partial class Page
     /// after navigation or page close. Null when the hook is disabled or no collection has run.
     /// </summary>
     internal PerformanceMetrics? LastPerformanceMetrics { get; set; }
+
+    /// <summary>
+    /// The active performance budget for this page, set by test framework adapters
+    /// from <see cref="PerformanceBudgetAttribute"/> resolution.
+    /// </summary>
+    internal PerformanceBudget? ActivePerformanceBudget { get; set; }
 }

src/Motus/Performance/PerformanceBudgetContext.cs

@@ -15,9 +15,28 @@ public static class PerformanceBudgetContext
     /// <summary>Sets the active budget for the current async flow.</summary>
     public static void Push(PerformanceBudget? budget) => s_current.Value = budget;
 
+    /// <summary>
+    /// Sets the active budget directly on a page. This avoids <see cref="AsyncLocal{T}"/>
+    /// limitations where writes inside async test initializers don't flow to the test method.
+    /// </summary>
+    public static void SetBudget(IPage page, PerformanceBudget? budget)
+    {
+        if (page is Page concrete)
+            concrete.ActivePerformanceBudget = budget;
+    }
+
     /// <summary>Clears the active budget.</summary>
     public static void Clear() => s_current.Value = null;
 
+    /// <summary>
+    /// Clears the budget from a page. Call this in test teardown alongside <see cref="Clear"/>.
+    /// </summary>
+    public static void ClearBudget(IPage page)
+    {
+        if (page is Page concrete)
+            concrete.ActivePerformanceBudget = null;
+    }
+
     /// <summary>The active budget for the current async flow, or null if none set.</summary>
     internal static PerformanceBudget? Current => s_current.Value;
 }