Stabilize editor toolbar coverage flow

Author: KSemenenko

.github/workflows/deploy-github-pages.yml

@@ -23,7 +23,7 @@ env:
 
 jobs:
   build_supporting_suites:
-    name: Restore + Build Supporting Suites
+    name: Build Supporting Tests
     runs-on: macos-latest
 
     permissions:
@@ -48,7 +48,7 @@ jobs:
         run: dotnet build "$SOLUTION_FILE" -warnaserror
 
   test_supporting_suites:
-    name: Run Supporting Suites
+    name: Supporting Tests
     needs: build_supporting_suites
     runs-on: macos-latest
 
@@ -87,7 +87,7 @@ jobs:
           if-no-files-found: ignore
 
   build_browser_suites:
-    name: Restore + Build Browser Suites
+    name: Build Browser Tests
     runs-on: macos-latest
 
     permissions:
@@ -111,8 +111,8 @@ jobs:
       - name: Build solution
         run: dotnet build "$SOLUTION_FILE" -warnaserror
 
-  test_browser_suites:
-    name: Run Browser Suite (${{ matrix.suite.name }})
+  browser_tests:
+    name: ${{ matrix.suite.name }}
     needs: build_browser_suites
     runs-on: macos-latest
     strategy:
@@ -185,7 +185,7 @@ jobs:
     name: Resolve Release Version
     needs:
       - test_supporting_suites
-      - test_browser_suites
+      - browser_tests
     runs-on: macos-latest
     env:
       APP_PROJECT: src/PrompterOne.Web/PrompterOne.Web.csproj

.github/workflows/pr-validation.yml

@@ -21,7 +21,7 @@ env:
 
 jobs:
   build_supporting_suites:
-    name: Restore + Build Supporting Suites
+    name: Build Supporting Tests
     runs-on: macos-latest
 
     steps:
@@ -43,7 +43,7 @@ jobs:
         run: dotnet build "$SOLUTION_FILE" -warnaserror
 
   test_supporting_suites:
-    name: Run Supporting Suites
+    name: Supporting Tests
     needs: build_supporting_suites
     runs-on: macos-latest
 
@@ -79,7 +79,7 @@ jobs:
           if-no-files-found: ignore
 
   build_browser_suites:
-    name: Restore + Build Browser Suites
+    name: Build Browser Tests
     runs-on: macos-latest
 
     steps:
@@ -100,8 +100,8 @@ jobs:
       - name: Build solution
         run: dotnet build "$SOLUTION_FILE" -warnaserror
 
-  test_browser_suites:
-    name: Run Browser Suite (${{ matrix.suite.name }})
+  browser_tests:
+    name: ${{ matrix.suite.name }}
     needs: build_browser_suites
     runs-on: macos-latest
     strategy:

AGENTS.md

@@ -202,6 +202,7 @@ Browser test execution rules:
 - Do not run any `PrompterOne.Web.UITests*` project in parallel with another `dotnet build` or `dotnet test` command on the same local machine context.
 - In GitHub Actions, run the browser suite family in dedicated macOS jobs or matrix entries and keep supporting suites in separate jobs so CI can parallelize work without Linux x64 browser-runner contention stretching release validation.
 - GitHub Actions pipelines must expose explicit staged jobs with readable names such as restore, build, supporting tests, browser tests, release publish, and deploy; vague single-job `validate` graphs are not acceptable when the user needs to see pipeline phases clearly in the Actions UI.
+- GitHub Actions browser-test matrix jobs must use the suite name itself as the visible job name, such as `Shell`, `Studio`, `Editor`, or `Reader`; do not wrap it in long labels like `Run Browser Suite (...)` because GitHub truncates the useful part.
 - When monitoring long-running GitHub Actions jobs from the terminal, poll with coarse waits of roughly `3-5` minutes between checks; frequent short-interval polling is noise and does not help on multi-minute browser suites.
 - Browser acceptance tests must stay on the production-shaped runtime path; do not add or keep `?wasm-debug=1` or similar debug-query scenarios in automated acceptance coverage unless the user explicitly asks for that path.
 - Browser acceptance tests must be isolation-safe under in-suite parallelism: each scenario must create and own its own script, storage, and browser context state instead of mutating shared documents, shared pages, or leftover browser storage from another test.

tests/PrompterOne.Web.UITests.Editor/Editor/EditorToolbarCoverageScenarios.cs

