@testspectra/cli 1.1.8-rc.2 → 1.1.8-rc.4

package/templates/default/specs/ApiInterception/TC-0008-fetch-mocking/web.test.ts

@@ -1,31 +1,31 @@
-it("Mock and assert GET API requests using browser.intercept", async () => {
-  // Navigate to API Fetch section
-  await MatchersPage.open("api-fetch");
-
-  // The app fetches the demo server's own self-hosted endpoint (/api/posts) — served by the
-  // built-in demo app (started with `--demo`), so no external network is involved. Clear any mock
-  // left registered by an earlier test in this same continuous session before adding this one,
-  // since rules aren't scoped per-test and the first matching rule wins.
-  Spectra.clearMocks();
-  const mock = await Spectra.intercept(
-    "api/posts",
-    "GET",
-    Fixture.apiData.mockPosts
-  );
-
-  // Trigger fetch button
-  await MatchersPage.fetchApiButton.click();
-
-  // Assert status and mocked elements
-  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK");
-  await MatchersPage.fetchedItems.shouldHaveLength(Fixture.apiData.mockPosts.length);
-  await MatchersPage.fetchedItems.first().shouldContainText(Fixture.apiData.mockPosts[0].title);
-
-  // Dynamically update fixture response
-  await mock.respondWith([
-    { id: 99, title: "Dynamic Updated Mock Title", body: "Updated on the fly" }
-  ]);
-  await MatchersPage.fetchApiButton.click();
-  await MatchersPage.fetchedItems.shouldHaveLength(1);
-  await MatchersPage.fetchedItems.first().shouldContainText("Dynamic Updated Mock Title");
-});
+it("Mock and assert GET API requests using browser.intercept", async () => {
+  // Navigate to API Fetch section
+  await MatchersPage.open("api-fetch");
+
+  // The app fetches the demo server's own self-hosted endpoint (/api/posts) — served by the
+  // built-in demo app (started with `--demo`), so no external network is involved. Clear any mock
+  // left registered by an earlier test in this same continuous session before adding this one,
+  // since rules aren't scoped per-test and the first matching rule wins.
+  Spectra.clearMocks();
+  const mock = await Spectra.intercept(
+    "api/posts",
+    "GET",
+    Fixture.apiData.mockPosts
+  );
+
+  // Trigger fetch button
+  await MatchersPage.fetchApiButton.click();
+
+  // Assert status and mocked elements
+  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK");
+  await MatchersPage.fetchedItems.shouldHaveLength(Fixture.apiData.mockPosts.length);
+  await MatchersPage.fetchedItems.first().shouldContainText(Fixture.apiData.mockPosts[0].title);
+
+  // Dynamically update fixture response
+  await mock.respondWith([
+    { id: 99, title: "Dynamic Updated Mock Title", body: "Updated on the fly" }
+  ]);
+  await MatchersPage.fetchApiButton.click();
+  await MatchersPage.fetchedItems.shouldHaveLength(1);
+  await MatchersPage.fetchedItems.first().shouldContainText("Dynamic Updated Mock Title");
+});

package/templates/default/specs/ApiInterception/TC-0009-post-mocking/android.test.ts

@@ -1,3 +1,3 @@
-it('Mock and assert POST API requests using browser.intercept', async () => {
-  // TODO: Implement test steps and assertions
-});
+it('Mock and assert POST API requests using browser.intercept', async () => {
+  // TODO: Implement test steps and assertions
+});

package/templates/default/specs/ApiInterception/TC-0009-post-mocking/common.test.ts

@@ -1,3 +1,3 @@
-it('Mock and assert POST API requests using browser.intercept', async () => {
-  // TODO: Implement test steps and assertions
-});
+it('Mock and assert POST API requests using browser.intercept', async () => {
+  // TODO: Implement test steps and assertions
+});

package/templates/default/specs/ApiInterception/TC-0009-post-mocking/mobile.test.ts

