chore(ci): quarantine always-red e2e and fail fast (#57951)

This commit is contained in:
Kit Langton
2026-10-22 14:10:16 -07:00
committed by GitHub
Unverified
parent 12d43d6959
commit 9899022996
15 changed files with 216 additions and 130 deletions
+23
View File
@@ -0,0 +1,23 @@
name: nightly-beta
# GitHub runs schedules only from the default branch (dev), so this fires once this file is on dev.
# It tests beta with the full suite on both OSes, then runs beta's quarantined browser tests.
on:
schedule:
- cron: "17 9 * * *"
workflow_dispatch:
permissions:
actions: write
jobs:
dispatch:
if: github.repository == 'anomalyco/opencode'
runs-on: ubuntu-latest
steps:
- name: Dispatch beta test runs
env:
GH_TOKEN: ${{ github.token }}
run: |
gh workflow run test.yml --repo "$GITHUB_REPOSITORY" --ref beta
gh workflow run test.yml --repo "$GITHUB_REPOSITORY" --ref beta -f quarantine=true
+32 -18
View File
@@ -7,11 +7,16 @@ on:
- beta
pull_request:
workflow_dispatch:
inputs:
quarantine:
description: Run only the quarantined browser tests (packages/app/e2e/QUARANTINE.md)
type: boolean
default: false
concurrency:
# Keep every run on dev so cancelled checks do not pollute the default branch
# commit history. PRs and other branches still share a group and cancel stale runs.
group: ${{ case(github.ref == 'refs/heads/dev', format('{0}-{1}', github.workflow, github.run_id), format('{0}-{1}', github.workflow, github.event.pull_request.number || github.ref)) }}
# A new push to a pull request cancels its stale run. Every push and manual run keeps its own group, so each
# dev and beta commit gets a verdict and a quarantine run never cancels a normal one.
group: ${{ case(github.event_name == 'pull_request', format('{0}-{1}', github.workflow, github.event.pull_request.number), format('{0}-{1}', github.workflow, github.run_id)) }}
cancel-in-progress: true
permissions:
@@ -56,6 +61,7 @@ jobs:
unit:
name: unit (${{ matrix.settings.name }})
if: ${{ !inputs.quarantine }}
strategy:
fail-fast: false
matrix:
@@ -141,6 +147,7 @@ jobs:
build:
name: build (${{ matrix.settings.name }})
if: ${{ !inputs.quarantine }}
strategy:
fail-fast: false
matrix:
@@ -206,17 +213,17 @@ jobs:
bun run script/service-smoke.ts --node
e2e-suite:
name: e2e (${{ matrix.settings.name }}, ${{ matrix.suite.id }})
name: e2e (${{ matrix.settings.name }}, ${{ matrix.suite.id }}${{ matrix.quarantine && ', quarantine' || '' }})
needs: affected
if: needs.affected.outputs.e2e == 'true'
# Quarantined tests are known red; their legs report without failing the e2e checks.
continue-on-error: ${{ matrix.quarantine }}
strategy:
fail-fast: false
matrix:
settings:
- name: linux
host: blacksmith-4vcpu-ubuntu-2404
- name: windows
host: blacksmith-4vcpu-windows-2025
# Beta PRs gate on Linux; Windows runs on pushes and manual runs (nightly-beta.yml dispatches beta).
settings: ${{ fromJSON(github.base_ref == 'beta' && '[{"name":"linux","host":"blacksmith-4vcpu-ubuntu-2404"}]' || '[{"name":"linux","host":"blacksmith-4vcpu-ubuntu-2404"},{"name":"windows","host":"blacksmith-4vcpu-windows-2025"}]') }}
quarantine: ${{ fromJSON(inputs.quarantine && '[true]' || '[false]') }}
# Playwright splits whole spec files across shards by test count, not duration. Every app-N
# entry must use the same total, and the entries must cover 1..total. The service worker suite
# reuses shard 2's production build. Each component suite runs once per OS in its own leg, so the
@@ -231,6 +238,9 @@ jobs:
runs-on: ${{ matrix.settings.host }}
env:
PLAYWRIGHT_BROWSERS_PATH: ${{ github.workspace }}/.playwright-browsers
# Beta only (packages/app/e2e/QUARANTINE.md): gate legs skip quarantined tests, retry once and stop after 8
# failures; quarantine legs run only those tests, to the end. Other branches keep the config defaults.
PLAYWRIGHT_ARGS: ${{ matrix.quarantine && '--grep @quarantine --pass-with-no-tests --retries=1' || (github.base_ref == 'beta' || github.ref == 'refs/heads/beta') && '--grep-invert @quarantine --max-failures=8 --retries=1' || '' }}
defaults:
run:
shell: bash
@@ -274,36 +284,36 @@ jobs:
- name: Run app e2e tests against production build
if: matrix.suite.shard
run: bun --cwd packages/app test:e2e:built --shard=${{ matrix.suite.shard }}
run: bun --cwd packages/app test:e2e:built --shard=${{ matrix.suite.shard }} ${{ env.PLAYWRIGHT_ARGS }}
env:
CI: true
timeout-minutes: 15
timeout-minutes: ${{ (matrix.quarantine || github.base_ref == 'beta' || github.ref == 'refs/heads/beta') && 10 || 15 }}
- name: Verify service worker precaching and upgrades
if: matrix.suite.shard == '2/2'
if: matrix.suite.shard == '2/2' && !matrix.quarantine
working-directory: packages/app
run: bunx playwright test --config e2e/service-worker/playwright.config.ts
timeout-minutes: 5
- name: Run session UI component tests
if: matrix.suite.id == 'session-ui-components'
run: bun --cwd packages/session-ui test:components
run: bun --cwd packages/session-ui test:components ${{ env.PLAYWRIGHT_ARGS }}
env:
CI: true
timeout-minutes: 15
timeout-minutes: ${{ (matrix.quarantine || github.base_ref == 'beta' || github.ref == 'refs/heads/beta') && 10 || 15 }}
- name: Run app component tests
if: matrix.suite.id == 'app-components'
run: bun --cwd packages/app test:components
run: bun --cwd packages/app test:components ${{ env.PLAYWRIGHT_ARGS }}
env:
CI: true
timeout-minutes: 15
timeout-minutes: ${{ (matrix.quarantine || github.base_ref == 'beta' || github.ref == 'refs/heads/beta') && 10 || 15 }}
- name: Upload Playwright artifacts
if: always()
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
with:
name: playwright-${{ matrix.settings.name }}-${{ matrix.suite.id }}-${{ github.run_attempt }}
name: playwright-${{ matrix.settings.name }}-${{ matrix.suite.id }}${{ matrix.quarantine && '-quarantine' || '' }}-${{ github.run_attempt }}
if-no-files-found: ignore
retention-days: 7
path: |
@@ -319,7 +329,7 @@ jobs:
e2e:
name: e2e (${{ matrix.os }})
needs: [affected, e2e-suite]
if: ${{ !cancelled() }}
if: ${{ !cancelled() && !inputs.quarantine }}
strategy:
fail-fast: false
matrix:
@@ -332,5 +342,9 @@ jobs:
SUITES: ${{ needs.e2e-suite.result }}
EXPECTED: ${{ needs.affected.outputs.e2e == 'true' && 'success' || 'skipped' }}
run: |
if [ "${{ matrix.os }}" = windows ] && [ "${{ github.base_ref }}" = beta ]; then
echo "Windows browser tests run on beta pushes and nightly, not on beta pull requests"
exit 0
fi
echo "affected packages: $AFFECTED, browser test legs: $SUITES (expected $EXPECTED)"
test "$AFFECTED" = success && test "$SUITES" = "$EXPECTED"
@@ -59,50 +59,53 @@ for (const input of [
{ name: "offset-only", count: 1, rowHeight: 600, reveal: { scrollTop: 0 } },
{ name: "zero-height", count: 4, rowHeight: 60, reveal: {} },
]) {
story(`reveals ready measured rows after an ${input.name} reconnect`, async ({ page }) => {
await page.evaluate(
async ({ fixture, input }) => {
const { mountTimelineVirtualizer } = await import(fixture)
mountTimelineVirtualizer(input)
},
{ fixture, input },
)
const root = page.getByTestId("timeline-virtualizer-fixture")
const content = root.locator("[data-timeline-virtual-content]")
await expect(root).toHaveAttribute("data-observed-height", "180")
await expect(content).toHaveCSS("visibility", "hidden")
await expect(content.locator("[data-timeline-key]")).toHaveCount(1)
story(
`reveals ready measured rows after an ${input.name} reconnect${input.name === "offset-only" ? " @quarantine" : ""}`,
async ({ page }) => {
await page.evaluate(
async ({ fixture, input }) => {
const { mountTimelineVirtualizer } = await import(fixture)
mountTimelineVirtualizer(input)
},
{ fixture, input },
)
const root = page.getByTestId("timeline-virtualizer-fixture")
const content = root.locator("[data-timeline-virtual-content]")
await expect(root).toHaveAttribute("data-observed-height", "180")
await expect(content).toHaveCSS("visibility", "hidden")
await expect(content.locator("[data-timeline-key]")).toHaveCount(1)
if (input.name === "offset-only") {
await expect(root).toHaveAttribute("data-last-scroll-top", "484")
await root.locator("[data-scrollable]").dispatchEvent("wheel", { deltaY: -1 })
await expect(root.getByTestId("timeline-controls")).toHaveAttribute("data-pinned", "false")
}
if (input.name === "offset-only") {
await expect(root).toHaveAttribute("data-last-scroll-top", "484")
await root.locator("[data-scrollable]").dispatchEvent("wheel", { deltaY: -1 })
await expect(root.getByTestId("timeline-controls")).toHaveAttribute("data-pinned", "false")
}
if (input.name === "zero-height") {
await root.getByRole("button", { name: "Hide viewport", exact: true }).click()
// Wait for ResizeObserver to clear the actual range, not just for display:none.
await expect(root).toHaveAttribute("data-observed-height", "0")
await expect(content.locator("[data-timeline-key]")).toHaveCount(0)
}
if (input.name === "zero-height") {
await root.getByRole("button", { name: "Hide viewport", exact: true }).click()
// Wait for ResizeObserver to clear the actual range, not just for display:none.
await expect(root).toHaveAttribute("data-observed-height", "0")
await expect(content.locator("[data-timeline-key]")).toHaveCount(0)
}
await expect(root).not.toHaveAttribute("data-first-reveal")
const resizes = await root.getAttribute("data-viewport-resizes")
await root.getByRole("button", { name: "Reconnect ready rows", exact: true }).click()
await expect(content).toHaveCSS("visibility", "visible")
await expect(root).toHaveAttribute("data-first-reveal", /.+/)
expect(await root.evaluate((element) => JSON.parse(element.dataset.firstReveal!))).toMatchObject({
rows: input.count === 1 ? [0] : [0, 1, 2, 3],
pendingMarkdown: 0,
clipped: [],
viewportHeight: 180,
...input.reveal,
})
await expect(root).not.toHaveAttribute("data-first-reveal")
const resizes = await root.getAttribute("data-viewport-resizes")
await root.getByRole("button", { name: "Reconnect ready rows", exact: true }).click()
await expect(content).toHaveCSS("visibility", "visible")
await expect(root).toHaveAttribute("data-first-reveal", /.+/)
expect(await root.evaluate((element) => JSON.parse(element.dataset.firstReveal!))).toMatchObject({
rows: input.count === 1 ? [0] : [0, 1, 2, 3],
pendingMarkdown: 0,
clipped: [],
viewportHeight: 180,
...input.reveal,
})
if (input.name === "offset-only") {
// This repair must not depend on another native scroll or resize delivery.
await expect(root).toHaveAttribute("data-scrolls", "0")
await expect(root).toHaveAttribute("data-viewport-resizes", resizes!)
}
})
if (input.name === "offset-only") {
// This repair must not depend on another native scroll or resize delivery.
await expect(root).toHaveAttribute("data-scrolls", "0")
await expect(root).toHaveAttribute("data-viewport-resizes", resizes!)
}
},
)
}
+31 -28
View File
@@ -51,36 +51,39 @@ story("sizes provider options to their content", async ({ mount, page }) => {
for (const width of [360, 1200]) {
for (const direction of ["ltr", "rtl"]) {
for (const theme of ["light", "dark"]) {
story(`selects and confirms a provider at ${width}px in ${direction} ${theme}`, async ({ mount, page }) => {
await page.setViewportSize({ width, height: 900 })
story(
`selects and confirms a provider at ${width}px in ${direction} ${theme}${width === 360 ? " @quarantine" : ""}`,
async ({ mount, page }) => {
await page.setViewportSize({ width, height: 900 })
const component = await mount("app-current-session-surface--web-search-request", {
globals: { theme, direction },
})
const component = await mount("app-current-session-surface--web-search-request", {
globals: { theme, direction },
})
const card = component.getByRole("region", { name: "Third-party web search" })
const select = card.getByRole("button", { name: /^Search provider/ })
await expect(select).toBeEnabled()
await expect(card).toHaveCSS("direction", direction)
expect(await card.evaluate((node) => node.scrollWidth <= node.clientWidth)).toBe(true)
await select.focus()
await select.press("Enter")
const list = page.getByRole("listbox", { name: "Search provider", exact: true })
await expect(list).toHaveCSS("direction", direction)
await list.getByRole("option", { name: "Parallel", exact: true }).click()
await expect(select).toHaveText("Parallel")
await expect(card).toBeVisible()
await expect(component.getByRole("status")).toHaveText("Ready")
await expect(select).toBeFocused()
await select.press("Tab")
await expect(card.getByRole("button", { name: "Don’t use search", exact: true })).toBeFocused()
await page.keyboard.press("Tab")
const enable = card.getByRole("button", { name: "Enable", exact: true })
await expect(enable).toBeFocused()
await enable.press("Enter")
await expect(component.getByRole("status")).toHaveText("Web search selection (local only): parallel")
await expect(card).toHaveCount(0)
})
const card = component.getByRole("region", { name: "Third-party web search" })
const select = card.getByRole("button", { name: /^Search provider/ })
await expect(select).toBeEnabled()
await expect(card).toHaveCSS("direction", direction)
expect(await card.evaluate((node) => node.scrollWidth <= node.clientWidth)).toBe(true)
await select.focus()
await select.press("Enter")
const list = page.getByRole("listbox", { name: "Search provider", exact: true })
await expect(list).toHaveCSS("direction", direction)
await list.getByRole("option", { name: "Parallel", exact: true }).click()
await expect(select).toHaveText("Parallel")
await expect(card).toBeVisible()
await expect(component.getByRole("status")).toHaveText("Ready")
await expect(select).toBeFocused()
await select.press("Tab")
await expect(card.getByRole("button", { name: "Don’t use search", exact: true })).toBeFocused()
await page.keyboard.press("Tab")
const enable = card.getByRole("button", { name: "Enable", exact: true })
await expect(enable).toBeFocused()
await enable.press("Enter")
await expect(component.getByRole("status")).toHaveText("Web search selection (local only): parallel")
await expect(card).toHaveCount(0)
},
)
}
}
}
+42
View File
@@ -0,0 +1,42 @@
# Quarantined browser tests
Beta pull request and push runs skip the 23 tests tagged `@quarantine` (`--grep-invert @quarantine`). Most failed in every beta run, so they gave no signal and slowed every leg with retries. `dev` runs are unchanged.
To run only the quarantined tests, use `gh workflow run test.yml --ref beta -f quarantine=true`. Their legs report without failing the e2e checks. `nightly-beta.yml` dispatches that run, plus a full beta run, every night. GitHub fires schedules only from the default branch (`dev`), so the nightly run starts once that workflow is on `dev`; until then, dispatch by hand.
**Rule:** fix a quarantined test or delete it within 14 days of quarantine. When a fix lands, remove the tag and its row in the same pull request. Never quarantine a test that fails because of your own change; fix the test or the change.
Quarantined 2026-10-21, so the deadline is **2026-11-04**; the rows first seen red on 2026-10-22 were added that day and are due **2026-11-05**. "First red" is the earliest beta run seen failing; runs before 2026-10-20 05:32 UTC were not collected. "Unowned" means `git blame` points at the history import (#53822).
## App e2e (`packages/app/e2e`)
| Test | Failure signature | First red | Owner |
| ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ------------------ | ----------- |
| `regression/timeline-cache.spec.ts` › focuses Find in the selected cached timeline | `timeline-search-bar input` `toBeFocused()`: inactive | ≤ 2026-10-20 05:32 | unowned |
| `regression/timeline-cache.spec.ts` › disposes the old workspace's shell while destination history is loading | `[data-session-title]` text has a `smoke-project/` prefix | ≤ 2026-10-20 05:32 | unowned |
| `regression/mobile-timeline-scroll.spec.ts` › Pixel 7 › returns Home after scrolling the touch target out of view (touchEnd) | `Part 66.` `not.toBeInViewport()`: still in viewport | ≤ 2026-10-20 05:32 | unowned |
| `regression/mobile-timeline-scroll.spec.ts` › Pixel 7 › returns Home after scrolling the touch target out of view (touchCancel) | same | ≤ 2026-10-20 05:32 | unowned |
| `regression/mobile-timeline-scroll.spec.ts` › iPhone 13 › returns Home after scrolling the touch target out of view (touchEnd) | same | ≤ 2026-10-20 05:32 | unowned |
| `regression/mobile-timeline-scroll.spec.ts` › iPhone 13 › returns Home after scrolling the touch target out of view (touchCancel) | same | ≤ 2026-10-20 05:32 | unowned |
| `regression/new-session.spec.ts` › keeps the user message blue for a managed worktree | `user-message-text` color `rgb(245, 248, 255)`, received `rgb(242, 242, 242)` | ≤ 2026-10-20 11:29 | Luke Parker |
| `regression/new-session.spec.ts` › keeps the user message blue for the main root written with Windows case and separators | same | ≤ 2026-10-20 11:29 | Luke Parker |
| `regression/review.spec.ts` › open file tab browses, searches, and tracks missing files | file search request has an unexpected `directory` field | ≤ 2026-10-20 11:29 | unowned |
| `regression/review.spec.ts` › rereads a file each time an artifact link opens it | `first draft` never visible in `#review-panel` | ≤ 2026-10-20 11:29 | unowned |
| `regression/session-queue.spec.ts` › keeps finished tools above a pending steer follow-up | pending steer color `rgb(242, 242, 242)`, received `rgb(250, 250, 250)` | ≤ 2026-10-20 11:29 | unowned |
| `regression/tabs.spec.ts` › switching between busy sessions keeps the busy indicators and the activity capsule at rest | `html` keeps `data-test-capsule-missing` | ≤ 2026-10-20 05:32 | Kit Langton |
| `regression/review.spec.ts` › restores review state and the side-panel tab per session | heading `Alpha review state` not found | ≤ 2026-10-22 16:26 | unowned |
| `regression/session-queue.spec.ts` › reverting to another prompt replaces the file chips of an earlier restore | `Revert message` resolves to 2 buttons (strict mode) | ≤ 2026-10-22 16:26 | unowned |
| `regression/session-queue.spec.ts` › waiting steers group under one Pending line, each keeping its own actions beside its bubble | `Move to queue` resolves to 2 buttons (strict mode) | ≤ 2026-10-22 16:26 | Kit Langton |
| `regression/session-timeline-accessibility.spec.ts` › shows the agent name in message meta when agents are on | meta `Pending·Build·…`, expected `/^Build\s·\s/` | ≤ 2026-10-22 16:26 | Kit Langton |
| `regression/timeline-stream.spec.ts` › static projection › renders current protocol notices in CLI order | `session-timeline-notice` classes differ | ≤ 2026-10-22 16:26 | unowned |
| `regression/timeline-stream.spec.ts` › background shortcut › holds a revealed shell from far below just under its stuck group header | predicate expected `0`, received `1` (10 s) | ≤ 2026-10-22 16:26 | unowned |
## App component tests (`packages/app/component-tests`)
| Test | Failure signature | First red | Owner |
| ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------ | ------- |
| `websearch.spec.ts` › selects and confirms a provider at 360px in ltr light | 60 s timeout clicking the `Parallel` option: element is not stable | ≤ 2026-10-20 06:39 | unowned |
| `websearch.spec.ts` › selects and confirms a provider at 360px in ltr dark | same | ≤ 2026-10-20 06:39 | unowned |
| `websearch.spec.ts` › selects and confirms a provider at 360px in rtl light | same | ≤ 2026-10-20 06:39 | unowned |
| `websearch.spec.ts` › selects and confirms a provider at 360px in rtl dark | same | ≤ 2026-10-20 06:39 | unowned |
| `timeline-virtualizer.spec.ts` › reveals ready measured rows after an offset-only reconnect | `data-last-scroll-top` `484`, received `502` | ≤ 2026-10-20 06:39 | unowned |
+13 -11
View File
@@ -137,14 +137,11 @@ test("the free usage limit opens the Go dialog once, leaves a readable notice, a
id: "opencode-go",
name: "OpenCode Go",
methods: [{ type: "key" }],
connections: state.authorized ? [{ type: "credential", id: "cred_go", label: "Anomaly", method: "oauth" }] : [],
connections: state.authorized ? [{ type: "credential", id: "cred_go", label: "Go key", method: "key" }] : [],
},
],
onIntegrationOAuth: () => ({ url: "https://auth.example.test/device?user_code=GOGO-1234" }),
onIntegrationOAuthStatus: () => {
state.authorized = true
return "complete"
onConnectKey: (input) => {
if (input.integrationID === "opencode-go") state.authorized = true
},
pageMessages: () => ({
items: [
@@ -183,10 +180,11 @@ test("the free usage limit opens the Go dialog once, leaves a readable notice, a
await expect(view.editor).toHaveText("Refactor the parser")
await expect(page.getByText("Free usage limit reached.")).toHaveCount(0)
// Subscribe -> Go sign-in -> Continue switches the model in the current session without opening a new draft tab.
// Subscribe -> Go API key -> Continue switches the model in the current session without opening a new draft tab.
await upsell.getByRole("button", { name: "Subscribe", exact: true }).click()
const connect = page.getByRole("dialog")
await connect.getByRole("button", { name: "Continue in the browser", exact: true }).click()
const connect = page.getByRole("dialog", { name: "Connect OpenCode Go", exact: true })
await connect.getByPlaceholder("API key").fill("sk-go-test")
await connect.getByRole("button", { name: "Continue", exact: true }).click()
const connected = page.getByRole("dialog", { name: "Connected to OpenCode Go" })
await expect(connected.getByRole("radio", { name: "GLM-5 Go", exact: true })).toHaveAttribute("aria-checked", "true")
await connected.getByRole("button", { name: "Continue", exact: true }).click()
@@ -232,7 +230,9 @@ test("the free usage limit opens the Go dialog once, leaves a readable notice, a
mimeType: "image/png",
buffer: Buffer.from("png-bytes"),
})
await expect(page.locator('[data-component="composer-attachments"]')).toContainText("diagram.png")
await expect(
page.locator('[data-component="composer-attachments"]').getByRole("img", { name: "diagram.png", exact: true }),
).toBeVisible()
await view.push([
{
@@ -255,7 +255,9 @@ test("the free usage limit opens the Go dialog once, leaves a readable notice, a
await expect(page.getByRole("status").filter({ hasText: "You've used today's free messages." })).toBeVisible()
await expect(page.getByRole("dialog")).toHaveCount(0)
await expect(page.locator('[data-component="composer-attachments"]')).toContainText("diagram.png")
await expect(
page.locator('[data-component="composer-attachments"]').getByRole("img", { name: "diagram.png", exact: true }),
).toBeVisible()
await expect(view.editor).toHaveText("")
})
@@ -647,7 +647,9 @@ for (const device of ["Pixel 7", "iPhone 13"]) {
const cause =
detach === "scroll" ? "scrolling the touch target out of view" : "streaming replaces the touch target"
test(`returns Home after ${cause} (${release})`, async ({ page }, testInfo) => {
test(`returns Home after ${cause} (${release})${detach === "scroll" ? " @quarantine" : ""}`, async ({
page,
}, testInfo) => {
const image = Promise.withResolvers<void>()
const url = new URL(`/${detach}-target-image.svg`, testInfo.project.use.baseURL).href
await page.route(url, async (route) => {
@@ -651,7 +651,7 @@ for (const row of [
accent: false,
},
]) {
test(`keeps the user message blue for ${row.name}`, async ({ page }) => {
test(`keeps the user message blue for ${row.name} @quarantine`, async ({ page }) => {
const inventory: WorktreeDirectory[] = [{ directory: accentRoot }, { directory: accentWorkspace, strategy: "git" }]
const listed = page.waitForResponse(
+3 -3
View File
@@ -123,7 +123,7 @@ test("a rejected Git init releases its session's button without showing an error
await expect(init).toBeEnabled()
})
test("open file tab browses, searches, and tracks missing files", async ({ page }) => {
test("open file tab browses, searches, and tracks missing files @quarantine", async ({ page }) => {
const searches: { query: string; dirs?: string; limit?: number }[] = []
const directory = "C:/OpenCode/ReviewOpenFile"
const files = Array.from({ length: 80 }, (_, index) => `file-${String(index).padStart(2, "0")}.ts`)
@@ -558,7 +558,7 @@ test("file tree expands Windows paths and scrolls long names in both directions"
await expect(panel.getByText("contents:frontend/app.ts", { exact: true })).toBeVisible()
})
test("rereads a file each time an artifact link opens it", async ({ page }) => {
test("rereads a file each time an artifact link opens it @quarantine", async ({ page }) => {
// Enough lines to scroll the code view, ending in the draft's name.
const draft = (name: string) => [...Array.from({ length: 200 }, (_, index) => `item ${index + 1}`), name].join("\n")
const file = { content: draft("first draft") }
@@ -957,7 +957,7 @@ test("video files stream into the viewer behind a loading state, open into the p
expect(await page.evaluate(() => document.fullscreenElement)).toBeNull()
})
test("restores review state and the side-panel tab per session", async ({ page }) => {
test("restores review state and the side-panel tab per session @quarantine", async ({ page }) => {
const sessions = [
{ id: "ses_review_state_a", title: "Alpha review state" },
{ id: "ses_review_state_b", title: "Beta review state" },
@@ -847,7 +847,7 @@ for (const delivery of ["queue", "steer"] as const) {
})
}
test("reverting to another prompt replaces the file chips of an earlier restore", async ({ page }) => {
test("reverting to another prompt replaces the file chips of an earlier restore @quarantine", async ({ page }) => {
const mock = createQueueMock(
[],
[
@@ -1008,7 +1008,7 @@ for (const [action, status] of [
})
}
test("waiting steers group under one Pending line, each keeping its own actions beside its bubble", async ({
test("waiting steers group under one Pending line, each keeping its own actions beside its bubble @quarantine", async ({
page,
}) => {
const mock = createQueueMock(
@@ -1080,7 +1080,7 @@ test("/undo returns a pending steer's review comment to the composer", async ({
})
for (const delivery of ["steer", "queue"] as const) {
test(`keeps finished tools above a pending ${delivery === "queue" ? "queue-to-steer" : "steer"} follow-up`, async ({
test(`keeps finished tools above a pending ${delivery === "queue" ? "queue-to-steer" : "steer"} follow-up${delivery === "steer" ? " @quarantine" : ""}`, async ({
page,
}, testInfo) => {
const model = { id: "queue-model", providerID: "opencode" }
@@ -75,7 +75,7 @@ function lines(count: number) {
}
for (const visible of [false, true]) {
test(`${visible ? "shows" : "omits"} the agent name in message meta when agents are ${visible ? "on" : "off"}`, async ({
test(`${visible ? "shows" : "omits"} the agent name in message meta when agents are ${visible ? "on @quarantine" : "off"}`, async ({
page,
}, testInfo) => {
await setupTimeline(page, {
+8 -15
View File
@@ -1106,27 +1106,20 @@ test("providers: the free tier upsell opens Go on its own, sized to its content"
{
id: "evt_free_tier_limit",
created: 1700000000000,
type: "session.status",
type: "session.step.failed",
location: { directory: view.directory },
durable: { aggregateID: view.session.id, seq: 1, version: 1 },
data: {
sessionID: view.session.id,
status: {
type: "retry",
attempt: 1,
message: "Free tier limit reached",
next: 1700000060000,
action: {
reason: "free_tier_limit",
provider: "opencode",
title: "Free tier limit reached",
message: "Subscribe to OpenCode Go to keep going.",
label: "Continue with OpenCode Go",
},
},
assistantMessageID: "msg_free_tier_assistant",
error: { type: "provider.free-limit", message: "Free usage limit reached.", status: 429 },
},
},
])
await page.getByRole("button", { name: "Continue with OpenCode Go", exact: true }).click()
await page
.getByRole("dialog", { name: "Free limit reached" })
.getByRole("button", { name: "Subscribe", exact: true })
.click()
const dialog = page.getByRole("dialog", { name: "Connect OpenCode Go", exact: true })
const container = page.locator('[data-slot="dialog-container"]')
+3 -1
View File
@@ -843,7 +843,9 @@ test("inactive tabs stay busy while work waits in their inbox, and pulse on a ne
await expect(tab(a.id).locator('[data-slot="tab-prompt-pulse"]')).toHaveCount(0)
})
test("switching between busy sessions keeps the busy indicators and the activity capsule at rest", async ({ page }) => {
test("switching between busy sessions keeps the busy indicators and the activity capsule at rest @quarantine", async ({
page,
}) => {
const children = [
{ id: "ses_tab_a_child", title: "Map the orchard", parentID: a.id },
{ id: "ses_tab_b_child", title: "Chart the harbor", parentID: b.id },
@@ -63,10 +63,10 @@ for (const width of [1440, 390]) {
const reveal = await page.evaluate(() => window.__coldReveal)
expect(reveal).toMatchObject({ pending: 0, clipped: [], tables: 1, codeBlocks: 4 })
expect(Math.abs(reveal?.bottomError ?? Infinity)).toBeLessThanOrEqual(1)
// The gap above the composer is part of the tail: the status lane, then the activity pill's lane.
// The gap above the composer is part of the tail: the status lane, then the activity pill and its gap.
const spacer = page.locator('[data-timeline-row="bottom-spacer"]')
await expect(spacer).toBeVisible()
expect(await spacer.evaluate((element) => element.getBoundingClientRect().height)).toBe(80)
expect(await spacer.evaluate((element) => element.getBoundingClientRect().height)).toBe(82)
} finally {
release.resolve()
}
@@ -334,7 +334,7 @@ test("recovers from a failed cold history load when another session is selected"
await expect(page.getByRole("heading", { name: "Something went wrong", exact: true })).toHaveCount(0)
})
test("focuses Find in the selected cached timeline", async ({ page }) => {
test("focuses Find in the selected cached timeline @quarantine", async ({ page }) => {
await openTabs(page, { pageMessages: placeholderHistory })
await page.goto(sessionHref(fixture.sourceID))
await expect(page.getByText(`History for ${fixture.sourceID}`, { exact: true })).toBeVisible()
@@ -355,7 +355,7 @@ test("focuses Find in the selected cached timeline", async ({ page }) => {
await expect(search).toHaveCount(0)
})
test("disposes the old workspace's shell while destination history is loading", async ({ page }) => {
test("disposes the old workspace's shell while destination history is loading @quarantine", async ({ page }) => {
const destination = "C:/OpenCode/OtherProject"
const requested = Promise.withResolvers<void>()
const release = Promise.withResolvers<void>()
@@ -43,7 +43,7 @@ const completed = {
} satisfies SessionMessageAssistant
test.describe("static projection", () => {
test("renders current protocol notices in CLI order", async ({ page }) => {
test("renders current protocol notices in CLI order @quarantine", async ({ page }) => {
const ownerWarnings: string[] = []
page.on("console", (message) => {
if (message.text().includes("computations created outside a `createRoot` or `render`"))
@@ -1218,7 +1218,9 @@ test.describe("background shortcut", () => {
// Reaching the shell lands on the end of the timeline, which would otherwise follow new content again.
{ name: "at the end of the timeline", before: 40, searches: 0, after: 0 },
]) {
test(`holds a revealed shell ${fixture.name} just under its stuck group header`, async ({ page }) => {
test(`holds a revealed shell ${fixture.name} just under its stuck group header${fixture.name === "from far below" ? " @quarantine" : ""}`, async ({
page,
}) => {
const timeline = await setupTimeline(page, {
settings: { timelineDetail: detailed },
sessionStatus: { [sessionID]: { type: "busy" } },