@@ -12,12 +12,19 @@ public enum EditorScenarioSelectionMode
 public sealed record EditorCommandScenario(
     string TestId,
     string? MenuTriggerTestId,
+    string? MenuPanelTestId,
     EditorCommandRequest Command,
-    EditorScenarioSelectionMode SelectionMode);
+    EditorScenarioSelectionMode SelectionMode)
+{
+    public override string ToString() => TestId;
+}
 
 public sealed record EditorMenuScenario(
     string TriggerTestId,
-    string PanelTestId);
+    string PanelTestId)
+{
+    public override string ToString() => TriggerTestId;
+}
 
 internal static class EditorToolbarCoverageScenarios
 {
@@ -54,6 +61,7 @@ private static IEnumerable<EditorCommandScenario> BuildFloatingDirectCommandScen
             .Select(action => new EditorCommandScenario(
                 action.TestId!,
                 null,
+                null,
                 action.Command!,
                 GetFloatingSelectionMode(action.Command!)));
 
@@ -65,6 +73,7 @@ private static IEnumerable<EditorCommandScenario> BuildFloatingMenuCommandScenar
                     .Select(action => new EditorCommandScenario(
                         action.TestId!,
                         menu.TriggerTestId,
+                        menu.PanelTestId,
                         action.Command!,
                         GetFloatingSelectionMode(action.Command!)))));
 
@@ -74,7 +83,7 @@ private static IReadOnlyList<EditorCommandScenario> BuildToolbarCommandScenarios
 
         foreach (var section in EditorToolbarCatalog.Sections)
         {
-            scenarios.AddRange(BuildSectionCommandScenarios(section.MainActions, null));
+            scenarios.AddRange(BuildSectionCommandScenarios(section.MainActions, null, null));
 
             if (!string.IsNullOrWhiteSpace(section.MainActions.FirstOrDefault(action => action.ActionType == EditorToolbarActionType.ToggleMenu)?.TestId))
             {
@@ -84,7 +93,7 @@ private static IReadOnlyList<EditorCommandScenario> BuildToolbarCommandScenarios
 
                 foreach (var group in section.DropdownGroups)
                 {
-                    scenarios.AddRange(BuildSectionCommandScenarios(group.Actions, menuTriggerTestId));
+                    scenarios.AddRange(BuildSectionCommandScenarios(group.Actions, menuTriggerTestId, section.DropdownTestId));
                 }
             }
         }
@@ -94,12 +103,14 @@ private static IReadOnlyList<EditorCommandScenario> BuildToolbarCommandScenarios
 
     private static IEnumerable<EditorCommandScenario> BuildSectionCommandScenarios(
         IReadOnlyList<EditorToolbarActionDescriptor> actions,
-        string? menuTriggerTestId) =>
+        string? menuTriggerTestId,
+        string? menuPanelTestId) =>
         actions
             .Where(action => action.ActionType == EditorToolbarActionType.Command && action.Command is not null && !string.IsNullOrWhiteSpace(action.TestId))
             .Select(action => new EditorCommandScenario(
                 action.TestId!,
                 menuTriggerTestId,
+                menuPanelTestId,
                 action.Command!,
                 GetSelectionMode(action.Command!)));
 

tests/PrompterOne.Web.UITests.Editor/Editor/EditorToolbarCoverageTests.cs

@@ -21,89 +21,155 @@ public sealed class EditorToolbarCoverageTests(StandaloneAppFixture fixture)
     public static IEnumerable<EditorCommandScenario> FloatingCommandScenarios => EditorToolbarCoverageScenarios.FloatingCommandScenarios;
 
     [Test]
