Files
clean-architecture-frontend…/tests/runtime-schema/http-schema.test.ts

95 lines
3.0 KiB
TypeScript

import { describe, expect, it } from "vitest";
import {
validateEnvelope,
validateOperationPayload,
validateOperationRequest,
} from "../../src/adapters/http/schema-registry.ts";
import {
composeRuntimeSchemaCodecs,
validateWithRuntimeSchemaRegistry,
} from "../../src/contracts/schema-registry.ts";
describe("HTTP platform schema boundary", () => {
it("rejects an invalid top-level envelope", () => {
expect(validateEnvelope({ success: true }).success).toBe(false);
});
it("accepts and clones a generic valid response envelope", () => {
const source = {
success: true,
data: [],
meta: { requestId: "request-1", traceId: "trace-1" },
};
const result = validateEnvelope(source);
expect(result).toMatchObject({ success: true, data: source });
if (!result.success) throw new Error("expected valid envelope");
expect(result.data).not.toBe(source);
});
it("fails closed without leaking input when a feature schema is absent", () => {
const result = validateOperationPayload("UnknownPayload", {
secret: "not-projected",
});
expect(result).toMatchObject({
success: false,
issues: [{ path: "", code: "SCHEMA_NOT_REGISTERED" }],
});
expect(JSON.stringify(result)).not.toContain("not-projected");
expect(
validateOperationRequest("UnknownCommand", { name: "Example" }).success,
).toBe(false);
});
});
describe("runtime schema codec contribution", () => {
const codec = {
schemaId: "Example",
parse: (value: unknown) => ({ success: true as const, data: value }),
};
it("resolves installed codecs and fails missing IDs closed", () => {
const registry = composeRuntimeSchemaCodecs([{ Example: codec }]);
expect(validateWithRuntimeSchemaRegistry("Example", 42, registry)).toEqual({
success: true,
data: 42,
});
expect(
validateWithRuntimeSchemaRegistry("Missing", 42, registry),
).toMatchObject({
success: false,
issues: [{ code: "SCHEMA_NOT_REGISTERED" }],
});
});
it("bounds failure issues returned by an installed codec", () => {
const noisyCodec = {
schemaId: "Noisy",
parse: () => ({
success: false as const,
issues: [
{ path: "p".repeat(121), code: "TOO_LONG_PATH" },
{ path: "field", code: "C".repeat(81) },
...Array.from({ length: 100 }, (_, index) => ({
path: `field.${index}`,
code: "INVALID",
})),
],
}),
};
const registry = composeRuntimeSchemaCodecs([{ Noisy: noisyCodec }]);
const result = validateWithRuntimeSchemaRegistry("Noisy", {}, registry);
expect(result.success).toBe(false);
if (result.success) throw new Error("expected validation failure");
expect(result.issues).toHaveLength(50);
expect(result.issues[0]).toEqual({ path: "field.0", code: "INVALID" });
});
it("rejects duplicate codec contributions", () => {
expect(() =>
composeRuntimeSchemaCodecs([{ Example: codec }, { Example: codec }]),
).toThrow("duplicate runtime schema codec");
});
});