Files
clean-architecture-frontend…/tests/runtime-schema/runtime-config.test.ts
DongHyeonka 2e1acb1f21 fix(bootstrap): 금지된 설정 키로 멈춘 부팅 오류에 그 키 이름을 싣는다
문제: 런타임 설정에 비밀처럼 보이는 키(`CLIENT_SECRET` 등)가 있으면
부팅이 CONFIG_SECRET_NAME_REJECTED로 멈추지만, 안전한 부팅 오류에는
buildId만 있고 어느 키인지가 없다. assertSafeConfigNames가 던진 오류의
message에는 키 이름이 있었지만 loadRuntimeConfig가 그 오류를 버렸다.
같은 파일의 스키마 실패는 키 이름을 invalidKeys로 싣는다.

고른 방법: assertSafeConfigNames가 UnsafeConfigNameError를 던지고 그
`key`에 거절한 키의 점 경로(`CAPABILITY_OVERRIDES.AUTH_TOKEN`,
`FEATURE_OVERRIDES.<id>.CLIENT_SECRET`)를 싣는다. 로더는 그 경로를
스키마 실패와 같은 SAFE_KEY_PATTERN으로 거른 뒤 invalidKeys에 넣는다.
오류 화면은 이미 invalidKeys를 "잘못된 설정 키"로 보인다. 값은 어디에도
싣지 않는다. 버린 대안: message에서 키를 정규식으로 다시 읽는 것.
message 문구가 바뀌면 조용히 빠진다.

위험·한계: 키 이름은 거절된 문서에서 온다. 그래서 길이·문자를 제한하고,
그 밖의 이름은 빼고 코드만 남긴다. 첫 번째로 걸린 키 하나만 싣는다
(검사가 첫 키에서 멈추는 동작은 그대로). assertSafeConfigNames의
시그니처와 message는 바꾸지 않았다. UnsafeConfigNameError는
src/contracts/env.ts에 새로 더한 export다(추가만).

검증: desktop batch에서 확인.
node scripts/run-vitest.ts run tests/runtime-schema/runtime-config.test.ts

Refs: 1103/07-04
2026-11-05 22:08:22 +09:00

357 lines
11 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");
});
// 1103/07-04. A secret-looking key stops boot before the schema runs. The
// boot error names that key, with its path below a nested map, and never
// its value. A key name that is not safe to show is left out.
it.each<[Record<string, unknown>, readonly string[] | undefined]>([
[{ CLIENT_SECRET: "value-probe" }, ["CLIENT_SECRET"]],
[
{ CAPABILITY_OVERRIDES: { AUTH_TOKEN: "value-probe" } },
["CAPABILITY_OVERRIDES.AUTH_TOKEN"],
],
[
{ FEATURE_OVERRIDES: { alpha: { CLIENT_SECRET: "value-probe" } } },
["FEATURE_OVERRIDES.alpha.CLIENT_SECRET"],
],
[{ "<b>CLIENT_SECRET": "value-probe" }, undefined],
])(
"names the forbidden key of %o as %o, never its value (1103/07-04)",
async (extra, invalidKeys) => {
const failure = await loadRuntimeConfig({
buildConfig: {
buildId: "build-a",
commitSha: "local",
routerBasePath: "/",
runtimeConfigUrl: "/config.json",
},
fetcher: async () =>
new Response(JSON.stringify({ ...validConfig, ...extra }), {
headers: { "content-type": "application/json" },
}),
}).catch((error: unknown) => error);
expect(failure).toBeInstanceOf(BootConfigError);
const safe = (failure as BootConfigError).safe;
expect(safe.code).toBe("CONFIG_SECRET_NAME_REJECTED");
expect(safe.invalidKeys).toEqual(invalidKeys);
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",
},
});
});
});