Files
clean-architecture-frontend…/tests/features/reference-feature/reference-page.test.tsx
T
DongHyeonka ee81c448f0 fix(reference): 샘플 링크를 route ID로 만들고 route 입력 cast를 없앤다 (1101/16-04)
문제: 경로 정본은 계약의 `routes[*].path`인데, 샘플 페이지가 같은 경로를
문자열로 8곳에 다시 적는다(목록 2, 상세 1, 폼 3, 상태 1, 실패 행동 1).
route 입력은 `routeInput.search as ReferenceListFilters`와
`String(route.params.resourceId)`로 cast한다. 계약에서 경로만 바꾸면 tsc는
통과하고 링크는 NOT_FOUND로 간다. 문서(routing-pages-and-patterns 4.2절,
10절 4단계)는 codec 기반 builder와 cast 금지를 권하는데, 샘플이 반대
패턴을 보여 주고 복사되는 기능이 그 습관을 가져간다.

고른 방법: 이미 있는 URL builder를 쓴다.
- `buildRouteUrl(routeId, input, featureCodecs)`(`src/presentation/routes/
  route-codecs.ts`)가 route ID로 계약 `path`를 찾고, 라우터가 parse에 쓰는
  같은 codec으로 직렬화한다. canonical redirect도 이 함수를 쓴다.
  `src/platform`에는 URL builder가 없다. 그래서 플랫폼에 새 공개 헬퍼를
  더하지 않았다.
- 기능 쪽 helper는 `presentation/reference-routes.ts`에 둔다.
  - `referenceRouteUrl(routeId, input)`: `buildRouteUrl`에 이 기능의
    codec을 넘기는 한 줄 래퍼다. routeId는 이 기능 계약의 키로 좁힌다.
  - `useReferenceListFilters()`, `useReferenceResourceId()`: 라우터가 이미
    통과시킨 route 입력을 같은 codec으로 다시 parse해서 codec의 출력
    타입을 얻는다. cast가 없다. 목록 필터는 `useMemo`로 묶어 route 입력이
    그대로면 같은 객체를 준다.
- `REFERENCE_FEATURE_ROUTE_CODECS`를 `reference-feature-runtime.ts`에서
  새 `presentation/reference-route-codecs.ts`로 옮겼다.
  - runtime 파일이 페이지를 lazy import하므로, 페이지 쪽이 runtime 파일에서
    codec을 가져오면 순환 의존이 된다.
  - codec 표를 helper 파일에 같이 두지 않은 이유: 그러면
    `context-routes.ts`가 router의 builder·hook까지 끌어와 초기 JS가
    585 B 늘었다(204,809 B로 예산 204,800 B 초과). 분리하면 475 B다.
  - `context-routes.ts`와 `reference-contract.test.ts`는 새 위치에서
    가져온다.
- 페이지 8곳을 route ID 호출로 바꿨다. 기능 presentation에 `"/examples/`
  문자열이 0건, route 입력 cast가 0건이다. 남은 `"/examples/` 4건은 계약의
  `path`(정본)다.
- 기능 README에 helper 위치와 쓰는 법을 적었다.

버린 대안:
- 리뷰 (b)처럼 기능 안에 경로 치환·직렬화를 새로 쓰는 헬퍼: 라우터와 같은
  일을 두 번 구현한다. 플랫폼 builder가 이미 route ID와 기능 codec을 받는다.
- 리뷰 (c)처럼 `buildRouteUrl`의 input 타입을 route ID별로 좁히기: 플랫폼은
  기능 codec 타입을 모른다(15-01 이후 codec은 지연 적재). 라우터 API
  변경이라 이 발견 범위를 넘는다.
- 플랫폼 `useRouteInput`을 제네릭으로 바꿔 타입 단언하기: 런타임 검사 없는
  단언이라 cast를 다른 이름으로 옮길 뿐이다.

