mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-21 15:33:45 +00:00
A route handler that calls `route.fetch()` can still be running when its test returns. Closing the browser context disposes the fetched response, the handler throws `Response has been disposed`, and Playwright reports that against a test whose assertions had all passed. With `failOnFlakyTests` on, that fails the shard.
Specs that answer requests through `route.fetch()` now take `test` from `e2e/specs/mock/fixtures.ts`. Its `context` fixture detaches the routes on the context and its pages with `unrouteAll({ behavior: 'ignoreErrors' })` before Playwright closes it; contexts a spec opens itself close through `closeContext`.
`ignoreErrors` rather than `wait`: a wait never ends for a handler parked on a promise the test leaves unsettled, and with two handlers in flight Playwright stops intercepting when the first finishes and continues the other request itself, so the second handler's `route.fulfill()` throws `Route is already handled!`.
365 lines
15 KiB
TypeScript
365 lines
15 KiB
TypeScript
import type { Page } from '@playwright/test';
|
|
import {
|
|
MOCK_ENDPOINTS,
|
|
NEW_CHAT_PATH,
|
|
messagesView,
|
|
selectMockEndpoint,
|
|
sendMessage,
|
|
sendMessageAndWaitForCompletion,
|
|
} from '../helpers';
|
|
import { expect, test } from '../fixtures';
|
|
|
|
/**
|
|
* The artifacts pane can leave the side panel for a window of its own. The pane
|
|
* stays in this tab's React tree and is portaled into that window, so these
|
|
* scenarios are about what survives the move: the artifact itself, its styling,
|
|
* its preview frame, its menus, and unsaved editor text.
|
|
*
|
|
* There is deliberately no scenario for a browser that denies Web Storage. The
|
|
* pane's own fallback to default bounds is covered where it can be observed, in
|
|
* `client/src/components/Artifacts/__tests__/undockedWindow.spec.ts`; denying
|
|
* storage in the browser takes the whole app into its error boundary before any
|
|
* of this is reachable, so asserting it here would test a capability the shell
|
|
* does not have.
|
|
*/
|
|
|
|
const UNDOCK = 'Open in new window';
|
|
const DOCK = 'Dock back to panel';
|
|
const HTML_ARTIFACT = 'E2E HTML Artifact';
|
|
const UNDOCKED_PANE = '#undocked-artifacts-root #artifact-viewer';
|
|
/**
|
|
* The trigger row's accessible name carries its format badge and whether
|
|
* opening it renders a preview, alongside the title and the action — so it is
|
|
* matched on the title rather than spelled out here.
|
|
*/
|
|
const artifactTrigger = (page: Page, title: string) =>
|
|
messagesView(page).getByRole('button', {
|
|
name: new RegExp(title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
|
|
});
|
|
|
|
async function openHtmlArtifact(page: Page) {
|
|
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
|
await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
|
|
/* Opened while the reply is still finalizing, the pane follows the stream
|
|
* onto the code tab; these cases start from a settled reply. */
|
|
await sendMessageAndWaitForCompletion(page, 'E2E_HTML_ARTIFACT_REPLY', { timeout: 60000 });
|
|
|
|
await artifactTrigger(page, HTML_ARTIFACT).click();
|
|
const panel = page.getByRole('region', { name: HTML_ARTIFACT });
|
|
await expect(panel).toBeVisible();
|
|
return panel;
|
|
}
|
|
|
|
async function undock(page: Page) {
|
|
const panel = page.getByRole('region', { name: HTML_ARTIFACT });
|
|
const [popup] = await Promise.all([
|
|
page.waitForEvent('popup'),
|
|
panel.getByRole('button', { name: UNDOCK }).click(),
|
|
]);
|
|
await expect(popup.locator(UNDOCKED_PANE)).toBeVisible({ timeout: 20000 });
|
|
return popup;
|
|
}
|
|
|
|
/**
|
|
* Docking closes the window from inside the press that asks for it, so the press can lose
|
|
* its reply to a page that is already gone. The window closing is the outcome that settles;
|
|
* a press that fails while the window is still open is a real failure.
|
|
*/
|
|
async function dockBack(popup: Page, press: () => Promise<void>) {
|
|
await Promise.all([
|
|
popup.waitForEvent('close'),
|
|
press().catch((error: Error) => {
|
|
if (!popup.isClosed()) {
|
|
throw error;
|
|
}
|
|
}),
|
|
]);
|
|
}
|
|
|
|
/** The undock control is desktop-only: it is hidden below 868px. */
|
|
test.use({ viewport: { width: 1280, height: 800 } });
|
|
|
|
test.describe('undocked artifacts pane', () => {
|
|
test('the pane moves into a window of its own @scenario:artifacts-pane-moves-into-its-own-window', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await openHtmlArtifact(page);
|
|
|
|
const popup = await undock(page);
|
|
|
|
await expect(popup.getByRole('region', { name: HTML_ARTIFACT })).toBeVisible();
|
|
/* The conversation gets its column back: nothing of the pane is left here. */
|
|
await expect(page.locator('#artifact-viewer')).toHaveCount(0);
|
|
await expect(page.getByRole('region', { name: HTML_ARTIFACT })).toHaveCount(0);
|
|
});
|
|
|
|
test('the artifact renders in the window with the app styling @scenario:undocked-pane-renders-the-artifact-preview', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await openHtmlArtifact(page);
|
|
|
|
const popup = await undock(page);
|
|
const pane = popup.locator(UNDOCKED_PANE);
|
|
|
|
/* A portal carries nodes, not the document that styled them: an unstyled
|
|
* pane would render transparent and collapsed. The mirrored sheet is a
|
|
* fetch, so the painted canvas is what settles, not what renders first. */
|
|
await expect
|
|
.poll(
|
|
() =>
|
|
pane.evaluate(
|
|
(node) => node.ownerDocument.defaultView?.getComputedStyle(node).backgroundColor ?? '',
|
|
),
|
|
{ timeout: 15000 },
|
|
)
|
|
.not.toBe('rgba(0, 0, 0, 0)');
|
|
const paneBox = await pane.boundingBox();
|
|
expect(paneBox).not.toBeNull();
|
|
expect(paneBox!.height).toBeGreaterThan(200);
|
|
|
|
/* The preview lives in the window too, in its own frame. The runtime
|
|
* bundler compiles it there, which on a loaded machine takes a while. */
|
|
await expect(pane.locator('iframe')).toHaveCount(1, { timeout: 30000 });
|
|
await expect(popup.getByRole('button', { name: 'Refresh' })).toBeVisible();
|
|
});
|
|
|
|
test('docking back returns the pane to the side panel @scenario:undocked-pane-returns-to-the-side-panel', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await openHtmlArtifact(page);
|
|
const popup = await undock(page);
|
|
|
|
await dockBack(popup, () => popup.getByRole('button', { name: DOCK }).click());
|
|
|
|
expect(popup.isClosed()).toBe(true);
|
|
await expect(page.getByRole('region', { name: HTML_ARTIFACT })).toBeVisible({ timeout: 20000 });
|
|
await expect(page.getByRole('button', { name: UNDOCK })).toBeVisible();
|
|
});
|
|
|
|
test('closing the window brings the pane home @scenario:closing-the-undocked-window-returns-the-pane', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await openHtmlArtifact(page);
|
|
const popup = await undock(page);
|
|
|
|
await popup.close();
|
|
|
|
await expect(page.getByRole('region', { name: HTML_ARTIFACT })).toBeVisible({ timeout: 20000 });
|
|
await expect(page.getByRole('button', { name: UNDOCK })).toBeVisible();
|
|
});
|
|
|
|
test('docking hands focus to the control that replaces it @scenario:docking-returns-focus-to-the-pane-control', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await openHtmlArtifact(page);
|
|
const popup = await undock(page);
|
|
|
|
/* Keyboard path: the button pressed in the window disappears with it. */
|
|
await popup.getByRole('button', { name: DOCK }).focus();
|
|
await dockBack(popup, () => popup.keyboard.press('Enter'));
|
|
|
|
const undockButton = page.getByRole('button', { name: UNDOCK });
|
|
await expect(undockButton).toBeVisible({ timeout: 20000 });
|
|
await expect(undockButton).toBeFocused();
|
|
});
|
|
|
|
test('undocking hands focus to the pane in its new window @scenario:undocking-moves-focus-into-the-window', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
const panel = await openHtmlArtifact(page);
|
|
|
|
/* Keyboard path: the control pressed here disappears with the docked
|
|
* toolbar, so focus has to follow the pane rather than stay on an empty
|
|
* document in the window that just opened. */
|
|
const undockButton = panel.getByRole('button', { name: UNDOCK });
|
|
await undockButton.focus();
|
|
const [popup] = await Promise.all([page.waitForEvent('popup'), page.keyboard.press('Enter')]);
|
|
|
|
await expect(popup.locator(UNDOCKED_PANE)).toBeVisible({ timeout: 20000 });
|
|
await expect(popup.getByRole('button', { name: DOCK })).toBeFocused();
|
|
});
|
|
|
|
test('unsaved editor text moves with the pane @scenario:unsaved-artifact-edits-survive-undocking', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(120000);
|
|
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
|
await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
|
|
await sendMessageAndWaitForCompletion(page, 'E2E_HTML_ARTIFACT_REPLY', { timeout: 60000 });
|
|
|
|
await artifactTrigger(page, HTML_ARTIFACT).click();
|
|
const panel = page.getByRole('region', { name: HTML_ARTIFACT });
|
|
await expect(panel).toBeVisible();
|
|
|
|
await panel.getByRole('radio', { name: 'Code' }).click();
|
|
const editor = panel.locator('#artifacts-code .monaco-editor').first();
|
|
await expect(editor).toBeVisible({ timeout: 30000 });
|
|
await editor.click();
|
|
await page.keyboard.press('End');
|
|
await page.keyboard.type('<!-- undock-edit -->');
|
|
await expect(panel.locator('#artifacts-code')).toContainText('undock-edit', {
|
|
timeout: 15000,
|
|
});
|
|
|
|
const popup = await undock(page);
|
|
|
|
/* Landing back on the preview would read as the edit having been lost.
|
|
* Polled, because a tab reset lands a frame after the move and a
|
|
* first-match assertion would accept the frame before it. */
|
|
await expect
|
|
.poll(async () => popup.getByRole('radio', { name: 'Code' }).getAttribute('aria-checked'), {
|
|
timeout: 10000,
|
|
})
|
|
.toBe('true');
|
|
await expect(popup.locator(`${UNDOCKED_PANE} #artifacts-code`)).toBeVisible({ timeout: 30000 });
|
|
await expect(popup.locator(`${UNDOCKED_PANE} #artifacts-code`)).toContainText('undock-edit', {
|
|
timeout: 30000,
|
|
});
|
|
});
|
|
|
|
test('pane menus open in the window that owns them @scenario:undocked-pane-menus-open-in-its-own-window', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
|
await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
|
|
const response = await sendMessage(page, 'E2E_MERMAID_ARTIFACT_REPLY');
|
|
expect(response.ok()).toBeTruthy();
|
|
|
|
const messages = messagesView(page);
|
|
await expect(messages.getByRole('img', { name: 'Mermaid diagram' })).toBeVisible();
|
|
await messages.getByRole('button', { name: 'Open as artifact', exact: true }).click();
|
|
|
|
const panel = page.getByRole('region', { name: 'Mermaid diagram' });
|
|
await expect(panel.getByRole('img', { name: 'Mermaid diagram' })).toBeVisible();
|
|
|
|
const [popup] = await Promise.all([
|
|
page.waitForEvent('popup'),
|
|
panel.getByRole('button', { name: UNDOCK }).click(),
|
|
]);
|
|
const pane = popup.locator(UNDOCKED_PANE);
|
|
await expect(pane).toBeVisible({ timeout: 20000 });
|
|
await expect(pane.getByRole('img', { name: 'Mermaid diagram' })).toBeVisible({
|
|
timeout: 20000,
|
|
});
|
|
|
|
await popup.getByRole('button', { name: 'Export diagram' }).click();
|
|
|
|
/* Radix portals default to the host document's body; the menu has to open
|
|
* where the user clicked instead. */
|
|
await expect(popup.getByRole('menuitem', { name: 'Export as SVG', exact: true })).toBeVisible();
|
|
await expect(page.getByRole('menuitem', { name: 'Export as SVG', exact: true })).toHaveCount(0);
|
|
});
|
|
|
|
test('a failure raised in the window is reported there @scenario:undocked-pane-reports-failures-in-its-own-window', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await openHtmlArtifact(page);
|
|
const popup = await undock(page);
|
|
|
|
/* Take both clipboard paths away inside the window, which is what a
|
|
* non-secure context with a refused selection copy looks like. */
|
|
await popup.evaluate(() => {
|
|
Object.defineProperty(navigator, 'clipboard', {
|
|
configurable: true,
|
|
value: { writeText: () => Promise.reject(new Error('denied')) },
|
|
});
|
|
document.execCommand = () => false;
|
|
});
|
|
|
|
await popup.getByRole('button', { name: 'Copy' }).click();
|
|
|
|
/* The app's toast viewport lives in the chat tab, which the user is not
|
|
* looking at: the notice has to appear in the window they are. */
|
|
await expect(popup.getByText('Failed to copy to clipboard')).toBeVisible({ timeout: 15000 });
|
|
});
|
|
|
|
/* The capability is a deployment choice, and a viewer must not be able to
|
|
* act on it before the deployment has answered. */
|
|
test('a deployment can keep the pane docked @scenario:a-deployment-can-turn-undocking-off', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
await page.route('**/api/config', async (route) => {
|
|
const response = await route.fetch();
|
|
const config = await response.json();
|
|
await route.fulfill({
|
|
response,
|
|
json: { ...config, interface: { ...config.interface, artifactUndocking: false } },
|
|
});
|
|
});
|
|
|
|
const panel = await openHtmlArtifact(page);
|
|
|
|
await expect(panel.getByRole('button', { name: 'Copy' })).toBeVisible();
|
|
await expect(panel.getByRole('button', { name: UNDOCK })).toHaveCount(0);
|
|
});
|
|
|
|
/* The tab is pane state, and the pane is a new instance in every host. A
|
|
* reset driven by the instance rather than by the artifact sends the user
|
|
* back to Preview on both transitions, which reads as their code being gone.
|
|
* Asserting the settled tab matters: the reset lands a frame after the move,
|
|
* so a first-match assertion can pass on the frame before it. */
|
|
test('the pane keeps the code tab across both host changes @scenario:the-code-tab-survives-a-host-change', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(120000);
|
|
const panel = await openHtmlArtifact(page);
|
|
|
|
await panel.getByRole('radio', { name: 'Code' }).click();
|
|
await expect(panel.locator('#artifacts-code')).toBeVisible({ timeout: 30000 });
|
|
|
|
const popup = await undock(page);
|
|
|
|
const popupCodeTab = popup.getByRole('radio', { name: 'Code' });
|
|
await expect(popupCodeTab).toBeVisible({ timeout: 20000 });
|
|
await expect
|
|
.poll(async () => popupCodeTab.getAttribute('aria-checked'), { timeout: 10000 })
|
|
.toBe('true');
|
|
/* Visible, not merely present: the code pane stays mounted when the tab
|
|
* changes, so presence alone would not show which tab is on screen. */
|
|
await expect(popup.locator(`${UNDOCKED_PANE} #artifacts-code`)).toBeVisible({
|
|
timeout: 30000,
|
|
});
|
|
|
|
await dockBack(popup, () => popup.getByRole('button', { name: DOCK }).click());
|
|
|
|
const docked = page.getByRole('region', { name: HTML_ARTIFACT });
|
|
await expect(docked).toBeVisible({ timeout: 20000 });
|
|
const dockedCodeTab = docked.getByRole('radio', { name: 'Code' });
|
|
await expect
|
|
.poll(async () => dockedCodeTab.getAttribute('aria-checked'), { timeout: 10000 })
|
|
.toBe('true');
|
|
await expect(docked.locator('#artifacts-code')).toBeVisible({ timeout: 30000 });
|
|
});
|
|
});
|
|
|
|
test.describe('artifacts sheet on a phone', () => {
|
|
test.use({ viewport: { width: 390, height: 844 } });
|
|
|
|
test('the sheet offers no undock action @scenario:mobile-artifacts-sheet-offers-no-undock-action', async ({
|
|
page,
|
|
}) => {
|
|
test.setTimeout(90000);
|
|
expect(page.viewportSize()?.width ?? 0).toBeLessThan(868);
|
|
|
|
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
|
await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
|
|
const response = await sendMessage(page, 'E2E_HTML_ARTIFACT_REPLY');
|
|
expect(response.ok()).toBeTruthy();
|
|
|
|
await artifactTrigger(page, HTML_ARTIFACT).click();
|
|
|
|
const sheet = page.getByRole('dialog', { name: HTML_ARTIFACT });
|
|
await expect(sheet).toBeVisible();
|
|
await expect(sheet.getByRole('button', { name: UNDOCK })).toHaveCount(0);
|
|
await expect(sheet.getByRole('button', { name: 'Close' })).toBeVisible();
|
|
});
|
|
});
|