@celilo/e2e 0.3.0 → 0.4.0

package/bin/e2e-down

@@ -1,10 +1,13 @@
 #!/bin/bash
-# Tear down ALL E2E test artifacts — interactive sessions AND orphaned test runs.
+# Tear down E2E test artifacts:
+# - Persistent test networks (from `e2e-run --keep`)
+# - Interactive sessions (from `e2e-up`)
+# - Orphaned test runs
 #
 # Usage:
-#   ./bin/e2e-down           # Stop and remove everything
-#   ./bin/e2e-down --keep    # Stop containers but keep volumes (faster restart)
-#   ./bin/e2e-down --all     # Also stop module containers (authentik, etc.) that compete for resources
+#   ./bin/e2e-down           # tear down everything e2e-related
+#   ./bin/e2e-down --keep    # stop containers but keep volumes
+#   ./bin/e2e-down --all     # also stop module containers that compete for resources
 
 set -e
 SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
@@ -19,20 +22,42 @@ for arg in "$@"; do
   esac
 done
 
-# 1. Stop the interactive session (if running)
+# 1. Tear down any persistent test networks (look for marker files in common test dirs)
+for dir in "$(pwd)" "$(pwd)/../../e2e" "$(pwd)/../../../e2e"; do
+  MARKER="$dir/.e2e-persistent.json"
+  if [ -f "$MARKER" ]; then
+    PROJECT=$(bun -e "console.log(JSON.parse(require('fs').readFileSync('$MARKER', 'utf-8')).projectName)" 2>/dev/null || echo "")
+    if [ -n "$PROJECT" ]; then
+      echo "Tearing down persistent network: $PROJECT"
+      docker compose -f docker-compose.test.yml -p "$PROJECT" down --volumes --remove-orphans 2>/dev/null || true
+    fi
+    rm -f "$MARKER"
+  fi
+done
+
+# Also check E2E_TEST_DIR if set
+if [ -n "$E2E_TEST_DIR" ] && [ -f "$E2E_TEST_DIR/.e2e-persistent.json" ]; then
+  PROJECT=$(bun -e "console.log(JSON.parse(require('fs').readFileSync('$E2E_TEST_DIR/.e2e-persistent.json', 'utf-8')).projectName)" 2>/dev/null || echo "")
+  if [ -n "$PROJECT" ]; then
+    echo "Tearing down persistent network: $PROJECT"
+    docker compose -f docker-compose.test.yml -p "$PROJECT" down --volumes --remove-orphans 2>/dev/null || true
+  fi
+  rm -f "$E2E_TEST_DIR/.e2e-persistent.json"
+fi
+
+# 2. Stop the interactive session (if running)
 echo "Stopping interactive session..."
-docker compose -p "conductor-e2e-interactive" down --remove-orphans 2>/dev/null || true
+docker compose -p "celilo-e2e-interactive" down --remove-orphans 2>/dev/null || true
 
-# 2. Kill ALL containers matching conductor-e2e-* (orphaned test runs)
-CONTAINERS=$(docker ps -a --filter "name=conductor-e2e" --format "{{.ID}}" 2>/dev/null)
+# 3. Kill ALL containers matching celilo-e2e-* (orphaned test runs)
+CONTAINERS=$(docker ps -a --filter "name=celilo-e2e" --format "{{.ID}}" 2>/dev/null)
 if [ -n "$CONTAINERS" ]; then
   COUNT=$(echo "$CONTAINERS" | wc -l | tr -d ' ')
   echo "Removing $COUNT orphaned e2e containers..."
   echo "$CONTAINERS" | xargs docker rm -f 2>/dev/null || true
 fi
 
-# 3. Stop module containers that compete for resources (--all flag)
-# These come from local docker-compose runs, not from e2e, but starve the VM.
+# 4. Stop module containers that compete for resources (--all flag)
 if [ "$STOP_ALL" = true ]; then
   MODULE_PATTERNS="authentik- caddy- build-your-own-internet-"
   for pattern in $MODULE_PATTERNS; do
@@ -45,23 +70,23 @@ if [ "$STOP_ALL" = true ]; then
   done
 fi
 
-# 3. Remove all conductor-e2e networks
-NETWORKS=$(docker network ls --filter "name=conductor-e2e" --format "{{.ID}}" 2>/dev/null)
+# 5. Remove all celilo-e2e networks
+NETWORKS=$(docker network ls --filter "name=celilo-e2e" --format "{{.ID}}" 2>/dev/null)
 if [ -n "$NETWORKS" ]; then
   echo "Removing e2e networks..."
   echo "$NETWORKS" | xargs docker network rm 2>/dev/null || true
 fi
 
-# 4. Remove volumes (unless --keep)
+# 6. Remove volumes (unless --keep)
 if [ "$KEEP_VOLUMES" = false ]; then