@@ -1,27 +1,27 @@
-it("Mock and assert POST API requests using browser.intercept", async () => {
-  // Navigate to API POST section
-  await MatchersPage.open("api-post");
-
-  // Setup POST API interception with status 201 — the app posts to the host demo server's
-  // self-hosted endpoint (http://localhost:5200/api/posts), transparently routed through the
-  // worker's mock proxy via the device's global HTTP proxy set up at bootstrap.
-  Spectra.clearMocks();
-  await Spectra.intercept(
-    "api/posts",
-    "POST",
-    Fixture.apiData.mockPostResponse,
-    { statusCode: 201 }
-  );
-
-  // Fill in form fields from Fixture
-  await MatchersPage.postTitleInput.type(Fixture.apiData.mockNewPost.title);
-  await MatchersPage.postBodyInput.type(Fixture.apiData.mockNewPost.body);
-
-  // Submit POST form
-  await MatchersPage.submitPostButton.click();
-
-  // Assert response elements and status
-  await MatchersPage.postStatusBadge.shouldHaveText("201 Created");
-  await MatchersPage.postSuccessBanner.shouldBeVisible();
-  await MatchersPage.postResponseJson.shouldContainText(Fixture.apiData.mockNewPost.title);
-});
+it("Mock and assert POST API requests using browser.intercept", async () => {
+  // Navigate to API POST section
+  await MatchersPage.open("api-post");
+
+  // Setup POST API interception with status 201 — the app posts to the host demo server's
+  // self-hosted endpoint (http://localhost:5200/api/posts), transparently routed through the
+  // worker's mock proxy via the device's global HTTP proxy set up at bootstrap.
+  Spectra.clearMocks();
+  await Spectra.intercept(
+    "api/posts",
+    "POST",
+    Fixture.apiData.mockPostResponse,
+    { statusCode: 201 }
+  );
+
+  // Fill in form fields from Fixture
+  await MatchersPage.postTitleInput.type(Fixture.apiData.mockNewPost.title);
+  await MatchersPage.postBodyInput.type(Fixture.apiData.mockNewPost.body);
+
+  // Submit POST form
+  await MatchersPage.submitPostButton.click();
+
+  // Assert response elements and status
+  await MatchersPage.postStatusBadge.shouldHaveText("201 Created");
+  await MatchersPage.postSuccessBanner.shouldBeVisible();
+  await MatchersPage.postResponseJson.shouldContainText(Fixture.apiData.mockNewPost.title);
+});

package/templates/default/specs/ApiInterception/TC-0009-post-mocking/spec.md

@@ -1,19 +1,19 @@
----
-id: TC-0009-post-mocking
-title: Mock and assert POST API requests using browser.intercept
-priority: High
-caseType: Positive
-status: ready-for-automation
-coverage:
-  web: automated
-  mobile: automated
----
-
-# Mock and assert POST API requests using browser.intercept
-
-## Test Steps
-1. Open API POST section in matchers page
-2. Intercept POST /api/posts with mock response returning 201 status
-3. Fill post title and post body inputs from fixture
-4. Click submit POST button
-5. Assert status badge displays 201 Created and response JSON contains new title
+---
+id: TC-0009-post-mocking
+title: Mock and assert POST API requests using browser.intercept
+priority: High
+caseType: Positive
+status: ready-for-automation
+coverage:
+  web: automated
+  mobile: automated
+---
+
+# Mock and assert POST API requests using browser.intercept
+
+## Test Steps
+1. Open API POST section in matchers page
+2. Intercept POST /api/posts with mock response returning 201 status
+3. Fill post title and post body inputs from fixture
+4. Click submit POST button
+5. Assert status badge displays 201 Created and response JSON contains new title

package/templates/default/specs/ApiInterception/TC-0009-post-mocking/web.test.ts

