refactor: 프론트 템플릿 리펙토링

tests/features/reference-feature/reference-http-gateway.test.ts

@@ -1,9 +1,10 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it } from "vitest";
 
-import { createFailure } from "../../../src/contracts/errors.ts";
+import type { Result } from "../../../src/contracts/result.ts";
+import { createFailure, type ApiFailure } from "../../../src/contracts/errors.ts";
 import {
   createReferenceHttpGateway,
-  type RawReferenceHttpExecutor,
+  type ReferenceHttpBinding,
 } from "../../../src/features/reference-feature/adapters/reference-http-gateway.ts";
 import type { ReferenceResource } from "../../../src/features/reference-feature/domain/reference-resource.ts";
 
@@ -20,14 +21,42 @@ const resources = Object.freeze({
   }),
 }) satisfies Readonly<Record<string, ReferenceResource>>;
 
+type ScriptedResult = Result<
+  ReferenceResource | readonly ReferenceResource[],
+  ApiFailure
+>;
+
+function scriptedBinding(results: ScriptedResult[]) {
+  const calls: Array<
+    readonly [operationId: string, input: unknown, context: unknown]
+  > = [];
+  let index = 0;
+  const execute = (async (
+    operationId: string,
+    input: unknown,
+    context?: unknown,
+  ) => {
+    calls.push([operationId, input, context]);
+    const result = results[index];
+    index += 1;
+    if (!result) throw new Error("Missing scripted result");
+    return result;
+  }) as ReferenceHttpBinding["execute"];
+
+  return {
+    binding: Object.freeze({ execute }) satisfies ReferenceHttpBinding,
+    calls,
+  };
+}
+
 describe("reference HTTP operation gateway", () => {
-  it("builds the exact registered request for every gateway operation", async () => {
-    const execute = vi
-      .fn<RawReferenceHttpExecutor["execute"]>()
-      .mockResolvedValueOnce({ ok: true, value: [resources.first] })
-      .mockResolvedValueOnce({ ok: true, value: resources.created })
-      .mockResolvedValueOnce({ ok: true, value: resources.first });
-    const gateway = createReferenceHttpGateway({ execute });
+  it("delegates exact typed feature inputs to the capability binding", async () => {
+    const scripted = scriptedBinding([
+      { ok: true, value: [resources.first] },
+      { ok: true, value: resources.created },
+      { ok: true, value: resources.first },
+    ]);
+    const gateway = createReferenceHttpGateway(scripted.binding);
     const signal = new AbortController().signal;
 
     await expect(
@@ -40,67 +69,37 @@ describe("reference HTTP operation gateway", () => {
       gateway.get("reference-1", { signal }),
     ).resolves.toEqual({ ok: true, value: resources.first });
 
-    expect(execute.mock.calls).toEqual([
+    expect(scripted.calls).toEqual([
       [
-        {
-          operationId: "LIST_REFERENCE_RESOURCES",
-          routeId: "REFERENCE_RESOURCE_LIST",
-          searchParams: {
-            cursor: "next",
-            limit: 20,
-            tags: ["active"],
-          },
-          signal,
-        },
+        "LIST_REFERENCE_RESOURCES",
+        { cursor: "next", limit: 20, tags: ["active"] },
+        { signal },
       ],
       [
-        {
-          operationId: "CREATE_REFERENCE_RESOURCE",
-          routeId: "REFERENCE_RESOURCE_LIST",
-          body: { name: "Created", note: "safe note" },
-        },
+        "CREATE_REFERENCE_RESOURCE",
+        { name: "Created", note: "safe note" },
+        undefined,
       ],
       [
-        {
-          operationId: "GET_REFERENCE_RESOURCE",
-          routeId: "REFERENCE_RESOURCE_DETAIL",
-          pathParams: { resourceId: "reference-1" },
-          signal,
-        },
+        "GET_REFERENCE_RESOURCE",
+        { resourceId: "reference-1" },
+        { signal },
       ],
     ]);
   });
 
-  it("preserves a validated raw failure without casting it into success", async () => {
+  it("preserves a capability-normalized failure across the feature gateway", async () => {
     const failure = createFailure(
       "SCHEMA_MISMATCH",
       "GET_REFERENCE_RESOURCE",
       0,
     );
-    const execute = vi
-      .fn<RawReferenceHttpExecutor["execute"]>()
-      .mockResolvedValue({ ok: false, error: failure });
-    const gateway = createReferenceHttpGateway({ execute });
+    const scripted = scriptedBinding([{ ok: false, error: failure }]);
+    const gateway = createReferenceHttpGateway(scripted.binding);
 
     await expect(gateway.get("invalid")).resolves.toEqual({
       ok: false,
       error: failure,
     });
   });
-
-  it("fails closed when a raw success does not match its operation result", async () => {
-    const execute = vi
-      .fn<RawReferenceHttpExecutor["execute"]>()
-      .mockResolvedValue({ ok: true, value: { id: "not-a-list" } });
-    const gateway = createReferenceHttpGateway({ execute });
-
-    await expect(gateway.list({ limit: 20 })).resolves.toMatchObject({
-      ok: false,
-      error: {
-        kind: "MAPPING_CONTRACT_VIOLATION",
-        code: "BOUND_RESULT_TYPE_MISMATCH",
-        operationId: "LIST_REFERENCE_RESOURCES",
-      },
-    });
-  });
 });