On CONFIG_SCHEMA_INVALID the loader copied the raw RELEASE_ID and CONFIG_SCHEMA_VERSION strings (up to the 64 KB body limit) into the "safe" error that BootErrorShell and diagnostics show, contradicting the file's own contract. The error now carries the schema version only when it passed the version gate (no validator issue at CONFIG_SCHEMA_VERSION) and never the release id of a rejected document. Verified: two cases in tests/runtime-schema/runtime-config.test.ts (invalid field with a 10 KB RELEASE_ID; unsupported 10 KB version) RED before, green after; test:runtime-schema and all gates PASS. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
293 lines
9.1 KiB
TypeScript
293 lines
9.1 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("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",
|
|
},
|
|
});
|
|
});
|
|
});
|