From a94006b9daf604dcf743fef2fa3f8ef76e59ea1a Mon Sep 17 00:00:00 2001 From: DongHyeonka Date: Wed, 4 Nov 2026 20:19:33 +0900 Subject: [PATCH] =?UTF-8?q?test(contracts):=20=EC=BF=A0=ED=82=A4=20?= =?UTF-8?q?=EC=93=B0=EA=B8=B0=20CSRF=EC=99=80=20realtime=20snapshot=20?= =?UTF-8?q?=EA=B2=80=EC=82=AC=EB=A5=BC=20method=EB=B3=84=20=ED=91=9C?= =?UTF-8?q?=EB=A1=9C=20=EA=B3=A0=EC=A0=95=ED=95=9C=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 문제 V2에서 옮긴 두 조립 검사가 한 사례씩만 테스트된다. 쿠키 쓰기 CSRF 검사는 POST와 x-xsrf-token 한 쌍만 본다. 그래서 `!isRead`를 `method === "POST"`로 좁히거나, CSRF 헤더 이름 대신 "필수 헤더가 하나라도 있으면"으로 바꾸거나, x-csrf-token 허용을 지워도 테스트가 통과한다. realtime snapshot 바인딩(GET + SAFE·IDEMPOTENT)은 거절 사례가 없어 method 조건이나 retrySemantics 조건을 지워도 통과한다. 고른 방법 - rest-profile-contract: POST·PUT·PATCH·DELETE마다 CSRF 없는 쿠키 프로필과 x-tenant-context만 요구하는 쿠키 프로필을 거절하고, x-csrf-token과 x-xsrf-token을 각각 받는지 본다. GET·HEAD 쿠키 읽기는 CSRF 없이 된다. - realtime-stream-registry: 6 method × 4 retrySemantics 표를 CURSOR와 SNAPSHOT_ONLY 두 복구 모드로 돈다. 받는 조합은 GET×SAFE, GET×IDEMPOTENT 뿐이다. 행은 조립한 descriptor를 projectApiOperationRows로 뽑은 것에서 method와 retrySemantics만 바꾼다. 투영 칸 이름이 바뀌어도 이 표가 같이 깨진다. FE-REG-API 행이 없는 id도 거절한다. 버린 대안 - 손으로 쓴 행(fixture.ts)을 그대로 쓰기: 투영과 realtime 검사가 따로 바뀌는 것을 못 잡는다. 위험·한계 - 검사 코드는 바꾸지 않았다. 테스트만 더했다. - resumable upload 제어 요청의 쿠키 POST는 descriptor 밖이라 이 검사 범위가 아니다(영역 01). 검증 - 변이 7종을 하나씩 넣고 두 테스트 파일을 돌렸다. 모두 실패한다: M2(POST만), M3(아무 필수 헤더), H19(x-csrf-token 허용 삭제), M9(method 조건 삭제), M9b(method·retry 조건 삭제), S2(retry 조건 삭제), H21-PUT(GET 또는 PUT 허용). - 변이 없이 두 파일 47건 통과. check:types, eslint 통과. Refs: docs/reviews/2026-11-03-maturity-review/07-contracts.md 07-02 Refs: docs/reviews/2026-11-03-maturity-review/10-tests-fast-layers.md 10-03, 10-04 Refs: docs/reviews/2026-11-03-maturity-review/04-adapters-realtime.md 04-03 --- .../realtime/realtime-stream-registry.test.ts | 106 ++++++++++++++++++ tests/unit/rest-profile-contract.test.ts | 63 ++++++++++- 2 files changed, 164 insertions(+), 5 deletions(-) diff --git a/tests/unit/realtime/realtime-stream-registry.test.ts b/tests/unit/realtime/realtime-stream-registry.test.ts index dfb7ed62..f4c5f78d 100644 --- a/tests/unit/realtime/realtime-stream-registry.test.ts +++ b/tests/unit/realtime/realtime-stream-registry.test.ts @@ -1,5 +1,11 @@ import { describe, expect, it } from "vitest"; +import { projectApiOperationRows } from "../../../src/contracts/api-operations.ts"; +import { + composeContractContributions, + type HttpMethod, + type RetrySemantics, +} from "../../../src/contracts/external-contract-runtime.ts"; import { createRealtimePolicyRegistry, defineEventTypeId, @@ -20,6 +26,7 @@ import { TEST_SCHEMA_CODECS, createTestRealtimeRegistry, } from "./fixture.ts"; +import { TEST_CONTRACT_CONTRIBUTION } from "../../helpers/external-contract-fixture.ts"; describe("realtime policy registry", () => { it("deep-snapshots registrations and resolves only stream-owned event types", () => { @@ -209,6 +216,105 @@ describe("realtime policy registry", () => { }); }); +/** + * 1103/04-03, 07-02, 10-04. Recovery sends the snapshot operation on every + * reconnect, so it must be a read that may be sent again: GET with SAFE or + * IDEMPOTENT. A HEAD carries no checkpoint body. The row is the FE-REG-API + * projection of a composed descriptor, so a renamed projected field breaks + * this table too. + */ +describe("realtime snapshot operation binding", () => { + const projected = projectApiOperationRows( + composeContractContributions([TEST_CONTRACT_CONTRIBUTION]).contributions, + ); + const methods: readonly HttpMethod[] = [ + "GET", + "HEAD", + "POST", + "PUT", + "PATCH", + "DELETE", + ]; + const retries: readonly RetrySemantics[] = [ + "SAFE", + "IDEMPOTENT", + "KEYED", + "NEVER", + ]; + const register = ( + recovery: "CURSOR" | "SNAPSHOT_ONLY", + apiOperations: Readonly>, + ) => { + const baseline = createTestRealtimeRegistry(); + const stream = baseline.listStreams()[0]!; + return createRealtimePolicyRegistry({ + streams: [ + { + ...stream, + recovery: + recovery === "CURSOR" + ? stream.recovery + : { + mode: "SNAPSHOT_ONLY", + snapshotOperationId: "GET_REFERENCE_REALTIME_SNAPSHOT", + checkpointCodecId: "ReferenceRealtimeCheckpoint", + barrier: "CONNECT_BUFFER", + }, + }, + ], + eventTypes: [baseline.listEventTypes()[0]!], + bindings: { + ...bindings(), + apiOperations: apiOperations as ReturnType< + typeof bindings + >["apiOperations"], + }, + }); + }; + const snapshotRow = (method: HttpMethod, retrySemantics: RetrySemantics) => ({ + GET_REFERENCE_REALTIME_SNAPSHOT: { + ...projected.TEST_LIST_ENTITIES!, + operationId: "GET_REFERENCE_REALTIME_SNAPSHOT", + method, + retrySemantics, + }, + }); + const cases = methods.flatMap((method) => + retries.map((retrySemantics) => ({ + method, + retrySemantics, + accepted: + method === "GET" && + (retrySemantics === "SAFE" || retrySemantics === "IDEMPOTENT"), + })), + ); + + it.each(cases)( + "$method $retrySemantics as the snapshot operation: accepted=$accepted", + ({ method, retrySemantics, accepted }) => { + for (const recovery of ["CURSOR", "SNAPSHOT_ONLY"] as const) { + const install = () => + register(recovery, snapshotRow(method, retrySemantics)); + if (accepted) { + expect(install().findStream(STREAM_ID)?.recovery.mode).toBe(recovery); + } else { + expect(install, recovery).toThrow( + recovery === "CURSOR" + ? "Realtime cursor recovery profile is invalid." + : "Realtime snapshot recovery profile is invalid.", + ); + } + } + }, + ); + + it("refuses a snapshot operation id with no FE-REG-API row", () => { + expect(() => register("CURSOR", {})).toThrow( + "Realtime cursor recovery profile is invalid.", + ); + }); +}); + function bindings() { return { schemaCodecs: TEST_SCHEMA_CODECS, diff --git a/tests/unit/rest-profile-contract.test.ts b/tests/unit/rest-profile-contract.test.ts index 8451c7a3..b7c0abc7 100644 --- a/tests/unit/rest-profile-contract.test.ts +++ b/tests/unit/rest-profile-contract.test.ts @@ -63,26 +63,79 @@ describe("one installed REST auth profile registry", () => { * installed HTTP contract has to refuse it too. */ describe("cookie profiles on writes", () => { - const cookie = (authProfileId: string, csrf: readonly ("x-csrf-token" | "x-xsrf-token")[]) => ({ + const cookie = ( + authProfileId: string, + headers: readonly ("x-csrf-token" | "x-xsrf-token" | "x-tenant-context")[], + ) => ({ authProfileId, transport: "SAME_ORIGIN_COOKIE" as const, credentials: "include" as const, - allowedCredentialHeaders: [...csrf], - requiredCredentialHeaders: [...csrf], + allowedCredentialHeaders: [...headers], + requiredCredentialHeaders: [...headers], }); const registry = installRestAuthProfileRegistry({ ...REST_AUTH_PROFILES, COOKIE_READ: cookie("COOKIE_READ", []), COOKIE_WRITE: cookie("COOKIE_WRITE", ["x-xsrf-token"]), + COOKIE_CSRF: cookie("COOKIE_CSRF", ["x-csrf-token"]), + COOKIE_TENANT: cookie("COOKIE_TENANT", ["x-tenant-context"]), }); - const withProfile = (index: number, authProfileId: string) => { + const withProfile = ( + index: number, + authProfileId: string, + method?: "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE", + ) => { const row = TEST_CONTRACT_CONTRIBUTION.http[index]!; return { ...TEST_CONTRACT_CONTRIBUTION, - http: [{ ...row, frontend: { ...row.frontend, authProfileId } }], + http: [ + { + contract: method ? { ...row.contract, method } : row.contract, + frontend: { ...row.frontend, authProfileId }, + }, + ], }; }; // TEST_CONTRACT_CONTRIBUTION.http: [list (GET), detail (GET), create (POST)] + const compose = ( + index: number, + authProfileId: string, + method?: "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE", + ) => + composeContractContributions( + [withProfile(index, authProfileId, method)], + registry, + ).httpByOperationId.size; + + // 1103/07-02, 10-03. Every write method, not POST alone, and only the two + // CSRF header names count: another required header is not a CSRF proof. + it.each(["POST", "PUT", "PATCH", "DELETE"] as const)( + "refuses a %s whose cookie profile requires no CSRF header", + (method) => { + for (const authProfileId of ["COOKIE_READ", "COOKIE_TENANT"]) { + expect(() => compose(2, authProfileId, method)).toThrow( + expect.objectContaining({ + reason: `test-feature/TEST_CREATE_ENTITY: ${method} with cookie profile ${authProfileId} must require x-csrf-token or x-xsrf-token`, + }), + ); + } + }, + ); + + it.each(["POST", "PUT", "PATCH", "DELETE"] as const)( + "accepts a %s that requires x-csrf-token or x-xsrf-token", + (method) => { + expect(compose(2, "COOKIE_CSRF", method)).toBe(1); + expect(compose(2, "COOKIE_WRITE", method)).toBe(1); + }, + ); + + it.each(["GET", "HEAD"] as const)( + "accepts a cookie %s without a CSRF header", + (method) => { + expect(compose(0, "COOKIE_READ", method)).toBe(1); + }, + ); it("refuses a write whose cookie profile requires no CSRF header", () => { expect(() =>