- Extract auth DTOs, cookie/JWT helpers and the generic duration parser. - Configure the session cookie and map domain auth failures to HTTP responses. - Add typed Swagger responses and focused regression coverage.
259 lines
9.0 KiB
TypeScript
259 lines
9.0 KiB
TypeScript
import { INestApplication } from "@nestjs/common";
|
|
import { getRepositoryToken } from "@nestjs/typeorm";
|
|
import request from "supertest";
|
|
import { Repository } from "typeorm";
|
|
import { filter, firstValueFrom, timeout } from "rxjs";
|
|
import { AuthService } from "../src/auth/auth.service";
|
|
import { tokenHash } from "../src/auth/jwt.helpers";
|
|
import { PasswordService } from "../src/auth/password.service";
|
|
import { RevokedTokenEntity } from "../src/auth/revoked-token.entity";
|
|
import { EnvironmentService } from "../src/environment/environment.service";
|
|
import { RunEventsService } from "../src/scenario/run-events.service";
|
|
import { ScenarioSchedulerService } from "../src/scenario/scenario-scheduler.service";
|
|
import { ScenarioService } from "../src/scenario/scenario.service";
|
|
import { UserEntity } from "../src/auth/user.entity";
|
|
import { buildTestApp } from "./app.harness";
|
|
|
|
function firstSetCookie(response: {
|
|
headers: Record<string, unknown>;
|
|
}): string {
|
|
const value = response.headers["set-cookie"];
|
|
return Array.isArray(value) ? String(value[0]) : String(value);
|
|
}
|
|
|
|
describe("optional authentication", () => {
|
|
const envKeys = [
|
|
"AUTH_ENABLED",
|
|
"AUTH_JWT_SECRET",
|
|
"AUTH_JWT_EXPIRES_IN",
|
|
"AUTH_REVOKED_TOKEN_CLEANUP_CRON",
|
|
] as const;
|
|
const previousEnv = new Map<string, string | undefined>();
|
|
let app: INestApplication;
|
|
let users: Repository<UserEntity>;
|
|
let passwords: PasswordService;
|
|
let auth: AuthService;
|
|
let revokedTokens: Repository<RevokedTokenEntity>;
|
|
let user: UserEntity;
|
|
|
|
beforeAll(async () => {
|
|
for (const key of envKeys) previousEnv.set(key, process.env[key]);
|
|
process.env.AUTH_ENABLED = "true";
|
|
process.env.AUTH_JWT_SECRET = "auth-test-secret-only";
|
|
process.env.AUTH_JWT_EXPIRES_IN = "1h";
|
|
app = await buildTestApp();
|
|
users = app.get<Repository<UserEntity>>(getRepositoryToken(UserEntity));
|
|
passwords = app.get(PasswordService);
|
|
auth = app.get(AuthService);
|
|
revokedTokens = app.get<Repository<RevokedTokenEntity>>(
|
|
getRepositoryToken(RevokedTokenEntity),
|
|
);
|
|
user = await users.save(
|
|
users.create({
|
|
username: "alice",
|
|
passwordHash: await passwords.hash("correct-test-password"),
|
|
}),
|
|
);
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await app?.close();
|
|
for (const key of envKeys) {
|
|
const value = previousEnv.get(key);
|
|
if (value === undefined) delete process.env[key];
|
|
else process.env[key] = value;
|
|
}
|
|
});
|
|
|
|
it("keeps health and the secret-free auth flag public while protecting REST, MCP, and run events", async () => {
|
|
await request(app.getHttpServer()).get("/health").expect(200);
|
|
const manifest = await request(app.getHttpServer())
|
|
.get("/manifest.json")
|
|
.expect(200);
|
|
expect(manifest.body.auth).toEqual({ enabled: true });
|
|
expect(JSON.stringify(manifest.body)).not.toContain("AUTH_JWT_SECRET");
|
|
expect(JSON.stringify(manifest.body)).not.toContain(
|
|
"auth-test-secret-only",
|
|
);
|
|
|
|
await request(app.getHttpServer()).get("/scenarios").expect(401);
|
|
await request(app.getHttpServer())
|
|
.get("/scenarios/runs/events")
|
|
.expect(401);
|
|
await request(app.getHttpServer())
|
|
.post("/mcp")
|
|
.send({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} })
|
|
.expect(401);
|
|
});
|
|
|
|
it("continues processing scheduled scenarios without an HTTP credential", async () => {
|
|
const environments = app.get(EnvironmentService);
|
|
const scenarios = app.get(ScenarioService);
|
|
const scheduler = app.get(ScenarioSchedulerService);
|
|
const events = app.get(RunEventsService);
|
|
const environment = await environments.create({
|
|
name: "auth-scheduler-environment",
|
|
data: {},
|
|
});
|
|
const scenario = await scenarios.create({
|
|
name: "auth-scheduler-scenario",
|
|
});
|
|
await scenarios.createStep(scenario.id, {
|
|
title: "Return a value",
|
|
execCode: "return 1;",
|
|
});
|
|
const run = await scenarios.createRun(scenario.id, environment.id);
|
|
const finished = firstValueFrom(
|
|
events.stream().pipe(
|
|
filter(
|
|
(event) => event.type === "run.finished" && event.runId === run.id,
|
|
),
|
|
timeout({ first: 5000 }),
|
|
),
|
|
);
|
|
|
|
await scheduler.pickUpPendingRuns();
|
|
await finished;
|
|
expect((await scenarios.findRun(scenario.id, run.id)).status).toBe("pass");
|
|
});
|
|
|
|
it("logs in with a strict HttpOnly cookie and returns only safe identity fields", async () => {
|
|
const response = await request(app.getHttpServer())
|
|
.post("/auth/login")
|
|
.set("x-forwarded-proto", "https")
|
|
.send({ username: "alice", password: "correct-test-password" })
|
|
.expect(200);
|
|
|
|
expect(response.body.user).toMatchObject({
|
|
id: user.id,
|
|
username: "alice",
|
|
});
|
|
expect(response.body.user.passwordHash).toBeUndefined();
|
|
expect(response.body.token).toBeUndefined();
|
|
expect(JSON.stringify(response.body)).not.toContain(
|
|
"correct-test-password",
|
|
);
|
|
const cookie = firstSetCookie(response);
|
|
expect(cookie).toContain("HttpOnly");
|
|
expect(cookie).toContain("SameSite=Strict");
|
|
expect(cookie).toContain("Secure");
|
|
expect(cookie).toContain("Max-Age=");
|
|
});
|
|
|
|
it("rejects unknown or incorrect credentials without returning account data", async () => {
|
|
for (const username of ["alice", "missing-user"]) {
|
|
const response = await request(app.getHttpServer())
|
|
.post("/auth/login")
|
|
.send({ username, password: "wrong-test-password" })
|
|
.expect(401);
|
|
expect(JSON.stringify(response.body)).not.toContain("passwordHash");
|
|
expect(JSON.stringify(response.body)).not.toContain(
|
|
"wrong-test-password",
|
|
);
|
|
}
|
|
});
|
|
|
|
it("accepts cookie and Bearer credentials and keeps the password hash private", async () => {
|
|
const login = await request(app.getHttpServer())
|
|
.post("/auth/login")
|
|
.send({ username: "alice", password: "correct-test-password" })
|
|
.expect(200);
|
|
const cookiePair = firstSetCookie(login).split(";")[0];
|
|
const token = decodeURIComponent(
|
|
cookiePair.slice(cookiePair.indexOf("=") + 1),
|
|
);
|
|
|
|
const cookieMe = await request(app.getHttpServer())
|
|
.get("/auth/me")
|
|
.set("Cookie", cookiePair)
|
|
.expect(200);
|
|
expect(cookieMe.body).toMatchObject({ id: user.id, username: "alice" });
|
|
expect(cookieMe.body.passwordHash).toBeUndefined();
|
|
await request(app.getHttpServer())
|
|
.get("/scenarios")
|
|
.set("Cookie", cookiePair)
|
|
.expect(200);
|
|
|
|
await request(app.getHttpServer())
|
|
.get("/scenarios")
|
|
.set("Authorization", `Bearer ${token}`)
|
|
.expect(200);
|
|
|
|
const mcp = await request(app.getHttpServer())
|
|
.post("/mcp")
|
|
.set("Authorization", `Bearer ${token}`)
|
|
.set("Content-Type", "application/json")
|
|
.set("Accept", "application/json, text/event-stream")
|
|
.send({
|
|
jsonrpc: "2.0",
|
|
id: 1,
|
|
method: "initialize",
|
|
params: {
|
|
protocolVersion: "2024-11-05",
|
|
capabilities: {},
|
|
clientInfo: { name: "auth-test", version: "0" },
|
|
},
|
|
})
|
|
.expect(200);
|
|
expect(mcp.text).toContain("protocolVersion");
|
|
});
|
|
|
|
it("rejects tampered and expired tokens and deleted users", async () => {
|
|
const valid = auth.issueToken(user).token;
|
|
const tampered = `${valid.slice(0, -2)}${valid.endsWith("A") ? "B" : "A"}A`;
|
|
await request(app.getHttpServer())
|
|
.get("/auth/me")
|
|
.set("Authorization", `Bearer ${tampered}`)
|
|
.expect(401);
|
|
|
|
const now = Date.now();
|
|
const oldClock = jest
|
|
.spyOn(Date, "now")
|
|
.mockReturnValue(now - 2 * 3600_000);
|
|
const expired = auth.issueToken(user).token;
|
|
oldClock.mockRestore();
|
|
await request(app.getHttpServer())
|
|
.get("/auth/me")
|
|
.set("Authorization", `Bearer ${expired}`)
|
|
.expect(401);
|
|
|
|
const removedUser = await users.save(
|
|
users.create({
|
|
username: "deleted-user",
|
|
passwordHash: await passwords.hash("temporary-test-password"),
|
|
}),
|
|
);
|
|
const deletedUserToken = auth.issueToken(removedUser).token;
|
|
await users.delete({ id: removedUser.id });
|
|
await request(app.getHttpServer())
|
|
.get("/auth/me")
|
|
.set("Authorization", `Bearer ${deletedUserToken}`)
|
|
.expect(401);
|
|
});
|
|
|
|
it("persists only the token digest on logout and rejects token reuse", async () => {
|
|
const login = await request(app.getHttpServer())
|
|
.post("/auth/login")
|
|
.send({ username: "alice", password: "correct-test-password" })
|
|
.expect(200);
|
|
const cookiePair = firstSetCookie(login).split(";")[0];
|
|
const token = decodeURIComponent(
|
|
cookiePair.slice(cookiePair.indexOf("=") + 1),
|
|
);
|
|
const logout = await request(app.getHttpServer())
|
|
.post("/auth/logout")
|
|
.set("Cookie", cookiePair)
|
|
.expect(204);
|
|
|
|
expect(firstSetCookie(logout)).toContain("Max-Age=0");
|
|
const storedRevocation = await revokedTokens.findOneBy({
|
|
tokenHash: tokenHash(token),
|
|
});
|
|
expect(storedRevocation?.tokenHash).not.toBe(token);
|
|
await request(app.getHttpServer())
|
|
.get("/scenarios")
|
|
.set("Authorization", `Bearer ${token}`)
|
|
.expect(401);
|
|
});
|
|
});
|