diff --git a/src/features/reference-feature/presentation/reference-resource-form-page.tsx b/src/features/reference-feature/presentation/reference-resource-form-page.tsx index 599bdd6e..d54e0eb1 100644 --- a/src/features/reference-feature/presentation/reference-resource-form-page.tsx +++ b/src/features/reference-feature/presentation/reference-resource-form-page.tsx @@ -1,5 +1,5 @@ import { useCallback } from "react"; -import { useNavigate } from "react-router-dom"; +import { Link, useNavigate } from "react-router-dom"; import { Button, @@ -13,6 +13,8 @@ import { useAppForm, useDirtyNavigationGuard, } from "../../../presentation/design-system/index.ts"; +import { useQueryInvalidationCoordinator } from "../../../presentation/adapters/query/query-invalidation-provider.tsx"; +import { REFERENCE_RESOURCE_INVALIDATION_TOPIC } from "../contracts/reference-feature-contract.ts"; import { REFERENCE_FORM_DEFAULTS, referenceResourceFormSchema, @@ -29,6 +31,7 @@ const FIELD_LABELS = Object.freeze({ export default function ReferenceResourceFormPage() { const navigate = useNavigate(); const mutation = useReferenceCreate(); + const invalidation = useQueryInvalidationCoordinator(); const submit = useCallback( (command: ReturnType) => mutation.submit(command), @@ -127,18 +130,31 @@ export default function ReferenceResourceFormPage() { } feedback={ mutationEffectUnknown ? ( - { - void mutation.reconcileUnknownEffect(resolution).then(() => { - if (resolution === "APPLIED") { - form.settleApplied(); - } else { - form.settleNotApplied(); - } - }); - }} - /> + <> + { + void mutation + .reconcileUnknownEffect(resolution) + .then(form.settleApplied); + }} + onResendUnknownEffect={() => { + void form.resendUnknown(mutation.resendUnknownEffect); + }} + /> +

+ { + void invalidation + ?.invalidate([REFERENCE_RESOURCE_INVALIDATION_TOPIC]) + .catch(() => {}); + }} + > + 목록을 새로 불러와 확인 + +

+ ) : form.result === "success" ? (

저장했습니다.

) : form.result === "conflict" ? ( diff --git a/src/presentation/adapters/query/application-query.ts b/src/presentation/adapters/query/application-query.ts index 696869f0..c747c916 100644 --- a/src/presentation/adapters/query/application-query.ts +++ b/src/presentation/adapters/query/application-query.ts @@ -219,9 +219,19 @@ type ApplicationMutationController = Readonly<{ state: AsyncState; submit(input: Input): Promise>; resolveConflict(): Promise; + /** + * Settles the oldest unknown effect. `NOT_APPLIED` needs evidence (an + * inspect operation or a server read); without it, resend instead. + */ reconcileUnknownEffect( resolution: "APPLIED" | "NOT_APPLIED", ): Promise; + /** + * D-1. Sends the oldest unknown-effect request again with its original + * intent, so a keyed command carries the same `Idempotency-Key`. Resolves + * to `null` when nothing is waiting to be resent. + */ + resendUnknownEffect(): Promise | null>; }>; type MutationExecution = @@ -231,7 +241,10 @@ type MutationExecution = type MutationAdmission = { sequence: number; state: "ACTIVE" | "UNKNOWN" | "RECONCILING" | "SETTLED"; + readonly input: unknown; intent: MutationIntent | null; + /** Held while UNKNOWN so the same input keeps the same identity token. */ + identityLease: Readonly<{ release(): void }> | null; scope: CacheScopeSnapshot | null; optimisticLayer: OptimisticLayerLease | null; optimisticQueryKey: readonly unknown[] | null; @@ -486,10 +499,19 @@ export function useApplicationMutation( ), }); } + // D-1. Saving the same canonical input again is the same logical + // request: it reuses the unknown admission's intent (and key). + const replayed = unknownEffectChannel.admissions.find( + (candidate) => + candidate.state === "UNKNOWN" && + candidate.intent?.canonicalInputIdentity === identity, + ); const admission: MutationAdmission = { sequence: unknownEffectChannel.nextSequence++, state: "ACTIVE", + input, intent: null, + identityLease: null, scope: scope ?? null, optimisticLayer: null, optimisticQueryKey: optimistic?.queryKey ?? null, @@ -498,6 +520,12 @@ export function useApplicationMutation( }; unknownEffectChannel.admissions.push(admission); unknownEffectChannel.registry.activeAdmissions += 1; + if (replayed) { + // The new attempt re-applies its own optimistic layer and owns the + // outcome from here. + replayed.optimisticLayer?.reconcile("NOT_APPLIED"); + settleMutationAdmission(unknownEffectChannel, replayed); + } notifyUnknownEffectChannel(unknownEffectChannel); setConflict(null); mutation.reset(); @@ -506,11 +534,13 @@ export function useApplicationMutation( const pending = (async (): Promise> => { let execution: MutationExecution; if (scope) { - const intent = mutationIntentFactory.create({ - operationId: mutationOperationId, - canonicalInputIdentity: identity, - requiresIdempotencyKey, - }); + const intent = + replayed?.intent ?? + mutationIntentFactory.create({ + operationId: mutationOperationId, + canonicalInputIdentity: identity, + requiresIdempotencyKey, + }); admission.intent = intent; execution = Object.freeze({ kind: "BOUND", input, intent }); } else { @@ -572,6 +602,10 @@ export function useApplicationMutation( optimisticLayer?.markUncertain(); if (!scope || scope.isCurrent()) { admission.state = "UNKNOWN"; + if (identityLease) { + identityLease.acquire(); + admission.identityLease = identityLease; + } notifyUnknownEffectChannel(unknownEffectChannel); } else { settleMutationAdmission(unknownEffectChannel, admission); @@ -699,6 +733,19 @@ export function useApplicationMutation( [mutation, queryClient, unknownEffectChannel], ); + const resendUnknownEffect = useCallback(async () => { + const head = unknownEffectChannel?.admissions[0]; + if ( + !head || + head.state !== "UNKNOWN" || + !head.intent || + unknownEffectChannel?.reconciliationInFlight + ) { + return null; + } + return submit(head.input as Input); + }, [submit, unknownEffectChannel]); + const unknownEffectHead = unknownEffectChannel?.admissions[0]; return Object.freeze({ @@ -714,6 +761,7 @@ export function useApplicationMutation( submit, resolveConflict, reconcileUnknownEffect, + resendUnknownEffect, }); } @@ -822,6 +870,8 @@ function markMutationAdmissionSettled( ): void { if (admission.state === "SETTLED") return; admission.state = "SETTLED"; + admission.identityLease?.release(); + admission.identityLease = null; channel.registry.activeAdmissions = Math.max( 0, channel.registry.activeAdmissions - 1, diff --git a/src/presentation/components/async-surface.tsx b/src/presentation/components/async-surface.tsx index 08bde41e..836c39db 100644 --- a/src/presentation/components/async-surface.tsx +++ b/src/presentation/components/async-surface.tsx @@ -96,9 +96,10 @@ export type AsyncSurfaceProps = Readonly<{ onAction?: () => void; onRetry?: () => void; onResolveConflict?: () => void; - onReconcileUnknownEffect?: ( - resolution: "APPLIED" | "NOT_APPLIED", - ) => void; + /** Only `APPLIED` is offered: "not applied" needs evidence the UI lacks. */ + onReconcileUnknownEffect?: (resolution: "APPLIED") => void; + /** D-1. Resends the unknown request with its original intent and key. */ + onResendUnknownEffect?: () => void; }>; export function AsyncSurface({ @@ -109,6 +110,7 @@ export function AsyncSurface({ onRetry, onResolveConflict, onReconcileUnknownEffect, + onResendUnknownEffect, }: AsyncSurfaceProps) { const { message } = useLocale(); if (state.base === "idle") return idle ?? null; @@ -155,18 +157,15 @@ export function AsyncSurface({ ) : null} {state.indicator === "mutation-effect-unknown" && onReconcileUnknownEffect ? ( - <> - - - + + ) : null} + {state.indicator === "mutation-effect-unknown" && + onResendUnknownEffect ? ( + ) : null} ) : null} diff --git a/src/presentation/forms/use-app-form.ts b/src/presentation/forms/use-app-form.ts index bf389ab3..a6b26482 100644 --- a/src/presentation/forms/use-app-form.ts +++ b/src/presentation/forms/use-app-form.ts @@ -175,6 +175,44 @@ export function useAppForm< setResult("idle"); }, []); + const applyOutcome = useCallback( + (outcome: FormResult, submittedValues: Values) => { + if (outcome.ok) { + settleSuccessfulValues(submittedValues); + return; + } + if (outcome.error.kind === "VALIDATION_REJECTED") { + unknownSubmissionRef.current = null; + const mapped = mapValidationFailureToFields( + outcome.error, + allowedServerFields, + message, + ); + setFieldErrors(mapped.fieldErrors); + setFormErrors(mapped.formErrors); + setResult("validation-error"); + focusFirstError(mapped.fieldErrors); + } else if (outcome.error.effect === "MAYBE_APPLIED") { + unknownSubmissionRef.current = submittedValues; + setFormErrors([]); + setResult("effect-unknown"); + } else if (outcome.error.effect === "APPLIED_CONFIRMED") { + settleSuccessfulValues(submittedValues); + } else if (outcome.error.kind === "CONFLICT") { + unknownSubmissionRef.current = null; + setFormErrors([ + message("form.conflict"), + ]); + setResult("conflict"); + } else { + unknownSubmissionRef.current = null; + setFormErrors([message("form.unavailable")]); + setResult("unavailable"); + } + }, + [allowedServerFields, focusFirstError, message, settleSuccessfulValues], + ); + const validateAndSubmit = useCallback( async (): Promise | null> => { setFieldErrors({} as FieldErrors); @@ -205,38 +243,7 @@ export function useAppForm< setPending(true); try { const outcome = await submit(command); - if (outcome.ok) { - settleSuccessfulValues(parsed.data); - return outcome; - } - if (outcome.error.kind === "VALIDATION_REJECTED") { - unknownSubmissionRef.current = null; - const mapped = mapValidationFailureToFields( - outcome.error, - allowedServerFields, - message, - ); - setFieldErrors(mapped.fieldErrors); - setFormErrors(mapped.formErrors); - setResult("validation-error"); - focusFirstError(mapped.fieldErrors); - } else if (outcome.error.effect === "MAYBE_APPLIED") { - unknownSubmissionRef.current = parsed.data; - setFormErrors([]); - setResult("effect-unknown"); - } else if (outcome.error.effect === "APPLIED_CONFIRMED") { - settleSuccessfulValues(parsed.data); - } else if (outcome.error.kind === "CONFLICT") { - unknownSubmissionRef.current = null; - setFormErrors([ - message("form.conflict"), - ]); - setResult("conflict"); - } else { - unknownSubmissionRef.current = null; - setFormErrors([message("form.unavailable")]); - setResult("unavailable"); - } + applyOutcome(outcome, parsed.data); return outcome; } finally { setPending(false); @@ -244,11 +251,11 @@ export function useAppForm< }, [ allowedServerFields, + applyOutcome, focusFirstError, mapToCommand, message, schema, - settleSuccessfulValues, submit, values, ], @@ -270,6 +277,37 @@ export function useAppForm< [validateAndSubmit], ); + /** + * D-1. Runs a resend of the unknown submission (for example + * `mutation.resendUnknownEffect`) through the same outcome handling as a + * submit. The form never builds a new command here: the caller resends the + * original request with its original key. + */ + const resendUnknown = useCallback( + ( + send: () => Promise | null>, + ): Promise | null> => { + if (pendingRef.current) return pendingRef.current; + // After a remount the form no longer holds the submitted values. + const submittedValues = unknownSubmissionRef.current ?? values; + const resend = (async () => { + setPending(true); + try { + const outcome = await send(); + if (outcome) applyOutcome(outcome, submittedValues); + return outcome; + } finally { + setPending(false); + } + })().finally(() => { + pendingRef.current = null; + }); + pendingRef.current = resend; + return resend; + }, + [applyOutcome, values], + ); + return Object.freeze({ formId, values, @@ -284,6 +322,7 @@ export function useAppForm< focusField, setValue, submitForm, + resendUnknown, reset, settleApplied, settleNotApplied, diff --git a/src/presentation/i18n/catalog.ts b/src/presentation/i18n/catalog.ts index 9bf90c7c..5fed1810 100644 --- a/src/presentation/i18n/catalog.ts +++ b/src/presentation/i18n/catalog.ts @@ -12,7 +12,7 @@ const PLATFORM_KO_MESSAGES = { "action.contactSupport": "지원 정보 확인", "action.resolveConflict": "충돌 해결", "action.confirmMutationApplied": "변경됨으로 확인", - "action.confirmMutationNotApplied": "변경되지 않음으로 확인", + "action.resendMutation": "같은 요청으로 다시 보내기", "action.continueEditing": "계속 작성", "action.discardAndLeave": "변경 버리고 이동", "action.signIn": "로그인 시작", @@ -171,7 +171,7 @@ const PLATFORM_EN_MESSAGES = { "action.contactSupport": "View support information", "action.resolveConflict": "Resolve conflict", "action.confirmMutationApplied": "Confirm the change was applied", - "action.confirmMutationNotApplied": "Confirm the change was not applied", + "action.resendMutation": "Send the same request again", "action.continueEditing": "Continue editing", "action.discardAndLeave": "Discard and leave", "action.signIn": "Start sign-in", diff --git a/tests/component/application-mutation-admission.test.tsx b/tests/component/application-mutation-admission.test.tsx index 64d7c43e..d569e635 100644 --- a/tests/component/application-mutation-admission.test.tsx +++ b/tests/component/application-mutation-admission.test.tsx @@ -8,6 +8,9 @@ import { useApplicationMutation, } from "../../src/presentation/adapters/query/application-query.ts"; import type { MutationIntentFactory } from "../../src/application/ports/mutation-intent-factory.ts"; +import { createFailure } from "../../src/contracts/errors.ts"; +import type { MutationIntent } from "../../src/contracts/mutation-intent.ts"; +import { createRuntimeIdentityRegistry } from "../../src/contracts/query-keys.ts"; import { MUTATION_COORDINATOR_BOUNDS } from "../../src/contracts/server-state.ts"; import { RESOURCE_INVALIDATION_TOPIC, @@ -371,4 +374,124 @@ describe("application mutation intent admission", () => { }); }); + describe("unknown-effect replay (D-1)", () => { + function replayScope() { + let token = 0; + return { + ...scopeSnapshot(), + identities: createRuntimeIdentityRegistry({ + tokenFactory: () => `replay-identity-token-${String(++token).padStart(4, "0")}`, + }), + }; + } + + function renderKeyedCreate( + outcomes: ApplicationResult[], + ) { + const client = queryClient(); + const intents: MutationIntent[] = []; + const execute = vi.fn( + async ( + input: string, + context: Readonly<{ signal: AbortSignal; intent: MutationIntent }>, + ): Promise> => { + intents.push(context.intent); + return outcomes.shift() ?? { ok: true, value: input }; + }, + ); + const scope = replayScope(); + const hook = renderHook( + () => + useApplicationMutation({ + definitionId: "replay-intent-v1", + definitionVersion: 1, + operationId: "CREATE_REPLAYED", + requiresIdempotencyKey: true, + owner: "platform-test", + duplicatePolicy: "REJECT_WHILE_ACTIVE", + scope, + execute, + invalidate: [], + }), + { wrapper: wrapper(client) }, + ); + return { hook, intents, execute }; + } + + const unknown: ApplicationResult = { + ok: false, + error: createFailure("SERVER_FAILURE", "CREATE_REPLAYED", 0, { + effect: "MAYBE_APPLIED", + }), + }; + + it("sends the same intent when the same input is saved again after an unknown effect", async () => { + const { hook, intents } = renderKeyedCreate([unknown]); + await act(() => hook.result.current.submit("same-input")); + expect(hook.result.current.state.indicator).toBe( + "mutation-effect-unknown", + ); + + await act(() => hook.result.current.submit("same-input")); + + expect(intents).toHaveLength(2); + expect(intents[1]).toBe(intents[0]); + expect(intents[1]?.idempotencyKey).toBe("key-1"); + await waitFor(() => + expect(hook.result.current.state.indicator).toBeNull(), + ); + }); + + it("mints a new key when the input changes after an unknown effect", async () => { + const { hook, intents } = renderKeyedCreate([unknown]); + await act(() => hook.result.current.submit("first-input")); + await act(() => hook.result.current.submit("changed-input")); + + expect(intents.map((intent) => intent.idempotencyKey)).toEqual([ + "key-1", + "key-2", + ]); + // The first request is still unresolved; a different request cannot + // settle it. + expect(hook.result.current.state.indicator).toBe( + "mutation-effect-unknown", + ); + }); + + it("resends the unknown head request with its original key", async () => { + const { hook, intents, execute } = renderKeyedCreate([unknown, unknown]); + await act(() => hook.result.current.submit("resent-input")); + + let resent: ApplicationResult | null | undefined; + await act(async () => { + resent = await hook.result.current.resendUnknownEffect(); + }); + expect(resent).toMatchObject({ + ok: false, + error: { effect: "MAYBE_APPLIED" }, + }); + await act(async () => { + resent = await hook.result.current.resendUnknownEffect(); + }); + + expect(resent).toEqual({ ok: true, value: "resent-input" }); + expect(execute.mock.calls.map(([input]) => input)).toEqual([ + "resent-input", + "resent-input", + "resent-input", + ]); + expect(new Set(intents.map((intent) => intent.idempotencyKey))).toEqual( + new Set(["key-1"]), + ); + await waitFor(() => + expect(hook.result.current.state.indicator).toBeNull(), + ); + // Nothing is left to resend once the effect is settled. + await act(async () => { + resent = await hook.result.current.resendUnknownEffect(); + }); + expect(resent).toBeNull(); + expect(execute).toHaveBeenCalledTimes(3); + }); + }); }); diff --git a/tests/component/async-surface.test.tsx b/tests/component/async-surface.test.tsx index 24d1ddd0..7cb44269 100644 --- a/tests/component/async-surface.test.tsx +++ b/tests/component/async-surface.test.tsx @@ -53,10 +53,11 @@ describe("async UI state matrix", () => { }); }); - it("renders unknown mutation effects with reconciliation-only actions", async () => { + it("renders unknown mutation effects with confirm-applied and resend only", async () => { const user = userEvent.setup(); const retry = vi.fn(); const reconcile = vi.fn(); + const resend = vi.fn(); const state = deriveAsyncState({ data: ["value"], hasMutationEffectUnknown: true, @@ -67,6 +68,7 @@ describe("async UI state matrix", () => { state={state} onRetry={retry} onReconcileUnknownEffect={reconcile} + onResendUnknownEffect={resend} > existing content
, @@ -81,12 +83,15 @@ describe("async UI state matrix", () => { expect( screen.queryByRole("button", { name: "다시 시도" }), ).not.toBeInTheDocument(); + expect( + screen.queryByRole("button", { name: "변경되지 않음으로 확인" }), + ).not.toBeInTheDocument(); await user.click(screen.getByRole("button", { name: "변경됨으로 확인" })); await user.click( - screen.getByRole("button", { name: "변경되지 않음으로 확인" }), + screen.getByRole("button", { name: "같은 요청으로 다시 보내기" }), ); - expect(reconcile).toHaveBeenNthCalledWith(1, "APPLIED"); - expect(reconcile).toHaveBeenNthCalledWith(2, "NOT_APPLIED"); + expect(reconcile).toHaveBeenCalledExactlyOnceWith("APPLIED"); + expect(resend).toHaveBeenCalledOnce(); expect(retry).not.toHaveBeenCalled(); }); diff --git a/tests/features/reference-feature/reference-page.test.tsx b/tests/features/reference-feature/reference-page.test.tsx index e65aae92..a09ad43a 100644 --- a/tests/features/reference-feature/reference-page.test.tsx +++ b/tests/features/reference-feature/reference-page.test.tsx @@ -337,25 +337,29 @@ describe("reference feature page states", () => { expect(screen.getByLabelText("설명")).toHaveValue("Keep this input"); }); - it("blocks resubmit and exposes only reconciliation for an unknown create effect", async () => { + it("blocks a new save and resends an unknown create with the same key", 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" }, - ), - })); + const createResource = vi + .fn() + .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", ); - await user.type( - await screen.findByRole("textbox", { name: /새 항목 이름/ }), - "Unknown result", - ); + const name = await screen.findByRole("textbox", { name: /새 항목 이름/ }); + await user.type(name, "Unknown result"); await user.click(screen.getByRole("button", { name: "저장" })); expect( @@ -365,22 +369,28 @@ describe("reference feature page states", () => { 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( - screen.getByRole("textbox", { name: /새 항목 이름/ }), - ).toHaveValue("Unknown result"); + expect(name).toHaveValue("Unknown result"); await user.click( - screen.getByRole("button", { name: "변경되지 않음으로 확인" }), + screen.getByRole("button", { name: "같은 요청으로 다시 보내기" }), ); - await waitFor(() => - expect(screen.getByRole("button", { name: "저장" })).toBeEnabled(), - ); - expect(createResource).toHaveBeenCalledOnce(); - expect( - screen.getByRole("textbox", { name: /새 항목 이름/ }), - ).toHaveValue("Unknown result"); + + 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("settles the form after confirming an unknown create was applied", async () => { diff --git a/tests/features/reference-feature/reference-production-vertical.test.tsx b/tests/features/reference-feature/reference-production-vertical.test.tsx index 18575f31..47a35f7b 100644 --- a/tests/features/reference-feature/reference-production-vertical.test.tsx +++ b/tests/features/reference-feature/reference-production-vertical.test.tsx @@ -2,6 +2,7 @@ import { render, screen } from "@testing-library/react"; import userEvent from "@testing-library/user-event"; +import { http, HttpResponse } from "msw"; import { afterAll, afterEach, @@ -118,4 +119,50 @@ describe("reference feature production vertical path", () => { expect(createRequests).toHaveBeenCalledWith({ name: "Created" }); expect(listRequests.mock.calls.length).toBeGreaterThanOrEqual(2); }); + + it("resends a create whose 504 lost the response with the same Idempotency-Key", async () => { + const user = userEvent.setup(); + const idempotencyKeys: (string | null)[] = []; + mockApi.server.use( + http.post("https://api.test/api/reference-resources", async ({ request }) => { + idempotencyKeys.push(request.headers.get("idempotency-key")); + // The first request reaches the server; only its response is lost. + if (idempotencyKeys.length === 1) { + return new HttpResponse(null, { status: 504 }); + } + const body = (await request.json()) as { name: string }; + return HttpResponse.json( + { + id: "reference-created", + name: body.name, + createdAt: "2026-07-26T00:00:00.000Z", + }, + { status: 201 }, + ); + }), + ); + const composition = await createRuntimeComposition({ + fetcher: absoluteFetch, + host: {}, + }); + window.history.pushState({}, "", "/examples/reference-resources/new"); + render(); + + await user.click( + await screen.findByRole("button", { name: "로그인 시작" }), + ); + await user.type( + await screen.findByRole("textbox", { name: /새 항목 이름/ }), + "Lost response", + ); + await user.click(screen.getByRole("button", { name: "저장" })); + await user.click( + await screen.findByRole("button", { name: "같은 요청으로 다시 보내기" }), + ); + + expect(await screen.findByText("저장했습니다.")).toBeVisible(); + expect(idempotencyKeys).toHaveLength(2); + expect(idempotencyKeys[0]).toMatch(/^[\x21-\x7e]+$/u); + expect(idempotencyKeys[1]).toBe(idempotencyKeys[0]); + }); });