-  VOLUMES=$(docker volume ls --filter "name=conductor-e2e" --format "{{.Name}}" 2>/dev/null)
+  VOLUMES=$(docker volume ls --filter "name=celilo-e2e" --format "{{.Name}}" 2>/dev/null)
   if [ -n "$VOLUMES" ]; then
     echo "Removing e2e volumes..."
     echo "$VOLUMES" | xargs docker volume rm 2>/dev/null || true
   fi
 fi
 
-# 5. Clean up generated compose file
+# 7. Clean up generated compose files
 rm -f docker-compose.test.yml
 
 echo "E2E environment cleaned."

package/config/dns/iamtheinternet.org.zone

@@ -2,7 +2,7 @@ $ORIGIN iamtheinternet.org.
 $TTL 300
 
 @ IN SOA ns1.iamtheinternet.org. admin.iamtheinternet.org. (
-    2024010769 300 60 604800 300
+    2024010772 300 60 604800 300
 )
 
 @       IN NS   ns1.iamtheinternet.org.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/e2e",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "E2E test infrastructure for Celilo-deployed applications. Provides a simulated internet with DNS hierarchy, ACME server, firewalls, and target machines in Docker.",
   "type": "module",
   "main": "./src/index.ts",

package/src/container-manager.ts

@@ -310,6 +310,8 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
   }
 
   console.log('[progress:done] network ready');
+  // Emit project name so the runner can persist it if --keep is set
+  console.log(`[e2e:project] ${projectName}`);
 
   const handle: NetworkHandle = {
     projectName,
@@ -362,6 +364,12 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
     waitFor,
 
     async stop(): Promise<void> {
+      // Respect --keep / --reuse: don't tear down the network
+      if (process.env.CELILO_E2E_KEEP === '1' || process.env.CELILO_E2E_REUSE === '1') {
+        console.log(`[progress:done] network kept alive (project: ${projectName})`);
+        activeProjects.delete(projectName);  // don't re-teardown on exit
+        return;
+      }
       console.log('[progress:start] stopping network | network stopped');
       try {
         run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} down --volumes --remove-orphans`,
@@ -375,3 +383,90 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
 
   return handle;
 }
+
+/**
+ * Reconnect to an existing test network (previously kept alive with --keep).
+ * Returns a NetworkHandle pointing to the existing Docker project. Skips
+ * all the setup (image build, container start, celilo init) — assumes the
+ * network is already running and healthy.
+ *
+ * If the project doesn't exist, throws with an actionable error.
+ */
+export function reconnectNetwork(projectName: string): NetworkHandle {
+  const composeDir = PACKAGE_ROOT;
+
+  // Verify the project actually exists
+  try {
+    const result = run(
+      `docker compose -f ${COMPOSE_FILE} -p ${projectName} ps -q`,
+      { cwd: composeDir, timeout: 10_000 },
+    );
+    if (!result.trim()) {
+      throw new Error(`No containers found for project ${projectName}`);
+    }
+  } catch (err) {
+    throw new Error(
+      `Cannot reconnect to network '${projectName}': ${err instanceof Error ? err.message : String(err)}\n` +
+      `Fix: Run without --reuse to create a fresh network, or check if containers were torn down.`,
+    );
+  }
+
+  activeProjects.add(projectName);
+  console.log(`[progress:done] reconnected to existing network (${projectName})`);
+  console.log(`[e2e:project] ${projectName}`);
+
+  return {
+    projectName,
+
+    async celilo(cmd: string, optsOrTimeout?: number | { check?: boolean; timeoutMs?: number }): Promise<ExecResult> {
+      const check = typeof optsOrTimeout === 'object' ? (optsOrTimeout.check ?? true) : true;
+      const timeoutMs = typeof optsOrTimeout === 'number' ? optsOrTimeout : (optsOrTimeout?.timeoutMs ?? 120_000);
+
+      const result = await dockerExecAsync(projectName, composeDir, 'management',
+        `celilo ${cmd}`, timeoutMs);
+
+      if (check && result.exitCode !== 0) {
+        throw new CeliloCommandError(cmd, result);
+      }
+      return result;
+    },
+
+    exec(container: string, cmd: string, timeoutMs = 60_000): Promise<ExecResult> {
+      return Promise.resolve(dockerExec(projectName, composeDir, container, cmd, timeoutMs));
+    },
+
+    async dig(name: string): Promise<string> {
+      const result = dockerExec(projectName, composeDir, 'management',
+        `dig +short ${name}`);
+      return result.stdout.trim();
+    },
+
+    async debug(container = 'management'): Promise<void> {
+      console.log(`[debug:pause] ${projectName} ${container}`);
+      const signalFile = join(composeDir, `.debug-resume-${process.pid}`);
+      const start = Date.now();
+      const timeout = 86_400_000;
+      while (!existsSync(signalFile) && Date.now() - start < timeout) {
+        await new Promise(r => setTimeout(r, 500));
+      }
+      try { require('node:fs').unlinkSync(signalFile); } catch {}
+      console.log('[debug:resumed]');
+    },
+
+    waitFor,
+
+    async stop(): Promise<void> {
+      // Respect --keep / --reuse: don't tear down
+      if (process.env.CELILO_E2E_KEEP === '1' || process.env.CELILO_E2E_REUSE === '1') {
+        console.log(`[progress:done] network kept alive (project: ${projectName})`);
+        activeProjects.delete(projectName);
+        return;
+      }
+      try {
+        run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} down --volumes --remove-orphans`,
+          { cwd: composeDir, timeout: 60_000 });
+      } catch {}
+      activeProjects.delete(projectName);
+    },
+  };
+}

