End-to-end testing guide

/**
 * The dispute.markets e2e fixture. Import `test` and `expect` from here
 * instead of `@playwright/test`.
 *
 * Contract (docs: https://dispute.markets/docs/api/e2e-testing):
 * - Every test gets its own correlation id, `${RUN_ID}:${testInfo.testId}`,
 *   checked against the API's pattern before use. `dm.api` sends it as
 *   `X-Correlation-Id`; for the browser it is the `dm_correlation_id`
 *   cookie on the portal host, which the portal forwards. Every audit
 *   event a test causes carries it.
 * - `mark()` returns the workspace's current audit high-water `seq`.
 * - `waitFor(filter)` calls `GET /v1/audit-events/wait` once and returns
 *   the matching events, or throws with the events it did see.
 * - `expectSequence(filter, expected, {mode, timeout})` waits repeatedly,
 *   moving `after_seq` to `high_water_seq`, until `expected` matches or
 *   the timeout passes, then throws a diff of everything seen.
 *   `subsequence` (default) lets other events interleave; `exact` needs
 *   an `action` filter so only the listed actions count.
 * - 429, 503 and 409 `generate_in_progress` are retried after `Retry-After`.
 * - `generate()` makes fixtures only this test touches (by
 *   `generate_job_id`) and deletes exactly them after the test.
 *   Never call `POST /v1/dev/reset`: it wipes every run's fixtures.
 *
 * Long-running flows (docs: https://dispute.markets/docs/api/flows):
 * - Every `dm.api` call sends `X-DM-Flow: fp_platform` and every browser
 *   context gets the `dm_flow=fp_platform` cookie, so the workspace default
 *   a person sets in the portal never reaches CI. `dm.useFlow(ref)` pins
 *   another profile for the rest of the test.
 * - `dm.flowProfile(name, variants)` creates `<name>-<hash8>` once
 *   (idempotent, never deleted) and returns its pinned `ref`.
 * - `dm.fastForward(filter)` moves scheduled jobs to now (or
 *   `to_remaining`) and waits until they ran, up to 60 s. No sleeps.
 * - `dm.sink()` is a dev webhook sink plus a webhook on it, scoped to this
 *   run's correlation prefix; both are deleted after the test.
 * - Flow opt-in is owner-only: `ownerTest` contexts (signed in as
 *   `DM_OWNER`) may `useFlow`; synthetic-account contexts (`uiTest`) see
 *   the profile the owner assigned to their account (`dmWorker.assignFlow`,
 *   worker setup only).
 * - Global teardown cancels every scheduled job the run left behind.
 */
