문제
lazy route 화면을 findBy*·waitFor 기본값(1초)으로 기다리는 테스트가 1코어
부하에서 코드와 무관하게 떨어진다. 수정 전 재현에서
runtime-application.test.tsx:65 "Unable to find role=heading name=Clean
Architecture Frontend"와 reference-production-vertical.test.tsx:103
"Unable to find role=button name=로그인 시작"이 났다. 두 DOM 모두
route-loading(aria-busy) 상태였다. 지난 리뷰는 router.test.tsx:244-250도
같은 이유로 실패했다고 적었다. React 19는 Suspense를 풀 때마다 실제 300ms
타이머(FALLBACK_THROTTLE_MS)를 기다린다. context route 표와 lazy 페이지를
거치는 화면은 렌더링 전에 1초 중 600ms를 쓴다. 이 사정을 아는 파일만
호출마다 { timeout: 5000 }을 붙이거나(7개 파일 13곳) 파일 단위로
configure를 바꿨다(reference-page). 새 테스트 작성자는 이 규칙을 알 방법이
없다.
고른 방법
tests/setup.ts에서 configure({ asyncUtilTimeout: 5_000 })를 한 번 정하고,
같은 값을 반복하던 호출·파일 단위 override를 지웠다. findBy*·waitFor는
DOM 변화가 오면 바로 끝나므로 기한은 멈춤을 알리는 용도뿐이다. 10초 테스트
제한의 절반이라 진짜 멈춤은 여전히 Testing Library의 DOM 덤프와 함께
실패한다. 기한을 늘리는 방식이라 고른 이유를 setup에 주석으로 남겼다.
버린 대안
- 가짜 시계: Testing Library는 Jest의 가짜 타이머만 알아본다
(jestFakeTimersAreEnabled가 jest 전역을 본다). Vitest 가짜 타이머에서
waitFor는 자기 타이머가 멈춰 끝나지 않는다. MSW와 user-event도 실제
시계로 돈다.
- route chunk를 테스트에서 미리 import하기: chunk를 받아도 React의 300ms
reveal 타이머와 렌더링 비용은 그대로 기한 안에 남는다. 테스트가 route
모듈 목록을 따로 알아야 한다.
- 실패한 파일에만 timeout 붙이기: 지금 상태와 같다. 다음 lazy 화면
테스트에서 같은 실패가 반복된다.
위험·한계
- 기다리다 실패하는 테스트는 실패까지 1초가 아니라 5초 걸린다. 부재를
findBy·waitFor의 실패로 확인하는 테스트는 없다(grep으로 확인).
- 가짜 타이머를 쓰는 테스트의 waitFor는 이 값과 무관하다(가짜 시간).
검증
- RED(수정 전, taskset -c 0 + 같은 코어의 바쁜 이웃 1개, --maxWorkers=4,
component·features·integration·platform/cardinality): 3회 중 1회 위 두
테스트 실패.
- GREEN(같은 조건): 대상 6개 파일 6회, 넓은 묶음 5회 모두 통과. 바쁜
이웃 2개로 3회 돌렸을 때도 이 커밋이 다루는 테스트는 모두 통과했다.
넓은 묶음 한 번의 시간은 RED 91~111s(실패가 몰린 209s 회차 제외)
-> GREEN 86~88s다.
- 기본 코어: tests/unit·component·integration 212파일 2,734개, features·
platform·architecture·contract·runtime-schema 60파일 403개 통과.
tsc -p tsconfig.test.json, 바꾼 파일 eslint 통과.
Refs: docs/reviews/2026-09-29-maturity-review/10-tests-fast-layers.md
628 lines
21 KiB
TypeScript
628 lines
21 KiB
TypeScript
// @vitest-environment jsdom
|
|
|
|
import {
|
|
QueryClient,
|
|
QueryClientProvider,
|
|
} from "@tanstack/react-query";
|
|
import { render, 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 { AuthSessionPort } from "../../../src/application/ports/auth-session-port.ts";
|
|
import type { MutationIntentFactory } from "../../../src/application/ports/mutation-intent-factory.ts";
|
|
import type {
|
|
ReferenceFeatureInput,
|
|
ReferenceResult,
|
|
} from "../../../src/features/reference-feature/application/reference-feature-api.ts";
|
|
import {
|
|
REFERENCE_FEATURE_ID,
|
|
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 type { QueryInvalidationCoordinator } from "../../../src/contracts/query-invalidation.ts";
|
|
import { QueryInvalidationProvider } from "../../../src/presentation/adapters/query/query-invalidation-provider.tsx";
|
|
import { MutationIntentProvider } from "../../../src/presentation/adapters/query/mutation-intent-provider.tsx";
|
|
import { ServerStateScopeProvider } from "../../../src/presentation/adapters/query/server-state-scope-provider.tsx";
|
|
import { createServerStateScopeRuntime } from "../../../src/adapters/query-cache/server-state-scope-runtime.ts";
|
|
import { ApplicationProvider } from "../../../src/presentation/providers/application-provider.tsx";
|
|
import { PreferenceProviders } from "../../../src/presentation/providers/preference-providers.tsx";
|
|
import { AppRouter } from "../../../src/presentation/routes/app-router.tsx";
|
|
import { createTestApplication } from "../../helpers/create-test-application.ts";
|
|
|
|
function renderReference(
|
|
input: ReferenceFeatureInput,
|
|
url = "/examples/reference-resources?limit=5",
|
|
session: AuthSessionPort = createDemoSessionAdapter("authenticated"),
|
|
) {
|
|
window.history.pushState({}, "", url);
|
|
const client = new QueryClient({
|
|
defaultOptions: {
|
|
queries: { retry: false, gcTime: Infinity },
|
|
mutations: { retry: false },
|
|
},
|
|
});
|
|
const invalidation: QueryInvalidationCoordinator = Object.freeze({
|
|
async invalidate() {},
|
|
beginMutation() {
|
|
return Object.freeze({
|
|
async release() {},
|
|
});
|
|
},
|
|
async resetLocal() {},
|
|
dispose() {},
|
|
});
|
|
const serverStateScope = createServerStateScopeRuntime({
|
|
session,
|
|
queryInvalidation: invalidation,
|
|
});
|
|
let intentSequence = 0;
|
|
const mutationIntentFactory: MutationIntentFactory = Object.freeze({
|
|
create(input) {
|
|
intentSequence += 1;
|
|
return Object.freeze({
|
|
intentId: `reference-page-intent-${intentSequence}`,
|
|
operationId: input.operationId,
|
|
canonicalInputIdentity: input.canonicalInputIdentity,
|
|
...(input.requiresIdempotencyKey
|
|
? { idempotencyKey: `reference-page-key-${intentSequence}` }
|
|
: {}),
|
|
createdAtMonotonicMs: intentSequence,
|
|
});
|
|
},
|
|
});
|
|
return Object.assign(render(
|
|
<MutationIntentProvider factory={mutationIntentFactory}>
|
|
<QueryClientProvider client={client}>
|
|
<ServerStateScopeProvider runtime={serverStateScope}>
|
|
<QueryInvalidationProvider coordinator={invalidation}>
|
|
<ApplicationProvider
|
|
application={createTestApplication({
|
|
session,
|
|
featureInputs: { [REFERENCE_FEATURE_ID]: input },
|
|
})}
|
|
>
|
|
<PreferenceProviders>
|
|
<AppRouter />
|
|
</PreferenceProviders>
|
|
</ApplicationProvider>
|
|
</QueryInvalidationProvider>
|
|
</ServerStateScopeProvider>
|
|
</QueryClientProvider>
|
|
</MutationIntentProvider>,
|
|
), { client });
|
|
}
|
|
|
|
function inputWith(
|
|
overrides: Partial<ReferenceFeatureInput> = {},
|
|
): ReferenceFeatureInput {
|
|
return {
|
|
listResources: async () => ({ ok: true, value: [] }),
|
|
createResource: async ({ name }) => ({
|
|
ok: true,
|
|
value: {
|
|
resourceId: "created",
|
|
title: name,
|
|
createdAt: null,
|
|
},
|
|
}),
|
|
getResource: async (resourceId) => ({
|
|
ok: true,
|
|
value: {
|
|
resourceId,
|
|
title: "Detail",
|
|
createdAt: null,
|
|
},
|
|
}),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("reference feature page states", () => {
|
|
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();
|
|
expect(
|
|
screen.getByRole("link", { name: "목록을 새로 불러와 확인" }),
|
|
).toHaveAttribute("href", "/examples/reference-resources");
|
|
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));
|
|
}
|
|
},
|
|
);
|
|
|
|
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);
|
|
});
|
|
});
|