Files
clean-architecture-frontend…/tests/unit/contract-snapshot-bypass.test.ts
DongHyeonka 6c5818faec refactor(contracts): bearer 인증 프로필을 EXTERNAL_BEARER로 바꾼다 (1101/16-03)
문제
유일한 bearer 인증 프로필 이름이 샘플 이름 REFERENCE_EXTERNAL_BEARER다.
세션이 필요한 제품 기능은 지운 샘플의 이름을 계속 쓰거나 템플릿 소유
파일에 프로필을 더해야 한다. 샘플 제거 드릴의 잔여 검사 정규식도 이
이름을 잡지 않아 샘플을 지운 제품에 그대로 남는다. 리뷰 (2) 오류
메시지는 abf3ce5가 했고 (1) 이름 변경이 남았다.

고른 방법 (2026-11-03 결정)
- 프로필 이름을 EXTERNAL_BEARER로 바꿨다. 참조 기능의 V2 operation 3개와
  V3 descriptor 3개, external-session-adapter 주석, 테스트, VD-23 문서를
  새 이름으로 옮겼다.
- 옛 이름은 한 릴리스 동안 REST_AUTH_PROFILES에 별칭 한 줄로 남기고
  JSDoc @deprecated를 붙였다. 레지스트리는 키와 authProfileId가 같아야
  하므로 별칭은 EXTERNAL_BEARER를 펼치고 id만 옛 이름으로 둔 객체다.
  그래서 옛 이름을 적은 다운스트림 operation도 같은 transport·헤더로
  해석된다.
- scripts/scale의 PLATFORM_TOKENS에서 이 이름을 뺐다. 참조 기능에 더는
  "REFERENCE"가 든 프로필 이름이 없어 이름 바꾸기에서 보호할 것이 없다.
- 새 테스트 두 개: 별칭이 id만 빼고 EXTERNAL_BEARER와 같게 설치되는지,
  src에 옛 이름이 별칭 한 줄 외에 없는지(완료 기준).

버린 대안
- 별칭 없이 바로 바꾸기: 옛 이름을 쓰는 다운스트림 기능이 모듈 로드에서
  바로 실패한다. 공개 이름을 깨는 변경은 BREAKING 결정이 있을 때만 한다.
- 조회 시점의 이름 매핑(alias 표): resolve·executor·composition 세 곳이
  매핑을 알아야 한다. 프로필 항목 하나가 더 작다.

위험·한계
- 설치된 프로필이 셋이 된다. 같은 설정이 두 id로 있을 뿐 권한이 넓어지지
  않는다. 별칭은 다음 minor에서 지우고 CHANGELOG [계약] 행을 남긴다.
  그때 "src only on the alias line" 테스트의 기대값을 빈 목록으로 바꾼다.
- 다운스트림 문자열 id("REFERENCE_EXTERNAL_BEARER")에는 @deprecated 표시가
  보이지 않는다. CHANGELOG로 알린다.
- FE-REG-API 행 3개의 authProfileId가 바뀐다. breakingFields가 아니라
  behavior-change이므로 증거 없이 게이트를 통과한다. 기준선 재승인은 이번
  작업 묶음 끝에서 한 번에 한다.
- 초기 JS gzip(초기 청크 파일별 gzip 합) 203,818 → 203,840 B(+22 B). 별칭
  항목이 rest-profiles가 있는 초기 청크에 실린다. 참조 기능 계약은 lazy
  청크라 초기 크기에 영향이 없다.

검증
- RED(수정 전): rest-profile-contract.test.ts 새 사례 2건 실패("expected
  undefined to match object { transport: 'BEARER_HEADER', …(1) }",
  "expected [ …(9) ] to deeply equal [ Array(1) ]").
- GREEN: 같은 파일 10/10 통과. check-registries "11 registries PASS"
  (FE-REG-API authProfileId 3건 behavior-change).
- 회귀: tests/{unit,integration,features,contract,runtime-schema}
  207 파일 2,366건 통과(pnpm·corepack을 띄우는 6개 제외:
  http-scenario-evidence, ci-workflow-generation, lab-performance,
  fixture-node-modules, deployment-admission, security-followup-archive).
  tsc app·test·node rc=0, 바꾼 파일 eslint rc=0. vite build 성공.