@@ -1,26 +1,26 @@
-it("Mock and assert POST API requests using browser.intercept", async () => {
-  // Navigate to API POST section
-  await MatchersPage.open("api-post");
-
-  // Setup POST API interception with status 201 — the app posts to the demo server's own
-  // self-hosted endpoint (/api/posts), no external network involved.
-  Spectra.clearMocks();
-  await Spectra.intercept(
-    "api/posts",
-    "POST",
-    Fixture.apiData.mockPostResponse,
-    { statusCode: 201 }
-  );
-
-  // Fill in form fields from Fixture
-  await MatchersPage.postTitleInput.type(Fixture.apiData.mockNewPost.title);
-  await MatchersPage.postBodyInput.type(Fixture.apiData.mockNewPost.body);
-
-  // Submit POST form
-  await MatchersPage.submitPostButton.click();
-
-  // Assert response elements and status
-  await MatchersPage.postStatusBadge.shouldHaveText("201 Created");
-  await MatchersPage.postSuccessBanner.shouldBeVisible();
-  await MatchersPage.postResponseJson.shouldContainText(Fixture.apiData.mockNewPost.title);
-});
+it("Mock and assert POST API requests using browser.intercept", async () => {
+  // Navigate to API POST section
+  await MatchersPage.open("api-post");
+
+  // Setup POST API interception with status 201 — the app posts to the demo server's own
+  // self-hosted endpoint (/api/posts), no external network involved.
+  Spectra.clearMocks();
+  await Spectra.intercept(
+    "api/posts",
+    "POST",
+    Fixture.apiData.mockPostResponse,
+    { statusCode: 201 }
+  );
+
+  // Fill in form fields from Fixture
+  await MatchersPage.postTitleInput.type(Fixture.apiData.mockNewPost.title);
+  await MatchersPage.postBodyInput.type(Fixture.apiData.mockNewPost.body);
+
+  // Submit POST form
+  await MatchersPage.submitPostButton.click();
+
+  // Assert response elements and status
+  await MatchersPage.postStatusBadge.shouldHaveText("201 Created");
+  await MatchersPage.postSuccessBanner.shouldBeVisible();
+  await MatchersPage.postResponseJson.shouldContainText(Fixture.apiData.mockNewPost.title);
+});

package/templates/default/specs/ApiInterception/TC-0012-direct-and-late-response/common.test.ts

@@ -1,30 +1,30 @@
-it("Intercept a direct (immediate) response and a late (delayed) response using Fixture data", async () => {
-  await MatchersPage.open("api-fetch");
-
-  // The app fetches the self-hosted demo endpoint (/api/posts on web, the same path served by
-  // the demo server and reached through the device proxy on mobile) — no external network, so
-  // there's no upstream latency leaking into the "immediate" assertion below. On web, CDP's
-  // Fetch domain intercepts it; on Android, the device's global HTTP proxy routes it through the
-  // same worker-side mock engine. Neither platform needs the app, or this test, to know anything
-  // special about being under test.
-  Spectra.clearMocks();
-
-  // Direct (immediate) response — Fixture data returned with no artificial latency.
-  const mock = await Spectra.intercept("api/posts", "GET", Fixture.apiData.mockPosts);
-  await MatchersPage.fetchApiButton.click();
-  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK");
-  await MatchersPage.fetchedItems.shouldHaveLength(Fixture.apiData.mockPosts.length);
-  await MatchersPage.fetchedItems.first().shouldContainText(Fixture.apiData.mockPosts[0].title);
-
-  // Late (delayed) response — same mock rule, switched to hold the response back via `delayMs`.
-  // The loading indicator must still be visible right after the click, proving this is real
-  // network-level latency (the request genuinely stays pending) rather than a client-side-only
-  // spinner timer. The delay is set past the default assertion timeout on purpose, to demonstrate
-  // the per-assertion `{ timeoutMs }` override below — without it, these assertions would fail-fast
-  // before the delayed response ever arrives.
-  await mock.respondWith(Fixture.apiData.mockPosts, { delayMs: 2500 });
-  await MatchersPage.fetchApiButton.click();
-  await MatchersPage.fetchLoadingIndicator.shouldBeVisible();
-  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK", { timeoutMs: 3500 });
-  await MatchersPage.fetchedItems.shouldHaveLength(Fixture.apiData.mockPosts.length, { timeoutMs: 3500 });
-});
+it("Intercept a direct (immediate) response and a late (delayed) response using Fixture data", async () => {
+  await MatchersPage.open("api-fetch");
+
+  // The app fetches the self-hosted demo endpoint (/api/posts on web, the same path served by
+  // the demo server and reached through the device proxy on mobile) — no external network, so
+  // there's no upstream latency leaking into the "immediate" assertion below. On web, CDP's
+  // Fetch domain intercepts it; on Android, the device's global HTTP proxy routes it through the
+  // same worker-side mock engine. Neither platform needs the app, or this test, to know anything
+  // special about being under test.
+  Spectra.clearMocks();
+
+  // Direct (immediate) response — Fixture data returned with no artificial latency.
+  const mock = await Spectra.intercept("api/posts", "GET", Fixture.apiData.mockPosts);
+  await MatchersPage.fetchApiButton.click();
+  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK");
+  await MatchersPage.fetchedItems.shouldHaveLength(Fixture.apiData.mockPosts.length);
+  await MatchersPage.fetchedItems.first().shouldContainText(Fixture.apiData.mockPosts[0].title);
+
+  // Late (delayed) response — same mock rule, switched to hold the response back via `delayMs`.
+  // The loading indicator must still be visible right after the click, proving this is real
+  // network-level latency (the request genuinely stays pending) rather than a client-side-only
+  // spinner timer. The delay is set past the default assertion timeout on purpose, to demonstrate
+  // the per-assertion `{ timeoutMs }` override below — without it, these assertions would fail-fast
+  // before the delayed response ever arrives.
+  await mock.respondWith(Fixture.apiData.mockPosts, { delayMs: 2500 });
+  await MatchersPage.fetchApiButton.click();
+  await MatchersPage.fetchLoadingIndicator.shouldBeVisible();
+  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK", { timeoutMs: 3500 });
+  await MatchersPage.fetchedItems.shouldHaveLength(Fixture.apiData.mockPosts.length, { timeoutMs: 3500 });
+});

