DongHyeonkaandClaude Opus 5
7ff9728a5c
Fix round 2 (review of 9864958):
Round 1's I2 fix made gate 1 (supportsEvidenceKeyIn) read the same
merged catalog gate 2 already checks, so gate 1 stopped asking "does a
real Asset (or the legacy key) back this key" and started asking the
identical question gate 2 asks ("is there any EVIDENCE catalog row for
it"). A real EVIDENCE catalog row that exists for something other than
media (fixtures.ts's row for a QUESTION resolution target) then passed
gate 1 with nothing backing it as evidence. validateDocument reported
VALID; createPreview's resolver -- which only ever knew the legacy key
and real Assets -- threw a raw, unwrapped Error, violating the port's
StudioGatewayError-only contract. I2's disagreement reproduced in the
opposite direction.
Rebuilt gate 1 in all three callers (validate-working-copy.ts,
adapters/mock/project-public-render-model.ts, instant-preview.tsx) as
"legacy key OR an Asset-derived catalog entry only" -- never the
merged document catalog -- while gate 2 keeps reading the merged
catalog as before. Also stopped emitting the real Asset UUID as the
synthesized CatalogEntry's id (prefixed instead), closing a path where
pasting an Asset's real id -- never something the Picker itself
produces -- would have resolved as an evidence key.
Restored content-format.test.ts's domain tests to exercise the same
gate-1 composition production callers now use instead of a bare
hand-injected predicate, and added coverage for: a real non-asset
EVIDENCE row still being rejected, an Asset-backed key being accepted
with no document-catalog row at all, the fixture-UUID case failing
both mock paths with no raw Error crossing the gateway port, and the
EVIDENCE_ALT_REQUIRED decorative-Asset pairing that had no test.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
543 lines
17 KiB
TypeScript
543 lines
17 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import { isSupportedEvidenceKey } from "../../../src/features/tech-log/adapters/static/evidence-assets.ts";
|
|
import { evidenceCatalogEntriesFromAssets } from "../../../src/features/tech-log/domain/content-format/asset-evidence-catalog.ts";
|
|
import {
|
|
ContentFormatError,
|
|
parseCaseContent,
|
|
} from "../../../src/features/tech-log/domain/content-format/parse-case-content.ts";
|
|
import {
|
|
evidenceCatalogEntryFor,
|
|
projectWorkingCopy,
|
|
} from "../../../src/features/tech-log/domain/content-format/project-public-render-model.ts";
|
|
import { serializeCaseContent } from "../../../src/features/tech-log/domain/content-format/serialize-case-content.ts";
|
|
import type { components } from "../../../src/features/tech-log/contracts/studio/generated.ts";
|
|
import type { Asset } from "../../../src/features/tech-log/contracts/studio/contract.ts";
|
|
|
|
/**
|
|
* Fix round 2. Mirrors the gate-1 composition every production caller now
|
|
* uses (`validate-working-copy.ts`, `adapters/mock/project-public-render-model.ts`,
|
|
* `instant-preview.tsx`): the legacy key, or an actually-loaded Asset backs
|
|
* it -- never "is there any EVIDENCE catalog row for it" (that's gate 2,
|
|
* `evidenceCatalogEntryFor`, a separate question `projectWorkingCopy` asks
|
|
* of its own `catalog` argument). Round 1 collapsed gate 1 into gate 2 in
|
|
* every production caller, which let a real EVIDENCE catalog row backing
|
|
* something other than media (e.g. a QUESTION resolution-target row) pass
|
|
* gate 1 with no Asset and no legacy key behind it. Tests below pass no
|
|
* `assets`, so this reduces to the legacy check alone for them -- the same
|
|
* outcome bare `isSupportedEvidenceKey` gave before, just now visibly tied
|
|
* to the real composition instead of standing in for it by coincidence.
|
|
*/
|
|
function supportsEvidenceKey(
|
|
key: string,
|
|
assets: readonly Asset[] = [],
|
|
): boolean {
|
|
return (
|
|
isSupportedEvidenceKey(key) ||
|
|
Boolean(evidenceCatalogEntryFor(evidenceCatalogEntriesFromAssets(assets), key))
|
|
);
|
|
}
|
|
|
|
const rich = `## 측정 결과 {#measurements}
|
|
|
|
:::table id="fetch-loss" caption="반환 손실" rowHeaderColumn="1"
|
|
| 상태 | 결과 |
|
|
| --- | ---: |
|
|
| before | :status[20건]{tone="warning"} |
|
|
:::
|
|
|
|
\`\`\`sql label="재현 쿼리"
|
|
select * from feed_item;
|
|
\`\`\``;
|
|
|
|
describe("Content Format v1", () => {
|
|
it("parses and serializes the rich source fixture byte-for-byte", () => {
|
|
const parsed = parseCaseContent(rich);
|
|
|
|
expect(serializeCaseContent(parsed)).toBe(rich);
|
|
expect(parseCaseContent(serializeCaseContent(parsed))).toEqual(parsed);
|
|
expect(parsed.map((block) => block.type)).toEqual([
|
|
"HEADING",
|
|
"DATA_TABLE",
|
|
"CODE_BLOCK",
|
|
]);
|
|
});
|
|
|
|
it("rejects unsafe, raw HTML, and unsupported input with source positions", () => {
|
|
const rejected = [
|
|
"<script>alert(1)</script>",
|
|
"[x](javascript:alert(1))",
|
|
"[x](//evil.example/path)",
|
|
"[x](//techlog.invalid/path)",
|
|
"[x](///techlog.invalid/path)",
|
|
"[x](//user@techlog.invalid/path)",
|
|
"[x](/\\evil.example/path)",
|
|
"[x](/\\\\evil.example/path)",
|
|
"[x](</safe\u0001path>)",
|
|
"[x](</safe\u001fpath>)",
|
|
"[x](</safe\u007fpath>)",
|
|
"- outer\n - nested",
|
|
"# level one",
|
|
"- [ ] task",
|
|
"> > nested",
|
|
':::unknown key="value"\ntext\n:::',
|
|
':::evidence key="https://example.com/x.png" alt="x" caption="x" zoom="true"\n:::',
|
|
];
|
|
|
|
for (const source of rejected) {
|
|
expect(() => parseCaseContent(source), source).toThrow(
|
|
/CONTENT_FORMAT_INVALID/,
|
|
);
|
|
}
|
|
|
|
try {
|
|
parseCaseContent("safe\n\n<script>alert(1)</script>");
|
|
throw new Error("expected malformed content to fail");
|
|
} catch (error) {
|
|
expect(error).toBeInstanceOf(ContentFormatError);
|
|
expect((error as ContentFormatError).issues).toEqual([
|
|
{
|
|
line: 3,
|
|
column: 1,
|
|
detail: "unsupported block syntax: html",
|
|
},
|
|
]);
|
|
}
|
|
});
|
|
|
|
it("keeps explicitly allowed links and same-origin paths", () => {
|
|
const [paragraph] = parseCaseContent(
|
|
"[fragment](#section) [path](/safe/path) [query](/safe/path?q=one) [http](http://example.com/path) [https](https://example.com/path) [mail](mailto:test@example.com)",
|
|
);
|
|
|
|
expect(paragraph?.type).toBe("PARAGRAPH");
|
|
if (paragraph?.type !== "PARAGRAPH") return;
|
|
expect(
|
|
paragraph.content
|
|
.filter((inline) => inline.type === "LINK")
|
|
.map((inline) => inline.href),
|
|
).toEqual([
|
|
"#section",
|
|
"/safe/path",
|
|
"/safe/path?q=one",
|
|
"http://example.com/path",
|
|
"https://example.com/path",
|
|
"mailto:test@example.com",
|
|
]);
|
|
});
|
|
|
|
it("generates stable Korean heading IDs and suffixes duplicates", () => {
|
|
const blocks = parseCaseContent("## 한글 API!\n\n## 한글 API?\n\n## !!!");
|
|
|
|
expect(
|
|
blocks.map((block) => (block.type === "HEADING" ? block.id : null)),
|
|
).toEqual(["한글-api", "한글-api-2", "section"]);
|
|
});
|
|
|
|
it("round trips every supported block and inline variant", () => {
|
|
const source = `## 본문 {#body}
|
|
|
|
일반 *강조* **강함** \`code\` [내부](/path) [메일](mailto:test@example.com)
|
|
|
|
> 한 문단 인용
|
|
|
|
- 첫째
|
|
- 둘째
|
|
|
|
1. 하나
|
|
2. 둘
|
|
|
|
:::callout tone="info" label="정보"
|
|
안전한 안내입니다.
|
|
:::
|
|
|
|
:::evidence key="fetch-strategy-boundary" alt="비교" caption="경계" zoom="false"
|
|
:::`;
|
|
const parsed = parseCaseContent(source);
|
|
|
|
expect(parseCaseContent(serializeCaseContent(parsed))).toEqual(parsed);
|
|
expect(parsed.map((block) => block.type)).toEqual([
|
|
"HEADING",
|
|
"PARAGRAPH",
|
|
"BLOCKQUOTE",
|
|
"UNORDERED_LIST",
|
|
"ORDERED_LIST",
|
|
"CALLOUT",
|
|
"EVIDENCE_FIGURE",
|
|
]);
|
|
});
|
|
|
|
it("parses a decorative evidence figure with an empty alt", () => {
|
|
const source =
|
|
':::evidence key="fetch-strategy-boundary" alt="" caption="" zoom="false"\n:::';
|
|
const [block] = parseCaseContent(source);
|
|
|
|
expect(block?.type).toBe("EVIDENCE_FIGURE");
|
|
if (block?.type !== "EVIDENCE_FIGURE") return;
|
|
expect(block.alt).toBe("");
|
|
});
|
|
|
|
it("round-trips an empty alt without reintroducing it as a parse error", () => {
|
|
const source =
|
|
':::evidence key="fetch-strategy-boundary" alt="" caption="" zoom="false"\n:::';
|
|
const parsed = parseCaseContent(source);
|
|
|
|
expect(() => parseCaseContent(serializeCaseContent(parsed))).not.toThrow();
|
|
});
|
|
|
|
it("still rejects an unsafe evidence key", () => {
|
|
expect(() =>
|
|
parseCaseContent(
|
|
':::evidence key="../etc" alt="x" caption="" zoom="false"\n:::',
|
|
),
|
|
).toThrow(/CONTENT_FORMAT_INVALID/);
|
|
});
|
|
|
|
it("derives stable table column and row IDs", () => {
|
|
const [table] = parseCaseContent(`:::table id="metrics" caption="측정" rowHeaderColumn="none"
|
|
| 이름 | 수치 |
|
|
| :--- | ---: |
|
|
| before | 20 |
|
|
:::`);
|
|
|
|
expect(table?.type).toBe("DATA_TABLE");
|
|
if (table?.type !== "DATA_TABLE") return;
|
|
expect(table.columns.map((column) => column.id)).toEqual([
|
|
"metrics-column-1",
|
|
"metrics-column-2",
|
|
]);
|
|
expect(table.rows.map((row) => row.id)).toEqual(["metrics-row-1"]);
|
|
});
|
|
|
|
it("rejects unsupported inline syntax in table headers", () => {
|
|
for (const header of [
|
|
"<script>alert(1)</script>",
|
|
"",
|
|
"~~deleted~~",
|
|
]) {
|
|
const source = `:::table id="unsafe-header" caption="검증" rowHeaderColumn="none"
|
|
| ${header} |
|
|
| --- |
|
|
| value |
|
|
:::`;
|
|
expect(() => parseCaseContent(source), header).toThrow(
|
|
/CONTENT_FORMAT_INVALID/,
|
|
);
|
|
}
|
|
});
|
|
|
|
const metricsTable = `:::table id="metrics" caption="측정" rowHeaderColumn="none"
|
|
| 이름 | 값 |
|
|
| --- | --- |
|
|
| before | 20 |
|
|
:::`;
|
|
|
|
it("rejects duplicate table IDs", () => {
|
|
expect(() =>
|
|
parseCaseContent(`${metricsTable}\n\n${metricsTable}`),
|
|
).toThrow(/duplicate explicit ID: metrics/);
|
|
});
|
|
|
|
it("rejects heading and table base ID collisions in either order", () => {
|
|
expect(() =>
|
|
parseCaseContent(`## 제목 {#metrics}\n\n${metricsTable}`),
|
|
).toThrow(/duplicate explicit ID: metrics/);
|
|
expect(() =>
|
|
parseCaseContent(`${metricsTable}\n\n## 제목 {#metrics}`),
|
|
).toThrow(/duplicate explicit ID: metrics/);
|
|
});
|
|
|
|
it("rejects heading IDs that collide with a later table column ID", () => {
|
|
expect(() =>
|
|
parseCaseContent(`## 열 {#metrics-column-1}\n\n${metricsTable}`),
|
|
).toThrow(/duplicate explicit ID: metrics-column-1/);
|
|
});
|
|
|
|
it("rejects table row IDs that collide with a later heading ID", () => {
|
|
expect(() =>
|
|
parseCaseContent(`${metricsTable}\n\n## 행 {#metrics-row-1}`),
|
|
).toThrow(/duplicate explicit ID: metrics-row-1/);
|
|
});
|
|
|
|
function expectRoundTrip(source: string) {
|
|
const parsed = parseCaseContent(source);
|
|
expect(parseCaseContent(serializeCaseContent(parsed))).toEqual(parsed);
|
|
}
|
|
|
|
it("round trips literal backslashes and intraword underscores", () => {
|
|
expectRoundTrip("literal_under_score and \\*star\\* and \\\\slash");
|
|
});
|
|
|
|
it("round trips literal emphasis-shaped underscores", () => {
|
|
expectRoundTrip("literal \\_emphasis\\_");
|
|
});
|
|
|
|
it("keeps escaped block-leading list and quote markers as paragraphs", () => {
|
|
for (const source of ["\\- literal", "\\> quote"]) {
|
|
const parsed = parseCaseContent(source);
|
|
expect(parsed[0]?.type).toBe("PARAGRAPH");
|
|
expect(parseCaseContent(serializeCaseContent(parsed))).toEqual(parsed);
|
|
}
|
|
});
|
|
|
|
it("round trips inline code containing backticks", () => {
|
|
expectRoundTrip("Use ``code ` tick`` here.");
|
|
});
|
|
|
|
it("round trips all-space inline code without semantic padding", () => {
|
|
expectRoundTrip("Use `` `` here.");
|
|
});
|
|
|
|
it("round trips escaped pipes in table cells", () => {
|
|
expectRoundTrip(`:::table id="pipes" caption="파이프" rowHeaderColumn="none"
|
|
| 표현 | 값 |
|
|
| --- | --- |
|
|
| a \\| b | c |
|
|
:::`);
|
|
});
|
|
|
|
it("round trips directive-looking text inside a longer code fence", () => {
|
|
expectRoundTrip(`\`\`\`\`text label="문법 예시"
|
|
:::callout tone="warning" label="코드 안"
|
|
\`\`\`inner
|
|
literal
|
|
\`\`\`
|
|
\`\`\`\``);
|
|
});
|
|
});
|
|
|
|
const catalog: components["schemas"]["CatalogEntry"][] = [
|
|
{
|
|
id: "topic-jpa",
|
|
type: "TOPIC",
|
|
label: "JPA",
|
|
publicPath: "/topics/jpa",
|
|
dependencyRevision: "r1",
|
|
},
|
|
{
|
|
id: "project-backend",
|
|
type: "PROJECT",
|
|
label: "Backend Skeleton",
|
|
publicPath: "/projects/backend-skeleton",
|
|
dependencyRevision: "r1",
|
|
},
|
|
{
|
|
id: "case-fetch",
|
|
type: "RELATION",
|
|
kind: "CASE",
|
|
label: "Fetch Join Case",
|
|
publicPath: "/cases/collection-fetch-join-pagination",
|
|
dependencyRevision: "r1",
|
|
},
|
|
{
|
|
id: "evidence-fetch",
|
|
type: "EVIDENCE",
|
|
label: "Fetch 전략 비교",
|
|
publicPath: "/media/fetch-strategy-boundary.svg",
|
|
dependencyRevision: "r1",
|
|
},
|
|
{
|
|
id: "resolution-evidence",
|
|
type: "EVIDENCE",
|
|
label: "Fetch Join Case",
|
|
publicPath: "/cases/collection-fetch-join-pagination",
|
|
dependencyRevision: "r1",
|
|
},
|
|
];
|
|
|
|
function caseWithEvidence(
|
|
key: string,
|
|
): components["schemas"]["CaseInput"] {
|
|
return {
|
|
kind: "CASE",
|
|
title: "Case",
|
|
slug: "case",
|
|
summary: "summary",
|
|
topicId: "topic-jpa",
|
|
projectId: "project-backend",
|
|
relations: [
|
|
{
|
|
id: "relation-1",
|
|
targetId: "case-fetch",
|
|
reason: "근거",
|
|
order: 1,
|
|
},
|
|
],
|
|
problem: "problem",
|
|
conclusion: "conclusion",
|
|
environment: "environment",
|
|
reproduction: "dataset",
|
|
lastVerifiedOn: "2026-08-14",
|
|
bodyMarkdown: `## 본문\n\n:::evidence key="${key}" alt="설명" caption="근거" zoom="true"\n:::`,
|
|
};
|
|
}
|
|
|
|
describe("Public render model projection", () => {
|
|
it("is pure and resolves a supported catalog evidence entry", () => {
|
|
const input = caseWithEvidence("fetch-strategy-boundary");
|
|
const before = structuredClone(input);
|
|
const model = projectWorkingCopy(
|
|
input,
|
|
catalog,
|
|
{
|
|
generatedAt: "2026-08-14T00:00:00Z",
|
|
dependencyRevision: "r1",
|
|
},
|
|
supportsEvidenceKey,
|
|
);
|
|
|
|
expect(model.kind).toBe("CASE");
|
|
expect(model.topic.label).toBe("JPA");
|
|
expect(model.project?.label).toBe("Backend Skeleton");
|
|
expect(model.relations[0]?.title).toBe("Fetch Join Case");
|
|
expect(input).toEqual(before);
|
|
});
|
|
|
|
it("preserves resolved Question fields and requires EVIDENCE", () => {
|
|
const input: components["schemas"]["QuestionInput"] = {
|
|
kind: "QUESTION",
|
|
title: "Question",
|
|
slug: "question",
|
|
summary: "summary",
|
|
topicId: "topic-jpa",
|
|
projectId: null,
|
|
relations: [],
|
|
questionStatus: "RESOLVED",
|
|
facts: [],
|
|
assumptions: [],
|
|
unknowns: [],
|
|
constraints: [],
|
|
options: [],
|
|
nextValidation: "다음에도 측정합니다.",
|
|
resolution: {
|
|
summary: "분리하기로 결정했습니다.",
|
|
evidenceTargetId: "resolution-evidence",
|
|
linkLabel: "Case 읽기",
|
|
},
|
|
};
|
|
const model = projectWorkingCopy(
|
|
input,
|
|
catalog,
|
|
{ mode: "PREVIEW", publishedAt: null },
|
|
supportsEvidenceKey,
|
|
);
|
|
|
|
expect(model.kind).toBe("QUESTION");
|
|
if (model.kind !== "QUESTION") return;
|
|
expect(model.nextValidation).toBe(input.nextValidation);
|
|
expect(model.resolution?.summary).toBe(input.resolution?.summary);
|
|
expect(model.resolution?.evidenceTarget.publicPath).toBe(
|
|
"/cases/collection-fetch-join-pagination",
|
|
);
|
|
expect(() =>
|
|
projectWorkingCopy(
|
|
{
|
|
...input,
|
|
resolution: {
|
|
...input.resolution!,
|
|
evidenceTargetId: "topic-jpa",
|
|
},
|
|
},
|
|
catalog,
|
|
{ mode: "PREVIEW", publishedAt: null },
|
|
supportsEvidenceKey,
|
|
),
|
|
).toThrow(/EVIDENCE catalog/);
|
|
});
|
|
|
|
const unsupportedEvidenceCatalog = [
|
|
...catalog,
|
|
{
|
|
id: "unsupported-id",
|
|
type: "EVIDENCE",
|
|
label: "지원하지 않음",
|
|
publicPath: "/media/unsupported-id.svg",
|
|
dependencyRevision: "r1",
|
|
},
|
|
{
|
|
id: "other-id",
|
|
type: "EVIDENCE",
|
|
label: "unsupported-label",
|
|
publicPath: "/media/unsupported-label.svg",
|
|
dependencyRevision: "r1",
|
|
},
|
|
] satisfies components["schemas"]["CatalogEntry"][];
|
|
|
|
function expectUnsupportedEvidence(key: string) {
|
|
expect(() =>
|
|
projectWorkingCopy(
|
|
caseWithEvidence(key),
|
|
unsupportedEvidenceCatalog,
|
|
{ mode: "PREVIEW", publishedAt: null },
|
|
supportsEvidenceKey,
|
|
),
|
|
).toThrow(/supported local evidence key/);
|
|
}
|
|
|
|
it("rejects an unknown evidence key", () => {
|
|
expectUnsupportedEvidence("unknown-asset");
|
|
});
|
|
|
|
it("rejects a catalog-matching unsupported evidence ID", () => {
|
|
expectUnsupportedEvidence("unsupported-id");
|
|
});
|
|
|
|
it("rejects a catalog-matching unsupported evidence label", () => {
|
|
expectUnsupportedEvidence("unsupported-label");
|
|
});
|
|
|
|
// Fix round 2 regression coverage. `catalog` above already carries
|
|
// "resolution-evidence" -- a real `EVIDENCE` row that exists for a
|
|
// QUESTION resolution target (see "requires EVIDENCE" above), not media.
|
|
// A production caller whose gate 1 collapsed into gate 2 (round 1's bug)
|
|
// would let this key through with no Asset and no legacy key backing it;
|
|
// this is the exact class of catalog row the reviewer used to reproduce
|
|
// that regression.
|
|
it("rejects a real EVIDENCE catalog row that exists for a different purpose than media (round 2 regression)", () => {
|
|
expect(() =>
|
|
projectWorkingCopy(
|
|
caseWithEvidence("resolution-evidence"),
|
|
catalog,
|
|
{ mode: "PREVIEW", publishedAt: null },
|
|
supportsEvidenceKey,
|
|
),
|
|
).toThrow(/supported local evidence key/);
|
|
});
|
|
|
|
it("accepts a key backed by a loaded READY Asset even though the document catalog carries no matching row", () => {
|
|
const assets: Asset[] = [
|
|
{
|
|
id: "99999999-9999-4999-8999-999999999999",
|
|
assetKey: "boundary-check",
|
|
kind: "DIAGRAM",
|
|
mediaType: "image/svg+xml",
|
|
originalFilename: "boundary.svg",
|
|
byteSize: 10,
|
|
width: null,
|
|
height: null,
|
|
altText: null,
|
|
decorative: false,
|
|
managementStatus: "READY",
|
|
publicPath: "/media/boundary-check.svg",
|
|
usageCount: 0,
|
|
version: 1,
|
|
createdAt: "2026-08-14T00:00:00.000Z",
|
|
updatedAt: "2026-08-14T00:00:00.000Z",
|
|
},
|
|
];
|
|
// `catalog` alone has no row for "boundary-check" -- gate 2 only passes
|
|
// because the caller merges in `evidenceCatalogEntriesFromAssets`, the
|
|
// same way every production caller does.
|
|
const evidenceCatalog = [...catalog, ...evidenceCatalogEntriesFromAssets(assets)];
|
|
|
|
const model = projectWorkingCopy(
|
|
caseWithEvidence("boundary-check"),
|
|
evidenceCatalog,
|
|
{ mode: "PREVIEW", publishedAt: null },
|
|
(key: string) => supportsEvidenceKey(key, assets),
|
|
);
|
|
|
|
expect(model.kind).toBe("CASE");
|
|
});
|
|
});
|