cabloy 5.1.140 → 5.1.142

package/e2e/scripts/runE2e.ts

@@ -0,0 +1,62 @@
+import { execFileSync } from 'node:child_process';
+import { createServer } from 'node:net';
+import { resolve } from 'node:path';
+
+import {
+  E2E_CONFIG_FILE,
+  E2E_LOCAL_BASE_URL,
+  E2E_PORT,
+  E2E_ROOT_DIR,
+  E2E_SPECS_DIR,
+} from './e2e.ts';
+import { combineGreps, parseE2eArgs } from './runE2eArgs.ts';
+
+function run(command: string, args: string[]): void {
+  // eslint-disable-next-line no-console
+  console.log(`\n===> ${[command, ...args].join(' ')}`);
+  execFileSync(command, args, {
+    cwd: E2E_ROOT_DIR,
+    stdio: 'inherit',
+  });
+}
+
+async function assertPortAvailable(): Promise<void> {
+  const server = createServer();
+  await new Promise<void>((resolvePromise, reject) => {
+    server.once('error', reject);
+    server.listen(E2E_PORT, '127.0.0.1', () => {
+      server.close(error => {
+        if (error) reject(error);
+        else resolvePromise();
+      });
+    });
+  });
+}
+
+const parsed = parseE2eArgs(process.argv.slice(2), E2E_SPECS_DIR);
+if (parsed.mode === 'clean' && process.env.E2E_BASE_URL) {
+  throw new Error(
+    'The clean E2E run manages the local target and cannot be used with E2E_BASE_URL. Use test:e2e:fast for an external target.',
+  );
+}
+
+if (parsed.mode === 'clean') {
+  await assertPortAvailable();
+  run('npm', ['run', 'db:reset']);
+}
+
+const playwrightCommand = resolve(
+  E2E_ROOT_DIR,
+  'node_modules',
+  '.bin',
+  process.platform === 'win32' ? 'playwright.cmd' : 'playwright',
+);
+const specPaths = parsed.specNames.map(name => resolve(E2E_SPECS_DIR, `${name}.spec.ts`));
+const playwrightArgs = combineGreps(parsed.playwrightArgs, parsed.tags);
+run(playwrightCommand, ['test', '--config', E2E_CONFIG_FILE, ...specPaths, ...playwrightArgs]);
+
+// Keep this value referenced in the runner's startup output and make the local target explicit.
+if (!process.env.E2E_BASE_URL) {
+  // eslint-disable-next-line no-console
+  console.log(`E2E target: ${E2E_LOCAL_BASE_URL}`);
+}

