Stabilize release and Windows transport tests

Author: pallyoung

scripts/test/start-dev-stack.mjs

@@ -1,21 +1,55 @@
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 
 const ROOT = fileURLToPath(new URL('../..', import.meta.url));
 const PNPM_CMD = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
-const server = spawn(PNPM_CMD, ['dev:server'], {
-  cwd: ROOT,
-  stdio: 'inherit',
-  windowsHide: true
-});
 let frontend = null;
 
 let shuttingDown = false;
 
+function quoteForCmd(value) {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (!/[\s"&^|<>()]/.test(value)) {
+    return value;
+  }
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+function resolveSpawn(command, args) {
+  if (process.platform === 'win32' && command.toLowerCase().endsWith('.cmd')) {
+    return {
+      command: process.env.ComSpec || 'cmd.exe',
+      args: ['/d', '/s', '/c', [command, ...args].map(quoteForCmd).join(' ')]
+    };
+  }
+
+  return { command, args };
+}
+
+function spawnPnpm(args) {
+  const resolved = resolveSpawn(PNPM_CMD, args);
+  return spawn(resolved.command, resolved.args, {
+    cwd: ROOT,
+    stdio: 'inherit',
+    windowsHide: true
+  });
+}
+
+const server = spawnPnpm(['dev:server']);
+
 const killChild = (child) => {
-  if (!child || child.killed) return;
+  if (!child || child.killed || child.pid == null) return;
   try {
+    if (process.platform === 'win32') {
+      spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], {
+        stdio: 'ignore',
+        windowsHide: true
+      });
+      return;
+    }
     child.kill('SIGTERM');
   } catch {
     // Ignore already stopped child processes.
@@ -61,11 +95,7 @@ try {
   throw error;
 }
 
-frontend = spawn(PNPM_CMD, ['dev:frontend'], {
-  cwd: ROOT,
-  stdio: 'inherit',
-  windowsHide: true
-});
+frontend = spawnPnpm(['dev:frontend']);
 
 frontend.on('exit', (code) => {
   if (!shuttingDown) {

tests/e2e/e2e.spec.ts

@@ -5,7 +5,6 @@ import type { APIRequestContext, Page } from '@playwright/test';
 import { expect, test } from '@playwright/test';
 
 const HOME_DIR = os.homedir();
-const HOME_LABEL = path.basename(HOME_DIR) || HOME_DIR;
 const TAB_STABILITY_DIRS = [
   path.join(HOME_DIR, 'coder-studio-e2e-tab-a'),
   path.join(HOME_DIR, 'coder-studio-e2e-tab-b'),
@@ -84,6 +83,8 @@ const gotoWorkspaceRoot = async (page: Page) => {
 
 const countWorkspaceTabs = async (page: Page) => page.locator('.workspace-top-tab').count();
 
+const workspaceLabelForPath = (workspacePath: string) => path.basename(workspacePath) || workspacePath;
+
 const openLaunchOverlay = async (page: Page) => {
   await gotoWorkspaceRoot(page);
   const overlay = page.getByTestId('overlay');
@@ -100,18 +101,21 @@ const openLaunchOverlay = async (page: Page) => {
 const launchLocalWorkspace = async (page: Page) => {
   await gotoWorkspaceRoot(page);
   if (await countWorkspaceTabs(page)) {
-    return;
+    const activeLabel = (await page.locator('.workspace-top-tab.active .session-top-label').textContent())?.trim();
+    return activeLabel ?? '';
   }
 
   await openLaunchOverlay(page);
   await expect(page.getByTestId('choice-local-only')).toBeVisible();
   await expect(page.getByTestId('folder-select')).toBeVisible();
 
   await page.getByRole('button', { name: 'Home' }).click();
+  const selectedPath = ((await page.locator('[data-testid="folder-select"] .web-folder-picker-paths strong').textContent()) ?? '').trim();
   await expect(page.getByTestId('start-workspace')).toBeEnabled();
   await page.getByTestId('start-workspace').click();
   await expect(page.getByTestId('overlay')).toHaveCount(0);
   await expect(page.getByTestId('workspace-topbar')).toBeVisible();
+  return workspaceLabelForPath(selectedPath);
 };
 
 const invokeRpc = async <T>(page: Page, command: string, payload: Record<string, unknown> = {}) => {
@@ -183,6 +187,7 @@ test.beforeEach(async ({ page }) => {
     }
   });
   await installRuntimeCommandMock(page);
+  await closeAllOpenWorkspaces(page);
 });
 
 test.beforeAll(async () => {
@@ -194,8 +199,8 @@ test.afterAll(async () => {
 });
 
 test('local workspace flow opens the workspace shell', async ({ page }) => {
-  await launchLocalWorkspace(page);
-  await expect(page.getByTestId('workspace-topbar')).toContainText(HOME_LABEL);
+  const expectedLabel = await launchLocalWorkspace(page);
+  await expect(page.getByTestId('workspace-topbar')).toContainText(expectedLabel);
   await expect(page.getByTestId('settings-open')).toBeVisible();
 });
 
@@ -257,11 +262,11 @@ test('settings persist across route changes and reloads', async ({ page }) => {
 });
 
 test('restores the last workspace after reload', async ({ page }) => {
-  await launchLocalWorkspace(page);
+  const expectedLabel = await launchLocalWorkspace(page);
   await page.reload();
 
   await expect(page.getByTestId('overlay')).toHaveCount(0);
-  await expect(page.getByTestId('workspace-topbar')).toContainText(HOME_LABEL);
+  await expect(page.getByTestId('workspace-topbar')).toContainText(expectedLabel);
 });
 
 test('workspace tabs keep a stable order when switching between workspaces', async ({ page }) => {

tests/e2e/transport.spec.ts

@@ -99,6 +99,10 @@ const emptyPollCounts = (): PollCounts => ({
   workspace_tree: 0,
 });
 
+test.beforeEach(async ({ page }) => {
+  await closeAllOpenWorkspaces(page);
+});
+
 test.describe('workspace transport baseline', () => {
   test('fallback polling refreshes git/tree/worktree on the configured cadence', async ({ page }) => {
     const baseline = await observePollingBaseline(page);
@@ -347,15 +351,31 @@ async function observeWatcherInvalidationBaseline(page: Page): Promise<WatcherIn
     'e2e',
     `.transport-watcher-probe-${process.pid}-${Date.now()}.txt`,
   );
+  const predicate = (payload: Record<string, unknown>) =>
+    payload.path === workspace.workspacePath && payload.reason === 'file_watcher';
 
   await fs.mkdir(path.dirname(probeFile), { recursive: true });
   try {
-    await fs.writeFile(probeFile, `watcher ${Date.now()}\n`, 'utf8');
-    const dirtyFrame = await waitForWsEvent(
-      page,
-      'workspace://artifacts_dirty',
-      (payload) => payload.path === workspace.workspacePath && payload.reason === 'file_watcher',
-    );
+    let dirtyFrame: WsEventFrame | null = null;
+    let lastError: unknown = null;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      await fs.writeFile(probeFile, `watcher ${Date.now()}-${attempt}\n`, 'utf8');
+      try {
+        dirtyFrame = await waitForWsEvent(
+          page,
+          'workspace://artifacts_dirty',
+          predicate,
+          2500,
+        );
+        break;
+      } catch (error) {
+        lastError = error;
+        await page.waitForTimeout(350);
+      }
+    }
+    if (!dirtyFrame) {
+      throw lastError ?? new Error('watcher_invalidation_timeout');
+    }
 
     return {
       dirtyFrame,
@@ -381,12 +401,14 @@ async function observeGitIndexInvalidationBaseline(page: Page): Promise<GitIndex
   const predicate = (payload: Record<string, unknown>) =>
     payload.path === workspace.workspacePath && payload.reason === 'file_watcher';
   const baselineCount = await countWsEvents(page, 'workspace://artifacts_dirty', predicate);
+  const countsBeforeFileWrite = snapshotCounts(probe.counts);
 
   await fs.mkdir(path.dirname(probeFile), { recursive: true });
   try {
     await fs.writeFile(probeFile, `index ${Date.now()}\n`, 'utf8');
     await waitForWsEventCount(page, 'workspace://artifacts_dirty', predicate, baselineCount + 1);
-    await page.waitForTimeout(400);
+    await waitForCountsAtLeast(probe.counts, incrementCounts(countsBeforeFileWrite));
+    await page.waitForTimeout(1000);
     const countsAfterFileWrite = await countWsEvents(page, 'workspace://artifacts_dirty', predicate);
 
     await execFileAsync('git', ['add', '--', probeFile], { cwd: WORKSPACE_PATH });
@@ -532,6 +554,18 @@ async function invokeRpc<T>(page: Page, command: string, payload: Record<string,
   return body.data as T;
 }
 
+async function closeAllOpenWorkspaces(page: Page) {
+  const bootstrap = await invokeRpc<{
+    ui_state: {
+      open_workspace_ids: string[];
+    };
+  }>(page, 'workbench_bootstrap');
+
+  for (const workspaceId of bootstrap.ui_state.open_workspace_ids) {
+    await invokeRpc(page, 'close_workspace', { workspace_id: workspaceId });
+  }
+}
+
 async function waitForPollCycle(counts: PollCounts) {
   await expect
     .poll(() => {
@@ -551,6 +585,20 @@ async function waitForCounts(actual: PollCounts, expected: PollCounts) {
     .toEqual(expected);
 }
 
+async function waitForCountsAtLeast(actual: PollCounts, expectedMinimum: PollCounts) {
+  await expect
+    .poll(() => {
+      const snapshot = snapshotCounts(actual);
+      return snapshot.git_status >= expectedMinimum.git_status
+        && snapshot.git_changes >= expectedMinimum.git_changes
+        && snapshot.worktree_list >= expectedMinimum.worktree_list
+        && snapshot.workspace_tree >= expectedMinimum.workspace_tree;
+    }, {
+      timeout: 10000,
+    })
+    .toBe(true);
+}
+
 function snapshotCounts(counts: PollCounts): PollCounts {
   return {
     git_status: counts.git_status,
@@ -602,6 +650,7 @@ async function waitForWsEvent(
   page: Page,
   eventName: string,
   predicate: (payload: Record<string, unknown>) => boolean,
+  timeoutMs = 10000,
 ): Promise<WsEventFrame> {
   await expect
     .poll(async () => {
@@ -615,7 +664,7 @@ async function waitForWsEvent(
         );
       return match ?? null;
     }, {
-      timeout: 10000,
+      timeout: timeoutMs,
     })
     .not.toBeNull();
 
@@ -650,10 +699,11 @@ async function waitForWsEventCount(
   eventName: string,
   predicate: (payload: Record<string, unknown>) => boolean,
   expectedCount: number,
+  timeoutMs = 10000,
 ) {
   await expect
     .poll(() => countWsEvents(page, eventName, predicate), {
-      timeout: 10000,
+      timeout: timeoutMs,
     })
     .toBeGreaterThanOrEqual(expectedCount);
 }