package/templates/default/specs/ApiInterception/TC-0012-direct-and-late-response/spec.md

@@ -1,22 +1,22 @@
----
-id: TC-0012-direct-and-late-response
-title: Intercept a direct (immediate) response and a late (delayed) response using Fixture data
-priority: High
-caseType: Positive
-status: ready-for-automation
-coverage:
-  web: automated
-  mobile: automated
----
-
-# Intercept a direct (immediate) response and a late (delayed) response using Fixture data
-
-## Test Steps
-1. Open the API fetch section in the matchers page
-2. Intercept GET /api/posts with mock posts fixture data
-3. Click the fetch API button
-4. Assert the status badge displays 200 OK and the immediate fixture items render
-5. Update the mock response with an artificial 50ms delay
-6. Click the fetch API button
-7. Assert the loading indicator is visible while the request is held
-8. Assert the status badge displays 200 OK and the delayed fixture items render
+---
+id: TC-0012-direct-and-late-response
+title: Intercept a direct (immediate) response and a late (delayed) response using Fixture data
+priority: High
+caseType: Positive
+status: ready-for-automation
+coverage:
+  web: automated
+  mobile: automated
+---
+
+# Intercept a direct (immediate) response and a late (delayed) response using Fixture data
+
+## Test Steps
+1. Open the API fetch section in the matchers page
+2. Intercept GET /api/posts with mock posts fixture data
+3. Click the fetch API button
+4. Assert the status badge displays 200 OK and the immediate fixture items render
+5. Update the mock response with an artificial 50ms delay
+6. Click the fetch API button
+7. Assert the loading indicator is visible while the request is held
+8. Assert the status badge displays 200 OK and the delayed fixture items render

package/templates/default/specs/ApiInterception/TC-0013-real-network-call-recorded/common.test.ts

