import { INestApplication } from "@nestjs/common"; import { getRepositoryToken } from "@nestjs/typeorm"; import * as fs from "node:fs"; import * as os from "node:os"; import * as path from "node:path"; import { DataSource, Repository } from "typeorm"; import request from "supertest"; import { EnvironmentService } from "../src/environment/environment.service"; import { ScenarioSchedulerService } from "../src/scenario/scenario-scheduler.service"; import { ScenarioService } from "../src/scenario/scenario.service"; import { PasswordService } from "../src/auth/password.service"; import { UserEntity } from "../src/auth/user.entity"; import { OperatorCliInput, runOperatorCommand, } from "../src/operator-cli/operator-cli"; import { buildTestApp } from "./app.harness"; const AUTH_SECRET = "synthetic-integration-secret-for-tests"; const USER_PASSWORD = "synthetic-integration-password"; function cookiePair(response: request.Response): string { const cookies = response.headers["set-cookie"]; if (!Array.isArray(cookies) || typeof cookies[0] !== "string") { throw new Error("Login response did not set an auth cookie"); } return cookies[0].split(";")[0]; } function cookieToken(cookie: string): string { return decodeURIComponent(cookie.slice(cookie.indexOf("=") + 1)); } function cliInput(): OperatorCliInput { const lines = ["integration-user"]; const secrets = [USER_PASSWORD, USER_PASSWORD]; return { line: async () => lines.shift() ?? "", secret: async () => secrets.shift() ?? "", }; } describe("authentication integration journey", () => { const envKeys = [ "AUTH_ENABLED", "AUTH_JWT_SECRET", "AUTH_JWT_EXPIRES_IN", "AUTH_REVOKED_TOKEN_CLEANUP_CRON", ] as const; const previousEnv = new Map(); let directory: string; let databasePath: string; let app: INestApplication; beforeAll(async () => { for (const key of envKeys) previousEnv.set(key, process.env[key]); process.env.AUTH_ENABLED = "true"; process.env.AUTH_JWT_SECRET = AUTH_SECRET; process.env.AUTH_JWT_EXPIRES_IN = "1h"; process.env.AUTH_REVOKED_TOKEN_CLEANUP_CRON = "0 3 * * *"; directory = fs.mkdtempSync(path.join(os.tmpdir(), "liqa-auth-e2e-")); databasePath = path.join(directory, "liqa.db"); app = await buildTestApp(databasePath); }); afterAll(async () => { await app?.close(); if (directory) fs.rmSync(directory, { recursive: true, force: true }); for (const key of envKeys) { const value = previousEnv.get(key); if (value === undefined) delete process.env[key]; else process.env[key] = value; } }); it("carries a CLI-created account through login, protected APIs, events, logout and deletion", async () => { const dataSource = app.get(DataSource); const passwords = app.get(PasswordService); await runOperatorCommand(["user:create"], { dataSource, config: { AUTH_ENABLED: true, AUTH_JWT_SECRET: AUTH_SECRET, AUTH_JWT_EXPIRES_IN: "1h", }, passwords, input: cliInput(), output: { write: () => undefined }, }); const users = app.get>( getRepositoryToken(UserEntity), ); const createdUser = await users.findOneByOrFail({ username: "integration-user", }); expect(createdUser.passwordHash).not.toBe(USER_PASSWORD); const listener = await app.listen(0, "127.0.0.1"); const address = listener.address(); if (!address || typeof address === "string") { throw new Error("Could not determine ephemeral test server port"); } const login = await request(app.getHttpServer()) .post("/auth/login") .send({ username: "integration-user", password: USER_PASSWORD }) .expect(200); expect(login.body.user).toMatchObject({ id: createdUser.id, username: "integration-user", }); const cookie = cookiePair(login); const token = cookieToken(cookie); await request(app.getHttpServer()) .get("/auth/me") .set("Cookie", cookie) .expect(200) .then(({ body }) => expect(body.id).toBe(createdUser.id)); await request(app.getHttpServer()) .get("/scenarios") .set("Authorization", `Bearer ${token}`) .expect(200); const mcpRequest = { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "auth-integration-test", version: "1" }, }, }; for (const credential of [ { name: "Cookie", value: cookie }, { name: "Authorization", value: `Bearer ${token}` }, ]) { await request(app.getHttpServer()) .post("/mcp") .set(credential.name, credential.value) .set("Content-Type", "application/json") .set("Accept", "application/json, text/event-stream") .send(mcpRequest) .expect(200); } const abort = new AbortController(); const eventResponse = await fetch( `http://127.0.0.1:${address.port}/scenarios/runs/events`, { headers: { Authorization: `Bearer ${token}` }, signal: abort.signal, }, ); expect(eventResponse.status).toBe(200); expect(eventResponse.headers.get("content-type")).toContain( "text/event-stream", ); const scenarios = app.get(ScenarioService); const environments = app.get(EnvironmentService); const scheduler = app.get(ScenarioSchedulerService); const scenario = await scenarios.create({ name: "auth integration run" }); await scenarios.createStep(scenario.id, { title: "Return a deterministic result", execCode: "return 'integration-ok';", }); const environment = await environments.create({ name: "auth integration environment", data: {}, }); const run = await scenarios.createRun(scenario.id, environment.id); await scheduler.pickUpPendingRuns(); const reader = eventResponse.body?.getReader(); if (!reader) throw new Error("Run events response has no readable body"); let eventText = ""; const readFinishedEvent = async () => { const decoder = new TextDecoder(); while ( !eventText.includes(`"runId":"${run.id}"`) || !eventText.includes("event: run.finished") ) { const { value, done } = await reader.read(); if (done) throw new Error("Run events stream closed before completion"); eventText += decoder.decode(value, { stream: true }); } return eventText; }; let timer: ReturnType | undefined; try { const output = await Promise.race([ readFinishedEvent(), new Promise((_, reject) => { timer = setTimeout( () => reject(new Error("Timed out waiting for run.finished SSE")), 5000, ); }), ]); expect(output).toContain("event: run.started"); expect(output).toContain("event: run.finished"); expect(output).toContain(`"runId":"${run.id}"`); expect(output).toContain('"status":"pass"'); } finally { if (timer) clearTimeout(timer); abort.abort(); await reader.cancel().catch(() => undefined); } await request(app.getHttpServer()) .post("/auth/logout") .set("Cookie", cookie) .expect(204); await request(app.getHttpServer()) .get("/scenarios") .set("Cookie", cookie) .expect(401); await request(app.getHttpServer()) .get("/scenarios") .set("Authorization", `Bearer ${token}`) .expect(401); const deletionInput = { line: async () => "delete-user", secret: async () => USER_PASSWORD, }; await runOperatorCommand(["user:create"], { dataSource, config: { AUTH_ENABLED: true, AUTH_JWT_SECRET: AUTH_SECRET, AUTH_JWT_EXPIRES_IN: "1h", }, passwords, input: deletionInput, output: { write: () => undefined }, }); const deletionLogin = await request(app.getHttpServer()) .post("/auth/login") .send({ username: "delete-user", password: USER_PASSWORD }) .expect(200); const deletionCookie = cookiePair(deletionLogin); const deletionToken = cookieToken(deletionCookie); await runOperatorCommand(["user:delete", "delete-user"], { dataSource, config: { AUTH_ENABLED: true, AUTH_JWT_SECRET: AUTH_SECRET, AUTH_JWT_EXPIRES_IN: "1h", }, passwords, input: deletionInput, output: { write: () => undefined }, }); await request(app.getHttpServer()) .get("/scenarios") .set("Cookie", deletionCookie) .expect(401); await request(app.getHttpServer()) .get("/scenarios") .set("Authorization", `Bearer ${deletionToken}`) .expect(401); const migrationsBeforeRestart = await dataSource.query( "SELECT timestamp FROM migrations ORDER BY timestamp", ); await app.close(); app = await buildTestApp(databasePath); const reopenedDataSource = app.get(DataSource); expect(await reopenedDataSource.showMigrations()).toBe(false); await expect( reopenedDataSource.query( "SELECT timestamp FROM migrations ORDER BY timestamp", ), ).resolves.toEqual(migrationsBeforeRestart); await expect( reopenedDataSource .getRepository(UserEntity) .findOneBy({ username: "integration-user" }), ).resolves.toMatchObject({ username: "integration-user" }); await expect( reopenedDataSource .getRepository(UserEntity) .findOneBy({ username: "delete-user" }), ).resolves.toBeNull(); }); });