package/e2e/scripts/runE2eArgs.test.ts

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import test from 'node:test';
+
+import { buildTagGrep, combineGreps, parseE2eArgs } from './runE2eArgs.ts';
+
+function withSpecs(callback: (specsDir: string) => void): void {
+  const tempDir = mkdtempSync(resolve(tmpdir(), 'cabloy-e2e-args-'));
+  try {
+    const specsDir = resolve(tempDir, 'specs');
+    mkdirSync(specsDir);
+    for (const name of ['account', 'a-commerce', 'cabloy-basic']) {
+      writeFileSync(resolve(specsDir, `${name}.spec.ts`), '');
+    }
+    callback(specsDir);
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+test('parses mode, multiple specs, and repeatable tags', () => {
+  withSpecs(specsDir => {
+    assert.deepEqual(
+      parseE2eArgs(
+        ['--clean', 'cabloy-basic', 'account', '--tag', '@web', '--tag=@smoke'],
+        specsDir,
+      ),
+      {
+        mode: 'clean',
+        specNames: ['cabloy-basic', 'account'],
+        playwrightArgs: [],
+        tags: ['@web', '@smoke'],
+      },
+    );
+  });
+});
+
+test('allows no spec names and forwards Playwright filters', () => {
+  withSpecs(specsDir => {
+    assert.deepEqual(parseE2eArgs(['--fast', '--grep', '@flow'], specsDir), {
+      mode: 'fast',
+      specNames: [],
+      playwrightArgs: ['--grep', '@flow'],
+      tags: [],
+    });
+  });
+});
+
+test('rejects invalid or unknown specs and managed config overrides', () => {
+  withSpecs(specsDir => {
+    assert.throws(() => parseE2eArgs(['--fast', '../account'], specsDir), /Invalid E2E spec name/);
+    assert.throws(() => parseE2eArgs(['--fast', 'missing'], specsDir), /Unknown E2E spec/);
+    assert.throws(
+      () => parseE2eArgs(['--fast', '--config', 'other.ts'], specsDir),
+      /manages --config/,
+    );
+  });
+});
+
+test('requires exactly one run mode', () => {
+  withSpecs(specsDir => {
+    assert.throws(() => parseE2eArgs(['account'], specsDir), /Missing E2E mode/);
+    assert.throws(() => parseE2eArgs(['--clean', '--fast'], specsDir), /exactly one/);
+  });
+});
+
+test('combines tags with an existing grep expression', () => {
+  assert.equal(buildTagGrep(['@web', '@smoke']), '(?=.*@web)(?=.*@smoke)');
+  assert.deepEqual(combineGreps(['--grep', '@flow'], ['@web', '@smoke']), [
+    '--grep',
+    '(?=.*(?:@flow))(?=.*@web)(?=.*@smoke)',
+  ]);
+});

package/e2e/scripts/runE2eArgs.ts

@@ -0,0 +1,158 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export type E2eRunMode = 'clean' | 'fast';
+
+export type ParsedE2eArgs = {
+  mode: E2eRunMode;
+  specNames: string[];
+  playwrightArgs: string[];
+  tags: string[];
+};
+
+const SPEC_NAME_PATTERN = /^[a-z0-9][\w-]*$/i;
+const VALUE_OPTIONS = new Set([
+  '--browser',
+  '--config',
+  '--grep',
+  '--grep-invert',
+  '--global-timeout',
+  '--ignore-snapshots',
+  '--last-failed',
+  '--max-failures',
+  '--output',
+  '--pass-with-no-tests',
+  '--project',
+  '--repeat-each',
+  '--reporter',
+  '--shard',
+  '--timeout',
+  '--trace',
+  '--workers',
+]);
+
+function optionName(arg: string): string {
+  const equalsIndex = arg.indexOf('=');
+  return equalsIndex === -1 ? arg : arg.slice(0, equalsIndex);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function buildTagGrep(tags: string[]): string | undefined {
+  if (tags.length === 0) return undefined;
+  return tags.map(tag => `(?=.*${escapeRegExp(tag)})`).join('');
+}
+
+export function parseE2eArgs(args: string[], specsDir: string): ParsedE2eArgs {
+  let mode: E2eRunMode | undefined;
+  const remainingArgs: string[] = [];
+
+  for (const arg of args) {
+    if (arg === '--clean' || arg === '--fast') {
+      if (mode && mode !== arg.slice(2)) {
+        throw new Error('Choose exactly one E2E mode: --clean or --fast.');
+      }
+      if (mode === arg.slice(2)) {
+        throw new Error(`E2E mode ${arg} was provided more than once.`);
+      }
+      mode = arg.slice(2) as E2eRunMode;
+    } else {
+      remainingArgs.push(arg);
+    }
+  }
+
+  if (!mode) {
+    throw new Error('Missing E2E mode. Use --clean or --fast.');
+  }
+
+  const specNames: string[] = [];
+  const playwrightArgs: string[] = [];
+  const tags: string[] = [];
+  let optionStarted = false;
+  let pendingValueFor: string | undefined;
+
+  for (let index = 0; index < remainingArgs.length; index++) {
+    const arg = remainingArgs[index];
+
+    if (pendingValueFor) {
+      if (!arg || arg.startsWith('--')) {
+        throw new Error(`Missing value for ${pendingValueFor}.`);
+      }
+      if (pendingValueFor === '--tag') {
+        tags.push(arg);
+      } else {
+        playwrightArgs.push(arg);
+      }
+      pendingValueFor = undefined;
+      continue;
+    }
+
+    if (arg === '--tag' || arg.startsWith('--tag=')) {
+      optionStarted = true;
+      const value = arg.slice('--tag'.length).replace(/^=/, '');
+      if (value) {
+        tags.push(value);
+      } else {
+        pendingValueFor = '--tag';
+      }
+      continue;
+    }
+
+    if (arg === '--config' || arg.startsWith('--config=')) {
+      throw new Error('The E2E runner manages --config; do not provide it.');
+    }
+
+    if (!optionStarted && !arg.startsWith('-')) {
+      if (!SPEC_NAME_PATTERN.test(arg)) {
+        throw new Error(`Invalid E2E spec name: ${arg}`);
+      }
+      const specPath = resolve(specsDir, `${arg}.spec.ts`);
+      if (!existsSync(specPath)) {
+        throw new Error(`Unknown E2E spec: ${arg} (expected ${specPath}).`);
+      }
+      specNames.push(arg);
+      continue;
+    }
+
+    if (arg.startsWith('-')) {
+      optionStarted = true;
+      const name = optionName(arg);
+      if (VALUE_OPTIONS.has(name) && !arg.includes('=')) {
+        pendingValueFor = name;
+      }
+      playwrightArgs.push(arg);
+      continue;
+    }
+
+    playwrightArgs.push(arg);
+  }
+
+  if (pendingValueFor) {
+    throw new Error(`Missing value for ${pendingValueFor}.`);
+  }
+
+  return { mode, specNames, playwrightArgs, tags };
+}
+
+export function combineGreps(args: string[], tags: string[]): string[] {
+  const tagGrep = buildTagGrep(tags);
+  if (!tagGrep) return args;
+
+  const result = [...args];
+  const grepIndex = result.findIndex(arg => arg === '--grep' || arg.startsWith('--grep='));
+  if (grepIndex === -1) {
+    result.push('--grep', tagGrep);
+    return result;
+  }
+
+  if (result[grepIndex].includes('=')) {
+    const [name, value] = result[grepIndex].split(/=(.*)/s, 2);
+    result[grepIndex] = `${name}=(?=.*(?:${value}))${tagGrep}`;
+  } else {
+    const value = result[grepIndex + 1];
+    result[grepIndex + 1] = `(?=.*(?:${value}))${tagGrep}`;
+  }
+  return result;
+}