@@ -1,27 +1,27 @@
-it("Make a genuine (non-intercepted) network call and verify it is recorded", async () => {
-  await MatchersPage.open("api-fetch");
-
-  // Deliberately no Spectra.intercept() call — this is a genuine request that actually leaves
-  // the app and hits a real server, not a mock. It targets the demo server's own self-hosted
-  // endpoint (started with `--demo`) instead of an external public API, so it's deterministic
-  // and fast everywhere. On web the browser reaches localhost directly; on Android it's
-  // transparently routed through the device's global HTTP proxy with no matching mock rule, so
-  // the worker's proxy just forwards it for real. Clear any mock a previous test in this suite
-  // left registered (e.g. against /api/posts) so it can't accidentally catch this request too —
-  // this test uses a different resource (/api/todos/1) specifically to avoid that collision,
-  // plus a cache-busting query param so a repeat run doesn't get a 304 Not Modified from the
-  // device/browser's own HTTP cache.
-  Spectra.clearMocks();
-  const cacheBuster = Date.now();
-  await MatchersPage.fetchCustomUrlInput.type(`http://localhost:5200/api/todos/1?cb=${cacheBuster}`);
-  await MatchersPage.fetchApiButton.click();
-  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK");
-
-  const entry = Spectra.browser.recordedNetwork.find((e) => e.url.includes(`todos/1?cb=${cacheBuster}`));
-  if (!entry) {
-    throw new Error("Expected a recorded network entry for the real demo-server call, found none");
-  }
-  if (entry.status !== 200) {
-    throw new Error(`Expected recorded entry status 200, got ${entry.status}`);
-  }
-});
+it("Make a genuine (non-intercepted) network call and verify it is recorded", async () => {
+  await MatchersPage.open("api-fetch");
+
+  // Deliberately no Spectra.intercept() call — this is a genuine request that actually leaves
+  // the app and hits a real server, not a mock. It targets the demo server's own self-hosted
+  // endpoint (started with `--demo`) instead of an external public API, so it's deterministic
+  // and fast everywhere. On web the browser reaches localhost directly; on Android it's
+  // transparently routed through the device's global HTTP proxy with no matching mock rule, so
+  // the worker's proxy just forwards it for real. Clear any mock a previous test in this suite
+  // left registered (e.g. against /api/posts) so it can't accidentally catch this request too —
+  // this test uses a different resource (/api/todos/1) specifically to avoid that collision,
+  // plus a cache-busting query param so a repeat run doesn't get a 304 Not Modified from the
+  // device/browser's own HTTP cache.
+  Spectra.clearMocks();
+  const cacheBuster = Date.now();
+  await MatchersPage.fetchCustomUrlInput.type(`http://localhost:5200/api/todos/1?cb=${cacheBuster}`);
+  await MatchersPage.fetchApiButton.click();
+  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK");
+
+  const entry = Spectra.browser.recordedNetwork.find((e) => e.url.includes(`todos/1?cb=${cacheBuster}`));
+  if (!entry) {
+    throw new Error("Expected a recorded network entry for the real demo-server call, found none");
+  }
+  if (entry.status !== 200) {
+    throw new Error(`Expected recorded entry status 200, got ${entry.status}`);
+  }
+});

package/templates/default/specs/ApiInterception/TC-0013-real-network-call-recorded/spec.md

@@ -1,20 +1,20 @@
----
-id: TC-0013-real-network-call-recorded
-title: Make a genuine (non-intercepted) network call and verify it is recorded
-priority: High
-caseType: Positive
-status: ready-for-automation
-coverage:
-  web: automated
-  mobile: automated
----
-
-# Make a genuine (non-intercepted) network call and verify it is recorded
-
-## Test Steps
-1. Open the API fetch section in the matchers page
-2. Clear any active mocks left by a previous test
-3. Enter a real (non-intercepted) demo-server todo endpoint URL with a cache-busting query param
-4. Click the fetch API button
-5. Assert the status badge displays 200 OK
-6. Assert the network report records the genuine call with status 200
+---
+id: TC-0013-real-network-call-recorded
+title: Make a genuine (non-intercepted) network call and verify it is recorded
+priority: High
+caseType: Positive
+status: ready-for-automation
+coverage:
+  web: automated
+  mobile: automated
+---
+
+# Make a genuine (non-intercepted) network call and verify it is recorded
+
+## Test Steps
+1. Open the API fetch section in the matchers page
+2. Clear any active mocks left by a previous test
+3. Enter a real (non-intercepted) demo-server todo endpoint URL with a cache-busting query param
+4. Click the fetch API button
+5. Assert the status badge displays 200 OK
+6. Assert the network report records the genuine call with status 200

package/templates/default/specs/ApiInterception/TC-0015-mock-server-sent-events/spec.md

