Files
DongHyeonka d42ad073ee fix(i18n): 상태 화면 문구를 최종 사용자 말로 쓰고 숫자·단수형·문장 조립을 catalog에 맡긴다
화면 문구 셋이 어긋난다.
- 상태 화면 문구가 템플릿 개발자용이다(04-01). 생성 기능은 모두
  `session-required`라 로그인 전 최종 사용자에게 "이 화면은 인증 연동 지점을
  확인하기 위한 보호 라우트입니다."가 보인다. 끈 기능 화면은 "코드에는
  포함되어 있으며 운영자가 다시 켤 수 있습니다.", 연동 실패 화면은 "외부 인증
  소유자가 연결되면…"이다.
- 숫자를 locale formatter 없이 그린다(04-03). 생성 목록이 "총 12345개 항목"을
  그리고, TextArea는 en에서 남은 1자도 "1 characters remaining"이다.
- ko·en 뜻이 다르다(04-07). en `form.conflict`에 "최신 상태를 확인해 주세요"가
  없고, en 문서 제목 "Page not found"와 h1 "Page not found."가 다르다.
  ErrorSummary가 번역 문장 사이에 JSX 글자 ": "를 넣는다.

고른 방법: 세 설명을 사용자 말("이 화면을 보려면 로그인해 주세요." 등)로 바꾸고
운영 설명은 뺐다. 생성 목록은 `useLocale().number(total)`을 넘긴다. TextArea는
`plural`로 `form.remaining.one`(en 단수)과 `form.remaining`을 고른다. en 충돌
문구에 행동을 더하고 not-found 제목을 h1과 같게 했다. 오류 요약 항목은
`form.errorSummary.item` "{label}: {message}"로 잇는다. 연동 실패 화면의 제목
"로그인 연동이 필요합니다."는 짝 백엔드 매뉴얼이 그 글자로 가리켜 그대로 뒀다.
검증 V4가 반박한 부분(세 화면에 행동 버튼이 없다, ProgressBar `%`)은 고치지
않았다: 셸 탐색이 늘 있고, `%`는 ko·en 결과가 같다.

위험·한계: 다운스트림이 이 키의 옛 문장을 시험으로 고정했으면 문장을 바꾼다.
이미 생성한 기능의 목록 페이지는 `count: query.data.total`을 그대로 갖는다.
`number(query.data.total)`로 바꾸면 된다(생성 명령의 새 출력과 같다).

검증: `tests/unit/i18n-contract.test.ts`(개발자 낱말, not-found 제목, 항목
문장), `tests/component/design-system-a11y.test.tsx`(en 단수·복수),
`tests/unit/create-feature.test.ts`(생성 목록의 `number(`)가 고치기 전에
실패하고 고친 뒤 통과한다. 생성 기능 시험의 total 12345 → "총 12,345개 항목"은
FE-GATE-005가 돌린다(desktop, PR 본문).

Refs: 1112/04-01, 1112/04-03, 1112/04-07
2026-11-13 19:03:18 +09:00

602 lines
25 KiB
TypeScript

