session caching + consolidate auth dir

Author: phyllis-sy-wu

packages/e2e/setup/global-auth.ts

@@ -1,19 +1,20 @@
 /**
  * Playwright globalSetup — authenticates once before any workers start.
  *
- * Performs CLI `auth login` with a dedicated temp dir, then stores the
- * path in E2E_AUTH_CONFIG_DIR so each worker can copy the session files
- * into its own isolated XDG dirs.
+ * Uses a stable `global-auth/` dir for session caching across runs.
+ * On subsequent runs, validates the cached browser session before
+ * re-authenticating. Workers copy the session files into their own
+ * isolated XDG dirs via E2E_AUTH_* env vars.
  */
 
 /* eslint-disable no-restricted-imports */
-import {createIsolatedEnv, directories, executables, globalLog} from './env.js'
+import {directories, executables, globalLog} from './env.js'
 import {CLI_TIMEOUT, BROWSER_TIMEOUT} from './constants.js'
 import {stripAnsi} from '../helpers/strip-ansi.js'
 import {waitForText} from '../helpers/wait-for-text.js'
 import {completeLogin} from '../helpers/browser-login.js'
 import {execa} from 'execa'
-import {chromium} from '@playwright/test'
+import {chromium, type Page} from '@playwright/test'
 import * as path from 'path'
 import * as fs from 'fs'
 
