Skip unrelated required checks without losing their names (#2542)

* fix(ci): skip unrelated required checks cleanly Matrix jobs had to start no-op runners to preserve interpolated required-check names. Static named jobs let GitHub report genuine skipped conclusions while keeping those names stable. * fix(ci): gate changes to install patching script * fix(ci): route cross-package test contracts narrowly * fix(ci): keep routed contracts merge-blocking * fix(server): exclude nested test utilities from builds * fix(ci): cover app-owned native and browser domains * refactor(ci): align tests with runtime domains Own browser specs, desktop specs, and Electron-only app code by stable directories so PR routing does not depend on filename conventions. Keep desktop integration coverage inside the required desktop check. * fix(ci): keep routing and desktop suites isolated The routing regression must run before dependency installation, and desktop Vitest must not collect Playwright-owned specs. * fix(ci): isolate desktop e2e runtime * perf(test): isolate Playwright workers * perf(test): parallelize Playwright within specs * fix(test): keep Playwright file scheduling * fix(test): share dynamic Metro fixture * fix(test): preserve own-host restart fixtures * fix(ci): preserve routed contracts after rebase * Stabilize Playwright wheel-scroll assertions
2026-08-02 00:56:05 +08:00
parent 429155b536
commit 5a30affd7f
256 changed files with 2693 additions and 2674 deletions
@@ -0,0 +1,146 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { Dialog, Page } from "@playwright/test";
+import { expect, test } from "../support/fixtures";
+import { gotoAppShell } from "../support/helpers/app";
+import {
+  archiveWorkspaceFromDaemon,
+  connectNewWorkspaceDaemonClient,
+  createWorktreeViaDaemon,
+  openProjectViaDaemon,
+} from "../support/helpers/new-workspace";
+import { getServerId } from "../support/helpers/server-id";
+import {
+  clickArchiveWorkspaceMenuItem,
+  expectWorkspaceAbsentFromSidebar,
+} from "../support/helpers/sidebar";
+import { createTempGitRepo } from "../support/helpers/workspace";
+import {
+  waitForSidebarHydration,
+  waitForWorkspaceInSidebar,
+} from "../support/helpers/workspace-ui";
+
+async function seedRiskyWorktree(
+  client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>,
+  worktreeDirectory: string,
+): Promise<void> {
+  // The daemon only reports unpushed commits when the branch has a configured
+  // upstream (aheadOfOrigin is computed against `branch.<name>.merge`). Push the
+  // worktree branch at its current head first so it tracks origin with 0 ahead,
+  // then add the local commit below that becomes the single unpushed commit.
+  const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+    cwd: worktreeDirectory,
+    stdio: "pipe",
+  })
+    .toString()
+    .trim();
+  execSync(`git push -u origin ${JSON.stringify(branch)}`, {
+    cwd: worktreeDirectory,
+    stdio: "ignore",
+  });
+
+  const committedFile = path.join(worktreeDirectory, "UNPUSHED.md");
+  await writeFile(committedFile, "# unpushed\n");
+  execSync(`git add ${JSON.stringify(path.basename(committedFile))}`, {
+    cwd: worktreeDirectory,
+    stdio: "ignore",
+  });
+  execSync('git commit -m "Add unpushed change"', {
+    cwd: worktreeDirectory,
+    stdio: "ignore",
+  });
+
+  const dirtyFile = path.join(worktreeDirectory, "DIRTY.md");
+  await writeFile(dirtyFile, "# dirty\n");
+
+  const refreshed = await client.checkoutRefresh(worktreeDirectory);
+  if (!refreshed.success) {
+    throw new Error(`Failed to refresh checkout for ${worktreeDirectory}`);
+  }
+}
+
+// The archive confirmation is a synchronous web `window.confirm()`. The click that
+// opens it does not resolve until the dialog is answered, so the handler must
+// accept/dismiss inline — awaiting the dialog only *after* the click deadlocks, as
+// the click waits for an answer that is gated behind that same click.
+async function clickArchiveAndAnswerWarning(
+  page: Page,
+  workspaceId: string,
+  answer: "accept" | "dismiss",
+): Promise<Dialog> {
+  let warning: Dialog | undefined;
+  page.once("dialog", (dialog) => {
+    warning = dialog;
+    void (answer === "accept" ? dialog.accept() : dialog.dismiss());
+  });
+  await clickArchiveWorkspaceMenuItem(page, workspaceId);
+  if (!warning) {
+    throw new Error("Expected an archive confirmation dialog, but none was shown.");
+  }
+  return warning;
+}
+
+test.describe("Workspace archive risk warning for worktree backing", () => {
+  let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
+  let tempRepo: { path: string; cleanup: () => Promise<void> };
+  const createdWorktreeDirectories = new Set<string>();
+
+  test.describe.configure({ retries: 1, timeout: 120_000 });
+
+  test.beforeEach(async () => {
+    client = await connectNewWorkspaceDaemonClient();
+    tempRepo = await createTempGitRepo("wt-archive-risk-", { withRemote: true });
+  });
+
+  test.afterEach(async () => {
+    for (const directory of createdWorktreeDirectories) {
+      await archiveWorkspaceFromDaemon(client, directory).catch(() => undefined);
+    }
+    createdWorktreeDirectories.clear();
+    await client?.close().catch(() => undefined);
+    await tempRepo?.cleanup().catch(() => undefined);
+  });
+
+  test("a risky workspace archive is gated by confirmation and removes its worktree after acceptance", async ({
+    page,
+  }) => {
+    const serverId = getServerId();
+    await openProjectViaDaemon(client, tempRepo.path);
+    const worktree = await createWorktreeViaDaemon(client, {
+      cwd: tempRepo.path,
+      slug: `archive-risk-${Date.now()}`,
+    });
+    createdWorktreeDirectories.add(worktree.workspaceDirectory);
+    expect(existsSync(worktree.workspaceDirectory)).toBe(true);
+
+    await seedRiskyWorktree(client, worktree.workspaceDirectory);
+
+    await gotoAppShell(page);
+    await waitForSidebarHydration(page);
+    await waitForWorkspaceInSidebar(page, { serverId, workspaceId: worktree.workspaceId });
+
+    const firstWarning = await clickArchiveAndAnswerWarning(page, worktree.workspaceId, "dismiss");
+    expect(firstWarning.type()).toBe("confirm");
+    expect(firstWarning.message()).toContain(`Archive "${worktree.workspaceName}"?`);
+    expect(firstWarning.message()).toContain("Uncommitted changes");
+    expect(firstWarning.message()).toContain("1 unpushed commit");
+
+    await expect(
+      page.getByTestId(`sidebar-workspace-row-${serverId}:${worktree.workspaceId}`),
+    ).toBeVisible({ timeout: 10_000 });
+    expect(existsSync(worktree.workspaceDirectory)).toBe(true);
+
+    const secondWarning = await clickArchiveAndAnswerWarning(page, worktree.workspaceId, "accept");
+    expect(secondWarning.message()).toContain("Uncommitted changes");
+    expect(secondWarning.message()).toContain("1 unpushed commit");
+
+    await expectWorkspaceAbsentFromSidebar(page, worktree.workspaceId);
+    await expect
+      .poll(() => existsSync(worktree.workspaceDirectory), { timeout: 30_000 })
+      .toBe(false);
+
+    createdWorktreeDirectories.delete(worktree.workspaceDirectory);
+  });
+});