위험·한계:
- 목록 링크가 이제 정식 URL(`/examples/reference-resources?limit=20`)을
  가리킨다. 전에는 `?limit` 없는 주소로 갔다가 라우터가 같은 URL로
  replace했다. 도착 URL과 history 항목 수는 같다. 폼의 "목록을 새로
  불러와 확인" 링크 href 기대값을 이 값으로 바꿨다.
- `buildRouteUrl`은 codec이 거절하는 입력에 예외를 던진다. 백엔드가
  공백만 있는 id를 주면(DTO는 `min(1)`, route codec은 trim 후 `min(1)`)
  목록 렌더가 기능 오류 경계로 간다. 전에는 링크가 잘못된 주소 화면으로
  갔다. DTO와 route codec의 id 규칙 차이는 이 변경 전부터 있다.
- route 입력을 한 번 더 parse한다. 값이 작아 비용은 무시할 만하다.
- 초기 JS gzip이 204,224 B에서 204,699 B로 475 B 늘었다(예산 204,800 B,
  여유 576 B → 101 B). 새 코드가 초기 청크에 들어간 것이 아니다.
  `route-codecs.ts`는 원래 초기 청크에 있었다. 페이지가 이 모듈을 import하자
  rolldown이 `boot` 청크에 있던 것을 공유 청크(`route-input`)로 옮기고,
  `route-input`과 `server-state-scope-provider`를 두 청크로 나눴다. 늘어난
  양은 청크 분리 비용이다. 예산 값은 바꾸지 않았다.
- 페이지 테스트의 진입 URL 문자열은 그대로 뒀다. 테스트가 경로를 적는
  것은 이 발견의 완료 기준 밖이다.
- 상태 페이지의 `(state as ReferenceSupportState)`는 history state 처리라
  route 입력 cast가 아니다. 그대로 뒀다.

검증:
- RED(수정 전): 새 `tests/features/reference-feature/
  reference-route-links.test.tsx`는 계약의 네 경로를 모두 옮긴(vi.mock)
  상태로 목록→상세→목록→폼→목록, 목록→지원 페이지→목록을 걷는다.
  2개 모두 실패했다. 상세 링크가 `href=".../items/reference-1"`(기대
  `.../entries/reference-1`), 지원 페이지 대신 NOT_FOUND가 나왔다.
- GREEN(수정 후): 같은 테스트 2개 통과. `tests/features/reference-feature`
  18 files 89 tests 통과(href 기대값 1곳 변경 뒤).
- 회귀: tests/features, tests/component, tests/architecture, tests/scale,
  관련 unit 3개, generator 테스트 81 files 464 tests 통과. 첫 실행에서는
  부하(평균 23~35)로 타임아웃 2건(app-build-input,
  global-local-independence)이 났고, 단독 재실행과 최종 재실행에서 통과했다.
- 초기 JS gzip(`scripts/build-frontend.ts` 후 check-bundle과 같은 분류로
  측정): 수정 전 204,224 B, 수정 후 204,699 B.
- `tsc` app·test·node 통과. 바꾼 파일 `eslint --max-warnings=0` 통과.
- `check-architecture.ts`(pnpm 대신 exec 전용 shim): 381 modules,
  순환·위반 없음, rc=0. `verify-documentation-readiness` PASS_SCOPED,
  `check-i18n` PASS.
- 페이지 테스트 harness(`renderReference`, `inputWith`)는 새 테스트와
  함께 쓰도록 `reference-page-harness.tsx`로 옮겼다. 내용은 그대로다.

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

630 lines
21 KiB
TypeScript