-    [MethodDataSource(nameof(MenuScenarios))]
-    public async Task EditorToolbar_MenuTrigger_ExposesExpectedBehavior(EditorMenuScenario scenario)
+    public async Task EditorToolbar_MenuTriggers_ExposeExpectedBehavior()
     {
         await UiPageScenarioDriver.RunWithIsolatedPageRetryAsync(
             _fixture,
             async page =>
             {
                 await OpenEditorAsync(page);
-                await page.GetByTestId(scenario.TriggerTestId).ClickAsync();
-                await Expect(page.GetByTestId(scenario.PanelTestId))
-                    .ToBeVisibleAsync(new() { Timeout = BrowserTestConstants.Timing.FastVisibleTimeoutMs });
+
+                foreach (var scenario in MenuScenarios)
+                {
+                    await RunCoverageStepAsync(
+                        scenario.TriggerTestId,
+                        async () =>
+                        {
+                            await UiInteractionDriver.ClickAndWaitForVisibleAsync(
+                                page.GetByTestId(scenario.TriggerTestId),
+                                page.GetByTestId(scenario.PanelTestId));
+                            await page.Keyboard.PressAsync("Escape");
+                        });
+                }
             },
-            $"Toolbar menu coverage failed for scenario '{scenario.TriggerTestId}'.");
+            "Toolbar menu coverage failed.");
     }
 
     [Test]
-    [MethodDataSource(nameof(FloatingMenuScenarios))]
-    public async Task EditorToolbar_FloatingMenuTrigger_ExposesExpectedBehavior(EditorMenuScenario scenario)
+    public async Task EditorToolbar_FloatingMenuTriggers_ExposeExpectedBehavior()
     {
         await UiPageScenarioDriver.RunWithIsolatedPageRetryAsync(
             _fixture,
             async page =>
             {
                 await OpenEditorAsync(page);
-                await SetSourceTextAndSelectPhraseAsync(page, BrowserTestSource.AlphaSource, BrowserTestSource.AlphaToken);
-                await Expect(page.GetByTestId(UiTestIds.Editor.FloatingBar))
-                    .ToBeVisibleAsync(new() { Timeout = BrowserTestConstants.Timing.FastVisibleTimeoutMs });
-                await page.GetByTestId(scenario.TriggerTestId).ClickAsync();
-                await Expect(page.GetByTestId(scenario.PanelTestId))
-                    .ToBeVisibleAsync(new() { Timeout = BrowserTestConstants.Timing.FastVisibleTimeoutMs });
+
+                foreach (var scenario in FloatingMenuScenarios)
+                {
+                    await RunCoverageStepAsync(
+                        scenario.TriggerTestId,
+                        async () =>
+                        {
+                            await SetSourceTextAndSelectPhraseAsync(page, BrowserTestSource.AlphaSource, BrowserTestSource.AlphaToken);
+                            await Expect(page.GetByTestId(UiTestIds.Editor.FloatingBar))
+                                .ToBeVisibleAsync(new() { Timeout = BrowserTestConstants.Timing.FastVisibleTimeoutMs });
+                            await UiInteractionDriver.ClickAndWaitForVisibleAsync(
+                                page.GetByTestId(scenario.TriggerTestId),
+                                page.GetByTestId(scenario.PanelTestId),
+                                noWaitAfter: true);
+                            await page.Keyboard.PressAsync("Escape");
+                        });
+                }
             },
-            $"Floating toolbar menu coverage failed for scenario '{scenario.TriggerTestId}'.");
+            "Floating toolbar menu coverage failed.");
     }
 
     [Test]
-    [MethodDataSource(nameof(ToolbarCommandScenarios))]
-    public async Task EditorToolbar_CommandButton_MutatesSource(EditorCommandScenario scenario)
+    public async Task EditorToolbar_CommandButtons_MutateSource()
     {
         await UiPageScenarioDriver.RunWithIsolatedPageRetryAsync(
             _fixture,
             async page =>
             {
                 await OpenEditorAsync(page);
-                await PrepareScenarioAsync(page, scenario);
-                if (!string.IsNullOrWhiteSpace(scenario.MenuTriggerTestId))
+
+                foreach (var scenario in ToolbarCommandScenarios)
                 {
-                    await page.GetByTestId(scenario.MenuTriggerTestId).ClickAsync();
+                    await RunCoverageStepAsync(
+                        scenario.TestId,
+                        async () =>
+                        {
+                            await PrepareScenarioAsync(page, scenario);
+                            if (!string.IsNullOrWhiteSpace(scenario.MenuTriggerTestId))
+                            {
+                                await OpenScenarioMenuAsync(page, scenario);
+                            }
+
+                            var beforeValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
+                            await UiInteractionDriver.ClickAndContinueAsync(page.GetByTestId(scenario.TestId));
+                            var afterValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
+
+                            await AssertCommandMutation(scenario, beforeValue, afterValue);
+                        });
                 }
-
-                var beforeValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
-                await page.GetByTestId(scenario.TestId).ClickAsync();
-                var afterValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
-
-                await AssertCommandMutation(scenario, beforeValue, afterValue);
             },
-            $"Toolbar command coverage failed for scenario '{scenario.TestId}'.");
+            "Toolbar command coverage failed.");
     }
 
     [Test]