@@ -1,24 +1,24 @@
----
-id: TC-0015-mock-server-sent-events
-title: Mock a Server-Sent Events (EventSource) stream via the existing network-intercept engine
-priority: Medium
-caseType: Positive
-status: ready-for-automation
-coverage:
-  web: automated
-  mobile: unsupported
----
-
-# Mock a Server-Sent Events (EventSource) stream via the existing network-intercept engine
-
-Mobile coverage is `unsupported`: React Native has no built-in `EventSource` — a real project
-targeting mobile would add a userland SSE client library, at which point whether/how it's
-mockable depends entirely on that library's own networking implementation, not something
-TestSpectra's driver can generalize over.
-
-## Test Steps
-1. Open the SSE matcher section
-2. Intercept GET /api/sse-feed with a text/event-stream mock body
-3. Click the connect button
-4. Assert two SSE messages render
-5. Assert the first message contains "hello from mock SSE" and the last contains "second event"
+---
+id: TC-0015-mock-server-sent-events
+title: Mock a Server-Sent Events (EventSource) stream via the existing network-intercept engine
+priority: Medium
+caseType: Positive
+status: ready-for-automation
+coverage:
+  web: automated
+  mobile: unsupported
+---
+
+# Mock a Server-Sent Events (EventSource) stream via the existing network-intercept engine
+
+Mobile coverage is `unsupported`: React Native has no built-in `EventSource` — a real project
+targeting mobile would add a userland SSE client library, at which point whether/how it's
+mockable depends entirely on that library's own networking implementation, not something
+TestSpectra's driver can generalize over.
+
+## Test Steps
+1. Open the SSE matcher section
+2. Intercept GET /api/sse-feed with a text/event-stream mock body
+3. Click the connect button
+4. Assert two SSE messages render
+5. Assert the first message contains "hello from mock SSE" and the last contains "second event"

package/templates/default/specs/ApiInterception/TC-0015-mock-server-sent-events/web.test.ts

@@ -1,26 +1,26 @@
-it("Mock a Server-Sent Events (EventSource) stream via the existing network-intercept engine", async () => {
-  await MatchersPage.open("sse");
-
-  // EventSource's initial request is a plain HTTP GET under the hood — CDP's Fetch domain
-  // intercepts it exactly like any other fetch()/XHR request. Fulfilling it with a
-  // text/event-stream body delivers every "data: ...\n\n" block at once; the browser's own
-  // EventSource parser still splits that into individual "message" events and dispatches them
-  // just as it would for a real stream, which is the part this demo actually cares about.
-  //
-  // What this can't fake: `Fetch.fulfillRequest` delivers a complete, connection-closing
-  // response (there's no way to keep it open indefinitely the way a real SSE endpoint would), so
-  // the browser's EventSource treats that closure as a connection error shortly after — the
-  // events still arrive and get processed first, but the app's own "CONNECTED" status flips back
-  // to disconnected right after, same as it would after a real server unexpectedly closed the
-  // connection. So this test verifies the events were received, not that the connection stayed
-  // open — genuinely-persistent SSE isn't something a request/response-shaped mock can simulate.
-  await Spectra.intercept("/api/sse-feed", "GET", {
-    body: 'data: {"text":"hello from mock SSE"}\n\ndata: {"text":"second event"}\n\n',
-    headers: { "Content-Type": "text/event-stream" },
-  });
-
-  await Spectra.get("#sse-connect-btn").click();
-  await Spectra.getAll(".sse-message-item").shouldHaveLength(2);
-  await Spectra.getAll(".sse-message-item").first().shouldContainText("hello from mock SSE");
-  await Spectra.getAll(".sse-message-item").last().shouldContainText("second event");
-});
+it("Mock a Server-Sent Events (EventSource) stream via the existing network-intercept engine", async () => {
+  await MatchersPage.open("sse");
+
+  // EventSource's initial request is a plain HTTP GET under the hood — CDP's Fetch domain
+  // intercepts it exactly like any other fetch()/XHR request. Fulfilling it with a
+  // text/event-stream body delivers every "data: ...\n\n" block at once; the browser's own
+  // EventSource parser still splits that into individual "message" events and dispatches them
+  // just as it would for a real stream, which is the part this demo actually cares about.
+  //
+  // What this can't fake: `Fetch.fulfillRequest` delivers a complete, connection-closing
+  // response (there's no way to keep it open indefinitely the way a real SSE endpoint would), so
+  // the browser's EventSource treats that closure as a connection error shortly after — the
+  // events still arrive and get processed first, but the app's own "CONNECTED" status flips back
+  // to disconnected right after, same as it would after a real server unexpectedly closed the
+  // connection. So this test verifies the events were received, not that the connection stayed
+  // open — genuinely-persistent SSE isn't something a request/response-shaped mock can simulate.
+  await Spectra.intercept("/api/sse-feed", "GET", {
+    body: 'data: {"text":"hello from mock SSE"}\n\ndata: {"text":"second event"}\n\n',
+    headers: { "Content-Type": "text/event-stream" },
+  });
+
+  await Spectra.get("#sse-connect-btn").click();
+  await Spectra.getAll(".sse-message-item").shouldHaveLength(2);
+  await Spectra.getAll(".sse-message-item").first().shouldContainText("hello from mock SSE");
+  await Spectra.getAll(".sse-message-item").last().shouldContainText("second event");
+});

