test: resolve issues

Author: danielroe

playwright.config.ts

@@ -18,9 +18,8 @@ export default defineConfig<ConfigOptions>({
     reuseExistingServer: false,
     timeout: 60_000,
   },
-  // Start/stop mock connector server before/after all tests
+  // Start/stop mock connector server before/after all tests (teardown via returned closure)
   globalSetup: fileURLToPath(new URL('./test/e2e/global-setup.ts', import.meta.url)),
-  globalTeardown: fileURLToPath(new URL('./test/e2e/global-teardown.ts', import.meta.url)),
   // We currently only test on one browser on one platform
   snapshotPathTemplate: '{snapshotDir}/{testFileDir}/{testFileName}-snapshots/{arg}{ext}',
   use: {

test/e2e/connector.spec.ts

@@ -3,11 +3,16 @@
  *
  * These tests use a mock connector server (started in global setup)
  * to test features that require being logged in via the connector.
+ *
+ * All tests run serially because they share a single mock connector server
+ * whose state is reset before each test via `mockConnector.reset()`.
  */
 
 import type { Page } from '@playwright/test'
 import { test, expect } from './helpers/fixtures'
 
+test.describe.configure({ mode: 'serial' })
+
 /**
  * When connected, the header shows "packages" and "orgs" links scoped to the user.
  * This helper waits for the packages link to appear as proof of successful connection.

test/e2e/global-setup.ts

@@ -1,25 +1,33 @@
 /**
  * Playwright global setup - starts the mock connector server before all tests.
+ *
+ * Returns an async teardown function (Playwright's recommended pattern for
+ * sharing state between setup and teardown via closure).
  */
 
 import { MockConnectorServer, DEFAULT_TEST_CONFIG } from './helpers/mock-connector'
 
-let mockServer: MockConnectorServer | null = null
-
 export default async function globalSetup() {
   console.log('[Global Setup] Starting mock connector server...')
 
-  mockServer = new MockConnectorServer(DEFAULT_TEST_CONFIG)
+  const mockServer = new MockConnectorServer(DEFAULT_TEST_CONFIG)
 
   try {
     await mockServer.start()
     console.log(`[Global Setup] Mock connector ready at http://127.0.0.1:${mockServer.port}`)
     console.log(`[Global Setup] Test token: ${mockServer.token}`)
-
-    // Store the server instance for global teardown
-    ;(globalThis as Record<string, unknown>).__mockConnectorServer = mockServer
   } catch (error) {
     console.error('[Global Setup] Failed to start mock connector:', error)
     throw error
   }
+
+  // Return teardown function — Playwright calls this after all tests complete
+  return async () => {
+    console.log('[Global Teardown] Stopping mock connector server...')
+    try {
+      await mockServer.stop()
+    } catch (error) {
+      console.error('[Global Teardown] Error stopping mock connector:', error)
+    }
+  }
 }

test/e2e/global-teardown.ts

@@ -81,20 +81,33 @@ export class MockConnectorClient {
         ...options?.headers,
       },
     })
+    if (!response.ok) {
+      throw new Error(
+        `Mock connector request failed: ${response.status} ${response.statusText} (${path})`,
+      )
+    }
     return response.json() as Promise<T>
   }
 
-  /** Reset the mock connector state */
-  async reset(): Promise<void> {
-    // Reset state via test endpoint (no auth required)
-    await fetch(`${this.baseUrl}/__test__/reset`, { method: 'POST' })
-
-    // Connect to establish session
-    await fetch(`${this.baseUrl}/connect`, {
+  /** Make a fire-and-forget POST to a test-only endpoint, throwing on failure. */
+  private async testEndpoint(path: string, body: unknown): Promise<void> {
+    const response = await fetch(`${this.baseUrl}${path}`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ token: this.token }),
+      body: JSON.stringify(body),
     })
+    if (!response.ok) {
+      throw new Error(
+        `Mock connector test endpoint failed: ${response.status} ${response.statusText} (${path})`,
+      )
+    }
+  }
+
+  /** Reset the mock connector state */
+  async reset(): Promise<void> {
+    await this.testEndpoint('/__test__/reset', {})
+    // Connect to establish session
+    await this.testEndpoint('/connect', { token: this.token })
   }
 
   /** Set org data */
@@ -106,41 +119,25 @@ export class MockConnectorClient {
       teamMembers?: Record<string, string[]>
     },
   ): Promise<void> {
-    await fetch(`${this.baseUrl}/__test__/org`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ org, ...data }),
-    })
+    await this.testEndpoint('/__test__/org', { org, ...data })
   }
 
   /** Set user orgs */
   async setUserOrgs(orgs: string[]): Promise<void> {
-    await fetch(`${this.baseUrl}/__test__/user-orgs`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ orgs }),
-    })
+    await this.testEndpoint('/__test__/user-orgs', { orgs })
   }
 
   /** Set user packages */
   async setUserPackages(packages: Record<string, 'read-only' | 'read-write'>): Promise<void> {
-    await fetch(`${this.baseUrl}/__test__/user-packages`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ packages }),
-    })
+    await this.testEndpoint('/__test__/user-packages', { packages })
   }
 
   /** Set package data */
   async setPackageData(
     pkg: string,
     data: { collaborators?: Record<string, 'read-only' | 'read-write'> },
   ): Promise<void> {
-    await fetch(`${this.baseUrl}/__test__/package`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ package: pkg, ...data }),
-    })
+    await this.testEndpoint('/__test__/package', { package: pkg, ...data })
   }
 
   /** Add an operation */

test/e2e/helpers/fixtures.ts

@@ -523,6 +523,7 @@ export class MockConnectorServer {
       const port = this.stateManager.port
 
       this.server!.on('error', (err: NodeJS.ErrnoException) => {
+        this.server = null
         if (err.code === 'EADDRINUSE') {
           reject(new Error(`Port ${port} is already in use. Is the real connector running?`))
         } else {