package/src/index.ts

@@ -24,6 +24,9 @@
 // Builder API
 export { network, NetworkBuilder } from './network-builder';
 
+// Reconnect to an existing network (for --reuse mode)
+export { reconnectNetwork } from './container-manager';
+
 // Progress reporting (emit signals the test runner displays)
 export { progress } from './progress';
 

package/src/runner.ts

@@ -27,7 +27,13 @@ const PKG_DIR = resolve(import.meta.dir, '..');
 const testDir = process.env.E2E_TEST_DIR || process.cwd();
 const testsPath = join(testDir, 'tests');
 const timingFile = join(testDir, '.e2e-timing.json');
-const patterns = process.argv.slice(2);
+const persistentFile = join(testDir, '.e2e-persistent.json');
+
+// Parse flags out of argv
+const rawArgs = process.argv.slice(2);
+const flagKeep = rawArgs.includes('--keep');
+const flagReuse = rawArgs.includes('--reuse');
+const patterns = rawArgs.filter((a) => !a.startsWith('--'));
 
 // ─── Colors ──────────────────────────────────────────────────────────
 
@@ -309,6 +315,7 @@ interface TestResult {
   duration: number;
   error?: string;
   hadDebugPause?: boolean;
+  projectName?: string;
 }
 
 async function runTest(
@@ -323,13 +330,29 @@ async function runTest(
 
   display.reset(start, expectedDuration);
   let hadDebugPause = false;
+  let capturedProjectName: string | undefined;
 
   return new Promise<TestResult>((resolveTest) => {
+    // Env vars let the test detect --keep / --reuse modes
+    const testEnv: NodeJS.ProcessEnv = { ...process.env };
+    if (flagKeep) testEnv.CELILO_E2E_KEEP = '1';
+    if (flagReuse) {
+      // Read the persistent project and pass it to the test
+      try {
+        const data = JSON.parse(readFileSync(persistentFile, 'utf-8'));
+        testEnv.CELILO_E2E_REUSE = '1';
+        testEnv.CELILO_E2E_PROJECT = data.projectName;
+      } catch {
+        console.error(`${red}✗ --reuse: no persistent network found. Run with --keep first.${reset}`);
+        process.exit(1);
+      }
+    }
+
     // 1 hour timeout per test (debug sessions can be long)
     const proc = spawn('bun', ['test', '--timeout', '3600000', file], {
       cwd: PKG_DIR,
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env },
+      env: testEnv,
     });
 
     let stdout = '';
@@ -393,6 +416,13 @@ async function runTest(
           continue;
         }
 
+        // Capture project name for persistent network tracking
+        const projectMatch = trimmed.match(/\[e2e:project\] (\S+)/);
+        if (projectMatch) {
+          capturedProjectName = projectMatch[1];
+          continue;
+        }
+
         parseLine(trimmed, display);
       }
     }
@@ -423,10 +453,11 @@ async function runTest(
             status: 'suspicious',
             duration,
             hadDebugPause,
+            projectName: capturedProjectName,
             error: '0 assertions — test likely exited before reaching assertions',
           });
         } else {
-          resolveTest({ name, status: 'pass', duration, hadDebugPause });
+          resolveTest({ name, status: 'pass', duration, hadDebugPause, projectName: capturedProjectName });
         }
       } else {
         resolveTest({
@@ -434,6 +465,7 @@ async function runTest(
           status: 'fail',
           duration,
           hadDebugPause,
+          projectName: capturedProjectName,
           error: extractFailureMessage(lines, code ?? 1),
         });
       }
@@ -556,6 +588,21 @@ async function main() {
       history[name] = result.duration;
     }
 
+    // Write persistent network info if --keep was set and we captured a project
+    if (flagKeep && result.projectName) {
+      writeFileSync(
+        persistentFile,
+        JSON.stringify({
+          projectName: result.projectName,
+          testFile: file,
+          createdAt: new Date().toISOString(),
+        }, null, 2) + '\n',
+      );
+      console.log(`${dim}  Persistent network: ${result.projectName}${reset}`);
+      console.log(`${dim}  Reuse: ${basename(process.argv[1])} --reuse${reset}`);
+      console.log(`${dim}  Tear down: e2e-down${reset}`);
+    }
+
     if (result.status === 'pass') {
       console.log(`  ${green}✔ passed (${result.duration}s)${reset}`);
       passed++;