import { test as base, expect } from '@playwright/test';
import type { APIRequestContext, Browser, BrowserContext, Page, PlaywrightWorkerArgs } from '@playwright/test';
import { existsSync, mkdirSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { ApiError, DmApi } from './api';
import { describeEvent, ExpectedEvent, matchesSequence, sequenceDiff, SequenceMode } from './audit';
import { assertCorrelationId, CORRELATION_COOKIE, CORRELATION_ID_HEADER } from './correlation';
import { API_URL, apiKey, otherApiKey, ownerAccount, PORTAL_URL, RUN_ID, SyntheticAccount, syntheticAccounts } from './env';
import {
  assertPinnedRef,
  cancelRun,
  ensureFlowProfile,
  fastForward,
  FastForwardOptions,
  FastForwardResult,
  FLOW_COOKIE,
  FLOW_HEADER,
  FlowProfileRef,
  FlowVariants,
  listScheduledJobs,
  PLATFORM_FLOW,
} from './flows';
import { totp, totpSecondsLeft } from './totp';
import type {
  AuditCursor,
  AuditEvent,
  AuditEventList,
  AuditFilter,
  AuditWaitResult,
  BackgroundTaskFeed,
  ExpireSessionsResult,
  GenerateJob,
  GenerateRequest,
  ScheduledJob,
  ScheduledJobFilter,
  ScheduledJobQuery,
  Webhook,
  WebhookSink,
  Whoami,
} from './types';

/** The API caps one wait at 25 s; longer timeouts wait again. */
const WAIT_MAX_S = 25;

export interface WaitOptions {
  /** How many matching events to wait for (1-50). Default 1. */
  minCount?: number;
  /** Milliseconds. Default 15 000. */
  timeout?: number;
}

export interface SequenceOptions {
  mode?: SequenceMode;
  /** Milliseconds. Default 15 000. */
  timeout?: number;
}

export interface GeneratedFixtures {
  job: GenerateJob;
  /** The `generate_job.run` event: `metadata.disputes` says how many disputes it made. */
  run: AuditEvent;
}

/** A dev webhook sink and a webhook on it, scoped to this run (`dm.sink()`). */
export interface RunSink {
  sink: WebhookSink;
  webhook: Webhook;
}

export interface SinkOptions {
  /** Event types the webhook subscribes to. Default: all. */
  events?: string[];
}

/** The `dm_prefs` keys a browser may override (Settings > Preferences, per browser). */
export interface BrowserPrefs {
  /** An IANA time zone, e.g. `Asia/Tokyo`. */
  tz?: string;
  locale?: 'en' | 'pt' | 'ro' | 'nn' | 'no' | 'he';
  date_format?: 'locale' | 'iso';
  hour_cycle?: 'h12' | 'h23';
  page_size?: 25 | 50 | 100 | 200;
}

/** Which kind of portal session a browser context holds. */
export type BrowserSession = 'owner' | 'synthetic_account';

export interface Dm {
  /** The API, authenticated with the key and tagged with this test's correlation id. */
  api: DmApi;
  correlationId: string;
  mark(): Promise<number>;
  waitFor(filter: AuditFilter, options?: WaitOptions): Promise<AuditEvent[]>;
  /** Every matching event, oldest first (follows `next_cursor`). */
  events(filter: AuditFilter): Promise<AuditEvent[]>;
  expectSequence(filter: AuditFilter, expected: readonly ExpectedEvent[], options?: SequenceOptions): Promise<AuditEvent[]>;
  /** Starts a generate job, waits until it ran, and deletes its data after the test. */
  generate(request?: Partial<GenerateRequest>): Promise<GeneratedFixtures>;
  /** Runs after the test, newest first, even when the test failed. */
  onCleanup(fn: () => Promise<unknown>): void;

  /** Creates `<name>-<hash8 of the canonical variants>` once (idempotent, cached, never deleted). */
  flowProfile(name: string, variants: FlowVariants): Promise<FlowProfileRef>;
  /**
   * Pins a profile (`fp_platform` or `fp_…@N`) for the rest of the test:
   * `X-DM-Flow` on `dm.api` and, in an owner browser, the `dm_flow`
   * cookie. Throws in a synthetic-account browser, whose cookie the
   * portal ignores (use `dmWorker.assignFlow` in worker setup instead).
   */
  useFlow(ref: string): Promise<void>;
  /** The profile `dm.api` sends now. */
  readonly flowRef: string;
  /** Moves the matching scheduled jobs to now (or `to_remaining`) and, by default, waits until they ran (60 s ceiling). */
  fastForward(filter: ScheduledJobFilter, options?: FastForwardOptions): Promise<FastForwardResult>;
  /** Every scheduled job matching `query`, newest first. */
  scheduledJobs(query: ScheduledJobQuery): Promise<ScheduledJob[]>;
  /** Cancels every scheduled job of this run (correlation prefix `<RUN_ID>:`). Global teardown calls it too. */
  cancelRun(): Promise<number>;
  /** A dev webhook sink and a webhook on it, both scoped to this run; deleted after the test. */
  sink(options?: SinkOptions): Promise<RunSink>;
  /** Sets the `dm_prefs` cookie (time zone, language, …) on a browser context. */
  prefs(context: BrowserContext, prefs: BrowserPrefs): Promise<void>;
  /** The signed-in user's background tasks (`GET /v1/me/background-tasks`), read in the browser's session. */
  tasks(page: Page): Promise<BackgroundTaskFeed>;
  /** Makes every current session of a synthetic account answer 401 `session_expired` (key with `flow.write`). */
  expireSessions(accountId: string): Promise<ExpireSessionsResult>;
}

/** The API's query parameters for a filter. */
export function toQuery(filter: AuditFilter): Record<string, string | number | undefined> {
  const { action, after_seq, ...rest } = filter;
  const q: Record<string, string | number | undefined> = { ...rest, after_seq: String(after_seq) };
  if (action !== undefined) q.action = typeof action === 'string' ? action : action.join(',');
  return q;
}

function sleep(ms: number): Promise<void> {
  return new Promise((r) => setTimeout(r, ms));
}

class DmFixture implements Dm {
  private readonly cleanups: Array<() => Promise<unknown>> = [];
  private browser: { context: BrowserContext; session: BrowserSession } | null = null;

  constructor(
    readonly api: DmApi,
    readonly correlationId: string,
  ) {
    api.setDefaultHeader(FLOW_HEADER, PLATFORM_FLOW);
  }

  /** Called by the browser fixtures: which context `useFlow` sets the cookie on. */
  bindBrowser(context: BrowserContext, session: BrowserSession): void {
    this.browser = { context, session };
  }

  get flowRef(): string {
    return this.api.defaultHeader(FLOW_HEADER) ?? PLATFORM_FLOW;
  }

  flowProfile(name: string, variants: FlowVariants): Promise<FlowProfileRef> {
    return ensureFlowProfile(this.api, name, variants);
  }

  async useFlow(ref: string): Promise<void> {
    assertPinnedRef(ref);
    if (this.browser?.session === 'synthetic_account') {
      throw new Error(
        'dm.useFlow in a synthetic-account browser: the portal ignores dm_flow for anyone but the owner ' +
          '(docs/api/flows, "Only the owner opts in"). Assign the account a profile in worker setup ' +
          '(dmWorker.assignFlow), or test this variant in an ownerTest context.',
      );
    }
    this.api.setDefaultHeader(FLOW_HEADER, ref);
    if (this.browser) {
      await this.browser.context.addCookies([{ name: FLOW_COOKIE, value: ref, url: PORTAL_URL }]);
    }
  }

  fastForward(filter: ScheduledJobFilter, options?: FastForwardOptions): Promise<FastForwardResult> {
    return fastForward(this.api, filter, options);
  }

  scheduledJobs(query: ScheduledJobQuery): Promise<ScheduledJob[]> {
    return listScheduledJobs(this.api, query);
  }

  cancelRun(): Promise<number> {
    return cancelRun(this.api);
  }

  async sink(options: SinkOptions = {}): Promise<RunSink> {
    const filter = { correlation_prefix: `${RUN_ID}:` };
    const sink = await this.api.post<WebhookSink>('/v1/dev/webhook-sinks', { filter });
    // Free the sink's slot (10 live per workspace) as soon as the test ends.
    this.onCleanup(() => this.api.delete(`/v1/dev/webhook-sinks/${sink.id}`));
    const webhook = await this.api.post<Webhook>('/v1/webhooks', {
      url: sink.url,
      ...(options.events ? { events: options.events } : {}),
      filter,
    });
    this.onCleanup(() => this.api.delete(`/v1/webhooks/${webhook.id}`));
    return { sink, webhook };
  }

  async prefs(context: BrowserContext, prefs: BrowserPrefs): Promise<void> {
    const value = Object.entries(prefs)
      .filter(([, v]) => v !== undefined)
      .map(([k, v]) => `${k}=${v}`)
      .join(';');
    await context.addCookies([{ name: 'dm_prefs', value: encodeURIComponent(value), url: PORTAL_URL }]);
  }

  async tasks(page: Page): Promise<BackgroundTaskFeed> {
    // The portal forwards /api/proxy/* to the API with the session's token.
    const res = await page.request.get(`${PORTAL_URL}/api/proxy/me/background-tasks`, { params: { limit: 20 } });
    if (!res.ok()) throw new Error(`GET /v1/me/background-tasks answered ${res.status()}`);
    return (await res.json()) as BackgroundTaskFeed;
  }

  expireSessions(accountId: string): Promise<ExpireSessionsResult> {
    return this.api.post<ExpireSessionsResult>(`/v1/team/synthetic-accounts/${accountId}/expire-sessions`);
  }

  async mark(): Promise<number> {
    const res = await this.api.get<AuditCursor>('/v1/audit-events/cursor');
    return res.seq;
  }

  private async waitOnce(filter: AuditFilter, minCount: number, timeoutMs: number): Promise<AuditWaitResult> {
    const timeout_s = Math.max(1, Math.min(WAIT_MAX_S, Math.ceil(timeoutMs / 1000)));
    return this.api.get<AuditWaitResult>('/v1/audit-events/wait', {
      ...toQuery(filter),
      min_count: minCount,
      timeout_s,
    });
  }

  async waitFor(filter: AuditFilter, options: WaitOptions = {}): Promise<AuditEvent[]> {
    const minCount = options.minCount ?? 1;
    const deadline = Date.now() + (options.timeout ?? 15_000);
    for (;;) {
      const res = await this.waitOnce(filter, minCount, deadline - Date.now());
      if (res.satisfied) return res.data;
      if (Date.now() >= deadline) {
        throw new Error(
          `waitFor(${JSON.stringify(filter)}) saw ${res.data.length} of ${minCount} event(s):\n` +
            res.data.map((e) => `  ${describeEvent(e)}`).join('\n'),
        );
      }
    }
  }

  async events(filter: AuditFilter): Promise<AuditEvent[]> {
    const out: AuditEvent[] = [];
    let cursor: string | undefined;
    do {
      const page = await this.api.get<AuditEventList>('/v1/audit-events', {
        ...toQuery(filter),
        order: 'asc',
        limit: 200,
        cursor,
      });
      out.push(...page.data);
      cursor = page.pagination.next_cursor ?? undefined;
    } while (cursor);
    return out;
  }

  async expectSequence(
    filter: AuditFilter,
    expected: readonly ExpectedEvent[],
    options: SequenceOptions = {},
  ): Promise<AuditEvent[]> {
    const mode = options.mode ?? 'subsequence';
    if (mode === 'exact' && filter.action === undefined) {
      throw new Error("expectSequence mode 'exact' needs an action filter, so only the listed actions count");
    }
    const deadline = Date.now() + (options.timeout ?? 15_000);
    const seen: AuditEvent[] = [];
    let afterSeq = filter.after_seq;
    for (;;) {
      const res = await this.waitOnce({ ...filter, after_seq: afterSeq }, 1, deadline - Date.now());
      seen.push(...res.data);
      afterSeq = Math.max(afterSeq, res.high_water_seq);
      if (matchesSequence(seen, expected, mode)) return seen;
      if (mode === 'exact' && seen.length >= expected.length) break;
      if (Date.now() >= deadline) break;
    }
    throw new Error(`expectSequence failed for ${JSON.stringify(filter)}\n${sequenceDiff(seen, expected, mode)}`);
  }

  async generate(request: Partial<GenerateRequest> = {}): Promise<GeneratedFixtures> {
    const mark = await this.mark();
    const body: GenerateRequest = {
      count: 5,
      dispute_rate: 1,
      currency: 'USD',
      range_days: 30,
      ...request,
    };
    const job = await this.api.post<GenerateJob>('/v1/dev/generate', body);
    this.onCleanup(() => this.api.post(`/v1/dev/generate-jobs/${job.id}/cleanup`));
    const [run] = await this.waitFor(
      { action: 'generate_job.run', target_id: job.id, after_seq: mark },
      { timeout: 60_000 },
    );
    if (run.outcome !== 'success') {
      throw new Error(`generate job ${job.id} failed: ${describeEvent(run)}`);
    }
    return { job, run };
  }

  onCleanup(fn: () => Promise<unknown>): void {
    this.cleanups.push(fn);
  }

  async runCleanups(): Promise<void> {
    const errors: unknown[] = [];
    for (const fn of this.cleanups.reverse()) {
      try {
        await fn();
      } catch (err) {
        errors.push(err);
      }
    }
    if (errors.length) throw new AggregateError(errors, `${errors.length} cleanup step(s) failed`);
  }
}

/**
 * What the browser specs do in the portal: read disputes and act on them.
 * A role without `dispute.write` (View only, Reports) gets no action
 * buttons in the portal and 403 `missing_permission` from the API, so
 * without this check it would fail a spec far from the cause.
 */
const UI_REQUIRED_PERMISSIONS = ['dispute.read', 'dispute.write'] as const;

/** Fails the worker at once, naming the account and its role, when it cannot run the browser specs. */
async function assertUiPermissions(page: import('@playwright/test').Page, identifier: string): Promise<void> {
  // The portal forwards /api/proxy/* to the API with the session's token.
  const res = await page.request.get('/api/proxy/auth/me');
  if (!res.ok()) throw new Error(`GET /v1/auth/me as ${identifier} answered ${res.status()}`);
  const me = (await res.json()) as { is_owner?: boolean; tenant_role?: string | null; permissions?: string[] };
  const missing = me.is_owner ? [] : UI_REQUIRED_PERMISSIONS.filter((p) => !me.permissions?.includes(p));
  if (missing.length > 0) {
    throw new Error(
      `${identifier} has role ${me.tenant_role ?? 'none'} and lacks ${missing.join(', ')}. ` +
        'The browser specs act on disputes: give the account Full access (or Disputes) in Team > Synthetic accounts.',
    );
  }
}

/** Answers the sign-in MFA prompt. A code is accepted once: when another run (or worker) just used this window's code for the same account, it tries the next window's. */
async function answerTotp(page: Page, account: SyntheticAccount): Promise<void> {
  if (!account.totp_secret) throw new Error(`${account.identifier} needs MFA but has no totp_secret`);
  const code = page.getByLabel('Code', { exact: true });
  for (let attempt = 1; ; attempt++) {
    if (totpSecondsLeft() < 5) await sleep(totpSecondsLeft() * 1000 + 500);
    const window = Math.floor(Date.now() / 30_000);
    await code.fill(totp(account.totp_secret));
    await page.getByRole('button', { name: 'Verify' }).click();
    const ok = await page
      .waitForURL(/\/dashboard/, { timeout: 10_000 })
      .then(() => true)
      .catch(() => false);
    if (ok) return;
    if (attempt === 3) throw new Error(`${account.identifier}: the TOTP code was refused 3 times`);
    await sleep(Math.max(0, (window + 1) * 30_000 - Date.now()) + 500);
  }
}

/**
 * Signs `account` in through the portal's own form (answering TOTP when
 * asked) and saves the session to `file`. `checkRole` (default true)
 * fails at once when a synthetic account cannot act on disputes.
 */
export async function signInTo(
  browser: Browser,
  account: SyntheticAccount,
  file: string,
  { checkRole = true }: { checkRole?: boolean } = {},
): Promise<void> {
  mkdirSync(dirname(file), { recursive: true });
  const page = await browser.newPage({ baseURL: PORTAL_URL, storageState: undefined });
  try {
    // Several CI jobs signing in from one address can meet the sign-in
    // rate limit (429, shown on the form): wait and try again, twice.
    for (let attempt = 1; ; attempt++) {
      await page.goto('/en/sign-in');
      await page.getByLabel('Username or email').fill(account.identifier);
      await page.getByLabel('Password', { exact: true }).fill(account.password);
      await page.getByRole('button', { name: 'Sign in' }).click();
      const code = page.getByLabel('Code', { exact: true });
      const landed = page.waitForURL(/\/dashboard/, { timeout: 30_000 }).then(() => 'done' as const);
      const challenged = code.waitFor({ timeout: 30_000 }).then(() => 'mfa' as const);
      // Whichever loses the race must not reject unobserved.
      landed.catch(() => undefined);
      challenged.catch(() => undefined);
      const outcome = await Promise.race([landed, challenged]).catch(() => 'stuck' as const);
      if (outcome === 'stuck') {
        const shown = (await page.getByRole('alert').allInnerTexts().catch(() => [])).join(' ').trim();
        if (attempt === 3) throw new Error(`${account.identifier} could not sign in: ${shown || 'no dashboard, no MFA prompt'}`);
        await sleep(20_000);
        continue;
      }
      if (outcome === 'mfa') await answerTotp(page, account);
      break;
    }
    if (checkRole) await assertUiPermissions(page, account.identifier);
    await page.context().storageState({ path: file });
  } finally {
    await page.close();
  }
}

/** Signs one synthetic account in and returns the saved session file. */
async function signIn(browser: Browser, index: number, outputDir: string): Promise<string> {
  const accounts = syntheticAccounts();
  if (accounts.length === 0) {
    throw new Error('UI specs need DM_SYNTHETIC_ACCOUNTS (a JSON list, one synthetic account per worker).');
  }
  const account = accounts[index % accounts.length];
  // Workers that share an account sign in one after another (sign-in is
  // rate limited per identifier); each still gets its own session.
  await sleep(Math.floor(index / accounts.length) * 15_000);
  const file = join(outputDir, '.auth', `${RUN_ID}-worker-${index}.json`);
  await signInTo(browser, account, file);
  return file;
}

/** Where global setup saves the owner's session (one per run, shared by the owner contexts of every worker). */
export const OWNER_STATE_FILE = join(__dirname, '..', '.auth', `${RUN_ID}-owner.json`);

/** Global setup: signs `DM_OWNER` in once for the run. A no-op without it. */
export async function signInOwner(browser: Browser): Promise<boolean> {
  const owner = ownerAccount();
  if (!owner) return false;
  await signInTo(browser, owner, OWNER_STATE_FILE, { checkRole: false });
  return true;
}

/**
 * The owner's portal session as an API client (`/api/proxy/*` → `/v1/*`):
 * the routes no key may call (team, the workspace default).
 */
export async function ownerRequest(playwright: PlaywrightWorkerArgs['playwright']): Promise<APIRequestContext> {
  if (!existsSync(OWNER_STATE_FILE)) {
    throw new Error('Owner-only setup needs DM_OWNER (global setup signs the workspace owner in once per run).');
  }
  return playwright.request.newContext({ baseURL: `${PORTAL_URL}/api/proxy/`, storageState: OWNER_STATE_FILE });
}

/** The synthetic account's id (`sa_…`): from DM_SYNTHETIC_ACCOUNTS, else looked up by email as the owner. */
async function accountId(owner: APIRequestContext, account: SyntheticAccount): Promise<string> {
  if (account.id) return account.id;
  const res = await owner.get('team/synthetic-accounts');
  if (!res.ok()) throw new Error(`GET /v1/team/synthetic-accounts as the owner answered ${res.status()}`);
  const { items } = (await res.json()) as { items: Array<{ id: string; email: string }> };
  const found = items.find((a) => a.email.toLowerCase() === account.identifier.toLowerCase());
  if (!found) throw new Error(`no synthetic account with email ${account.identifier}: add its "id" to DM_SYNTHETIC_ACCOUNTS`);
  return found.id;
}

/** Worker-scoped helpers for owner-only setup (`dmWorker`). */
export interface DmWorker {
  /** This worker's synthetic account (DM_SYNTHETIC_ACCOUNTS), or null when none is set. */
  account: SyntheticAccount | null;
  /**
   * Assigns a synthetic account's flow profile (`fp_platform`, `fp_…@N`,
   * or null for the workspace default) as the owner. Worker setup only:
   * accounts are shared by concurrent runs, so never toggle one inside a
   * test. The worker restores the previous assignment when it ends.
   */
  assignFlow(account: SyntheticAccount, ref: string | null): Promise<void>;
}

export const test = base.extend<{ dm: Dm; correlationId: string }>({
  // Playwright requires a destructuring pattern as a fixture's first argument.
  // eslint-disable-next-line no-empty-pattern
  correlationId: async ({}, use, testInfo) => {
    await use(assertCorrelationId(`${RUN_ID}:${testInfo.testId}`));
  },

  // Browser specs: the portal forwards this cookie as X-Correlation-Id,
  // so the test's clicks land under its correlation id too.
  context: async ({ context, correlationId }, use) => {
    await context.addCookies([
      { name: CORRELATION_COOKIE, value: correlationId, url: PORTAL_URL },
      { name: FLOW_COOKIE, value: PLATFORM_FLOW, url: PORTAL_URL },
    ]);
    await use(context);
  },

  dm: async ({ playwright, correlationId }, use) => {
    await withDm(playwright, apiKey(), correlationId, use);
  },
});

/** A `Dm` on its own request context for `key`; runs its cleanups and disposes it after `use`. */
async function withDm(
  playwright: PlaywrightWorkerArgs['playwright'],
  key: string,
  correlationId: string,
  use: (dm: Dm) => Promise<void>,
): Promise<void> {
  const request = await playwright.request.newContext({
    baseURL: API_URL,
    extraHTTPHeaders: {
      Authorization: `Bearer ${key}`,
      [CORRELATION_ID_HEADER]: correlationId,
    },
  });
  const dm = new DmFixture(new DmApi(request), correlationId);
  try {
    await use(dm);
  } finally {
    try {
      await dm.runCleanups();
    } finally {
      await request.dispose();
    }
  }
}

/**
 * For specs that span two workspaces: `test` plus `other`, a second `Dm`
 * on `DM_API_KEY_B` (a key from another workspace of the same person),
 * with its own cleanups. Skips the test when `DM_API_KEY_B` is not set.
 * Both fixtures tag requests with the same correlation id; each
 * workspace keeps its own audit trail.
 */
export const workspacesTest = test.extend<{ other: Dm }>({
  other: async ({ playwright, correlationId }, use, testInfo) => {
    const key = otherApiKey();
    testInfo.skip(!key, 'needs DM_API_KEY_B, a key from a second workspace (README, "One workspace per environment")');
    await withDm(playwright, key!, correlationId, use);
  },
});

/** `GET /v1/whoami`: the workspace (with its environment label) this key acts in. */
export function whoami(dm: Dm): Promise<Whoami> {
  return dm.api.get<Whoami>('/v1/whoami');
}

/**
 * `GET /v1/whoami` for a key, outside any test's fixture (browser specs
 * use it to learn which workspaces their keys point at).
 */
export async function whoamiOfKey(playwright: PlaywrightWorkerArgs['playwright'], key: string): Promise<Whoami> {
  const request = await playwright.request.newContext({
    baseURL: API_URL,
    extraHTTPHeaders: { Authorization: `Bearer ${key}`, [CORRELATION_ID_HEADER]: `${RUN_ID}:whoami` },
  });
  try {
    const res = await request.get('/v1/whoami');
    if (!res.ok()) throw new Error(`GET /v1/whoami answered ${res.status()} ${await res.text()}`);
    return (await res.json()) as Whoami;
  } finally {
    await request.dispose();
  }
}

/** Worker options of the browser specs. */
export interface UiWorkerOptions {
  /**
   * Which DM_SYNTHETIC_ACCOUNTS entry this worker signs in as. Default:
   * the worker's index (wrapping). Set it with `test.use` when a spec needs
   * two specific accounts at once.
   */
  accountSlot: number | undefined;
  /**
   * The flow profile the owner assigns to this worker's account before it
   * signs in, restored when the worker ends: `fp_platform`, `fp_…@N`,
   * `{name, variants}` (created like `dm.flowProfile`, then pinned) or
   * null (the workspace default). `undefined` (the default) leaves the
   * assignment alone. A worker option, so it changes only between
   * workers, never inside a test.
   */
  accountFlow: string | null | { name: string; variants: FlowVariants } | undefined;
}

/**
 * For browser specs: `test` plus a signed-in portal session per worker.
 * (Kept apart so API-only specs never start a browser.)
 */
export const uiTest = test.extend<{ session: BrowserSession }, UiWorkerOptions & { workerStorageState: string; dmWorker: DmWorker }>({
  // One session per worker, never shared: Heimdall revokes a session
  // whose refresh token is reused after its 60 s grace.
  storageState: async ({ workerStorageState }, use) => {
    await use(workerStorageState);
  },
  session: ['synthetic_account', { option: true }],
  dm: async ({ dm, context, session }, use) => {
    (dm as DmFixture).bindBrowser(context, session);
    await use(dm);
  },
  accountSlot: [undefined, { scope: 'worker', option: true }],
  accountFlow: [undefined, { scope: 'worker', option: true }],
  dmWorker: [
    async ({ playwright, accountSlot }, use, workerInfo) => {
      const accounts = syntheticAccounts();
      const account = accounts.length ? accounts[(accountSlot ?? workerInfo.parallelIndex) % accounts.length] : null;
      const restore: Array<() => Promise<void>> = [];
      const state: { owner: APIRequestContext | null } = { owner: null };
      const patch = async (id: string, ref: string | null): Promise<unknown> => {
        const res = await state.owner!.patch(`team/synthetic-accounts/${id}`, { data: { flow_profile: ref } });
        if (!res.ok()) throw new Error(`PATCH /v1/team/synthetic-accounts/${id} answered ${res.status()} ${await res.text()}`);
        return res.json();
      };
      const worker: DmWorker = {
        account,
        async assignFlow(acc, ref) {
          if (ref !== null) assertPinnedRef(ref);
          state.owner ??= await ownerRequest(playwright);
          const owner = state.owner;
          const id = await accountId(owner, acc);
          const list = await owner.get('team/synthetic-accounts');
          const { items } = (await list.json()) as { items: Array<{ id: string; flow_profile?: { ref: string } | null }> };
          const before = items.find((a) => a.id === id)?.flow_profile?.ref ?? null;
          await patch(id, ref);
          restore.push(() => patch(id, before).then(() => undefined));
        },
      };
      try {
        await use(worker);
      } finally {
        for (const fn of restore.reverse()) await fn();
        await state.owner?.dispose();
      }
    },
    { scope: 'worker' },
  ],
  workerStorageState: [
    async ({ browser, playwright, dmWorker, accountFlow, accountSlot }, use, workerInfo) => {
      if (accountFlow !== undefined) {
        if (!dmWorker.account) throw new Error('accountFlow needs DM_SYNTHETIC_ACCOUNTS');
        let ref: string | null;
        if (accountFlow === null || typeof accountFlow === 'string') {
          ref = accountFlow;
        } else {
          const request = await playwright.request.newContext({
            baseURL: API_URL,
            extraHTTPHeaders: { Authorization: `Bearer ${apiKey()}`, [CORRELATION_ID_HEADER]: `${RUN_ID}:worker-setup` },
          });
          try {
            ref = (await ensureFlowProfile(new DmApi(request), accountFlow.name, accountFlow.variants)).ref;
          } finally {
            await request.dispose();
          }
        }
        await dmWorker.assignFlow(dmWorker.account, ref);
      }
      await use(await signIn(browser, accountSlot ?? workerInfo.parallelIndex, workerInfo.project.outputDir));
    },
    { scope: 'worker' },
  ],
});

/**
 * For browser specs that choose a flow: the workspace owner's session
 * (`DM_OWNER`, signed in once per run by global setup and shared by every
 * worker). Only the owner may opt into a flow (`dm.useFlow`); keep
 * everything else in `uiTest`, as a synthetic account.
 */
export const ownerTest = test.extend<{ owner: APIRequestContext }>({
  // eslint-disable-next-line no-empty-pattern
  storageState: async ({}, use) => {
    if (!existsSync(OWNER_STATE_FILE)) throw new Error('ownerTest needs DM_OWNER (see the README).');
    await use(OWNER_STATE_FILE);
  },
  dm: async ({ dm, context }, use) => {
    (dm as DmFixture).bindBrowser(context, 'owner');
    await use(dm);
  },
  // The owner's session as an API client for routes no key may call
  // (`owner.post('team/synthetic-accounts', …)` is `POST /v1/team/synthetic-accounts`).
  owner: async ({ playwright }, use) => {
    const owner = await ownerRequest(playwright);
    try {
      await use(owner);
    } finally {
      await owner.dispose();
    }
  },
});

/** True when the owner was signed in for this run (DM_OWNER set). */
export function hasOwner(): boolean {
  return ownerAccount() !== null;
}

export { expect, ApiError };
export type { ExpectedEvent };

import { expect, test } from '../../src/dm';
import type { ErrorBody } from '../../src/types';

// (6) Keys never manage people or credentials: team and key routes
// refuse them outright, whatever their scopes.
for (const [method, path] of [
  ['GET', '/v1/team/synthetic-accounts'],
  ['POST', '/v1/team/synthetic-accounts'],
  // Setup emails too: only the owner can send one (the id is never looked up).
  ['POST', '/v1/team/synthetic-accounts/sa_example/email-setup'],
  ['GET', '/v1/api-keys'],
] as const) {
  test(`a key is refused on ${method} ${path}`, async ({ dm }) => {
    const res = await dm.api.fetch<ErrorBody>(method, path, method === 'POST' ? { data: {} } : {});
    expect(res.status).toBe(401);
    expect(res.body.code).toBe('api_key_not_allowed');
  });
}

import { expect, request as playwrightRequest, test } from '@playwright/test';
import { API_URL } from '../../src/env';

// (7) Revocation: a key revoked in Settings > API keys stops working on
// every server within 30 s (60 s budget here).
//
// This is a manual, occasional check, not part of an unattended run: an
// API key cannot revoke keys (/v1/api-keys answers 401
// api_key_not_allowed), and revoking takes a signed-in workspace owner.
// So a person creates a throwaway key, revokes it in Settings > API keys,
// and runs this spec within a minute, passing the key and the time of
// the revoke (README, "The revoked-key check"). Without them it skips,
// which is the expected result in CI.
const revokedKey = process.env.DM_REVOKED_API_KEY;
const revokedAt = Number(process.env.DM_REVOKED_AT ?? Date.now());

test.skip(
  !revokedKey,
  'manual check: revoke a throwaway key in Settings > API keys, then set DM_REVOKED_API_KEY (and DM_REVOKED_AT, ms since epoch) within 60 s',
);

test('a revoked key is refused within 60 s of revocation', async () => {
  const api = await playwrightRequest.newContext({
    baseURL: API_URL,
    extraHTTPHeaders: { Authorization: `Bearer ${revokedKey}` },
  });
  try {
    // Requests may land on any server; three refusals in a row (6 s
    // apart, longer than one server's cache answer) count as "everywhere".
    const deadline = revokedAt + 60_000;
    let streak = 0;
    let code: string | undefined;
    while (streak < 3 && Date.now() < deadline) {
      const res = await api.get('/v1/whoami');
      code = ((await res.json().catch(() => null)) as { code?: string } | null)?.code;
      streak = res.status() === 401 ? streak + 1 : 0;
      if (streak < 3) await new Promise((r) => setTimeout(r, 2_000));
    }
    expect(streak, `refused 3 times in a row by ${new Date(deadline).toISOString()}`).toBe(3);
    expect(code).toBe('invalid_api_key');
  } finally {
    await api.dispose();
  }
});

import type { BrowserContext, Page } from '@playwright/test';
import { expect, signInTo, test, whoamiOfKey } from '../../src/dm';
import { apiKey, expectedEnvironment, otherApiKey, ownerAccount, PORTAL_URL } from '../../src/env';
import type { WhoamiWorkspace } from '../../src/types';

// The workspace switcher, as a person (DM_OWNER) who belongs to both the
// workspace of DM_API_KEY ("A") and that of DM_API_KEY_B ("B"): the
// chrome names the environment you are in, and switching lands on the
// dashboard of the other workspace.
//
// The test signs the person in on a session of its own: switching moves
// that session to another workspace, so it must never be the run's
// shared owner session. It switches back to A at the end, so the next
// sign-in lands where it did before (sign-in picks the workspace used
// last).

test.skip(!ownerAccount() || !otherApiKey(), 'needs DM_OWNER and DM_API_KEY_B (README, "One workspace per environment")');

/** The sidebar's switcher trigger: [ENV chip] name / "dispute.markets · <Role>". */
const trigger = (page: Page) => page.getByTestId('workspace-switcher');

/** `#d97706` → `rgb(217, 119, 6)`, as computed styles report colours. */
function rgb(hex: string): string {
  const n = parseInt(hex.slice(1), 16);
  return `rgb(${(n >> 16) & 255}, ${(n >> 8) & 255}, ${n & 255})`;
}

/** Matches a tab title that starts with `label · ` (case-insensitive). */
function titlePrefix(label: string): RegExp {
  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  return new RegExp('^' + escaped + ' · ', 'i');
}

/** The chrome shows `w`: its name and environment chip on the switcher, and the stripe in its colour (none without a label). */
async function expectChrome(page: Page, w: WhoamiWorkspace): Promise<void> {
  await expect(trigger(page)).toContainText(w.name);
  const stripe = page.getByTestId('environment-stripe');
  if (w.environment_label) {
    await expect(trigger(page).getByTestId('env-chip')).toHaveText(w.environment_label, { ignoreCase: true });
    await expect(stripe).toBeVisible();
    if (w.environment_color) await expect(stripe).toHaveCSS('background-color', rgb(w.environment_color));
    // The tab title starts with the environment: "Staging · Disputes · dispute.markets".
    await expect(page).toHaveTitle(titlePrefix(w.environment_label));
  } else {
    await expect(trigger(page).getByTestId('env-chip')).toHaveCount(0);
    await expect(stripe).toHaveCount(0);
  }
}

/** Switches through the menu; the portal reloads on the dashboard of the chosen workspace. */
async function switchTo(page: Page, w: WhoamiWorkspace): Promise<void> {
  await trigger(page).click();
  const row = page.locator(`[data-testid="workspace-switcher-row"][data-workspace-id="${w.id}"]`);
  await expect(row, `${w.name} (${w.id}) is in the switcher: is DM_OWNER a member of it?`).toBeVisible();
  await row.click();
  await page.waitForURL(/\/dashboard(\?|$)/);
  await expect(trigger(page)).toContainText(w.name);
}

/** The workspace this browser's session acts in, as the API sees it. */
async function sessionWorkspace(context: BrowserContext): Promise<string | undefined> {
  const res = await context.request.get(`${PORTAL_URL}/api/proxy/auth/me`);
  expect(res.ok(), `GET /v1/auth/me answered ${res.status()}`).toBe(true);
  return ((await res.json()) as { workspace?: { id: string } | null }).workspace?.id;
}

test('the switcher names the environment, and switching lands on the dashboard of the other workspace', async ({
  browser,
  playwright,
}, testInfo) => {
  const [{ workspace: a }, { workspace: b }] = await Promise.all([
    whoamiOfKey(playwright, apiKey()),
    whoamiOfKey(playwright, otherApiKey()!),
  ]);
  expect(b.id, 'DM_API_KEY and DM_API_KEY_B are keys of the same workspace').not.toBe(a.id);
  const expected = expectedEnvironment();
  if (expected !== undefined) expect((a.environment_label ?? '').toLowerCase()).toBe((expected ?? '').toLowerCase());

  const stateFile = testInfo.outputPath('person.json');
  await signInTo(browser, ownerAccount()!, stateFile, { checkRole: false });
  const context = await browser.newContext({ baseURL: PORTAL_URL, storageState: stateFile });
  const page = await context.newPage();
  try {
    // Start in A, whichever workspace the sign-in landed in.
    await page.goto('/en/dashboard');
    if ((await sessionWorkspace(context)) !== a.id) await switchTo(page, a);
    await expectChrome(page, a);

    // Switch from a deep page: ids belong to one workspace, so the switch
    // lands on B's dashboard, never on the same URL.
    await page.goto('/en/disputes');
    await expectChrome(page, a);
    await switchTo(page, b);
    await expect(page).toHaveURL(/\/en\/dashboard(\?|$)/);
    await expectChrome(page, b);
    // Nothing of A's environment stays on screen.
    if (a.environment_label && a.environment_label !== b.environment_label) {
      await expect(page).not.toHaveTitle(titlePrefix(a.environment_label));
    }
    expect(await sessionWorkspace(context)).toBe(b.id);
  } finally {
    // Back to A, so the next sign-in lands where it did before; then sign out.
    await context.request
      .post(`${PORTAL_URL}/api/auth/switch-workspace`, { data: { workspace_id: a.id } })
      .catch(() => undefined);
    await context.request.post(`${PORTAL_URL}/api/auth/sign-out`).catch(() => undefined);
    await context.close();
  }
});

import { expect, hasOwner, ownerTest as test } from '../../src/dm';
import type { Dispute, DisputePage } from '../../src/types';

test.skip(!hasOwner(), 'set DM_OWNER to run the owner browser specs');

const HOUR_MS = 3600_000;

// (7) "One hour before the deadline" without waiting days: the dispute's
// response window is a scheduled job; `to_remaining: 'PT1H'` moves its
// deadline (and the job) to one hour from now. The browser shows the
// countdown in the time zone set by `dm.prefs`.
test('a deadline moved to one hour out shows the T-1 h countdown in the chosen time zone', async ({ page, context, dm }) => {
  const windows = await dm.flowProfile('evidence-window-3d', { 'lifecycle.windows': { evidence_s: 3 * 24 * 3600 } });
  await dm.useFlow(windows.ref);
  const { job } = await dm.generate({ count: 12, dispute_rate: 1, seed: 42 });
  const list = await dm.api.get<DisputePage>('/v1/disputes', {
    generate_job_id: job.id,
    status: 'evidence_required',
    page_size: 1,
  });
  expect(list.items).toHaveLength(1);
  const id = list.items[0].id;

  const before = await dm.api.get<Dispute>(`/v1/disputes/${id}`);
  expect(before.lifecycle_mode).toBe('scheduled');
  // Leave one hour on the clock; the job stays scheduled, so no wait.
  const moved = await dm.fastForward({ target_id: id, kind: ['dispute.deadline'] }, { to_remaining: 'PT1H', wait: false });
  expect(moved.count).toBe(1);
  const after = await dm.api.get<Dispute>(`/v1/disputes/${id}`);
  const left = Date.parse(after.respond_by) - Date.now();
  expect(left).toBeGreaterThan(0.9 * HOUR_MS);
  expect(left).toBeLessThanOrEqual(HOUR_MS);

  await dm.prefs(context, { tz: 'Asia/Tokyo' });
  await page.goto(`/en/disputes/${id}`);
  const deadline = page.getByTestId('dispute-deadline');
  await expect(deadline).toContainText(/(59 min \d{2} s|1 h 0 min) left/);
  await expect(deadline.getByTestId('deadline-zone')).toHaveAttribute('title', 'Asia/Tokyo');
});

import { expect, hasOwner, uiTest as test } from '../../src/dm';
import { syntheticAccounts } from '../../src/env';
import { disputeReadyToChallenge, SCHEME_DOWN, submitChallenge } from './account-profiles';

test.skip(syntheticAccounts().length < 2 || !hasOwner(), 'needs DM_OWNER and two DM_SYNTHETIC_ACCOUNTS');

// (9a) Per-account flow profiles. The owner assigns this worker's account
// (the first in DM_SYNTHETIC_ACCOUNTS) a profile that fails every
// challenge, in worker setup, and the worker restores the old assignment
// when it ends. A synthetic account cannot choose a flow itself (its
// dm_flow cookie is ignored); it gets what the owner assigned. The other
// half (23-account-profile-platform) runs at the same time as another
// account and sees the normal path. Tagged @account-profiles: concurrent
// CI jobs share the account pool, so only one of them runs the pair
// (`--grep-invert @account-profiles` in the others).
test.use({ accountSlot: 0, accountFlow: SCHEME_DOWN });

test('@account-profiles an account assigned a failing profile sees the scheme outage', async ({ page, dm }) => {
  const { ref } = await dm.flowProfile(SCHEME_DOWN.name, SCHEME_DOWN.variants);
  const disputeId = await disputeReadyToChallenge(dm);
  const mark = await dm.mark();

  await submitChallenge(page, disputeId);
  await expect(page.getByText('The card scheme is unavailable; the action was not applied. Retry later.')).toBeVisible();

  const [row] = await dm.waitFor({ after_seq: mark, correlation_id: dm.correlationId, action: 'dispute.challenge' });
  expect(row).toMatchObject({
    outcome: 'failed',
    error_code: 'simulated_scheme_unavailable',
    actor: { type: 'synthetic_account' },
    request: { source: 'portal' },
    target: { id: disputeId },
    flow: { profile_id: ref, profile_source: 'account' },
  });
  expect((await dm.api.get<{ status: string }>(`/v1/disputes/${disputeId}`)).status).toBe('evidence_required');
});

import type { Page } from '@playwright/test';
import { Dm, expect } from '../../src/dm';
import { uploadEvidence } from '../../src/evidence';
import type { FlowVariants } from '../../src/flows';
import type { DisputePage } from '../../src/types';

/**
 * Shared by the two per-account profile specs (23-…). Each file pins its
 * worker to one synthetic account with a worker option, so the two run
 * in two workers at the same time, each signed in as its own account.
 */

/** Every challenge fails before anything is written, as a scheme outage. */
export const SCHEME_DOWN = {
  name: 'challenge-scheme-down',
  variants: {
    'dispute.action_failure': { actions: ['challenge'], mode: 'always', error: 'scheme_unavailable' },
  } satisfies FlowVariants,
};

/** A dispute awaiting evidence with one available file, made with the key under fp_platform. */
export async function disputeReadyToChallenge(dm: Dm): Promise<string> {
  const { job } = await dm.generate({ count: 12, dispute_rate: 1, seed: 42 });
  const list = await dm.api.get<DisputePage>('/v1/disputes', {
    generate_job_id: job.id,
    status: 'evidence_required',
    page_size: 1,
  });
  expect(list.items).toHaveLength(1);
  await uploadEvidence(dm, list.items[0].id);
  return list.items[0].id;
}

export async function submitChallenge(page: Page, disputeId: string): Promise<void> {
  await page.goto(`/en/disputes/${disputeId}/challenge`);
  await page.getByRole('button', { name: /^Submit challenge/ }).click();
}

import { CORRELATION_COOKIE } from '../../src/correlation';
import { expect, hasOwner, ownerTest as test, signInTo } from '../../src/dm';
import { PORTAL_URL } from '../../src/env';

test.skip(!hasOwner(), 'set DM_OWNER to run the owner browser specs');

// (6, browser half) Session expiry without waiting an hour: the owner's
// key expires every session of a synthetic account, and the portal sends
// that browser back to sign-in on its next page. The account is a
// throwaway the owner creates for this test, so no other test (or
// concurrent run) loses its session.
test('expire-sessions sends a synthetic account back to sign-in', async ({ browser, owner, dm, correlationId }, testInfo) => {
  const created = await owner.post('team/synthetic-accounts', {
    data: { label: `expiry ${correlationId}`.slice(0, 80), role: 'read_only', notes: 'e2e: deleted by the test' },
  });
  expect(created.status()).toBe(201);
  const { account, credentials } = (await created.json()) as {
    account: { id: string };
    credentials: { email: string; password: string };
  };
  try {
    const file = testInfo.outputPath('expiry-account.json');
    await signInTo(browser, { identifier: credentials.email, password: credentials.password }, file, { checkRole: false });
    const context = await browser.newContext({ baseURL: PORTAL_URL, storageState: file });
    await context.addCookies([{ name: CORRELATION_COOKIE, value: correlationId, url: PORTAL_URL }]);
    const page = await context.newPage();
    await page.goto('/en/disputes');
    await expect(page).toHaveURL(/\/en\/disputes/);

    const mark = await dm.mark();
    const res = await dm.expireSessions(account.id);
    expect(res.id).toBe(account.id);

    await page.goto('/en/transactions');
    await expect(page).toHaveURL(/\/sign-in/);
    await expect(page.getByLabel('Username or email')).toBeVisible();

    const [expired] = await dm.waitFor({
      after_seq: mark,
      correlation_id: correlationId,
      action: 'synthetic_account.expire_sessions',
    });
    expect(expired).toMatchObject({ outcome: 'success', actor: { type: 'api_key' }, target: { id: account.id } });
    await context.close();
  } finally {
    await owner.delete(`team/synthetic-accounts/${account.id}`);
  }
});

import { request } from '@playwright/test';
import { DmApi } from './api';
import { CORRELATION_ID_HEADER } from './correlation';
import { API_URL, RUN_ID } from './env';
import { cancelRun } from './flows';

/**
 * Cancels every scheduled job this run left behind (a report still
 * queued, a deadline that was never fast-forwarded), so nothing the run
 * started fires after it. Flow profiles stay: they are content-addressed
 * and archived by the API after 30 days unused.
 */
export default async function globalTeardown(): Promise<void> {
  const key = process.env.DM_API_KEY;
  if (!key) return;
  const ctx = await request.newContext({
    baseURL: API_URL,
    extraHTTPHeaders: { Authorization: `Bearer ${key}`, [CORRELATION_ID_HEADER]: `${RUN_ID}:teardown` },
  });
  try {
    const canceled = await cancelRun(new DmApi(ctx));
    if (canceled > 0) console.log(`global teardown: canceled ${canceled} scheduled job(s) of run ${RUN_ID}`);
  } finally {
    await ctx.dispose();
  }
}

import { randomBytes } from 'node:crypto';
import { expect, test } from '@playwright/test';
import { API_URL } from '../../src/env';
import type { ErrorBody, SetupToken } from '../../src/types';

// (8) A setup link the API does not know. The account-setup routes are
// public (the token is the credential), so these calls carry no key.
// Keep such calls few: inspect and complete allow 20 attempts a minute
// per IP. Inspect consumes nothing, so it is safe to call on any link.
for (const [kind, token] of [
  ['a malformed', 'not-a-setup-token'],
  ['an unknown, well-formed', `dmsu_${randomBytes(32).toString('base64url')}`],
] as const) {
  test(`inspect answers 404 setup_link_invalid for ${kind} token`, async ({ request }) => {
    const res = await request.post(`${API_URL}/v1/auth/account-setup/inspect`, {
      data: { token } satisfies SetupToken,
    });
    expect(res.status()).toBe(404);
    expect(((await res.json()) as ErrorBody).code).toBe('setup_link_invalid');
  });
}

import { defineConfig, devices } from '@playwright/test';
import { PORTAL_URL } from './src/env';

/**
 * Worker budget: at most 8 workers per API key, one key per CI job
 * (the API allows a key 600 requests a minute per server). The key and
 * correlation headers are set by the `dm` fixture on its own request
 * context, never here: `extraHTTPHeaders` in this file would send the
 * key to the portal and every page the browser opens.
 */
export default defineConfig({
  // Signs DM_OWNER in once (owner browser specs); cancels the run's scheduled jobs at the end.
  globalSetup: require.resolve('./src/global-setup'),
  globalTeardown: require.resolve('./src/global-teardown'),
  // Room for a generate that waits on the workspace budget (src/api.ts, GENERATE_BUDGET_WAIT_MS).
  timeout: 300_000,
  expect: { timeout: 15_000 },
  fullyParallel: true,
  workers: Number(process.env.DM_WORKERS ?? 4),
  retries: 0,
  reporter: process.env.CI ? [['list'], ['html', { open: 'never' }]] : 'list',
  projects: [
    { name: 'api', testDir: './tests/api' },
    {
      name: 'ui',
      testDir: './tests/ui',
      use: { ...devices['Desktop Chrome'], baseURL: PORTAL_URL, trace: 'retain-on-failure' },
    },
  ],
});