@celilo/e2e 0.6.0 → 0.6.2

package/src/cli/command-registry.ts

@@ -23,12 +23,13 @@ export interface FlagDef {
 export const COMMANDS: CommandDef[] = [
   {
     name: 'run',
-    description: 'Run e2e tests (pattern filters by test file name)',
+    description: 'Run e2e tests — pass a module path or pattern, or --all-modules',
     flags: [
       { name: '--keep', description: 'Keep network running after tests' },
       { name: '--reuse', description: 'Reuse existing network if running' },
       { name: '--live', description: 'Use live (non-simulated) internet' },
       { name: '--published', description: 'Use published .netapp packages' },
+      { name: '--all-modules', description: 'Run e2e tests for all modules with e2e/ directories' },
     ],
   },
   {
@@ -92,7 +93,7 @@ export const COMMANDS: CommandDef[] = [
 
 export const UP_PRESETS = ['--caddy', '--full-stack', '--infrastructure'];
 
-export const RUN_FLAGS = ['--keep', '--reuse', '--live', '--published'];
+export const RUN_FLAGS = ['--keep', '--reuse', '--live', '--published', '--all-modules'];
 
 export const DOWN_FLAGS = ['--keep', '--all'];
 

package/src/cli/completion.ts

@@ -10,6 +10,7 @@ import {
   RUN_FLAGS,
   UP_PRESETS,
 } from './command-registry';
+import { findAllTestNames } from './module-discovery';
 
 export function getCompletions(words: string[], current: number): string[] {
   const args = words[0] === 'cele2e' ? words.slice(1) : words;
@@ -26,10 +27,13 @@ export function getCompletions(words: string[], current: number): string[] {
 
   if (command === 'run' && currentIndex >= 1) {
     const used = new Set(args.slice(1));
-    return filterSuggestions(
-      RUN_FLAGS.filter((f) => !used.has(f)),
-      args[currentIndex] || '',
-    );
+    const flags = RUN_FLAGS.filter((f) => !used.has(f));
+    const currentArg = args[currentIndex] || '';
+    if (currentArg.startsWith('--')) {
+      return filterSuggestions(flags, currentArg);
+    }
+    const testNames = findAllTestNames(process.cwd());
+    return filterSuggestions([...testNames, ...flags], currentArg);
   }
 
   if (command === 'up' && currentIndex === 1) {
@@ -87,6 +91,13 @@ export function generateZshCompletion(): string {
 _cele2e() {
   local curcontext="$curcontext" state line
   typeset -A opt_args
+  # Capture the original command line — _arguments mutates words/CURRENT
+  # as it consumes arguments, but our dynamic completer needs the originals.
+  # zsh dynamic scoping makes these visible to nested functions.
+  local -a _cele2e_orig_words
+  local _cele2e_orig_current
+  _cele2e_orig_words=( "\${words[@]}" )
+  _cele2e_orig_current=$CURRENT
 
   _arguments -C \\
     '1: :_cele2e_commands' \\
@@ -101,7 +112,8 @@ _cele2e() {
             '--reuse[Reuse existing network if running]' \\
             '--live[Use live (non-simulated) internet]' \\
             '--published[Use published .netapp packages]' \\
-            '*:test pattern:'
+            '--all-modules[Run e2e tests for all modules with e2e/ directories]' \\
+            '*::test name or module path:_cele2e_run_args'
           ;;
         up)
           _arguments '1: :_cele2e_up_presets'
@@ -166,6 +178,18 @@ _cele2e_completion_shells() {
   _describe 'shell' shells
 }
 
+# Dynamic completion for 'cele2e run' positional args — calls the CLI to
+# discover test names from modules under the current directory. Uses the
+# original (un-stripped) words array captured by _cele2e.
+_cele2e_run_args() {
+  local -a completions
+  local IFS=$'\\n'
+  completions=( \${(f)"$(cele2e --get-completions "\${_cele2e_orig_words[@]}" "$((_cele2e_orig_current - 1))" 2>/dev/null)"} )
+  if (( \${#completions[@]} > 0 )); then
+    _describe 'test' completions
+  fi
+}
+
 _cele2e "$@"
 `;
 }

package/src/cli/index.ts

@@ -17,21 +17,42 @@
 
 import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, rmSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
 import { runBuild } from './build';
 import { runScaffold } from './scaffold';
 import { generateBashCompletion, generateZshCompletion, getCompletions } from './completion';
+import { findAllModules, findModulesWithMatchingTest } from './module-discovery';
 
 const PKG_DIR = resolve(import.meta.dir, '../..');
 const BIN_DIR = join(PKG_DIR, 'bin');
 
-function detectTestDir(): string {
-  if (process.env.E2E_TEST_DIR) return process.env.E2E_TEST_DIR;
+
+function readManifestTestsDir(manifestPath: string): string | undefined {
+  try {
+    const parsed = parseYaml(readFileSync(manifestPath, 'utf-8')) as { e2e?: { tests_dir?: string } };
+    return parsed?.e2e?.tests_dir;
+  } catch {
+    return undefined;
+  }
+}
+
+function detectTestDir(): { stateDir: string; testsPath: string } {
+  if (process.env.E2E_TEST_DIR) {
+    const stateDir = process.env.E2E_TEST_DIR;
+    return { stateDir, testsPath: join(stateDir, 'tests') };
+  }
   const cwd = process.cwd();
-  // Check e2e/tests/ first — more specific than a generic tests/ directory
-  if (existsSync(join(cwd, 'e2e', 'tests'))) return join(cwd, 'e2e');
-  if (existsSync(join(cwd, 'tests'))) return cwd;
-  return cwd;
+  const manifestPath = join(cwd, 'manifest.yml');
+  if (existsSync(manifestPath)) {
+    const testsDir = readManifestTestsDir(manifestPath);
+    if (testsDir) {
+      const testsPath = resolve(cwd, testsDir);
+      return { stateDir: dirname(testsPath), testsPath };
+    }
+  }
+  if (existsSync(join(cwd, 'tests'))) return { stateDir: cwd, testsPath: join(cwd, 'tests') };
+  return { stateDir: cwd, testsPath: join(cwd, 'tests') };
 }
 
 function runScript(script: string, args: string[], env?: Record<string, string>): never {
@@ -82,8 +103,9 @@ Options for \`build-infra\`:
   --skip-modules    Skip .netapp packaging (only rebuild Docker images)
 
 Examples:
-  cele2e run                        # run all tests
+  cele2e run                        # in a module: run its tests; outside: run all modules' tests
   cele2e run deploy                 # run tests matching "deploy"
+  cele2e run caddy-direct-internet  # from modules/, finds the matching module automatically
   cele2e run --reuse deploy         # reuse existing network
   cele2e up --full-stack            # interactive full-stack environment
   cele2e shell caddy                # debug running caddy container
@@ -95,7 +117,7 @@ Examples:
 }
 
 const [, , command, ...args] = process.argv;
-const testDir = detectTestDir();
+const { stateDir, testsPath: detectedTestsPath } = detectTestDir();
 
 // Handle --get-completions before routing (used by shell completion scripts)
 if (command === '--get-completions') {
@@ -107,20 +129,68 @@ if (command === '--get-completions') {
 }
 
 switch (command) {
-  case 'run':
-    runScript('e2e-run', args, { E2E_TEST_DIR: testDir });
+  case 'run': {
+    // Check if any non-flag arg is a module path (has manifest.yml)
+    const modulePath = args
+      .filter((a) => !a.startsWith('--'))
+      .find((a) => existsSync(join(resolve(a), 'manifest.yml')));
+
+    if (modulePath) {
+      const absModulePath = resolve(modulePath);
+      runScript('e2e-run', args.filter((a) => a !== modulePath), {
+        E2E_TEST_DIR: stateDir,
+        E2E_MODULE_DIR: absModulePath,
+      });
+    }
+
+    // If cwd is not a module, walk sibling modules so the user can invoke
+    // `cele2e run` from infra/modules/ (or the repo root) without cd-ing in.
+    const cwdHasManifest = existsSync(join(process.cwd(), 'manifest.yml'));
+    const positionals = args.filter((a) => !a.startsWith('--'));
+
+    if (!cwdHasManifest) {
+      if (positionals.length === 1) {
+        const matches = findModulesWithMatchingTest(process.cwd(), positionals[0]);
+        if (matches.length === 1) {
+          runScript('e2e-run', args, {
+            E2E_TEST_DIR: stateDir,
+            E2E_MODULE_DIR: matches[0].moduleDir,
+          });
+        }
+        if (matches.length > 1) {
+          console.error(`Multiple modules contain tests matching "${positionals[0]}":`);
+          for (const m of matches) {
+            console.error(`  ${basename(m.moduleDir)}: ${m.matchedTests.join(', ')}`);
+          }
+          console.error('\nDisambiguate by running from inside the module directory or passing its path.');
+          process.exit(1);
+        }
+      } else if (positionals.length === 0) {
+        const allModules = findAllModules(process.cwd());
+        if (allModules.length > 0) {
+          runScript('e2e-run', args, {
+            E2E_TEST_DIR: stateDir,
+            E2E_MODULE_DIRS: allModules.join('\n'),
+          });
+        }
+      }
+    }
+
+    runScript('e2e-run', args, { E2E_TEST_DIR: stateDir, E2E_TESTS_PATH: detectedTestsPath });
+    break;
+  }
 
   case 'up':
     runScript('e2e-up', args);
 
   case 'down':
-    runScript('e2e-down', args, { E2E_TEST_DIR: testDir });
+    runScript('e2e-down', args, { E2E_TEST_DIR: stateDir });
 
   case 'shell':
     runScript('e2e-shell', args);
 
   case 'status': {
-    const persistentFile = join(testDir, '.e2e-persistent.json');
+    const persistentFile = join(stateDir, '.e2e-persistent.json');
     let projectName: string | undefined;
     if (existsSync(persistentFile)) {
       try {
@@ -150,7 +220,7 @@ switch (command) {
   }
 
   case 'clear-timing': {
-    const timingFile = join(testDir, '.e2e-timing.json');
+    const timingFile = join(stateDir, '.e2e-timing.json');
     if (existsSync(timingFile)) {
       rmSync(timingFile);
       console.log(`Cleared timing data: ${timingFile}`);
@@ -166,7 +236,7 @@ switch (command) {
       console.error('Error: scaffold requires a test name\n  cele2e scaffold <name>');
       process.exit(1);
     }
-    runScaffold({ testDir, name });
+    runScaffold({ testsPath: detectedTestsPath, name });
     break;
   }
 

package/src/cli/module-discovery.ts

@@ -0,0 +1,120 @@
+/**
+ * Walks the cwd tree to find Celilo modules and their e2e tests.
+ *
+ * Used so that `cele2e run <test-name>` works from `infra/modules/` (or the
+ * repo root) without needing to cd into the module first, and so tab
+ * completion can suggest test names discovered across all modules.
+ *
+ * Scans direct subdirs and one level deeper — covers `modules/` (where each
+ * subdir is a module) and `infra/` (where `modules/<name>/` is one level
+ * deeper).
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+
+const MAX_DEPTH = 2;
+
+function readManifestTestsDir(manifestPath: string): string | undefined {
+  try {
+    const parsed = parseYaml(readFileSync(manifestPath, 'utf-8')) as { e2e?: { tests_dir?: string } };
+    return parsed?.e2e?.tests_dir;
+  } catch {
+    return undefined;
+  }
+}
+
+function listTestNames(testsPath: string): string[] {
+  if (!existsSync(testsPath)) return [];
+  try {
+    return readdirSync(testsPath)
+      .filter((f) => f.endsWith('.test.ts'))
+      .map((f) => f.replace(/\.test\.ts$/, ''));
+  } catch {
+    return [];
+  }
+}
+
+function isModule(dir: string): { manifestPath: string; testsPath: string } | null {
+  const manifestPath = join(dir, 'manifest.yml');
+  if (!existsSync(manifestPath)) return null;
+  // Match the runner's resolution: prefer e2e.tests_dir from the manifest,
+  // fall back to a conventional e2e/ directory at the module root.
+  const testsDir = readManifestTestsDir(manifestPath) ?? 'e2e';
+  return { manifestPath, testsPath: resolve(dir, testsDir) };
+}
+
+function walkModules(cwd: string, visit: (moduleDir: string, testsPath: string) => void): void {
+  function scan(dir: string, depth: number): void {
+    if (depth > MAX_DEPTH) return;
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.startsWith('.') || entry === 'node_modules') continue;
+      const subdir = join(dir, entry);
+      try {
+        if (!statSync(subdir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const mod = isModule(subdir);
+      if (mod) {
+        visit(subdir, mod.testsPath);
+      } else if (depth < MAX_DEPTH) {
+        scan(subdir, depth + 1);
+      }
+    }
+  }
+  scan(cwd, 1);
+}
+
+export interface ModuleTestMatch {
+  moduleDir: string;
+  matchedTests: string[];
+}
+
+/**
+ * Find modules under `cwd` whose e2e dir contains a test name including `pattern`.
+ * Used by `cele2e run <pattern>` when invoked outside any module dir.
+ */
+export function findModulesWithMatchingTest(cwd: string, pattern: string): ModuleTestMatch[] {
+  const results: ModuleTestMatch[] = [];
+  walkModules(cwd, (moduleDir, testsPath) => {
+    const matched = listTestNames(testsPath).filter((t) => t.includes(pattern));
+    if (matched.length > 0) results.push({ moduleDir, matchedTests: matched });
+  });
+  return results;
+}
+
+/**
+ * Collect all test names reachable from `cwd`. Includes tests in cwd itself
+ * (when cwd is a module) and tests in any module discovered under cwd.
+ */
+export function findAllTestNames(cwd: string): string[] {
+  const names = new Set<string>();
+  const cwdMod = isModule(cwd);
+  if (cwdMod) {
+    for (const n of listTestNames(cwdMod.testsPath)) names.add(n);
+  }
+  walkModules(cwd, (_moduleDir, testsPath) => {
+    for (const n of listTestNames(testsPath)) names.add(n);
+  });
+  return Array.from(names).sort();
+}
+
+/**
+ * Return the absolute paths of all modules discoverable under `cwd` that have
+ * an e2e tests directory containing at least one `*.test.ts` file.
+ */
+export function findAllModules(cwd: string): string[] {
+  const modules: string[] = [];
+  walkModules(cwd, (moduleDir, testsPath) => {
+    if (listTestNames(testsPath).length > 0) modules.push(moduleDir);
+  });
+  return modules.sort();
+}

package/src/cli/scaffold.ts

@@ -10,7 +10,7 @@ const dim = '\x1b[2m';
 const reset = '\x1b[0m';
 
 interface ScaffoldOptions {
-  testDir: string;
+  testsPath: string;
   name: string;
 }
 
@@ -92,12 +92,11 @@ describe('${name}', () => {
 }
 
 export function runScaffold(options: ScaffoldOptions): void {
-  const { testDir, name } = options;
+  const { testsPath, name } = options;
 
-  const testsDir = join(testDir, 'tests');
-  mkdirSync(testsDir, { recursive: true });
+  mkdirSync(testsPath, { recursive: true });
 
-  const outPath = join(testsDir, `${name}.test.ts`);
+  const outPath = join(testsPath, `${name}.test.ts`);
   if (existsSync(outPath)) {
     console.error(`Error: ${outPath} already exists`);
     process.exit(1);