Any error the loaders did not classify was shown as BOOT_CONFIG_FAILURE and dropped. It now shows BOOT_UNEXPECTED_FAILURE with the build id and error class, logs the original in development, and a schema failure lists the rejected key names (bounded, never values). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
319 lines
10 KiB
TypeScript
319 lines
10 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import {
|
|
BootConfigError,
|
|
loadRuntimeConfig,
|
|
} from "../../src/bootstrap/load-runtime-config.ts";
|
|
import { validateRuntimeConfig } from "../../src/bootstrap/runtime-config-schema.ts";
|
|
import { assertSafeConfigNames } from "../../src/contracts/env.ts";
|
|
|
|
const validConfig = {
|
|
APP_ENV: "local",
|
|
API_BASE_URL: "http://localhost:8080/",
|
|
REQUEST_TIMEOUT_MS: 10_000,
|
|
MAX_RETRY_ATTEMPTS: 2,
|
|
TELEMETRY_ENABLED: false,
|
|
AUTH_MODE: "external",
|
|
CONFIG_SCHEMA_VERSION: "2.0",
|
|
RELEASE_MANIFEST_URL: "/release-manifest.json",
|
|
BUILD_ID: "build-a",
|
|
};
|
|
|
|
const validV1Config = {
|
|
...validConfig,
|
|
CONFIG_SCHEMA_VERSION: "1",
|
|
API_CONTRACT_VERSION: "1.4.0",
|
|
};
|
|
|
|
describe("runtime configuration boundary", () => {
|
|
it.each([
|
|
[{ ...validConfig, API_BASE_URL: undefined }, "required key"],
|
|
[{ ...validConfig, REQUEST_TIMEOUT_MS: 0 }, "integer range"],
|
|
[{ ...validConfig, MAX_RETRY_ATTEMPTS: 3 }, "retry cap"],
|
|
[{ ...validConfig, TELEMETRY_ENABLED: "false" }, "ambiguous boolean"],
|
|
[{ ...validConfig, CONFIG_SCHEMA_VERSION: "next" }, "version"],
|
|
[
|
|
{ ...validConfig, API_CONTRACT_VERSION: "1" },
|
|
"§5.1 scalar contract version is removed from V2",
|
|
],
|
|
[
|
|
{ ...validConfig, API_BASE_URL: "http://localhost:8080/api" },
|
|
"§6.2 base URL path must end with /",
|
|
],
|
|
[
|
|
{ ...validConfig, API_BASE_URL: "http://localhost:8080/#frag" },
|
|
"§6.2 hash in base URL",
|
|
],
|
|
[
|
|
{ ...validConfig, API_BASE_URL: "http://user:pw@localhost:8080/" },
|
|
"§6.2 credentials in URL",
|
|
],
|
|
[
|
|
{ ...validConfig, RELEASE_MANIFEST_URL: "/a/../b.json" },
|
|
"§6.2 dot segment traversal",
|
|
],
|
|
[
|
|
{ ...validConfig, RELEASE_MANIFEST_URL: "/manifest.json?v=1" },
|
|
"§6.2 query in manifest URL",
|
|
],
|
|
[
|
|
{ ...validConfig, RELEASE_MANIFEST_URL: "/\t/evil.example/m.json" },
|
|
"R-7.3 tab turns the path into a protocol-relative URL",
|
|
],
|
|
[
|
|
{ ...validConfig, RELEASE_MANIFEST_URL: "/\n/evil.example/m.json" },
|
|
"R-7.3 newline is stripped by the URL parser",
|
|
],
|
|
[
|
|
{ ...validConfig, RELEASE_MANIFEST_URL: "/a/%2e%2e/b.json" },
|
|
"R-7.3 encoded dot segment",
|
|
],
|
|
[
|
|
{ ...validConfig, RELEASE_MANIFEST_URL: "/a/%2E/b.json" },
|
|
"R-7.3 encoded single dot segment",
|
|
],
|
|
[{ ...validConfig, UNKNOWN_KEY: true }, "unknown key"],
|
|
])("rejects invalid config: %s (%s)", (candidate, _reason) => {
|
|
void _reason;
|
|
expect(validateRuntimeConfig(candidate).success).toBe(false);
|
|
});
|
|
|
|
it.each(["/release-manifest.json", "/app/v1/release-manifest.json", "/a/.well-known/m.json"])(
|
|
"accepts a same-origin manifest path: %s",
|
|
(RELEASE_MANIFEST_URL) => {
|
|
expect(
|
|
validateRuntimeConfig({ ...validConfig, RELEASE_MANIFEST_URL }).success,
|
|
).toBe(true);
|
|
},
|
|
);
|
|
|
|
it("rejects secret-like names before schema validation", () => {
|
|
expect(() => assertSafeConfigNames({ CLIENT_SECRET: "not-safe" })).toThrow(
|
|
"Forbidden client configuration key",
|
|
);
|
|
});
|
|
|
|
// R-7.2. FEATURE_OVERRIDES keys are feature ids (data), not configuration
|
|
// names; a kill switch for `cookie-consent` must not fail boot.
|
|
it("loads a config whose FEATURE_OVERRIDES name a secret-looking feature id", async () => {
|
|
const result = await loadRuntimeConfig({
|
|
buildConfig: {
|
|
buildId: "build-a",
|
|
commitSha: "local",
|
|
routerBasePath: "/",
|
|
runtimeConfigUrl: "/config.json",
|
|
},
|
|
fetcher: async () =>
|
|
new Response(
|
|
JSON.stringify({
|
|
...validConfig,
|
|
FEATURE_OVERRIDES: {
|
|
"cookie-consent": "DISABLED",
|
|
"password-reset": "DISABLED",
|
|
"token-wallet": "DEFAULT",
|
|
},
|
|
}),
|
|
{ headers: { "content-type": "application/json" } },
|
|
),
|
|
});
|
|
|
|
expect(result.config.FEATURE_OVERRIDES["cookie-consent"]).toBe("DISABLED");
|
|
});
|
|
|
|
it.each<[Record<string, unknown>, string]>([
|
|
[{ FEATURE_OVERRIDES: {}, CLIENT_SECRET: "x" }, "top level"],
|
|
[{ CAPABILITY_OVERRIDES: { AUTH_TOKEN: "DEFAULT" } }, "other nested map"],
|
|
[{ NESTED: { deeper: { PRIVATE_KEY: "x" } } }, "deeper nesting"],
|
|
[{ FEATURE_OVERRIDES: { alpha: { CLIENT_SECRET: "x" } } }, "below a feature id"],
|
|
])("still rejects forbidden names outside feature ids: %o (%s)", (candidate) => {
|
|
expect(() => assertSafeConfigNames(candidate)).toThrow(
|
|
"Forbidden client configuration key",
|
|
);
|
|
});
|
|
|
|
it("allows demo authentication only for local runtime configuration", () => {
|
|
expect(
|
|
validateRuntimeConfig({ ...validConfig, AUTH_MODE: "demo" }).success,
|
|
).toBe(true);
|
|
expect(
|
|
validateRuntimeConfig({
|
|
...validConfig,
|
|
APP_ENV: "production",
|
|
API_BASE_URL: "https://api.example.test/",
|
|
AUTH_MODE: "demo",
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts only the explicitly supported V1 and V2 boot versions", () => {
|
|
expect(validateRuntimeConfig(validV1Config)).toMatchObject({
|
|
success: true,
|
|
schema: "V1",
|
|
});
|
|
expect(validateRuntimeConfig(validConfig)).toMatchObject({
|
|
success: true,
|
|
schema: "V2",
|
|
});
|
|
|
|
for (const version of ["0", "1.0", "2.0.1", "3.0"]) {
|
|
expect(
|
|
validateRuntimeConfig({
|
|
...validV1Config,
|
|
CONFIG_SCHEMA_VERSION: version,
|
|
}).success,
|
|
).toBe(false);
|
|
}
|
|
});
|
|
|
|
it.each([
|
|
"file:///tmp/api/",
|
|
"data:text/plain,/",
|
|
"blob:https://example.test/00000000-0000-0000-0000-000000000000",
|
|
])("rejects a non-HTTP API endpoint in local mode: %s", (API_BASE_URL) => {
|
|
expect(validateRuntimeConfig({ ...validConfig, API_BASE_URL }).success).toBe(
|
|
false,
|
|
);
|
|
});
|
|
|
|
it.each(["file:///tmp/telemetry", "data:text/plain,telemetry"])(
|
|
"rejects a non-HTTP telemetry endpoint in local mode: %s",
|
|
(TELEMETRY_ENDPOINT) => {
|
|
expect(
|
|
validateRuntimeConfig({
|
|
...validConfig,
|
|
TELEMETRY_ENABLED: true,
|
|
TELEMETRY_ENDPOINT,
|
|
}).success,
|
|
).toBe(false);
|
|
},
|
|
);
|
|
|
|
it("validates a fetched config under the 500ms budget excluding network", async () => {
|
|
let current = 100;
|
|
const result = await loadRuntimeConfig({
|
|
buildConfig: {
|
|
buildId: "build-a",
|
|
commitSha: "local",
|
|
routerBasePath: "/",
|
|
runtimeConfigUrl: "/config.json",
|
|
},
|
|
fetcher: async () =>
|
|
new Response(JSON.stringify(validConfig), {
|
|
headers: { "content-type": "application/json" },
|
|
}),
|
|
now: () => (current += 2),
|
|
});
|
|
|
|
expect(result.validationDurationMs).toBeLessThanOrEqual(500);
|
|
expect(result.config.API_BASE_URL).toBe("http://localhost:8080/");
|
|
expect(result.configSchema).toBe("V2");
|
|
expect(result.config.CAPABILITY_OVERRIDES.SERVICE_WORKER).toBe("DEFAULT");
|
|
});
|
|
|
|
it("does not include network acquisition in validationDurationMs", async () => {
|
|
let current = 0;
|
|
const result = await loadRuntimeConfig({
|
|
buildConfig: {
|
|
buildId: "build-a",
|
|
commitSha: "local",
|
|
routerBasePath: "/",
|
|
runtimeConfigUrl: "/config.json",
|
|
},
|
|
fetcher: async () => {
|
|
current = 10_000;
|
|
return new Response(JSON.stringify(validConfig), {
|
|
headers: { "content-type": "application/json" },
|
|
});
|
|
},
|
|
now: () => current,
|
|
});
|
|
|
|
expect(result.validationDurationMs).toBe(0);
|
|
});
|
|
|
|
it.each([
|
|
[
|
|
"an invalid field",
|
|
{ ...validConfig, REQUEST_TIMEOUT_MS: -1, RELEASE_ID: "r".repeat(10_000) },
|
|
{ configSchemaVersion: "2.0" },
|
|
],
|
|
[
|
|
"an unsupported version",
|
|
{ ...validConfig, CONFIG_SCHEMA_VERSION: "v".repeat(10_000), RELEASE_ID: "release-a" },
|
|
{},
|
|
],
|
|
])(
|
|
"puts only validated config values into the safe error for %s (Q-6.9-10)",
|
|
async (_case, document, expected) => {
|
|
const failure = await loadRuntimeConfig({
|
|
buildConfig: {
|
|
buildId: "build-a",
|
|
commitSha: "local",
|
|
routerBasePath: "/",
|
|
runtimeConfigUrl: "/config.json",
|
|
},
|
|
fetcher: async () =>
|
|
new Response(JSON.stringify(document), {
|
|
headers: { "content-type": "application/json" },
|
|
}),
|
|
}).catch((error: unknown) => error);
|
|
|
|
expect(failure).toBeInstanceOf(BootConfigError);
|
|
const safe = (failure as BootConfigError).safe;
|
|
expect(safe.code).toBe("CONFIG_SCHEMA_INVALID");
|
|
expect({
|
|
configSchemaVersion: safe.configSchemaVersion,
|
|
releaseId: safe.releaseId,
|
|
}).toEqual({ configSchemaVersion: undefined, releaseId: undefined, ...expected });
|
|
},
|
|
);
|
|
|
|
it("names the rejected keys, never their values (09-04)", async () => {
|
|
const failure = await loadRuntimeConfig({
|
|
buildConfig: {
|
|
buildId: "build-a",
|
|
commitSha: "local",
|
|
routerBasePath: "/",
|
|
runtimeConfigUrl: "/config.json",
|
|
},
|
|
fetcher: async () =>
|
|
new Response(
|
|
JSON.stringify({
|
|
...validConfig,
|
|
REQUEST_TIMEOUT_MS: -1,
|
|
TELEMETRY_ENABELD: "value-probe",
|
|
["<b>" + "x".repeat(200)]: true,
|
|
}),
|
|
{ headers: { "content-type": "application/json" } },
|
|
),
|
|
}).catch((error: unknown) => error);
|
|
|
|
expect(failure).toBeInstanceOf(BootConfigError);
|
|
const safe = (failure as BootConfigError).safe;
|
|
expect(safe.invalidKeys).toEqual(["REQUEST_TIMEOUT_MS", "TELEMETRY_ENABELD"]);
|
|
expect(JSON.stringify(safe)).not.toContain("value-probe");
|
|
});
|
|
|
|
it("returns only safe boot fields on failure", async () => {
|
|
await expect(
|
|
loadRuntimeConfig({
|
|
buildConfig: {
|
|
buildId: "build-a",
|
|
commitSha: "local",
|
|
routerBasePath: "/",
|
|
runtimeConfigUrl: "/config.json",
|
|
},
|
|
fetcher: async () =>
|
|
new Response("{", {
|
|
headers: { "content-type": "application/json" },
|
|
}),
|
|
}),
|
|
).rejects.toMatchObject({
|
|
safe: {
|
|
kind: "BOOT_CONFIG_FAILURE",
|
|
buildId: "build-a",
|
|
},
|
|
});
|
|
});
|
|
});
|