@ankhorage/infra 4.1.10 → 5.0.0

package/src/adapters/minikube/base/portForwardRuntime.test.ts

@@ -1,624 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
-
-import { generateInfrastructure } from '../../../index.js';
-import { ensureProjectInfrastructureRuntime } from '../../../project/index.js';
-import { createAppManifest } from '../../../testSupport.js';
-import type { InfraManifestInput } from '../../../types.js';
-
-const temporaryPaths = new Set<string>();
-
-afterEach(async () => {
-  for (const rootPath of temporaryPaths) {
-    await stopFixtureProcesses(rootPath);
-    await fs.rm(rootPath, { force: true, recursive: true });
-  }
-  temporaryPaths.clear();
-});
-
-describe('generated Minikube runtime port-forward lifecycle', () => {
-  test(
-    'keeps healthy app forwarding, repairs a stopped Supabase gateway, and isolates operational forwards',
-    async () => {
-      const fixture = await createPortForwardFixture(createSupabaseManifest(), 'runtime-recovery');
-
-      const firstStart = await runPortForward(fixture, 'start', 'runtime');
-      expect(firstStart.stdout).toContain('app: started');
-      expect(firstStart.stdout).toContain('supabase-gateway: started');
-
-      const appPid = await readForwardPid(fixture, 'app');
-      const firstGatewayPid = await readForwardPid(fixture, 'supabase-gateway');
-      await expectForwardPid(fixture, 'studio', false);
-      await expectForwardPid(fixture, 'db-migration', false);
-
-      const repeatedStart = await runPortForward(fixture, 'start', 'runtime');
-      expect(repeatedStart.stdout).toContain(`app: running (pid ${appPid})`);
-      expect(repeatedStart.stdout).toContain(`supabase-gateway: running (pid ${firstGatewayPid})`);
-      expect(await readForwardPid(fixture, 'app')).toBe(appPid);
-      expect(await readForwardPid(fixture, 'supabase-gateway')).toBe(firstGatewayPid);
-
-      await runPortForward(fixture, 'stop', 'supabase-gateway');
-      expect(await readForwardPid(fixture, 'app')).toBe(appPid);
-      await expectForwardPid(fixture, 'supabase-gateway', false);
-
-      const recovery = await ensureProjectInfrastructureRuntime({
-        projectId: fixture.profile,
-        projectPath: fixture.rootPath,
-        target: 'minikube',
-      });
-      expect(recovery.stdout).toContain(`app: running (pid ${appPid})`);
-      expect(recovery.stdout).toContain('supabase-gateway: started');
-      expect(await readForwardPid(fixture, 'app')).toBe(appPid);
-      expect(await readForwardPid(fixture, 'supabase-gateway')).not.toBe(firstGatewayPid);
-      await expectForwardPid(fixture, 'studio', false);
-      await expectForwardPid(fixture, 'db-migration', false);
-
-      await runPortForward(fixture, 'stop', 'runtime');
-    },
-    { timeout: 30_000 },
-  );
-
-  test(
-    'starts only the app forward when no provider owns another runtime endpoint',
-    async () => {
-      const fixture = await createPortForwardFixture(
-        { deployment: { target: 'minikube', monitoring: false }, modules: [] },
-        'runtime-app-only',
-      );
-
-      const result = await runPortForward(fixture, 'start', 'runtime');
-
-      expect(result.stdout).toContain('app: started');
-      expect(result.stdout).not.toContain('supabase-gateway');
-      await expectForwardPid(fixture, 'app', true);
-      await expectForwardPid(fixture, 'supabase-gateway', false);
-      await expectForwardPid(fixture, 'studio', false);
-      await expectForwardPid(fixture, 'db-migration', false);
-
-      await runPortForward(fixture, 'stop', 'runtime');
-    },
-    { timeout: 15_000 },
-  );
-
-  test(
-    'restores only the Supabase gateway for a native-only app without an app service',
-    async () => {
-      const appManifest = {
-        ...createAppManifest('native-runtime'),
-        deploy: {
-          targets: {
-            android: { enabled: true, package: 'com.ankh.nativeruntime' },
-          },
-        },
-      };
-      const fixture = await createPortForwardFixture(
-        createSupabaseManifest(),
-        'native-runtime',
-        appManifest,
-        'service/app-runtime',
-      );
-
-      const firstEnsure = await ensureProjectInfrastructureRuntime({
-        projectId: fixture.profile,
-        projectPath: fixture.rootPath,
-        target: 'minikube',
-      });
-      expect(firstEnsure.stdout).toContain('supabase-gateway: started');
-      expect(firstEnsure.stdout).not.toContain('app:');
-      const gatewayPid = await readForwardPid(fixture, 'supabase-gateway');
-
-      const repeatedEnsure = await ensureProjectInfrastructureRuntime({
-        projectId: fixture.profile,
-        projectPath: fixture.rootPath,
-        target: 'minikube',
-      });
-      expect(repeatedEnsure.stdout).toContain(`supabase-gateway: running (pid ${gatewayPid})`);
-      expect(await readForwardPid(fixture, 'supabase-gateway')).toBe(gatewayPid);
-      await expectForwardPid(fixture, 'app', false);
-    },
-    { timeout: 15_000 },
-  );
-
-  test(
-    'retries a transient forward that becomes reachable and then loses its stale pod',
-    async () => {
-      const appManifest = {
-        ...createAppManifest('native-runtime-retry'),
-        deploy: {
-          targets: {
-            android: { enabled: true, package: 'com.ankh.nativeruntimeretry' },
-          },
-        },
-      };
-      const fixture = await createPortForwardFixture(
-        createSupabaseManifest(),
-        'native-runtime-retry',
-        appManifest,
-        undefined,
-        1,
-        750,
-      );
-
-      const recovery = await ensureProjectInfrastructureRuntime({
-        projectId: fixture.profile,
-        projectPath: fixture.rootPath,
-        target: 'minikube',
-      });
-
-      expect(recovery.stdout).toContain(
-        'supabase-gateway: port-forward attempt 1 exited before readiness; retrying',
-      );
-      expect(recovery.stdout).toContain('supabase-gateway: started');
-      expect(Number.parseInt(await fs.readFile(fixture.forwardAttemptPath, 'utf8'), 10)).toBe(2);
-      await expectForwardPid(fixture, 'supabase-gateway', true);
-      await expectForwardPid(fixture, 'app', false);
-    },
-    { timeout: 15_000 },
-  );
-
-  test(
-    'cleans an owned app forward removed from the native-only active topology',
-    async () => {
-      const fixture = await createPortForwardFixture(
-        createSupabaseManifest(),
-        'native-runtime-upgrade',
-        createNativeAppManifest('native-runtime-upgrade'),
-      );
-      const appPort = Number.parseInt(fixture.env.APP_PORT_FORWARD_LOCAL_PORT ?? '', 10);
-      const oldAppForward = Bun.spawn(
-        [
-          'kubectl',
-          '--context',
-          fixture.profile,
-          '-n',
-          'app',
-          'port-forward',
-          'service/app-runtime',
-          `${appPort}:80`,
-        ],
-        { env: fixture.env, stderr: 'ignore', stdout: 'ignore' },
-      );
-      await waitForHttpPort(appPort);
-      await writeForwardPid(fixture, 'app', oldAppForward.pid);
-
-      const cleanup = await runPortForward(fixture, 'stop', 'all');
-
-      expect(cleanup.stdout).toContain('app: stopped');
-      await oldAppForward.exited;
-      expect(isProcessRunning(oldAppForward.pid)).toBe(false);
-      await expectForwardPid(fixture, 'app', false);
-
-      const recovery = await runPortForward(fixture, 'start', 'runtime');
-      expect(recovery.stdout).toContain('supabase-gateway: started');
-      expect(recovery.stdout).not.toContain('app: started');
-      await expectForwardPid(fixture, 'app', false);
-      await expectForwardPid(fixture, 'supabase-gateway', true);
-    },
-    { timeout: 15_000 },
-  );
-
-  test(
-    'refuses to terminate a non-owned PID recorded as an obsolete app forward',
-    async () => {
-      const fixture = await createPortForwardFixture(
-        createSupabaseManifest(),
-        'native-runtime-non-owned',
-        createNativeAppManifest('native-runtime-non-owned'),
-      );
-      const appPort = Number.parseInt(fixture.env.APP_PORT_FORWARD_LOCAL_PORT ?? '', 10);
-      const nonOwnedProcess = Bun.spawn(['bun', fixture.serverScript, String(appPort)], {
-        env: fixture.env,
-        stderr: 'ignore',
-        stdout: 'ignore',
-      });
-
-      try {
-        await waitForHttpPort(appPort);
-        await writeForwardPid(fixture, 'app', nonOwnedProcess.pid);
-
-        const cleanup = await executePortForward(fixture, 'stop', 'all');
-
-        expect(cleanup.exitCode).not.toBe(0);
-        expect(cleanup.stdout).toContain(
-          `app: stale pid file pointed at non-owned live pid ${nonOwnedProcess.pid}`,
-        );
-        expect(cleanup.stdout).toContain(
-          `app: port occupied by non-owned process on local port ${appPort}`,
-        );
-        expect(isProcessRunning(nonOwnedProcess.pid)).toBe(true);
-        await expectForwardPid(fixture, 'app', false);
-      } finally {
-        nonOwnedProcess.kill();
-        await nonOwnedProcess.exited;
-      }
-    },
-    { timeout: 15_000 },
-  );
-
-  test('fails actionably when a generated Web app target is genuinely missing', async () => {
-    const fixture = await createPortForwardFixture(
-      createSupabaseManifest(),
-      'missing-web-runtime',
-      createAppManifest('missing-web-runtime'),
-      'service/app-runtime',
-    );
-
-    await expectFailureMessage(
-      ensureProjectInfrastructureRuntime({
-        projectId: fixture.profile,
-        projectPath: fixture.rootPath,
-        target: 'minikube',
-      }),
-      'app: target app/service/app-runtime not found',
-    );
-    await expectForwardPid(fixture, 'supabase-gateway', false);
-  });
-
-  test('fails actionably when a generated provider target is genuinely missing', async () => {
-    const appManifest = {
-      ...createAppManifest('missing-provider-runtime'),
-      deploy: {
-        targets: {
-          android: { enabled: true, package: 'com.ankh.missingprovider' },
-        },
-      },
-    };
-    const fixture = await createPortForwardFixture(
-      createSupabaseManifest(),
-      'missing-provider-runtime',
-      appManifest,
-      'service/gateway',
-    );
-
-    await expectFailureMessage(
-      ensureProjectInfrastructureRuntime({
-        projectId: fixture.profile,
-        projectPath: fixture.rootPath,
-        target: 'minikube',
-      }),
-      'supabase-gateway: target supabase/service/gateway not found',
-    );
-  });
-});
-
-interface PortForwardFixture {
-  readonly env: Record<string, string>;
-  readonly forwardAttemptPath: string;
-  readonly processDirectory: string;
-  readonly profile: string;
-  readonly rootPath: string;
-  readonly serverScript: string;
-  readonly scriptPath: string;
-}
-
-async function createPortForwardFixture(
-  manifest: InfraManifestInput,
-  profile: string,
-  appManifest = createAppManifest(profile),
-  missingResource?: string,
-  transientPortForwardFailures = 0,
-  transientPortForwardLifetimeMs = 0,
-): Promise<PortForwardFixture> {
-  const rootPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-port-forward-runtime-'));
-  temporaryPaths.add(rootPath);
-  const generated = generateInfrastructure(manifest, {
-    appManifest,
-  });
-  const generatedScript = generated.files.find(
-    (file) => file.path === 'infra/minikube/scripts/port-forward.sh',
-  );
-  if (generatedScript === undefined) {
-    throw new Error('Generated port-forward script was missing.');
-  }
-
-  const scriptPath = path.join(rootPath, generatedScript.path);
-  const fakeBin = path.join(rootPath, 'fake-bin');
-  const forwardAttemptPath = path.join(rootPath, 'forward-attempts');
-  const processDirectory = path.join(rootPath, 'fake-processes');
-  const serverScript = path.join(rootPath, 'forward-server.ts');
-  await fs.mkdir(path.dirname(scriptPath), { recursive: true });
-  await fs.mkdir(fakeBin, { recursive: true });
-  await fs.mkdir(processDirectory, { recursive: true });
-  await fs.writeFile(
-    serverScript,
-    [
-      "const port = Number.parseInt(Bun.argv[2] ?? '', 10);",
-      "const lifetimeMs = Number.parseInt(Bun.argv[3] ?? '0', 10);",
-      "const server = Bun.serve({ hostname: '127.0.0.1', port, fetch: () => new Response('ok') });",
-      'if (lifetimeMs > 0) {',
-      '  await Bun.sleep(lifetimeMs);',
-      '  server.stop(true);',
-      '  process.exit(1);',
-      '}',
-      'await new Promise(() => undefined);',
-      '',
-    ].join('\n'),
-    'utf8',
-  );
-  await writeExecutable(
-    path.join(fakeBin, 'kubectl'),
-    `#!/usr/bin/env bash
-set -euo pipefail
-if [[ " $* " == *" get "* ]]; then
-  if [[ -n "\${FAKE_MISSING_RESOURCE:-}" && " $* " == *" \${FAKE_MISSING_RESOURCE} "* ]]; then
-    exit 1
-  fi
-  exit 0
-fi
-if [[ " $* " != *" port-forward "* ]]; then
-  exit 1
-fi
-endpoint="\${!#}"
-local_port="\${endpoint%%:*}"
-forward_attempt=0
-if [[ -f "\${FAKE_FORWARD_ATTEMPT_FILE}" ]]; then
-  forward_attempt="$(cat "\${FAKE_FORWARD_ATTEMPT_FILE}")"
-fi
-forward_attempt="$((forward_attempt + 1))"
-printf '%s\n' "\${forward_attempt}" > "\${FAKE_FORWARD_ATTEMPT_FILE}"
-if [[ "\${forward_attempt}" -le "\${FAKE_TRANSIENT_FORWARD_FAILURES}" ]]; then
-  if [[ "\${FAKE_TRANSIENT_FORWARD_LIFETIME_MS}" -gt 0 ]]; then
-    bun "\${FAKE_FORWARD_SERVER_SCRIPT}" "\${local_port}" "\${FAKE_TRANSIENT_FORWARD_LIFETIME_MS}" || true
-  fi
-  echo 'error: error upgrading connection: unable to upgrade connection: pod does not exist' >&2
-  exit 1
-fi
-printf 'kubectl %s\n' "$*" > "\${FAKE_PROCESS_DIRECTORY}/$$.command"
-exec bun "\${FAKE_FORWARD_SERVER_SCRIPT}" "\${local_port}"
-`,
-  );
-  await writeExecutable(
-    path.join(fakeBin, 'ps'),
-    `#!/usr/bin/env bash
-set -euo pipefail
-pid=""
-format=""
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -p) pid="$2"; shift 2 ;;
-    -o) format="$2"; shift 2 ;;
-    *) shift ;;
-  esac
-done
-command_file="\${FAKE_PROCESS_DIRECTORY}/\${pid}.command"
-if [[ -f "\${command_file}" && "\${format}" == "comm=" ]]; then
-  echo kubectl
-elif [[ -f "\${command_file}" && "\${format}" == "command=" ]]; then
-  cat "\${command_file}"
-else
-  /bin/ps -p "\${pid}" -o "\${format}"
-fi
-`,
-  );
-
-  const ports = reserveAvailablePorts(4);
-  const env = {
-    ...process.env,
-    ANKH_APP_SLUG: profile,
-    APP_PORT_FORWARD_LOCAL_PORT: String(ports[0]),
-    SUPABASE_GATEWAY_FORWARD_LOCAL_PORT: String(ports[1]),
-    SUPABASE_STUDIO_FORWARD_LOCAL_PORT: String(ports[2]),
-    SUPABASE_DB_FORWARD_LOCAL_PORT: String(ports[3]),
-    FAKE_FORWARD_ATTEMPT_FILE: forwardAttemptPath,
-    FAKE_FORWARD_SERVER_SCRIPT: serverScript,
-    FAKE_PROCESS_DIRECTORY: processDirectory,
-    FAKE_TRANSIENT_FORWARD_FAILURES: String(transientPortForwardFailures),
-    FAKE_TRANSIENT_FORWARD_LIFETIME_MS: String(transientPortForwardLifetimeMs),
-    ...(missingResource ? { FAKE_MISSING_RESOURCE: missingResource } : {}),
-    PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
-  };
-  const injectedEnvironment = Object.entries(env)
-    .filter(([key]) =>
-      [
-        'ANKH_APP_SLUG',
-        'APP_PORT_FORWARD_LOCAL_PORT',
-        'SUPABASE_GATEWAY_FORWARD_LOCAL_PORT',
-        'SUPABASE_STUDIO_FORWARD_LOCAL_PORT',
-        'SUPABASE_DB_FORWARD_LOCAL_PORT',
-        'FAKE_FORWARD_ATTEMPT_FILE',
-        'FAKE_FORWARD_SERVER_SCRIPT',
-        'FAKE_PROCESS_DIRECTORY',
-        'FAKE_TRANSIENT_FORWARD_FAILURES',
-        'FAKE_TRANSIENT_FORWARD_LIFETIME_MS',
-        'FAKE_MISSING_RESOURCE',
-        'PATH',
-      ].includes(key),
-    )
-    .map(([key, value]) => `export ${key}=${shellQuote(value)}`)
-    .join('\n');
-  await fs.writeFile(
-    scriptPath,
-    generatedScript.content.replace(
-      '#!/usr/bin/env bash\n',
-      `#!/usr/bin/env bash\n${injectedEnvironment}\n`,
-    ),
-    'utf8',
-  );
-  await fs.chmod(scriptPath, 0o755);
-  return {
-    env,
-    forwardAttemptPath,
-    processDirectory,
-    profile,
-    rootPath,
-    serverScript,
-    scriptPath,
-  };
-}
-
-function shellQuote(value: string): string {
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-
-async function expectFailureMessage(promise: Promise<unknown>, expected: string): Promise<void> {
-  try {
-    await promise;
-    throw new Error('Expected runtime ensure to fail.');
-  } catch (error) {
-    expect(error instanceof Error ? error.message : String(error)).toContain(expected);
-  }
-}
-
-async function runPortForward(
-  fixture: PortForwardFixture,
-  action: string,
-  name: string,
-): Promise<{ readonly exitCode: number; readonly stderr: string; readonly stdout: string }> {
-  const result = await executePortForward(fixture, action, name);
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `port-forward ${action} ${name} failed (${result.exitCode}): ${result.stdout}${result.stderr}`,
-    );
-  }
-  return result;
-}
-
-async function executePortForward(
-  fixture: PortForwardFixture,
-  action: string,
-  name: string,
-): Promise<{ readonly exitCode: number; readonly stderr: string; readonly stdout: string }> {
-  const process = Bun.spawn(['bash', fixture.scriptPath, action, name], {
-    env: fixture.env,
-    stderr: 'pipe',
-    stdout: 'pipe',
-  });
-  const [exitCode, stdout, stderr] = await Promise.all([
-    process.exited,
-    new Response(process.stdout).text(),
-    new Response(process.stderr).text(),
-  ]);
-  return { exitCode, stderr, stdout };
-}
-
-async function writeForwardPid(
-  fixture: PortForwardFixture,
-  name: string,
-  pid: number,
-): Promise<void> {
-  const pidPath = forwardPidPath(fixture, name);
-  await fs.mkdir(path.dirname(pidPath), { recursive: true });
-  await fs.writeFile(pidPath, `${pid}\n`, 'utf8');
-}
-
-async function waitForHttpPort(port: number): Promise<void> {
-  for (let attempt = 0; attempt < 40; attempt += 1) {
-    try {
-      const response = await fetch(`http://127.0.0.1:${port}`, {
-        signal: AbortSignal.timeout(250),
-      });
-      if (response.ok) return;
-    } catch {
-      // The fixture process may still be binding its port.
-    }
-    await Bun.sleep(50);
-  }
-  throw new Error(`Timed out waiting for fixture port ${port}.`);
-}
-
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function readForwardPid(fixture: PortForwardFixture, name: string): Promise<number> {
-  const value = await fs.readFile(forwardPidPath(fixture, name), 'utf8');
-  return Number.parseInt(value.trim(), 10);
-}
-
-async function expectForwardPid(
-  fixture: PortForwardFixture,
-  name: string,
-  exists: boolean,
-): Promise<void> {
-  expect(await pathExists(forwardPidPath(fixture, name))).toBe(exists);
-}
-
-function forwardPidPath(fixture: PortForwardFixture, name: string): string {
-  return path.join(
-    fixture.rootPath,
-    'infra/minikube/.state/forwards',
-    `${fixture.profile}-${name}.pid`,
-  );
-}
-
-function reserveAvailablePorts(count: number): number[] {
-  const listeners = Array.from({ length: count }, () =>
-    Bun.listen({
-      hostname: '127.0.0.1',
-      port: 0,
-      socket: { data: () => undefined },
-    }),
-  );
-  const ports = listeners.map((listener) => listener.port);
-  listeners.forEach((listener) => listener.stop(true));
-  return ports;
-}
-
-async function writeExecutable(filePath: string, content: string): Promise<void> {
-  await fs.writeFile(filePath, content, 'utf8');
-  await fs.chmod(filePath, 0o755);
-}
-
-async function pathExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function stopFixtureProcesses(rootPath: string): Promise<void> {
-  const stateDirectory = path.join(rootPath, 'infra/minikube/.state/forwards');
-  let entries: string[];
-  try {
-    entries = await fs.readdir(stateDirectory);
-  } catch {
-    return;
-  }
-
-  await Promise.all(
-    entries
-      .filter((entry) => entry.endsWith('.pid'))
-      .map(async (entry) => {
-        const pid = Number.parseInt(
-          await fs.readFile(path.join(stateDirectory, entry), 'utf8'),
-          10,
-        );
-        if (Number.isInteger(pid)) {
-          try {
-            process.kill(pid, 'SIGKILL');
-          } catch {
-            // The generated lifecycle may already have stopped the process.
-          }
-        }
-      }),
-  );
-}
-
-function createSupabaseManifest(): InfraManifestInput {
-  return {
-    deployment: { target: 'minikube', monitoring: false },
-    auth: { scope: 'global', provider: 'supabase' },
-    database: { provider: 'supabase', tier: 'dev' },
-    modules: [],
-  };
-}
-
-function createNativeAppManifest(profile: string) {
-  return {
-    ...createAppManifest(profile),
-    deploy: {
-      targets: {
-        android: { enabled: true, package: `com.ankh.${profile.replaceAll('-', '')}` },
-      },
-    },
-  };
-}