@@ -35,10 +36,18 @@ export default async function globalSetup() {
   const debug = process.env.DEBUG === '1'
   globalLog('auth', 'global setup starting')
 
-  // Create a temp dir for the auth session
+  // Use a stable auth dir (reused across runs for session caching)
   const tmpBase = process.env.E2E_TEMP_DIR ?? path.join(directories.root, '.e2e-tmp')
   fs.mkdirSync(tmpBase, {recursive: true})
-  const {xdgEnv} = createIsolatedEnv(tmpBase)
+  const authDir = path.join(tmpBase, 'global-auth')
+  const storageStatePath = path.join(authDir, 'browser-storage-state.json')
+
+  const xdgEnv = {
+    XDG_DATA_HOME: path.join(authDir, 'XDG_DATA_HOME'),
+    XDG_CONFIG_HOME: path.join(authDir, 'XDG_CONFIG_HOME'),
+    XDG_STATE_HOME: path.join(authDir, 'XDG_STATE_HOME'),
+    XDG_CACHE_HOME: path.join(authDir, 'XDG_CACHE_HOME'),
+  }
 
   const processEnv: NodeJS.ProcessEnv = {
     ...process.env,
@@ -50,6 +59,33 @@ export default async function globalSetup() {
     SHOPIFY_FLAG_CLIENT_ID: undefined,
   }
 
+  // Check if cached session from a previous run is still valid
+  if (fs.existsSync(storageStatePath)) {
+    const browser = await chromium.launch({headless: true})
+    try {
+      const context = await browser.newContext({storageState: storageStatePath})
+      const page = await context.newPage()
+      await page.goto('https://admin.shopify.com/', {waitUntil: 'domcontentloaded', timeout: BROWSER_TIMEOUT.long})
+      if (!isAccountsShopifyUrl(page.url())) {
+        globalLog('auth', 'reusing cached session')
+        setAuthEnvVars(xdgEnv, storageStatePath)
+        return
+      }
+    } catch {
+      // Browser check failed — fall through to re-authenticate
+    } finally {
+      await browser.close().catch(() => {})
+    }
+    globalLog('auth', 'cached session expired, re-authenticating')
+  } else {
+    globalLog('auth', 'no cached session found')
+  }
+
+  // Create fresh XDG dirs
+  for (const dir of Object.values(xdgEnv)) {
+    fs.mkdirSync(dir, {recursive: true})
+  }
+
   // Clear any existing session
   await execa('node', [executables.cli, 'auth', 'logout'], {
     env: processEnv,
@@ -78,8 +114,6 @@ export default async function globalSetup() {
     if (debug) process.stdout.write(data)
   })
 
-  const storageStatePath = path.join(tmpBase, 'browser-storage-state.json')
-
   try {
     await waitForText(() => output, 'Open this link to start the auth process', CLI_TIMEOUT.short)
 
@@ -107,31 +141,8 @@ export default async function globalSetup() {
       // (completeLogin only authenticates on accounts.shopify.com)
       const orgId = (process.env.E2E_ORG_ID ?? '').trim()
       if (orgId) {
-        // Establish admin.shopify.com cookies
-        await page.goto('https://admin.shopify.com/', {waitUntil: 'domcontentloaded'})
-        await page.waitForTimeout(BROWSER_TIMEOUT.medium)
-
-        // Handle account picker if shown
-        if (isAccountsShopifyUrl(page.url())) {
-          const accountButton = page.locator(`text=${email}`).first()
-          if (await accountButton.isVisible({timeout: BROWSER_TIMEOUT.long}).catch(() => false)) {
-            await accountButton.click()
-            await page.waitForTimeout(BROWSER_TIMEOUT.medium)
-          }
-        }
-
-        // Establish dev.shopify.com cookies
-        await page.goto(`https://dev.shopify.com/dashboard/${orgId}/apps`, {waitUntil: 'domcontentloaded'})
-        await page.waitForTimeout(BROWSER_TIMEOUT.medium)
-
-        if (isAccountsShopifyUrl(page.url())) {
-          const accountButton = page.locator(`text=${email}`).first()
-          if (await accountButton.isVisible({timeout: BROWSER_TIMEOUT.long}).catch(() => false)) {
-            await accountButton.click()
-            await page.waitForTimeout(BROWSER_TIMEOUT.medium)
-          }
-        }
-
+        await visitAndHandleAccountPicker(page, 'https://admin.shopify.com/', email)
+        await visitAndHandleAccountPicker(page, `https://dev.shopify.com/dashboard/${orgId}/apps`, email)
         globalLog('auth', 'browser sessions established for admin + dev dashboard')
       }
 
@@ -149,14 +160,29 @@ export default async function globalSetup() {
     }
   }
 
-  // Store paths so workers can copy CLI auth + load browser state
+  setAuthEnvVars(xdgEnv, storageStatePath)
+  globalLog('auth', `global setup done, config at ${xdgEnv.XDG_CONFIG_HOME}`)
+}
+
+/** Navigate to a URL and dismiss the account picker if it appears. */
+async function visitAndHandleAccountPicker(page: Page, url: string, email: string) {
+  await page.goto(url, {waitUntil: 'domcontentloaded'})
+  await page.waitForTimeout(BROWSER_TIMEOUT.medium)
+  if (isAccountsShopifyUrl(page.url())) {
+    const accountButton = page.locator(`text=${email}`).first()
+    if (await accountButton.isVisible({timeout: BROWSER_TIMEOUT.long}).catch(() => false)) {
+      await accountButton.click()
+      await page.waitForTimeout(BROWSER_TIMEOUT.medium)
+    }
+  }
+}
+
+function setAuthEnvVars(xdgEnv: Record<string, string>, storageStatePath: string): void {
   /* eslint-disable require-atomic-updates */
   process.env.E2E_AUTH_CONFIG_DIR = xdgEnv.XDG_CONFIG_HOME
   process.env.E2E_AUTH_DATA_DIR = xdgEnv.XDG_DATA_HOME
   process.env.E2E_AUTH_STATE_DIR = xdgEnv.XDG_STATE_HOME
   process.env.E2E_AUTH_CACHE_DIR = xdgEnv.XDG_CACHE_HOME
   process.env.E2E_BROWSER_STATE_PATH = storageStatePath
   /* eslint-enable require-atomic-updates */
-
-  globalLog('auth', `global setup done, config at ${xdgEnv.XDG_CONFIG_HOME}`)
 }