274 lines
9.9 KiB
TypeScript
274 lines
9.9 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { test } from "vitest";
|
|
|
|
import { StudioGatewayError } from "../../../src/features/tech-log/application/ports/studio-gateway-error.ts";
|
|
import type { Asset } from "../../../src/features/tech-log/contracts/studio/contract.ts";
|
|
import { createTechLogFeatureInstalledInput } from "../../../src/features/tech-log/adapters/create-tech-log-feature-input.ts";
|
|
import { FIXTURE_IDS } from "../../../src/features/tech-log/adapters/mock/fixtures.ts";
|
|
import { createMockStudioGateway } from "../../../src/features/tech-log/adapters/mock/mock-studio-gateway.ts";
|
|
import { MOCK_STUDIO_INSTALL_CONTEXT } from "../../helpers/studio-install-context.ts";
|
|
|
|
import { studioAssetGatewayFromApplication, studioGatewayFromApplication } from "../../helpers/studio-application-gateway-adapter.ts";
|
|
// The staleness guards in `createPreview`/`publishDocument` compare the
|
|
// validation's `dependencyRevision` against `dependencies.dependencyRevision
|
|
// .current()`. While that default was a literal constant, it could not
|
|
// observe the Asset store at all -- so an Asset mutation between validate and
|
|
// preview was invisible to it, and the only thing standing between an
|
|
// author and a published figure with no accessible name was whatever the
|
|
// projection happened to re-derive.
|
|
|
|
function caseDraft(
|
|
overrides: Readonly<{ slug: string; bodyMarkdown: string; title?: string }>,
|
|
) {
|
|
return {
|
|
kind: "CASE",
|
|
title: overrides.title ?? "의존성 리비전 확인",
|
|
slug: overrides.slug,
|
|
summary: "검증과 미리보기 사이에서 Asset이 바뀌면 검증이 낡아야 합니다.",
|
|
topicId: FIXTURE_IDS.topicJpa,
|
|
projectId: FIXTURE_IDS.projectBackend,
|
|
relations: [],
|
|
problem: "문제",
|
|
conclusion: "결론",
|
|
environment: "env",
|
|
reproduction: "repro",
|
|
lastVerifiedOn: "2026-08-14",
|
|
bodyMarkdown: overrides.bodyMarkdown,
|
|
} as never;
|
|
}
|
|
|
|
function assetFixture(overrides: Partial<Asset>): Asset {
|
|
return {
|
|
id: "99999999-9999-4999-8999-999999999991",
|
|
assetKey: "revision-check",
|
|
kind: "IMAGE",
|
|
mediaType: "image/svg+xml",
|
|
originalFilename: "revision-check.svg",
|
|
byteSize: 10,
|
|
width: null,
|
|
height: null,
|
|
altText: null,
|
|
decorative: false,
|
|
managementStatus: "READY",
|
|
publicPath: "/media/revision-check.svg",
|
|
usageCount: 0,
|
|
version: 1,
|
|
createdAt: "2026-08-14T00:00:00.000Z",
|
|
updatedAt: "2026-08-14T00:00:00.000Z",
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function expectStale(error: unknown) {
|
|
assert.ok(
|
|
error instanceof StudioGatewayError,
|
|
`expected a StudioGatewayError, got ${String(error)}`,
|
|
);
|
|
assert.equal(error.code, "VALIDATION_STALE");
|
|
assert.equal(error.status, 409);
|
|
return true;
|
|
}
|
|
|
|
// The reported scenario, end to end through the composition the MOCK
|
|
// `studioSource` actually builds: one shared Asset store behind both mock
|
|
// gateways.
|
|
test("an Asset that turns non-decorative between validate and preview makes the validation stale", async () => {
|
|
const { input } = createTechLogFeatureInstalledInput(MOCK_STUDIO_INSTALL_CONTEXT);
|
|
const assetGateway = studioAssetGatewayFromApplication(input.createStudioApplication());
|
|
const gateway = studioGatewayFromApplication(input.createStudioApplication());
|
|
|
|
const uploaded = await assetGateway.uploadAsset(
|
|
{
|
|
file: new File(["<svg xmlns='http://www.w3.org/2000/svg'/>"], "race2.svg", {
|
|
type: "image/svg+xml",
|
|
}),
|
|
kind: "IMAGE",
|
|
decorative: true,
|
|
},
|
|
{ idempotencyKey: "race2-upload" },
|
|
);
|
|
assert.equal(uploaded.assetKey, "race2");
|
|
assert.equal(uploaded.decorative, true);
|
|
|
|
const created = await gateway.createDocument(
|
|
caseDraft({
|
|
slug: "asset-turns-non-decorative",
|
|
bodyMarkdown: ':::evidence key="race2" alt="" caption="근거" zoom="false"\n:::',
|
|
}),
|
|
{ idempotencyKey: "race2-create" },
|
|
);
|
|
|
|
// A decorative Asset may legitimately carry an empty alt, so this is VALID
|
|
// and stays VALID -- the defect is not here.
|
|
const report = await gateway.validateDocument(
|
|
created.id,
|
|
{ expectedVersion: created.version },
|
|
{ idempotencyKey: "race2-validate" },
|
|
);
|
|
assert.equal(report.status, "VALID", JSON.stringify(report.issues));
|
|
assert.deepEqual(report.issues, []);
|
|
|
|
// The state the validation depended on changes underneath it: the same
|
|
// evidence key now resolves to a meaningful image.
|
|
const updated = await assetGateway.updateAssetMetadata(
|
|
uploaded.id,
|
|
{ expectedVersion: uploaded.version, decorative: false },
|
|
{ idempotencyKey: "race2-update" },
|
|
);
|
|
assert.equal(updated.decorative, false);
|
|
assert.equal(updated.altText, null);
|
|
|
|
await assert.rejects(
|
|
gateway.createPreview(
|
|
created.id,
|
|
{ expectedVersion: created.version, validationId: report.validationId },
|
|
{ idempotencyKey: "race2-preview" },
|
|
),
|
|
expectStale,
|
|
);
|
|
|
|
// ...and the author is told the real problem when they re-validate, rather
|
|
// than being sent around a loop with no diagnosis.
|
|
const revalidated = await gateway.validateDocument(
|
|
created.id,
|
|
{ expectedVersion: created.version },
|
|
{ idempotencyKey: "race2-revalidate" },
|
|
);
|
|
assert.equal(revalidated.status, "INVALID", JSON.stringify(revalidated.issues));
|
|
assert.ok(
|
|
revalidated.issues.some((issue) => issue.code === "EVIDENCE_ALT_REQUIRED"),
|
|
JSON.stringify(revalidated.issues),
|
|
);
|
|
});
|
|
|
|
// The literal shape the reviewer reported: a second Asset sharing one
|
|
// `assetKey`, newer and not decorative, arriving in the shared Map. The Map
|
|
// is keyed by whatever the caller chooses -- the gateway only reads
|
|
// `.values()` -- so `id` is what lets two rows share a key.
|
|
test("a newer non-decorative duplicate for the same assetKey makes the validation stale", async () => {
|
|
const decorative = assetFixture({
|
|
id: "99999999-9999-4999-8999-999999999991",
|
|
assetKey: "race2",
|
|
publicPath: "/media/race2-decorative.svg",
|
|
decorative: true,
|
|
updatedAt: "2026-08-14T00:00:00.000Z",
|
|
});
|
|
const meaningful = assetFixture({
|
|
id: "99999999-9999-4999-8999-999999999992",
|
|
assetKey: "race2",
|
|
publicPath: "/media/race2-meaningful.svg",
|
|
decorative: false,
|
|
updatedAt: "2026-08-14T00:00:01.000Z",
|
|
});
|
|
const assets = new Map<string, Asset>([[decorative.id, decorative]]);
|
|
const gateway = createMockStudioGateway({ assets });
|
|
|
|
const created = await gateway.createDocument(
|
|
caseDraft({
|
|
slug: "duplicate-key-arrives-later",
|
|
bodyMarkdown: ':::evidence key="race2" alt="" caption="근거" zoom="false"\n:::',
|
|
}),
|
|
{ idempotencyKey: "dup-create" },
|
|
);
|
|
const report = await gateway.validateDocument(
|
|
created.id,
|
|
{ expectedVersion: created.version },
|
|
{ idempotencyKey: "dup-validate" },
|
|
);
|
|
assert.equal(report.status, "VALID", JSON.stringify(report.issues));
|
|
|
|
assets.set(meaningful.id, meaningful);
|
|
|
|
await assert.rejects(
|
|
gateway.createPreview(
|
|
created.id,
|
|
{ expectedVersion: created.version, validationId: report.validationId },
|
|
{ idempotencyKey: "dup-preview" },
|
|
),
|
|
expectStale,
|
|
);
|
|
});
|
|
|
|
// Reproducibility is load-bearing for this mock: the same logical Asset set
|
|
// must produce the same revision however the caller happened to insert it.
|
|
test("the same asset set in two insertion orders yields the same dependency revision", async () => {
|
|
const first = assetFixture({
|
|
id: "99999999-9999-4999-8999-99999999999a",
|
|
assetKey: "order-a",
|
|
publicPath: "/media/order-a.svg",
|
|
});
|
|
const second = assetFixture({
|
|
id: "99999999-9999-4999-8999-99999999999b",
|
|
assetKey: "order-b",
|
|
publicPath: "/media/order-b.svg",
|
|
});
|
|
const third = assetFixture({
|
|
id: "99999999-9999-4999-8999-99999999999c",
|
|
assetKey: "order-c",
|
|
publicPath: "/media/order-c.svg",
|
|
});
|
|
|
|
const revisionOf = async (...assets: Asset[]) => {
|
|
const gateway = createMockStudioGateway({
|
|
assets: new Map(assets.map((asset) => [asset.id, asset])),
|
|
});
|
|
return (await gateway.getDocument(FIXTURE_IDS.fetchJoinCase)).dependencyRevision;
|
|
};
|
|
|
|
const forward = await revisionOf(first, second, third);
|
|
const shuffled = await revisionOf(third, first, second);
|
|
const reversed = await revisionOf(third, second, first);
|
|
|
|
assert.equal(forward, shuffled);
|
|
assert.equal(forward, reversed);
|
|
|
|
// ...and a set that differs only in what the render and validation paths
|
|
// read is a different revision.
|
|
const changed = await revisionOf(first, second, assetFixture({ ...third, decorative: true }));
|
|
assert.notEqual(forward, changed);
|
|
});
|
|
|
|
// The regression the guard must not cause: the normal authoring flow changes
|
|
// no Asset, so it must still complete.
|
|
test("validate -> preview -> publish with no asset change still succeeds", async () => {
|
|
const asset = assetFixture({ assetKey: "steady", publicPath: "/media/steady.svg" });
|
|
const gateway = createMockStudioGateway({
|
|
assets: new Map<string, Asset>([[asset.assetKey, asset]]),
|
|
});
|
|
|
|
const created = await gateway.createDocument(
|
|
caseDraft({
|
|
slug: "steady-authoring-loop",
|
|
bodyMarkdown: ':::evidence key="steady" alt="근거 그림" caption="근거" zoom="false"\n:::',
|
|
}),
|
|
{ idempotencyKey: "steady-create" },
|
|
);
|
|
const report = await gateway.validateDocument(
|
|
created.id,
|
|
{ expectedVersion: created.version },
|
|
{ idempotencyKey: "steady-validate" },
|
|
);
|
|
assert.equal(report.status, "VALID", JSON.stringify(report.issues));
|
|
|
|
const preview = await gateway.createPreview(
|
|
created.id,
|
|
{ expectedVersion: created.version, validationId: report.validationId },
|
|
{ idempotencyKey: "steady-preview" },
|
|
);
|
|
assert.equal(preview.dependencyRevision, report.dependencyRevision);
|
|
|
|
const published = await gateway.publishDocument(
|
|
created.id,
|
|
{
|
|
expectedVersion: created.version,
|
|
validationId: report.validationId,
|
|
previewId: preview.previewId,
|
|
acknowledgedWarningCodes: report.issues
|
|
.filter((issue) => issue.severity === "WARNING")
|
|
.map((issue) => issue.code),
|
|
},
|
|
{ idempotencyKey: "steady-publish" },
|
|
);
|
|
assert.equal(published.event.type, "PUBLISHED");
|
|
});
|