refactor: 리펙토링

tests/unit/opfs-worker-runtime.test.ts

@@ -537,6 +537,87 @@ describe("OPFS dedicated worker runtime", () => {
 });
 
 describe("OPFS worker client lifecycle", () => {
+  it("rejects a colliding concurrent request id without replacing the first RPC", async () => {
+    let listener: ((event: MessageEvent<unknown>) => void) | undefined;
+    const posted: OpfsWorkerRequest[] = [];
+    const worker: OpfsWorkerLike = {
+      postMessage(message) {
+        posted.push(message);
+      },
+      addEventListener(_type, next) {
+        listener = next;
+      },
+      removeEventListener() {
+        listener = undefined;
+      },
+    };
+    const gateway = createOpfsWorkerGateway({
+      worker,
+      policy: runtimePolicy,
+      createRequestId: () => "request_collision_1234",
+    });
+
+    const first = gateway.capabilities();
+    const second = gateway.capabilities();
+    expect(posted).toHaveLength(1);
+
+    listener?.({
+      data: {
+        requestId: "request_collision_1234",
+        ok: true,
+        value: {
+          available: true,
+          dedicatedWorkerRequired: true,
+          crossContextMutationLockAvailable: true,
+          synchronousAccessHandleAvailable: true,
+        },
+      },
+    } as MessageEvent<unknown>);
+    const secondResult = await second;
+    gateway.close();
+    await expect(first).resolves.toMatchObject({ ok: true });
+    expect(secondResult).toMatchObject({
+      ok: false,
+      error: { code: "UNAVAILABLE" },
+    });
+  });
+
+  it("rejects pending RPCs immediately when the worker reports a fatal event", async () => {
+    let failureListener: ((event: Event) => void) | undefined;
+    const worker: OpfsWorkerLike = {
+      postMessage() {},
+      addEventListener() {},
+      removeEventListener() {},
+      addFailureEventListener(listener) {
+        failureListener = listener;
+      },
+      removeFailureEventListener() {
+        failureListener = undefined;
+      },
+    };
+    const gateway = createOpfsWorkerGateway({
+      worker,
+      policy: runtimePolicy,
+      createRequestId: () => "request_crash_1234",
+    });
+    const pending = gateway.capabilities();
+
+    expect(failureListener).toBeTypeOf("function");
+    if (!failureListener) {
+      gateway.close();
+      return;
+    }
+    failureListener(new Event("error"));
+    await expect(pending).resolves.toMatchObject({
+      ok: false,
+      error: { code: "UNAVAILABLE" },
+    });
+    await expect(gateway.capabilities()).resolves.toMatchObject({
+      ok: false,
+      error: { code: "UNAVAILABLE" },
+    });
+  });
+
   it("scopes the open signal to verification and leaves the acquired source readable", async () => {
     let listener:
       | ((event: MessageEvent<unknown>) => void)