first integration tests (#64)

resolves #60

Co-authored-by: johba <johba@harb.eth>
Reviewed-on: https://codeberg.org/johba/harb/pulls/64

tests/setup/stack.ts

@@ -0,0 +1,141 @@
+import { exec as execCallback } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+
+const exec = promisify(execCallback);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const repoRoot = resolve(__dirname, '..', '..');
+
+const DEFAULT_RPC_URL = process.env.STACK_RPC_URL ?? 'http://127.0.0.1:8545';
+const DEFAULT_WEBAPP_URL = process.env.STACK_WEBAPP_URL ?? 'http://localhost:5173';
+const DEFAULT_GRAPHQL_URL = process.env.STACK_GRAPHQL_URL ?? 'http://localhost:42069/graphql';
+
+let stackStarted = false;
+
+async function cleanupContainers(): Promise<void> {
+  try {
+    await run("podman pod ps -q --filter name=harb | xargs -r podman pod rm -f || true");
+    await run("podman ps -aq --filter name=harb | xargs -r podman rm -f || true");
+  } catch (error) {
+    console.warn('[stack] Failed to cleanup containers', error);
+  }
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise(resolveDelay => setTimeout(resolveDelay, ms));
+}
+
+async function run(command: string): Promise<void> {
+  await exec(command, { cwd: repoRoot, shell: true });
+}
+
+async function checkRpcReady(rpcUrl: string): Promise<void> {
+  const response = await fetch(rpcUrl, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'eth_chainId', params: [] }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`RPC health check failed with status ${response.status}`);
+  }
+
+  const payload = await response.json();
+  if (!payload?.result) {
+    throw new Error('RPC health check returned no result');
+  }
+}
+
+async function checkWebAppReady(webAppUrl: string): Promise<void> {
+  const url = webAppUrl.endsWith('/') ? `${webAppUrl}app/` : `${webAppUrl}/app/`;
+  const response = await fetch(url, {
+    method: 'GET',
+    redirect: 'manual',
+  });
+
+  if (!response.ok && response.status !== 308) {
+    throw new Error(`Web app health check failed with status ${response.status}`);
+  }
+}
+
+async function checkGraphqlReady(graphqlUrl: string): Promise<void> {
+  const response = await fetch(graphqlUrl, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ query: '{ __typename }' }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`GraphQL health check failed with status ${response.status}`);
+  }
+}
+
+export async function startStack(): Promise<void> {
+  if (stackStarted) {
+    return;
+  }
+
+  await cleanupContainers();
+
+  await run('nohup ./scripts/dev.sh start > ./tests/.stack.log 2>&1 &');
+  stackStarted = true;
+}
+
+export async function waitForStackReady(options: {
+  rpcUrl?: string;
+  webAppUrl?: string;
+  graphqlUrl?: string;
+  timeoutMs?: number;
+  pollIntervalMs?: number;
+} = {}): Promise<void> {
+  const rpcUrl = options.rpcUrl ?? DEFAULT_RPC_URL;
+  const webAppUrl = options.webAppUrl ?? DEFAULT_WEBAPP_URL;
+  const graphqlUrl = options.graphqlUrl ?? DEFAULT_GRAPHQL_URL;
+  const timeoutMs = options.timeoutMs ?? 180_000;
+  const pollIntervalMs = options.pollIntervalMs ?? 2_000;
+
+  const start = Date.now();
+  const errors = new Map<string, string>();
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await Promise.all([
+        checkRpcReady(rpcUrl),
+        checkWebAppReady(webAppUrl),
+        checkGraphqlReady(graphqlUrl),
+      ]);
+      return;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.set('lastError', message);
+      await delay(pollIntervalMs);
+    }
+  }
+
+  const logPath = resolve(repoRoot, 'tests', '.stack.log');
+  let logTail = '';
+  try {
+    const contents = await readFile(logPath, 'utf-8');
+    logTail = contents.split('\n').slice(-40).join('\n');
+  } catch (readError) {
+    logTail = `Unable to read stack log: ${readError}`;
+  }
+
+  throw new Error(`Stack failed to become ready within ${timeoutMs}ms\nLast error: ${errors.get('lastError')}\nLog tail:\n${logTail}`);
+}
+
+export async function stopStack(): Promise<void> {
+  if (!stackStarted) {
+    return;
+  }
+
+  try {
+    await run('./scripts/dev.sh stop');
+  } finally {
+    stackStarted = false;
+  }
+}