import { access, mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
import { pathToFileURL } from "node:url";
import { afterEach, describe, expect, it } from "vitest";
import {
CreateFeatureError,
parseRequest,
planFeature,
randomTopicSuffix,
writeFeatureFiles,
type FeatureRequest,
type InstalledFacts,
} from "../../scripts/create-feature.ts";
import { createFileSystemDeclarationSource } from "../../scripts/generate-product-feature-index.ts";
import { PLACEHOLDER_CONTRACT_PACKAGE_DIGEST } from "../../src/contracts/deployment-admission.ts";
/**
* U7. What `pnpm create:feature` renders, checked without touching the
* repository. test:feature-scaffold writes a feature into a copy and runs the
* gates on it; this file covers the ids, the topic, the order and the refusals.
*/
const INSTALLED: InstalledFacts = Object.freeze({
appIds: ["template-app"],
featureIds: ["orders-feature", "drafts-feature"],
contexts: [
{ id: "orders-context", routePath: "orders/*" },
{ id: "billing-context", routePath: "billing/*" },
],
contextDirectories: ["orders-context", "billing-context"],
routes: [
{ routeId: "APP_HOME", path: "/", chunkId: "route-home", navigationOrder: 10 },
{ routeId: "ORDERS_LIST", path: "/orders", chunkId: "route-orders-list", navigationOrder: 50 },
{ routeId: "NOT_FOUND", path: "*", chunkId: "route-not-found", navigationOrder: null },
],
topics: ["qinv.0000000000000000000000000a"],
messageKeys: ["route.APP_HOME.title", "home.list.title"],
});
const TOPIC_SUFFIX = "abcdefghjkmnpqrstvwxyz0123";
function plan(request: FeatureRequest, installed: InstalledFacts = INSTALLED) {
return planFeature(request, installed, () => TOPIC_SUFFIX);
}
function rendered(request: FeatureRequest): string {
return [...plan(request).files.values()].join("\n");
}
describe("create:feature rendering", () => {
it("prefixes every global id with the feature and carries no sample token", () => {
const text = rendered({ id: "invoice-feature" });
expect(text).not.toMatch(/reference/iu);
const ids = [
...text.matchAll(
/\b(?:schemaId|inputSchemaId|operationId|mapperId|outputContractId|policyId|diagnosticsOperation|definitionId|chunkId|routeId|moduleId|loadingSurface|contributionId|owner)\s*:\s*"([^"]+)"/gu,
),
...text.matchAll(/\bzodValidator\(\s*"([^"]+)"/gu),
...text.matchAll(/defineQueryNamespaceIdentity\(\s*"([^"]+)"/gu),
...text.matchAll(/kind: "([a-z][^"]*\.[^"]*)"/gu),
...text.matchAll(/^\s+"((?:route\.)?[A-Za-z_.]+)": "/gmu),
].map((match) => match[1] ?? "");
expect(ids.length).toBeGreaterThan(30);
for (const id of ids) {
expect(id).toMatch(
/^(?:INVOICE_|Invoice|invoice[.-]|route\.INVOICE_LIST\.|route-invoice-|feature-frontend-invoice-feature$)/u,
);
}
expect(text).not.toMatch(/"NoRequest"/u);
});
it("names the route, context and topic it creates", () => {
const created = plan({ id: "invoice-feature" });
expect(created).toMatchObject({
contextId: "invoice-context",
newContext: true,
routeId: "INVOICE_LIST",
routePath: "/invoice",
topic: `qinv.${TOPIC_SUFFIX}`,
placeholder: true,
});
expect([...created.files.keys()]).toEqual(
expect.arrayContaining([
"src/contexts/invoice-context/context-module.ts",
"src/features/invoice-feature/feature-module.ts",
"tests/features/invoice-feature/invoice-feature-input.test.ts",
"tests/features/invoice-feature/invoice-list-page.test.tsx",
"docs/accessibility/route-reviews/INVOICE_LIST.md",
]),
);
expect([...created.files.keys()].some((file) => file.includes("/domain/"))).toBe(false);
expect(created.files.get("src/contexts/invoice-context/context-module.ts")).toContain(
'CONTEXT_ROUTE_PATH = "invoice/*"',
);
expect(created.files.get("docs/accessibility/route-reviews/INVOICE_LIST.md")).toMatch(
/^Status: pending-manual-review$/mu,
);
});
it("generates a fresh lower-case 26-character topic and refuses an installed one", () => {
const first = randomTopicSuffix();
expect(first).toMatch(/^[0-9a-hjkmnp-tv-z]{26}$/u);
expect(randomTopicSuffix()).not.toBe(first);
expect(() =>
planFeature({ id: "invoice-feature" }, INSTALLED, () => "0000000000000000000000000a"),
).toThrow(/qinv\.0000000000000000000000000a is already installed/u);
});
it("places the route after the last navigation entry", () => {
expect(rendered({ id: "invoice-feature" })).toContain("navigationOrder: 60,");
});
it("adds the route under an existing context's root", () => {
const created = plan({ id: "invoice-feature", context: "billing-context" });
expect(created).toMatchObject({ newContext: false, routePath: "/billing/invoice" });
expect([...created.files.keys()].some((file) => file.startsWith("src/contexts/"))).toBe(false);
});
it("pins the placeholder through its exported constant, or the given package", () => {
expect(rendered({ id: "invoice-feature" })).toContain(
"digest: PLACEHOLDER_CONTRACT_PACKAGE_DIGEST,",
);
const digest = `sha256:${"ab".repeat(32)}`;
const pinned = plan({
id: "invoice-feature",
contractPackage: {
packageId: "@org-contracts/invoice",
version: "1.4.2",
digest,
sourceRevision: "0a1b2c3d",
},
});
const contract = pinned.files.get(
"src/features/invoice-feature/contracts/invoice-feature-contract.ts",
);
expect(pinned.placeholder).toBe(false);
expect(contract).toContain(`digest: "${digest}",`);
expect(contract).not.toContain("PLACEHOLDER");
expect(digest).not.toBe(PLACEHOLDER_CONTRACT_PACKAGE_DIGEST);
});
// 1101 README 14.3. test:feature-scaffold runs the gateway test this renders.
it("reads the paired backend's Envelope and tests it with the backend's own bodies", () => {
const { files } = plan({ id: "invoice-feature" });
const contracts = "src/features/invoice-feature/contracts";
expect(files.get(`${contracts}/invoice-contract-contribution.ts`)).toContain(
'responseEnvelope: "ENVELOPE_V1" as const,',
);
expect(files.get(`${contracts}/invoice-schemas.ts`)).toMatch(
/invoiceProblemSchema = z\s*\.object\(\{\s*code: z\.string\(\)\.regex/u,
);
expect(
files.get("tests/features/invoice-feature/invoice-http-gateway.test.ts"),
).toContain('success: true, data: [{ id: "item-1", name: "First item" }]');
});
// 1103/03-07. The paired backend's new-feature.sh maps /<plural> (its
// camel-case name plus s, es or ies); the frontend's list reads the same
// resource path. The backend's api-base-path belongs in API_BASE_URL.
it.each([
["invoice-feature", "/invoices"],
["purchase-order-feature", "/purchaseOrders"],
["batch-feature", "/batches"],
["box-feature", "/boxes"],
["company-feature", "/companies"],
["day-feature", "/days"],
["status-feature", "/statuses"],
])("lists %s at the backend scaffold's resource path %s", (id, apiPath) => {
const base = id.slice(0, -"-feature".length);
const contribution = plan({ id }).files.get(
`src/features/${id}/contracts/${base}-contract-contribution.ts`,
);
expect(contribution).toContain(`const API_PATH = "${apiPath}";`);
});
// 1103/03-02. A page list's meta.page.total counts every page; 1112/04-03 shows
// it as a locale-formatted number.
it("shows the total the backend counted, not the length of the first page", () => {
const { files } = plan({ id: "invoice-feature" });
expect(files.get("src/features/invoice-feature/contracts/invoice-mapper.ts")).toContain(
"total: page?.total ?? items.length",
);
expect(
files.get("src/features/invoice-feature/presentation/invoice-list-page.tsx"),
).toContain('message("invoice.list.resultCount", { count: number(query.data.total) })');
});
});
/**
* 1103/09-06, 03-07. `--with-create` adds the paired backend scaffold's other
* two endpoints (POST /<plural>, GET /<plural>/{id}) with a detail page, a
* create form and the unknown-result handling. test:feature-scaffold and
* test:sample-removal generate it and run the gates on it.
*/
describe("create:feature --with-create", () => {
const contributionOf = (files: ReadonlyMap<string, string>) =>
files.get("src/features/invoice-feature/contracts/invoice-contract-contribution.ts") ?? "";
it("prefixes every id of the slice and adds its routes, pages and tests", () => {
const created = plan({ id: "invoice-feature", write: "NEVER" });
const text = [...created.files.values()].join("\n");
// No sample id. (`supportReference` is a platform prop.) Written so this
// file holds no sample id itself, which test:sample-removal looks for.
expect(text).not.toMatch(/REFERENCE_|ReferenceResource|reference-(?:feature|context)/u);
const ids = [
...text.matchAll(
/\b(?:schemaId|operationId|policyId|diagnosticsOperation|definitionId|chunkId|routeId|moduleId|loadingSurface|contributionId)\s*:\s*"([^"]+)"/gu,
),
...text.matchAll(/\bzodValidator\(\s*"([^"]+)"/gu),
...text.matchAll(/kind: "([a-z][^"]*\.[^"]*)"/gu),
...text.matchAll(/^\s+"((?:route\.)?[A-Za-z_.]+)": "/gmu),
].map((match) => match[1] ?? "");
expect(ids.length).toBeGreaterThan(50);
for (const id of ids) {
expect(id).toMatch(
/^(?:INVOICE_|Invoice|invoice[.-]|route\.INVOICE_(?:LIST|DETAIL|CREATE)\.|route-invoice-)/u,
);
}
expect([...created.files.keys()]).toEqual(
expect.arrayContaining([
"src/features/invoice-feature/presentation/invoice-detail-page.tsx",
"src/features/invoice-feature/presentation/invoice-create-page.tsx",
"src/features/invoice-feature/presentation/invoice-form.ts",
"src/features/invoice-feature/presentation/invoice-route-codecs.ts",
"src/features/invoice-feature/presentation/use-invoice-item.ts",
"src/features/invoice-feature/presentation/use-invoice-create.ts",
"tests/features/invoice-feature/invoice-create-page.test.tsx",
"docs/accessibility/route-reviews/INVOICE_DETAIL.md",
"docs/accessibility/route-reviews/INVOICE_CREATE.md",
]),
);
expect(created.routes).toEqual([
{ routeId: "INVOICE_LIST", path: "/invoice" },
{ routeId: "INVOICE_DETAIL", path: "/invoice/items/:invoiceId" },
{ routeId: "INVOICE_CREATE", path: "/invoice/new" },
]);
});
// 1103/16-01. Every generated operation declares the Envelope.
it("declares the Envelope on every operation it writes", () => {
const contribution = contributionOf(plan({ id: "invoice-feature", write: "NEVER" }).files);
expect(contribution.match(/operationId: "INVOICE_[A-Z_]+",/gu)).toHaveLength(3);
expect(contribution.match(/responseEnvelope: "ENVELOPE_V1" as const,/gu)).toHaveLength(3);
expect(contribution).toContain("pathTemplate: `${API_PATH}/{id}`,");
});
// 1103/03-07. new-feature.sh generates a NOT_IDEMPOTENT create: the backend
// ignores a key, so a same-key resend would create a second item.
it("matches the backend scaffold's NOT_IDEMPOTENT create with a NEVER command", () => {
const contribution = contributionOf(plan({ id: "invoice-feature", write: "NEVER" }).files);
expect(contribution).toContain('retrySemantics: "NEVER" as const,');
expect(contribution).toContain("retryBudget: 0 as const,");
expect(contribution).not.toContain("IDEMPOTENCY_REPLAY");
expect(contribution).toContain("acceptedStatuses: Object.freeze([201]),");
// 1103/03-01. The backend checks the name before its transaction.
expect(contribution).toContain('refusedBeforeWrite: Object.freeze(["INVOICE_INVALID"]),');
});
// 1105/08-04. Like the reference form: while a save this page did not
// start holds the coordinator, the save is off and the feedback says a
// save is running, instead of a save button that does nothing.
// 1112/01-01. The rule is the platform form's (useAppForm `mutation`,
// FormSaveFeedback; tests/component/form-foundation.test.tsx walks it):
// the page turns the button off from the form's state.
it("keeps the create's save off and says so while another save of it runs", () => {
const page =
plan({ id: "invoice-feature", write: "NEVER" }).files.get(
"src/features/invoice-feature/presentation/invoice-create-page.tsx",
) ?? "";
expect(page).toContain("disabled={form.effectUnknown || form.otherSaveRunning}");
expect(page).toContain("<FormSaveFeedback");
expect(page).not.toContain("mutation.state.indicator");
});
// 1105/08-02. Confirming an unknown create used to leave an emptied form
// that said nothing. It opens the list, which shows whether the item is
// there, and the generated page test walks that path.
it.each(["NEVER", "KEYED"] as const)(
"opens the list after the user confirms an unknown %s create",
(write) => {
const { files } = plan({ id: "invoice-feature", write });
expect(
files.get("src/features/invoice-feature/presentation/invoice-create-page.tsx"),
).toContain('void navigate(invoiceRouteUrl("INVOICE_LIST"));');
expect(
files.get("tests/features/invoice-feature/invoice-create-page.test.tsx"),
).toContain('it("opens the list after the user confirms a create whose response was lost"');
},
);
// 1106/08-02. A save that ended after the user left the form took them to
// the item anyway. The page opens the item or the list only while it is
// still mounted, and the generated page test walks that path.
// 1112/01-01. "While mounted" is the platform form's rule: the page opens
// the item in `onSaved` and the list in FormSaveFeedback's `onConfirmed`,
// which the form calls only while it is mounted.
it.each(["NEVER", "KEYED"] as const)(
"does not open the item when the user left during a %s create",
(write) => {
const { files } = plan({ id: "invoice-feature", write });
const page =
files.get("src/features/invoice-feature/presentation/invoice-create-page.tsx") ?? "";
expect(page).toContain("onSaved: (item) => {");
expect(page).toContain("onConfirmed={() => {");
expect(page).not.toContain("mounted");
expect(
files.get("tests/features/invoice-feature/invoice-create-page.test.tsx"),
).toContain('it("stays on the list the user went to while the create was saving"');
},
);
// 1103/16-07. A backend create made KEYED (IdempotencyExecutor) takes these.
it("writes the KEYED values for a backend create made KEYED", () => {
const { files } = plan({ id: "invoice-feature", write: "KEYED" });
const contribution = contributionOf(files);
expect(contribution).toContain('retrySemantics: "KEYED" as const,');
expect(contribution).toContain('mode: "IDEMPOTENCY_REPLAY" as const,');
expect(contribution).toContain('operationIdentityField: "idempotencyKey",');
expect(contribution).toContain("retryBudget: 1 as const,");
expect(
files.get("tests/features/invoice-feature/invoice-create-page.test.tsx"),
).toContain('posts[1]!.headers.get("idempotency-key")');
expect(
files.get("src/features/invoice-feature/presentation/use-invoice-create.ts"),
).toContain("...commandMutationIdentity(INVOICE_CREATE_ITEM_CONTRACT),");
});
it("refuses a slice route that collides with an installed one", () => {
expect(() =>
plan(
{ id: "invoice-feature", write: "NEVER" },
{
...INSTALLED,
routes: [
...INSTALLED.routes,
{ routeId: "LEGACY", path: "/invoice/new", chunkId: "route-legacy", navigationOrder: null },
],
},
),
).toThrow(/route INVOICE_CREATE .* collides with installed route LEGACY/u);
});
it("takes --with-create and --keyed, and --keyed only with --with-create", () => {
expect(parseRequest(["invoice-feature", "--with-create"])).toMatchObject({
write: "NEVER",
});
expect(parseRequest(["invoice-feature", "--with-create", "--keyed"])).toMatchObject({
write: "KEYED",
});
expect(parseRequest(["invoice-feature"]).write).toBeUndefined();
expect(() => parseRequest(["invoice-feature", "--keyed"])).toThrow(
/--keyed needs --with-create/u,
);
});
});
/**
* X1 (2026-11-04). The generated context declaration is executed, not only
* read as text: the generator's declaration source reads it from disk, and an
* app module built from its exported route root accepts every route the
* feature declares (the check the router relies on, 09-06).
*/
describe("create:feature context declaration", () => {
const roots: string[] = [];
afterEach(async () => {
await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
});
async function appFor(
contextId: string,
routePath: string,
maxFeatures: number,
routes: readonly Readonly<{ routeId: string; path: string }>[],
) {
const { defineBoundedContextModule } = await import(
"../../src/contexts/bounded-context-module.ts"
);
const { defineDeployableAppModule } = await import("../../src/apps/deployable-app-module.ts");
return defineDeployableAppModule({
id: "template-app",
budget: { maxContexts: 20 },
contexts: [
defineBoundedContextModule({
id: contextId,
budget: { maxFeatures },
features: [
{
id: "invoice-feature",
contracts: {
routes: Object.fromEntries(routes.map((route) => [route.routeId, route])),
},
} as never,
],
route: { path: routePath, loadRoutes: async () => [] },
}),
],
});
}
it.each([undefined, "NEVER"] as const)(
"writes a context module the generator reads and whose root holds the routes (write %s)",
async (write) => {
const root = await mkdtemp(path.join(tmpdir(), "create-feature-context-"));
roots.push(root);
const created = plan({ id: "invoice-feature", write });
await mkdir(path.join(root, "src/apps/template-app"), { recursive: true });
await writeFile(
path.join(root, "src/apps/template-app/app-module.ts"),
'export const APP_MODULE_ID = "template-app";\nexport const APP_MAX_CONTEXTS = 20;\n',
);
await writeFeatureFiles(root, created.files);
const source = await createFileSystemDeclarationSource(root);
expect(source.contextsOf("template-app")).toEqual([
{ id: "invoice-context", appId: "template-app", routePath: "invoice/*", maxFeatures: 20 },
]);
expect(source.featuresOf("invoice-context").map((feature) => feature.id)).toEqual([
"invoice-feature",
]);
const declared = (await import(
pathToFileURL(path.join(root, "src/contexts/invoice-context/context-module.ts")).href
)) as Record<string, unknown>;
expect(declared).toMatchObject({
CONTEXT_MODULE_ID: "invoice-context",
CONTEXT_APP_ID: "template-app",
CONTEXT_ROUTE_PATH: "invoice/*",
});
const app = await appFor(
String(declared["CONTEXT_MODULE_ID"]),
String(declared["CONTEXT_ROUTE_PATH"]),
Number(declared["CONTEXT_MAX_FEATURES"]),
created.routes,
);
expect(app.contexts.map((context) => context.id)).toEqual(["invoice-context"]);
},
);
it("puts the routes under an existing context's root", async () => {
const created = plan({ id: "invoice-feature", context: "billing-context", write: "NEVER" });
expect(created.routes.map((route) => route.path)).toEqual([
"/billing/invoice",
"/billing/invoice/items/:invoiceId",
"/billing/invoice/new",
]);
await expect(appFor("billing-context", "billing/*", 20, created.routes)).resolves.toBeDefined();
});
});
// 1112/01-03. The generated input reports a failed load, not one a scope
// fence ended (sign-out, account switch): it asks the shared rule.
describe("generated feature input telemetry", () => {
it("does not report a load a scope fence ended", () => {
const { files } = plan({ id: "invoice-feature" });
expect(files.get("src/features/invoice-feature/application/invoice-feature-api.ts")).toContain(
"isAbortFailure(result.error)",
);
expect(files.get("tests/features/invoice-feature/invoice-feature-input.test.ts")).toContain(
'createFailure("SCOPE_GENERATION_CHANGED"',
);
});
});
describe("create:feature refusals", () => {
it.each(["Invoice", "invoice_feature", "-invoice", "invoice--x", "invoice-", "", "a".repeat(41)])(
"refuses the id %j",
(id) => {
expect(() => plan({ id })).toThrow(/kebab-case/u);
},
);
it.each([
[{ id: "orders-feature" }, /already a feature or context/u],
[{ id: "orders-context" }, /already a feature or context/u],
[{ id: "orders" }, /prefix its ids with "orders", which orders-feature already uses/u],
[{ id: "billing-feature" }, /pass --context billing-context/u],
[{ id: "invoice-feature", context: "orders" }, /already owns the route root orders\/\*/u],
[{ id: "invoice-feature", context: "drafts-feature" }, /is a feature id/u],
[{ id: "home-feature" }, /message keys already exist: home\.list\.title/u],
[
{
id: "invoice-feature",
contractPackage: {
packageId: "@org-contracts/invoice",
version: "1.4.2",
digest: "sha256:abc",
sourceRevision: "0a1b2c3d",
},
},
/not a pinned identity: invoice-feature: package digest/u,
],
] as const)("refuses %j", (request, reason) => {
expect(() => plan(request)).toThrow(reason);
});
it("refuses a route that collides with an installed one", () => {
expect(() =>
plan(
{ id: "invoice-feature" },
{
...INSTALLED,
routes: [
...INSTALLED.routes,
{ routeId: "LEGACY", path: "/invoice", chunkId: "route-legacy", navigationOrder: null },
],
},
),
).toThrow(/collides with installed route LEGACY/u);
});
});
describe("create:feature writing", () => {
const roots: string[] = [];
afterEach(async () => {
await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
});
async function emptyRoot(): Promise<string> {
const root = await mkdtemp(path.join(tmpdir(), "create-feature-"));
roots.push(root);
return root;
}
it("refuses to overwrite and writes nothing when one target exists", async () => {
const root = await emptyRoot();
const files = plan({ id: "invoice-feature" }).files;
await mkdir(path.join(root, "docs/accessibility/route-reviews"), { recursive: true });
await writeFile(path.join(root, "docs/accessibility/route-reviews/INVOICE_LIST.md"), "kept\n");
await expect(writeFeatureFiles(root, files)).rejects.toThrow(
/refusing to overwrite: docs\/accessibility\/route-reviews\/INVOICE_LIST\.md/u,
);
expect(await readdir(root)).toEqual(["docs"]);
});
it("refuses an existing feature directory", async () => {
const root = await emptyRoot();
await mkdir(path.join(root, "src/features/invoice-feature"), { recursive: true });
await expect(
writeFeatureFiles(root, plan({ id: "invoice-feature" }).files, [
"src/features/invoice-feature",
]),
).rejects.toThrow(CreateFeatureError);
});
it("removes what it wrote when a later write fails", async () => {
const root = await emptyRoot();
const files = new Map([
["src/features/broken/first.ts", "export {};\n"],
// A file cannot be a directory, so this write fails after the first.
["src/features/broken/first.ts/second.ts", "export {};\n"],
]);
await expect(writeFeatureFiles(root, files)).rejects.toThrow();
await expect(access(path.join(root, "src"))).rejects.toThrow();
});
});
// 1112/01-01. The generated create page leaves the rules of a save through
// its mutation to the platform form: it gives useAppForm the mutation and
// draws FormSaveFeedback, so a platform fix to those rules reaches it.
describe("generated create page", () => {
it("hands the save rules to the platform form", () => {
const { files } = plan({ id: "invoice-feature", write: "KEYED" });
const page = files.get("src/features/invoice-feature/presentation/invoice-create-page.tsx") ?? "";
expect(page).toContain(" mutation,\n");
expect(page).toContain("<FormSaveFeedback");
expect(page).not.toContain("mutation.state.indicator");
expect(page).not.toContain("reconcileUnknownEffect");
});
// R-01 완료 기준 (round9 confirm review). Opening what was saved only while
// the page is open is the form's rule too (onSaved), not a mount flag the
// page keeps, and the page calls no resend or settle of its own.
it("keeps no save rule of its own", () => {
const { files } = plan({ id: "invoice-feature", write: "KEYED" });
const page = files.get("src/features/invoice-feature/presentation/invoice-create-page.tsx") ?? "";
expect(page).toContain("onSaved:");
expect(page).not.toMatch(/useRef|useEffect|mounted/u);
expect(page).not.toMatch(/resendUnknown|settleApplied|onResent/u);
});
});