- 미실행: check:architecture, test:sample-removal(pnpm 필요), e2e.

Refs: docs/reviews/2026-11-01-maturity-review/16-structure-patterns.md
2026-11-03 00:55:33 +09:00

262 lines
8.1 KiB
TypeScript

import { describe, expect, it } from "vitest";
import { installBrowserRpcContractBindings } from "../../src/contracts/browser-rpc.ts";
import { parseCacheInvalidationWireEvent } from "../../src/contracts/cache-invalidation.ts";
import {
composeContractContributions,
ContractContributionError,
} from "../../src/contracts/external-contract-runtime.ts";
import { createRealtimePolicyRegistry } from "../../src/contracts/realtime-streams.ts";
import {
installRestAuthProfileRegistry,
REST_AUTH_PROFILES,
} from "../../src/contracts/rest-profiles.ts";
import { decodeStaticAssetManifest } from "../../src/contracts/service-worker-static-manifest.ts";
import { TEST_CONTRACT_CONTRIBUTION } from "../helpers/external-contract-fixture.ts";
import {
MAPPERS,
SCHEMA_CODECS,
UNARY_ENCODER,
unaryOperation,
unaryProfile,
} from "./browser-rpc/fixture.ts";
import {
EFFECT_PROFILE_ID,
ENDPOINT_ID,
KILL_SWITCH_ID,
TEST_API_OPERATIONS,
TEST_MAPPERS,
TEST_SCHEMA_CODECS,
createTestRealtimeRegistry,
} from "./realtime/fixture.ts";
/**
* Q-6.7-6. Every contract that installs a caller-supplied row must validate
* and install one owned snapshot. An own `Symbol.iterator` on an array or an
* accessor on a row lets the value that was checked differ from the value
* that was installed.
*/
/** An array whose length and indices say one thing and whose iterator says another. */
function iteratorSmuggling<T>(visible: readonly T[], smuggled: readonly T[]): T[] {
const array = [...visible];
Object.defineProperty(array, Symbol.iterator, {
value: function* () {
yield* smuggled;
},
});
return array;
}
const validator = Object.freeze({
schemaId: "SmuggledSchema",
safeParse: (value: unknown) =>
Object.freeze({ success: true as const, data: value }),
});
describe("external contract composition", () => {
it("does not install an event hidden behind an array iterator", () => {
const smuggled = Object.freeze({
eventType: "test.smuggled",
envelopeValidator: validator,
payloadValidator: validator,
});
let composed: ReturnType<typeof composeContractContributions> | undefined;
try {
composed = composeContractContributions([
{
contributionId: "smuggled-events-v1",
featureId: "test-feature",
// 07-04. A package source accepts events, so a hidden event that was
// read would be installed and fail the assertion below. A fixture
// source throws on any event, which hid whether it was read.
source: TEST_CONTRACT_CONTRIBUTION.source,
http: [],
events: iteratorSmuggling([], [smuggled]),
},
] as never);
} catch (error) {
expect(error).toBeInstanceOf(ContractContributionError);
return;
}
expect(composed.eventByType.has("test.smuggled")).toBe(false);
});
it("reports a throwing reflection trap as a composition failure", () => {
const row = new Proxy(
{ ...TEST_CONTRACT_CONTRIBUTION.http[0]! },
{
ownKeys() {
throw new TypeError("hostile ownKeys trap");
},
},
);
expect(() =>
composeContractContributions([
{ ...TEST_CONTRACT_CONTRIBUTION, http: [row] },
] as never),
).toThrow(ContractContributionError);
});
});
describe("realtime policy registry", () => {
it("rejects a limit accessor instead of reading it twice", () => {
const baseline = createTestRealtimeRegistry();
const stream = baseline.listStreams()[0]!;
let reads = 0;
const limits = { ...stream.limits };
Object.defineProperty(limits, "maxEventBytes", {
enumerable: true,
configurable: true,
get: () => {
reads += 1;
// Three reads validate it; the fourth is the install copy.
return reads <= 3 ? 1_024 : 999_999_999;
},
});
expect(() =>
createRealtimePolicyRegistry({
streams: [{ ...stream, limits }],
eventTypes: [baseline.listEventTypes()[0]!],
bindings: {
schemaCodecs: TEST_SCHEMA_CODECS,
mappers: TEST_MAPPERS,
apiOperations: TEST_API_OPERATIONS,
endpointIds: [ENDPOINT_ID],
effectProfileIds: [EFFECT_PROFILE_ID],
killSwitchIds: [KILL_SWITCH_ID],
rebuildInputIds: ["referenceRealtimeRebuild"],
},
}),
).toThrow();
});
});
describe("cache invalidation wire event", () => {
it("rejects an accessor field", () => {
const now = 1_000_000;
const event = {
protocolVersion: 1,
eventId: "remote-event-00000001",
sourceId: "remote-source-0000001",
sourceEpoch: "remote-epoch-0000001",
sequence: 1,
cacheEpoch: "cache-epoch-0001",
topicVersion: 1,
emittedAt: now,
expiresAt: now + 60_000,
};
Object.defineProperty(event, "topic", {
enumerable: true,
get: () => "sample-topic-alpha",
});
expect(
parseCacheInvalidationWireEvent(event, {
cacheEpoch: "cache-epoch-0001",
topicVersions: { "sample-topic-alpha": 1 },
nowEpochMilliseconds: now,
}),
).toEqual({ ok: false, reason: "INVALID_ENVELOPE" });
});
});
describe("static asset manifest", () => {
const row = {
url: "/assets/app-abcdefgh.js",
sha256: `sha256:${"a".repeat(64)}`,
bytes: 16,
contentType: "text/javascript",
};
const manifest = (assets: unknown) => ({
schemaVersion: 1,
buildId: "build-1",
releaseId: "release-1",
setDigest: `sha256:${"b".repeat(64)}`,
assets,
});
it("rejects an accessor on a row", () => {
const accessorRow = { ...row };
Object.defineProperty(accessorRow, "bytes", {
enumerable: true,
get: () => 16,
});
expect(decodeStaticAssetManifest(manifest([accessorRow])).ok).toBe(false);
});
it("does not decode rows hidden behind an array iterator", () => {
const decoded = decodeStaticAssetManifest(
manifest(iteratorSmuggling([], [row])),
);
expect(decoded.ok && decoded.manifest.assets.length > 0).toBe(false);
});
});
describe("browser RPC contract bindings", () => {
const install = (operations: Record<string, unknown>) =>
installBrowserRpcContractBindings({
operations: operations as never,
profiles: { [unaryProfile().runtimeProfileId]: unaryProfile() },
schemaCodecs: SCHEMA_CODECS,
mappers: MAPPERS,
requestEncoders: { RpcResourceRequestEncoder: UNARY_ENCODER },
});
it("rejects a non-enumerable registry entry", () => {
const operations = {};
Object.defineProperty(operations, "GET_RPC_RESOURCE", {
enumerable: false,
value: unaryOperation(),
});
expect(() => install(operations)).toThrow(TypeError);
});
it("rejects a non-enumerable row field", () => {
const { totalDeadlineMs, ...rest } = unaryOperation();
const operation = Object.defineProperty(rest, "totalDeadlineMs", {
enumerable: false,
value: totalDeadlineMs,
});
expect(() => install({ GET_RPC_RESOURCE: operation })).toThrow(TypeError);
});
});
describe("REST auth profile registry", () => {
it("rejects an accessor field", () => {
const profile = { ...REST_AUTH_PROFILES.ANONYMOUS };
Object.defineProperty(profile, "transport", {
enumerable: true,
get: () => "ANONYMOUS",
});
expect(() => installRestAuthProfileRegistry({ ANONYMOUS: profile })).toThrow(
TypeError,
);
});
it("installs the header set it validated, not the one an iterator yields", () => {
let iterations = 0;
const allowed = ["authorization"];
Object.defineProperty(allowed, Symbol.iterator, {
value: function* () {
iterations += 1;
yield "authorization";
if (iterations > 1) yield* ["x-csrf-token", "x-csrf-token"];
},
});
let installed: ReturnType<typeof installRestAuthProfileRegistry> | undefined;
try {
installed = installRestAuthProfileRegistry({
EXTERNAL_BEARER: {
...REST_AUTH_PROFILES.EXTERNAL_BEARER,
allowedCredentialHeaders: allowed as never,
},
});
} catch {
return;
}
expect(
installed.get("EXTERNAL_BEARER")?.allowedCredentialHeaders,
).toEqual(["authorization"]);
});
});