// @vitest-environment jsdom
import { screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { describe, expect, it, vi } from "vitest";
import { createDemoSessionAdapter } from "../../../src/adapters/auth/external-session-adapter.ts";
import type {
ReferenceFeatureInput,
ReferenceResult,
} from "../../../src/features/reference-feature/application/reference-feature-api.ts";
import {
REFERENCE_RESOURCE_INVALIDATION_TOPIC,
REFERENCE_RESOURCE_QUERY_NAMESPACE,
} from "../../../src/features/reference-feature/contracts/reference-feature-contract.ts";
import { INVALIDATION_REGISTRY } from "../../../src/features/installed-feature-contracts.ts";
import type { ReferenceResourceView } from "../../../src/features/reference-feature/contracts/reference-mapper.ts";
import { createFailure } from "../../../src/contracts/errors.ts";
import { KO_MESSAGES } from "../../../src/presentation/i18n/catalog.ts";
import { inputWith, renderReference } from "./reference-page-harness.tsx";
/**
* 0929/08-02. The main area's text and accessible names with every ko-KR
* catalog value and every given data value cut out. The lint rule sees JSX
* text and attributes only; this also sees words passed through props.
*/
function mainTextOutsideCatalog(data: readonly string[]): string {
const main = screen.getByRole("main");
const names = [...main.querySelectorAll("[aria-label],[title],[placeholder],[alt]")]
.flatMap((element) =>
["aria-label", "title", "placeholder", "alt"].map(
(name) => element.getAttribute(name) ?? "",
),
);
return [...data, ...Object.values(KO_MESSAGES)]
.sort((left, right) => right.length - left.length)
.reduce(
(text, known) => text.split(known).join(" "),
[main.textContent ?? "", ...names].join(" "),
);
}
describe("reference feature page states", () => {
it("shows no Latin words outside the catalog on the ko-KR screens", async () => {
const resource = {
resourceId: "reference-1",
title: "Loaded",
createdAt: null,
};
const input = inputWith({
listResources: async () => ({ ok: true, value: [resource] }),
});
for (const [url, ready] of [
["/examples/reference-resources?limit=5&tags=open", "Loaded"],
["/examples/reference-resources/items/reference-1", "Detail"],
["/examples/reference-resources/new", "저장"],
["/examples/reference-resources/status", "목록으로 이동"],
] as const) {
const view = renderReference(input, url);
await screen.findAllByText(ready);
expect(
mainTextOutsideCatalog(["reference-1", "Loaded", "Detail", "open"]),
url,
).not.toMatch(/[A-Za-z]/);
view.unmount();
}
});
it("mounts list and detail keys under the installed governed namespace", async () => {
expect(REFERENCE_RESOURCE_QUERY_NAMESPACE).toEqual({
namespaceId: "reference-resource",
namespaceVersion: 1,
});
const installedEdge = INVALIDATION_REGISTRY.edges.find(
(edge) => edge.topicId === REFERENCE_RESOURCE_INVALIDATION_TOPIC,
);
expect(installedEdge?.namespace).toEqual(
REFERENCE_RESOURCE_QUERY_NAMESPACE,
);
const list = renderReference(inputWith());
await screen.findByRole("heading", { name: "표시할 항목이 없습니다." });
const listKey = list.client.getQueryCache().getAll()[0]?.queryKey;
expect(listKey?.slice(0, 4)).toEqual([
"query",
2,
REFERENCE_RESOURCE_QUERY_NAMESPACE.namespaceId,
REFERENCE_RESOURCE_QUERY_NAMESPACE.namespaceVersion,
]);
list.unmount();
const detail = renderReference(
inputWith(),
"/examples/reference-resources/items/reference-1",
);
await screen.findByText("Detail");
const detailKey = detail.client.getQueryCache().getAll()[0]?.queryKey;
expect(detailKey?.slice(0, 4)).toEqual([
"query",
2,
installedEdge?.namespace.namespaceId,
installedEdge?.namespace.namespaceVersion,
]);
detail.unmount();
});
it("renders loading, success and empty states through the installed route", async () => {
let resolveList:
| ((result: ReferenceResult<readonly ReferenceResourceView[]>) => void)
| undefined;
const pending = new Promise<
ReferenceResult<readonly ReferenceResourceView[]>
>((resolve) => {
resolveList = resolve;
});
const loaded = renderReference(
inputWith({ listResources: async () => pending }),
);
expect(await screen.findByLabelText("불러오는 중")).toBeVisible();
resolveList?.({
ok: true,
value: [
{
resourceId: "reference-1",
title: "Loaded",
createdAt: null,
},
],
});
expect(await screen.findByText("Loaded")).toBeVisible();
loaded.unmount();
renderReference(inputWith(), "/examples/reference-resources?limit=10");
expect(
await screen.findByRole("heading", {
name: "표시할 항목이 없습니다.",
}),
).toBeVisible();
});
it("rejects invalid URL input before the feature application input", async () => {
const listResources = vi.fn();
renderReference(
inputWith({ listResources }),
"/examples/reference-resources?limit=invalid",
);
expect(
await screen.findByRole("heading", {
name: "올바르지 않은 주소입니다.",
}),
).toBeVisible();
expect(listResources).not.toHaveBeenCalled();
});
// 08-09. The count is a status only once there is a result to count.
it("shows the result count only for a loaded list", async () => {
const resultCount = () =>
document.querySelector(".collection-page__result-count");
let resolveList:
| ((result: ReferenceResult<readonly ReferenceResourceView[]>) => void)
| undefined;
const loading = renderReference(
inputWith({
listResources: () =>
new Promise((resolve) => {
resolveList = resolve;
}),
}),
);
expect(await screen.findByLabelText("불러오는 중")).toBeVisible();
expect(resultCount()).toBeNull();
resolveList?.({
ok: true,
value: [{ resourceId: "reference-1", title: "Loaded", createdAt: null }],
});
expect(await screen.findByText("Loaded")).toBeVisible();
expect(resultCount()).toHaveTextContent("총 1개 항목");
loading.unmount();
renderReference(
inputWith({
listResources: async () => ({
ok: false,
error: createFailure("SERVER_FAILURE", "LIST_REFERENCE_RESOURCES", 0),
}),
}),
);
expect(await screen.findByRole("alert")).toHaveTextContent(
"요청을 완료하지 못했습니다.",
);
expect(resultCount()).toBeNull();
});
// 08-13. A server id equal to a static segment still opens its detail.
it.each(["new", "status"])(
"opens the detail screen for an item whose id is %s",
async (resourceId) => {
const user = userEvent.setup();
const getResource = vi.fn(async (id: string) => ({
ok: true as const,
value: { resourceId: id, title: "Detail", createdAt: null },
}));
renderReference(
inputWith({
listResources: async () => ({
ok: true,
value: [
{ resourceId, title: `Item ${resourceId}`, createdAt: null },
],
}),
getResource,
}),
);
await user.click(
await screen.findByRole("link", { name: `Item ${resourceId}` }),
);
expect(
await screen.findByRole("heading", { level: 1, name: "Detail" }),
).toBeVisible();
expect(getResource.mock.calls[0]?.[0]).toBe(resourceId);
},
);
it("renders backend forbidden even when the client access hint allowed entry", async () => {
const user = userEvent.setup();
renderReference(
inputWith({
listResources: async () => ({
ok: false,
error: createFailure(
"FORBIDDEN",
"LIST_REFERENCE_RESOURCES",
0,
),
}),
}),
);
expect(await screen.findByRole("alert")).toHaveTextContent(
"접근할 수 없습니다.",
);
await user.click(
screen.getByRole("button", { name: "안전한 화면으로 이동" }),
);
expect(
await screen.findByRole("heading", {
level: 1,
name: "Clean Architecture Frontend",
}),
).toBeVisible();
});
it("starts sign-in with the current route for a backend auth failure", async () => {
const user = userEvent.setup();
const demoSession = createDemoSessionAdapter("authenticated");
const beginSignIn = vi.fn(async () => {});
const session = { ...demoSession, beginSignIn };
renderReference(
inputWith({
listResources: async () => ({
ok: false,
error: createFailure(
"AUTH_REQUIRED",
"LIST_REFERENCE_RESOURCES",
0,
),
}),
}),
"/examples/reference-resources?limit=5",
session,
);
await user.click(await screen.findByRole("button", { name: "로그인 시작" }));
expect(beginSignIn).toHaveBeenCalledWith(
"/examples/reference-resources?limit=5",
);
});
it("falls back to a public route when starting sign-in fails", async () => {
const user = userEvent.setup();
const demoSession = createDemoSessionAdapter("authenticated");
const beginSignIn = vi.fn(async () => {
throw new Error("identity provider unavailable");
});
renderReference(
inputWith({
listResources: async () => ({
ok: false,
error: createFailure(
"AUTH_REQUIRED",
"LIST_REFERENCE_RESOURCES",
0,
),
}),
}),
"/examples/reference-resources?limit=5",
{ ...demoSession, beginSignIn },
);
await user.click(await screen.findByRole("button", { name: "로그인 시작" }));
expect(
await screen.findByRole("heading", {
level: 1,
name: "Clean Architecture Frontend",
}),
).toBeVisible();
});
it("deduplicates create, preserves input and surfaces a conflict", async () => {
const user = userEvent.setup();
let finish:
| ((result: ReferenceResult<ReferenceResourceView>) => void)
| undefined;
const createResource = vi.fn(
() =>
new Promise<ReferenceResult<ReferenceResourceView>>((resolve) => {
finish = resolve;
}),
);
renderReference(
inputWith({ createResource }),
"/examples/reference-resources/new",
);
await screen.findByRole("heading", {
name: "Reference resource 만들기",
});
await user.type(
screen.getByRole("textbox", { name: /새 항목 이름/ }),
"Conflicting",
);
await user.type(screen.getByLabelText("설명"), "Keep this input");
const submit = screen.getByRole("button", { name: "저장" });
await user.dblClick(submit);
await waitFor(() => expect(createResource).toHaveBeenCalledOnce());
expect(screen.getByRole("button", { name: "저장 중…" })).toBeDisabled();
finish?.({
ok: false,
error: createFailure(
"CONFLICT",
"CREATE_REFERENCE_RESOURCE",
0,
{ effect: "NOT_APPLIED" },
),
});
expect(await screen.findByText(/다른 변경과 충돌했습니다/)).toBeVisible();
expect(
screen.getByRole("textbox", { name: /새 항목 이름/ }),
).toHaveValue("Conflicting");
expect(screen.getByLabelText("설명")).toHaveValue("Keep this input");
});
it("blocks a new save and resends an unknown create with the same key", async () => {
const user = userEvent.setup();
const createResource = vi
.fn<ReferenceFeatureInput["createResource"]>()
.mockResolvedValueOnce({
ok: false,
error: createFailure(
"SERVER_FAILURE",
"CREATE_REFERENCE_RESOURCE",
0,
{ effect: "MAYBE_APPLIED" },
),
})
.mockResolvedValue({
ok: true,
value: { resourceId: "created", title: "Unknown result", createdAt: null },
});
renderReference(
inputWith({ createResource }),
"/examples/reference-resources/new",
);
const name = await screen.findByRole("textbox", { name: /새 항목 이름/ });
await user.type(name, "Unknown result");
await user.click(screen.getByRole("button", { name: "저장" }));
expect(
await screen.findByText("변경 결과를 확인할 수 없습니다."),
).toBeVisible();
expect(screen.getByRole("button", { name: "저장" })).toBeDisabled();
expect(
screen.queryByText("저장하지 못했습니다. 잠시 후 다시 시도해 주세요."),
).not.toBeInTheDocument();
// No path lets the user declare "not applied" without evidence.
expect(
screen.queryByRole("button", { name: "변경되지 않음으로 확인" }),
).not.toBeInTheDocument();
// 16-04. Built by the route codec, so the link is already the canonical
// URL the router would redirect to (the default limit is written out).
expect(
screen.getByRole("link", { name: "목록을 새로 불러와 확인" }),
).toHaveAttribute("href", "/examples/reference-resources?limit=20");
await user.click(screen.getByRole("button", { name: "저장" }));
expect(createResource).toHaveBeenCalledOnce();
expect(name).toHaveValue("Unknown result");
await user.click(
screen.getByRole("button", { name: "같은 요청으로 다시 보내기" }),
);
expect(await screen.findByRole("status")).toHaveTextContent("저장했습니다.");
expect(createResource).toHaveBeenCalledTimes(2);
const [first, second] = createResource.mock.calls;
expect(second?.[0]).toEqual(first?.[0]);
expect(first?.[1]?.intent?.idempotencyKey).toBe("reference-page-key-1");
expect(second?.[1]?.intent?.idempotencyKey).toBe("reference-page-key-1");
expect(name).toHaveValue("");
});
it.each([
["AUTH_REQUIRED", "계속하려면 로그인이 필요합니다.", "로그인"],
["FORBIDDEN", "이 작업을 수행할 권한이 없습니다.", "안전한 화면으로 이동"],
["RATE_LIMITED", "요청이 많습니다. 잠시 후 다시 시도해 주세요.", "다시 시도"],
] as const)(
"gives a %s create failure its own copy and action",
async (kind, copy, action) => {
const user = userEvent.setup();
const demoSession = createDemoSessionAdapter("authenticated");
const beginSignIn = vi.fn(async () => {});
const createResource = vi.fn(async () => ({
ok: false as const,
error: createFailure(kind, "CREATE_REFERENCE_RESOURCE", 0, {
effect: "NOT_APPLIED",
}),
}));
renderReference(
inputWith({ createResource }),
"/examples/reference-resources/new",
{ ...demoSession, beginSignIn },
);
await user.type(
await screen.findByRole("textbox", { name: /새 항목 이름/ }),
"Rejected",
);
await user.click(screen.getByRole("button", { name: "저장" }));
expect(await screen.findByRole("alert")).toHaveTextContent(copy);
expect(document.body).not.toHaveTextContent("입력 내용을 확인해 주세요.");
expect(
screen.queryByText("변경 결과를 확인할 수 없습니다."),
).not.toBeInTheDocument();
await user.click(screen.getByRole("button", { name: action }));
if (kind === "AUTH_REQUIRED") {
expect(beginSignIn).toHaveBeenCalledWith(
"/examples/reference-resources/new",
);
} else if (kind === "FORBIDDEN") {
// Leaving still passes the dirty-input guard.
await user.click(
await screen.findByRole("button", { name: "변경 버리고 이동" }),
);
expect(
await screen.findByRole("heading", {
level: 1,
name: "Clean Architecture Frontend",
}),
).toBeVisible();
} else {
await waitFor(() => expect(createResource).toHaveBeenCalledTimes(2));
}
},
);
// 0929/08-04. The ids a user quotes to support reach the screens that
// need them, and the sample status page shows no made-up reference.
it("shows the request id of an unknown create next to its result", async () => {
const user = userEvent.setup();
renderReference(
inputWith({
createResource: async () => ({
ok: false,
error: createFailure("SERVER_FAILURE", "CREATE_REFERENCE_RESOURCE", 0, {
effect: "MAYBE_APPLIED",
requestId: "corr-save-500",
}),
}),
}),
"/examples/reference-resources/new",
);
await user.type(
await screen.findByRole("textbox", { name: /새 항목 이름/ }),
"Unknown result",
);
await user.click(screen.getByRole("button", { name: "저장" }));
expect(await screen.findByText("변경 결과를 확인할 수 없습니다.")).toBeVisible();
expect(screen.getByText("지원 참조: corr-save-500")).toBeVisible();
});
it("carries a failure's request id to the support status page", async () => {
const user = userEvent.setup();
renderReference(
inputWith({
listResources: async () => ({
ok: false,
error: createFailure("UNKNOWN_CLIENT_FAILURE", "LIST_REFERENCE_RESOURCES", 0, {
requestId: "corr-list-400",
}),
}),
}),
);
await user.click(await screen.findByRole("button", { name: "지원 정보 확인" }));
expect(
await screen.findByRole("heading", { level: 1, name: "잠시 사용할 수 없습니다." }),
).toBeVisible();
expect(screen.getByText("지원 참조: corr-list-400")).toBeVisible();
expect(document.body).not.toHaveTextContent("REFERENCE-STATUS-DEMO");
});
it("shows no support reference on a status page opened directly", async () => {
renderReference(inputWith(), "/examples/reference-resources/status");
expect(
await screen.findByRole("heading", { level: 1, name: "잠시 사용할 수 없습니다." }),
).toBeVisible();
expect(document.body).not.toHaveTextContent("지원 참조");
});
it("settles the form after confirming an unknown create was applied", async () => {
const user = userEvent.setup();
const createResource = vi.fn(async () => ({
ok: false as const,
error: createFailure(
"SERVER_FAILURE",
"CREATE_REFERENCE_RESOURCE",
0,
{ effect: "MAYBE_APPLIED" },
),
}));
renderReference(
inputWith({ createResource }),
"/examples/reference-resources/new",
);
const name = await screen.findByRole("textbox", {
name: /새 항목 이름/,
});
await user.type(name, "Already created");
await user.click(screen.getByRole("button", { name: "저장" }));
await user.click(
await screen.findByRole("button", { name: "변경됨으로 확인" }),
);
expect(await screen.findByRole("status")).toHaveTextContent("저장했습니다.");
expect(name).toHaveValue("");
await user.click(screen.getByRole("button", { name: "저장" }));
expect(createResource).toHaveBeenCalledOnce();
});
it("treats an applied-confirmed failure as a settled create", async () => {
const user = userEvent.setup();
const createResource = vi.fn(async () => ({
ok: false as const,
error: createFailure(
"SERVER_FAILURE",
"CREATE_REFERENCE_RESOURCE",
0,
{ effect: "APPLIED_CONFIRMED" },
),
}));
renderReference(
inputWith({ createResource }),
"/examples/reference-resources/new",
);
const name = await screen.findByRole("textbox", {
name: /새 항목 이름/,
});
await user.type(name, "Committed despite response");
await user.click(screen.getByRole("button", { name: "저장" }));
expect(await screen.findByRole("status")).toHaveTextContent("저장했습니다.");
expect(name).toHaveValue("");
expect(
screen.queryByText("저장하지 못했습니다. 잠시 후 다시 시도해 주세요."),
).not.toBeInTheDocument();
await user.click(screen.getByRole("button", { name: "저장" }));
expect(createResource).toHaveBeenCalledOnce();
});
it("keeps stale data visible during refresh failure and recovers on retry", async () => {
const user = userEvent.setup();
const listResources = vi
.fn<ReferenceFeatureInput["listResources"]>()
.mockResolvedValueOnce({
ok: true,
value: [
{
resourceId: "existing",
title: "Existing",
createdAt: null,
},
],
})
.mockResolvedValueOnce({
ok: false,
error: createFailure(
"SERVER_FAILURE",
"LIST_REFERENCE_RESOURCES",
0,
),
})
.mockResolvedValue({
ok: true,
value: [
{
resourceId: "recovered",
title: "Recovered",
createdAt: null,
},
],
});
renderReference(inputWith({ listResources }));
await screen.findByText("Existing");
await user.click(screen.getByRole("button", { name: "새로고침" }));
expect(
await screen.findByText("기존 정보를 표시하고 있습니다."),
).toBeVisible();
expect(screen.getByText("Existing")).toBeVisible();
await user.click(screen.getByRole("button", { name: "다시 시도" }));
expect(await screen.findByText("Recovered")).toBeVisible();
await waitFor(() =>
expect(screen.queryByText("stale-degraded")).not.toBeInTheDocument(),
);
expect(listResources).toHaveBeenCalledTimes(3);
});
});