104 lines
3.7 KiB
TypeScript
104 lines
3.7 KiB
TypeScript
import { readFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import { SuaveplanError } from "@suaveplan/error";
|
|
import { describe, expect, it } from "@suaveplan/testing/runner";
|
|
import { SRP_CODES, SrpError, srpError } from "./errors.js";
|
|
|
|
const SRC_ROOT = join(import.meta.dirname, "..");
|
|
|
|
describe("SRP_CODES", () => {
|
|
it("contains exactly the 6 documented codes", { timeout: 5000 }, () => {
|
|
const keys = Object.keys(SRP_CODES).sort();
|
|
expect(keys).toEqual([
|
|
"AUTH_FAILED",
|
|
"GROUP_UNSUPPORTED",
|
|
"HASH_UNSUPPORTED",
|
|
"INVALID_PARAMS",
|
|
"MUTUAL_AUTH_FAILED",
|
|
"PUBLIC_KEY_INVALID",
|
|
]);
|
|
for (const k of keys) {
|
|
expect(SRP_CODES[k as keyof typeof SRP_CODES]).toBe(`SRP.${k}`);
|
|
}
|
|
});
|
|
|
|
it("every SRP code reachable from a production path", {
|
|
timeout: 5000,
|
|
}, () => {
|
|
// Recursively read every .ts under src/ excluding test files, fixtures,
|
|
// and *.types.ts. For each registered code, assert at least one
|
|
// production file mentions the code literal.
|
|
const sources = readSrcSources(SRC_ROOT);
|
|
for (const code of Object.values(SRP_CODES)) {
|
|
const reason = code.split(".")[1];
|
|
const found = sources.some(({ body }) => body.includes(reason!));
|
|
expect(found).toBe(true);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("SrpError", () => {
|
|
it("instances carry the SRP.* code literal", { timeout: 5000 }, () => {
|
|
const err = srpError(SRP_CODES.AUTH_FAILED, "test");
|
|
expect(err).toBeInstanceOf(SrpError);
|
|
expect(err).toBeInstanceOf(SuaveplanError);
|
|
expect(err.code).toBe("SRP.AUTH_FAILED");
|
|
expect(err.message).toContain("SRP.AUTH_FAILED");
|
|
});
|
|
|
|
it("srpError threads through Error cause", { timeout: 5000 }, () => {
|
|
const cause = new Error("inner");
|
|
const err = srpError(SRP_CODES.INVALID_PARAMS, "outer", { cause });
|
|
expect((err as unknown as { cause: Error }).cause).toBe(cause);
|
|
});
|
|
|
|
it("SrpError constructor uses default empty options", {
|
|
timeout: 5000,
|
|
}, () => {
|
|
const err = new SrpError(SRP_CODES.INVALID_PARAMS, "no opts");
|
|
expect(err.code).toBe("SRP.INVALID_PARAMS");
|
|
});
|
|
|
|
it("srpError called without options argument", { timeout: 5000 }, () => {
|
|
const err = srpError(SRP_CODES.AUTH_FAILED, "no opts");
|
|
expect(err.code).toBe("SRP.AUTH_FAILED");
|
|
});
|
|
|
|
it("srpError ignores non-Error cause silently", { timeout: 5000 }, () => {
|
|
const err = srpError(SRP_CODES.INVALID_PARAMS, "outer", {
|
|
cause: "string",
|
|
});
|
|
expect(err.code).toBe("SRP.INVALID_PARAMS");
|
|
});
|
|
});
|
|
|
|
type SrcSource = { path: string; body: string };
|
|
|
|
function readSrcSources(root: string): SrcSource[] {
|
|
const out: SrcSource[] = [];
|
|
const fs = require("node:fs") as typeof import("node:fs");
|
|
function walk(dir: string): void {
|
|
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
|
const full = join(dir, entry.name);
|
|
if (entry.isDirectory()) {
|
|
if (
|
|
entry.name === "__fixtures__" ||
|
|
entry.name === "__benchmarks__"
|
|
) {
|
|
continue;
|
|
}
|
|
walk(full);
|
|
} else if (
|
|
entry.name.endsWith(".ts") &&
|
|
!entry.name.endsWith(".test.ts") &&
|
|
!entry.name.endsWith(".types.ts") &&
|
|
!entry.name.endsWith(".bench.ts")
|
|
) {
|
|
out.push({ path: full, body: readFileSync(full, "utf8") });
|
|
}
|
|
}
|
|
}
|
|
walk(root);
|
|
return out;
|
|
}
|