package/templates/default/specs/ApiInterception/TC-0016-bypass-websocket-with-app-level-mock/spec.md

@@ -1,37 +1,37 @@
----
-id: TC-0016-bypass-websocket-with-app-level-mock
-title: Bypass a real WebSocket connection via an app-level test-only mock flag
-priority: Medium
-caseType: Positive
-status: ready-for-automation
-coverage:
-  web: automated
-  mobile: unsupported
----
-
-# Bypass a real WebSocket connection via an app-level test-only mock flag
-
-**Why this isn't network-level interception like `Spectra.intercept()`:** a WebSocket connection
-starts as an HTTP `Upgrade` handshake and then becomes a raw bidirectional frame stream — it's
-never a single request/response CDP's `Fetch` domain can fulfill the way it fulfills a normal
-`fetch()`/`XHR`/`EventSource` request. Chrome DevTools Protocol's WebSocket-related events
-(`Network.webSocketCreated`, `webSocketFrameSent`/`webSocketFrameReceived`, etc.) are
-observation-only — CDP has no command that mocks or rewrites a WS frame in flight. This is a
-genuine protocol-level limitation, not a gap in this driver.
-
-The practical workaround, and what this demo shows: the app itself checks for a test-only global
-flag (`window.__mockWebSocketMessages`) and swaps in an in-memory fake socket when present,
-instead of opening a real connection. `Spectra.browser.evaluate()` sets that flag before the app
-connects. This is the same pattern used by Cypress/Playwright test suites for the same reason.
-
-Mobile coverage is `unsupported`: React Native's WebSocket implementation is a native module,
-not a page-context global reachable via a browser-style `evaluate()` call — a mobile equivalent
-would need the RN app's own WebSocket client wrapper to support a comparable test-only bypass.
-
-## Test Steps
-1. Open the WebSocket matcher section
-2. Set the app-level mock flag via browser.evaluate before the app connects
-3. Click the connect button
-4. Assert the connection status displays CONNECTED and two mocked frames render
-5. Click the disconnect button
-6. Assert the connection status displays DISCONNECTED
+---
+id: TC-0016-bypass-websocket-with-app-level-mock
+title: Bypass a real WebSocket connection via an app-level test-only mock flag
+priority: Medium
+caseType: Positive
+status: ready-for-automation
+coverage:
+  web: automated
+  mobile: unsupported
+---
+
+# Bypass a real WebSocket connection via an app-level test-only mock flag
+
+**Why this isn't network-level interception like `Spectra.intercept()`:** a WebSocket connection
+starts as an HTTP `Upgrade` handshake and then becomes a raw bidirectional frame stream — it's
+never a single request/response CDP's `Fetch` domain can fulfill the way it fulfills a normal
+`fetch()`/`XHR`/`EventSource` request. Chrome DevTools Protocol's WebSocket-related events
+(`Network.webSocketCreated`, `webSocketFrameSent`/`webSocketFrameReceived`, etc.) are
+observation-only — CDP has no command that mocks or rewrites a WS frame in flight. This is a
+genuine protocol-level limitation, not a gap in this driver.
+
+The practical workaround, and what this demo shows: the app itself checks for a test-only global
+flag (`window.__mockWebSocketMessages`) and swaps in an in-memory fake socket when present,
+instead of opening a real connection. `Spectra.browser.evaluate()` sets that flag before the app
+connects. This is the same pattern used by Cypress/Playwright test suites for the same reason.
+
+Mobile coverage is `unsupported`: React Native's WebSocket implementation is a native module,
+not a page-context global reachable via a browser-style `evaluate()` call — a mobile equivalent
+would need the RN app's own WebSocket client wrapper to support a comparable test-only bypass.
+
+## Test Steps
+1. Open the WebSocket matcher section
+2. Set the app-level mock flag via browser.evaluate before the app connects
+3. Click the connect button
+4. Assert the connection status displays CONNECTED and two mocked frames render
+5. Click the disconnect button
+6. Assert the connection status displays DISCONNECTED