-    [MethodDataSource(nameof(FloatingCommandScenarios))]
-    public async Task EditorToolbar_FloatingCommandButton_MutatesSource(EditorCommandScenario scenario)
+    public async Task EditorToolbar_FloatingCommandButtons_MutateSource()
     {
         await UiPageScenarioDriver.RunWithIsolatedPageRetryAsync(
             _fixture,
             async page =>
             {
                 await OpenEditorAsync(page);
-                await PrepareScenarioAsync(page, scenario);
-                await Expect(page.GetByTestId(UiTestIds.Editor.FloatingBar))
-                    .ToBeVisibleAsync(new() { Timeout = BrowserTestConstants.Timing.FastVisibleTimeoutMs });
-                await page.WaitForTimeoutAsync(BrowserTestConstants.Timing.FloatingToolbarSettleDelayMs);
-                if (!string.IsNullOrWhiteSpace(scenario.MenuTriggerTestId))
+
+                foreach (var scenario in FloatingCommandScenarios)
                 {
-                    await page.GetByTestId(scenario.MenuTriggerTestId).ClickAsync();
+                    await RunCoverageStepAsync(
+                        scenario.TestId,
+                        async () =>
+                        {
+                            await PrepareScenarioAsync(page, scenario);
+                            await Expect(page.GetByTestId(UiTestIds.Editor.FloatingBar))
+                                .ToBeVisibleAsync(new() { Timeout = BrowserTestConstants.Timing.FastVisibleTimeoutMs });
+                            if (!string.IsNullOrWhiteSpace(scenario.MenuTriggerTestId))
+                            {
+                                await OpenScenarioMenuAsync(page, scenario, noWaitAfter: true);
+                            }
+
+                            var beforeValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
+                            await UiInteractionDriver.ClickAndContinueAsync(page.GetByTestId(scenario.TestId), noWaitAfter: true);
+                            var afterValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
+
+                            await AssertCommandMutation(scenario, beforeValue, afterValue);
+                        });
                 }
+            },
+            "Floating toolbar coverage failed.");
+    }
+
+    private static async Task RunCoverageStepAsync(string scenarioId, Func<Task> step)
+    {
+        try
+        {
+            await step();
+        }
+        catch (Exception exception)
+        {
+            throw new InvalidOperationException($"Editor toolbar coverage step failed for '{scenarioId}'.", exception);
+        }
+    }
 
-                var beforeValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
-                await page.GetByTestId(scenario.TestId).ClickAsync();
-                var afterValue = await EditorMonacoDriver.SourceInput(page).InputValueAsync();
+    private static async Task OpenScenarioMenuAsync(IPage page, EditorCommandScenario scenario, bool noWaitAfter = false)
+    {
+        if (string.IsNullOrWhiteSpace(scenario.MenuTriggerTestId))
+        {
+            return;
+        }
 
-                await AssertCommandMutation(scenario, beforeValue, afterValue);
-            },
-            $"Floating toolbar coverage failed for scenario '{scenario.TestId}'.");
+        var trigger = page.GetByTestId(scenario.MenuTriggerTestId);
+        if (string.IsNullOrWhiteSpace(scenario.MenuPanelTestId))
+        {
+            await UiInteractionDriver.ClickAndContinueAsync(trigger, noWaitAfter);
+            return;
+        }
+
+        await UiInteractionDriver.ClickAndWaitForVisibleAsync(
+            trigger,
+            page.GetByTestId(scenario.MenuPanelTestId),
+            noWaitAfter);
     }
 
     private static async Task AssertCommandMutation(EditorCommandScenario scenario, string beforeValue, string afterValue)

tests/PrompterOne.Web.UITests.Editor/Editor/EditorToolbarDropdownPaintTests.cs

@@ -122,5 +122,8 @@ private sealed class DropdownHitTestResult
     public sealed record DropdownPaintScenario(
         int ScenarioIndex,
         string TriggerTestId,
-        string PanelTestId);
+        string PanelTestId)
+    {
+        public override string ToString() => TriggerTestId;
+    }
 }