@evolu/common 8.12.0 → 8.13.0

package/src/Task.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, mock } from "node:test";
+import { runInNewContext } from "node:vm";
 import {
   assertEqual,
   assertErr,
@@ -673,6 +674,211 @@ describe("Run", () => {
     );
   });
 
+  describe("SuppressedError from cleanup", () => {
+    const cleanupAbortError = createAbortError({
+      type: "CleanupAbortReason",
+    });
+    const throwCleanupAbortError = (): void => {
+      AbortSignal.abort(cleanupAbortError).throwIfAborted();
+    };
+
+    it("aborts an AbortableFiber whose cleanup observes the abort", async () => {
+      await using run = testCreateRun();
+
+      const fiber = run.abortable(async (run) => {
+        await using stack = new AsyncDisposableStack();
+        stack.defer(async () => {
+          await run(waitForAbort);
+        });
+        await run(waitForAbort);
+        return ok();
+      });
+      fiber.abort(testAbortReason);
+
+      assertEqual(await fiber, err(testAbortError));
+      assertEqual(run.deps.reportDefect.getDefects(), []);
+      assertFalse(run.signal.aborted);
+    });
+
+    it("reports only the panic when cleanup observes its abort", async () => {
+      await using run = testCreateRun();
+
+      const fiber = run(async (run) => {
+        await using stack = new AsyncDisposableStack();
+        stack.defer(async () => {
+          await run(waitForAbort);
+        });
+        await run(waitForAbort);
+        return ok();
+      });
+      const panicAbortError = run.panic(new Error("boom"));
+
+      await assertRejects(fiber, panicAbortError);
+      assertEqual(run.deps.reportDefect.getDefects(), [panicAbortError]);
+    });
+
+    it("aborts with the last cleanup AbortError as try/finally does", async () => {
+      await using run = testCreateRun();
+
+      const usingFiber = run.abortable(async (run) => {
+        using _resource = { [Symbol.dispose]: throwCleanupAbortError };
+        await run(waitForAbort);
+        return ok();
+      });
+      const finallyFiber = run.abortable(async (run) => {
+        try {
+          await run(waitForAbort);
+        } finally {
+          throwCleanupAbortError();
+        }
+        return ok();
+      });
+      usingFiber.abort(testAbortReason);
+      finallyFiber.abort(testAbortReason);
+
+      assertEqual(await usingFiber, err(cleanupAbortError));
+      assertEqual(await finallyFiber, err(cleanupAbortError));
+      assertEqual(run.deps.reportDefect.getDefects(), []);
+    });
+
+    it("reports a created Run finalizer defect once during abort", async () => {
+      await using run = testCreateRun();
+      const defect = new Error("finalizer failed");
+
+      const fiber = run.abortable(async (run) => {
+        await using createdRun = run.create();
+        createdRun.defer(() => {
+          throw defect;
+        });
+        await run(waitForAbort);
+        return ok();
+      });
+      fiber.abort(testAbortReason);
+
+      const result = await fiber;
+      assertErr(result);
+      assertPanicAbortError(result.error, defect);
+      assertEqual(run.deps.reportDefect.getDefects(), [result.error]);
+    });
+
+    it("reports a cleanup defect during abort as the whole SuppressedError", async () => {
+      await using run = testCreateRun();
+      const defect = new Error("cleanup failed");
+
+      const fiber = run.abortable(async (run) => {
+        using _resource = {
+          [Symbol.dispose]: () => {
+            throw defect;
+          },
+        };
+        await run(waitForAbort);
+        return ok();
+      });
+      fiber.abort(testAbortReason);
+
+      const result = await fiber;
+      assertErr(result);
+      assertType(AbortError, result.error);
+      const suppressedError = result.error.reason.defect;
+      assertInstanceOf(suppressedError, SuppressedError);
+      assertSame(suppressedError.error, defect);
+      assertEqual(suppressedError.suppressed, testAbortError);
+      assertEqual(run.deps.reportDefect.getDefects(), [result.error]);
+    });
+
+    it("reports a Task defect whose cleanup then aborts as the whole SuppressedError", async () => {
+      await using run = testCreateRun();
+      const defect = new Error("task failed");
+
+      const fiber = run.abortable(() => {
+        using _resource = { [Symbol.dispose]: throwCleanupAbortError };
+        throw defect;
+      });
+
+      const result = await fiber;
+      assertErr(result);
+      assertType(AbortError, result.error);
+      const suppressedError = result.error.reason.defect;
+      assertInstanceOf(suppressedError, SuppressedError);
+      assertEqual(suppressedError.error, cleanupAbortError);
+      assertSame(suppressedError.suppressed, defect);
+      assertEqual(run.deps.reportDefect.getDefects(), [result.error]);
+    });
+
+    it("aborts when thousands of cleanups observe the abort", async () => {
+      await using run = testCreateRun();
+
+      const fiber = run.abortable(async (run) => {
+        using stack = new DisposableStack();
+        // Each failing cleanup nests one more SuppressedError.
+        for (let i = 0; i < 20_000; i++) stack.defer(throwCleanupAbortError);
+        await run(waitForAbort);
+        return ok();
+      });
+      fiber.abort(testAbortReason);
+
+      assertEqual(await fiber, err(cleanupAbortError));
+      assertEqual(run.deps.reportDefect.getDefects(), []);
+      assertFalse(run.signal.aborted);
+    });
+
+    it("recognizes a downleveled SuppressedError by its name", async () => {
+      await using run = testCreateRun();
+      // TypeScript's downleveled `using` throws this without a native
+      // SuppressedError.
+      const suppressedError = Object.assign(
+        new Error("An error was suppressed during disposal."),
+        {
+          name: "SuppressedError",
+          error: testAbortError,
+          suppressed: testAbortError,
+        },
+      );
+
+      const fiber = run.abortable(() => {
+        throw suppressedError;
+      });
+
+      assertEqual(await fiber, err(testAbortError));
+      assertEqual(run.deps.reportDefect.getDefects(), []);
+    });
+
+    it("recognizes a SuppressedError from another realm", async () => {
+      await using run = testCreateRun();
+      const suppressedError = runInNewContext(
+        "new SuppressedError(error, suppressed)",
+        { error: testAbortError, suppressed: testAbortError },
+      ) as SuppressedError;
+
+      const fiber = run.abortable(() => {
+        throw suppressedError;
+      });
+
+      assertEqual(await fiber, err(testAbortError));
+      assertEqual(run.deps.reportDefect.getDefects(), []);
+      assertFalse(run.signal.aborted);
+    });
+
+    it("reports a defect whose inspection throws", async () => {
+      await using run = testCreateRun();
+      const defect = new Error("task failed");
+      Object.defineProperty(defect, "name", {
+        get: () => {
+          throw new Error("name getter failed");
+        },
+      });
+
+      const fiber = run.abortable(() => {
+        throw defect;
+      });
+
+      const result = await fiber;
+      assertErr(result);
+      assertPanicAbortError(result.error, defect);
+      assertEqual(run.deps.reportDefect.getDefects(), [result.error]);
+    });
+  });
+
   describe("lifecycle", () => {
     it("aborts Task Run after Task settles", async () => {
       await using run = createRun();
@@ -2970,6 +3176,24 @@ describe("DisposableRun", () => {
       await run[Symbol.asyncDispose]();
     });
 
+    it("reports a finalizer defect once when another finalizer awaits its Run", async () => {
+      const run = testCreateRun();
+      const createdRun = run.create();
+      const defect = new Error("finalizer failed");
+
+      createdRun.defer(() => {
+        throw defect;
+      });
+      run.defer(() => createdRun[Symbol.asyncDispose]());
+
+      await assertRejects(run[Symbol.asyncDispose](), (disposalError) => {
+        assertPanicAbortError(disposalError, defect);
+        assertEqual(run.deps.reportDefect.getDefectsSnapshot(), [
+          disposalError,
+        ]);
+      });
+    });
+
     it("reports multiple finalizer defects as SuppressedError", async () => {
       const run = testCreateRun();
       const firstDefect = new Error("first finalizer failed");
@@ -9054,7 +9278,6 @@ describe("Semaphore", () => {
             taken: 1,
             waiters: [],
             available: 0,
-            isIdle: false,
           });
 
           await completeTask.promise;
@@ -9071,7 +9294,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
   });
@@ -9104,7 +9326,6 @@ describe("Semaphore", () => {
             taken: 2,
             waiters: [],
             available: 1,
-            isIdle: false,
           });
           return ok("value");
         }),
@@ -9146,7 +9367,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
       assertEqual(events, ["first acquired"]);
 
@@ -9165,7 +9385,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
 
@@ -9190,7 +9409,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       fiber.abort(testAbortReason);
@@ -9202,7 +9420,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [],
         available: 0,
-        isIdle: false,
       });
       assertFalse(taskStarted);
 
@@ -9225,7 +9442,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
 
@@ -9242,7 +9458,6 @@ describe("Semaphore", () => {
             taken: 2,
             waiters: [],
             available: 0,
-            isIdle: false,
           });
           return err("error");
         }),
@@ -9255,7 +9470,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
 
@@ -9273,7 +9487,6 @@ describe("Semaphore", () => {
             taken: 2,
             waiters: [],
             available: 0,
-            isIdle: false,
           });
           taskStarted.resolve();
           await run.ok(
@@ -9295,7 +9508,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
   });
@@ -9328,7 +9540,6 @@ describe("Semaphore", () => {
             taken: 2,
             waiters: [],
             available: 0,
-            isIdle: false,
           });
           return ok("value");
         }),
@@ -9341,7 +9552,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
 
@@ -9366,7 +9576,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
 
@@ -9386,7 +9595,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }],
         available: 0,
-        isIdle: false,
       });
 
       const result = await run(
@@ -9419,7 +9627,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }],
         available: 1,
-        isIdle: false,
       });
 
       const result = await run(
@@ -9449,7 +9656,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
 
@@ -9467,7 +9673,6 @@ describe("Semaphore", () => {
             taken: 1,
             waiters: [],
             available: 0,
-            isIdle: false,
           });
           taskStarted.resolve();
           await run.ok(
@@ -9489,7 +9694,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
   });
@@ -9535,7 +9739,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
       assertEqual(events, ["waiting"]);
 
@@ -9566,7 +9769,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }],
         available: 0,
-        isIdle: false,
       });
 
       const smallerFiber = run(async (run) => {
@@ -9582,7 +9784,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }, { permits: 1 }],
         available: 0,
-        isIdle: false,
       });
       assertEqual(events, ["larger requesting", "smaller requesting"]);
 
@@ -9596,7 +9797,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }, { permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       firstPermit.release();
@@ -9632,7 +9832,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }],
         available: 1,
-        isIdle: false,
       });
 
       const smallerFiber = run(async (run) => {
@@ -9689,7 +9888,6 @@ describe("Semaphore", () => {
         taken: 3,
         waiters: [{ permits: 2 }, { permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       secondPermit.release();
@@ -9706,7 +9904,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }],
         available: 1,
-        isIdle: false,
       });
 
       firstPermit.release();
@@ -9733,7 +9930,6 @@ describe("Semaphore", () => {
           taken: 2,
           waiters: [],
           available: 0,
-          isIdle: false,
         });
       }
 
@@ -9743,7 +9939,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
 
@@ -9761,7 +9956,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
 
@@ -9780,7 +9974,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       waiterFiber.abort(testAbortReason);
@@ -9792,7 +9985,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [],
         available: 0,
-        isIdle: false,
       });
     });
 
@@ -9815,7 +10007,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [{ permits: 2 }, { permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       largerFiber.abort(testAbortReason);
@@ -9828,7 +10019,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [],
         available: 1,
-        isIdle: false,
       });
 
       firstPermit.release();
@@ -9853,7 +10043,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [{ permits: 1 }, { permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       firstWaiterFiber.abort(testAbortReason);
@@ -9865,7 +10054,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       firstPermit.release();
@@ -9877,7 +10065,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
   });
@@ -9909,7 +10096,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [{ permits: 2 }],
         available: 0,
-        isIdle: false,
       });
       assertEqual(events, ["waiting"]);
 
@@ -9923,7 +10109,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
 
@@ -9942,7 +10127,6 @@ describe("Semaphore", () => {
         taken: 2,
         waiters: [],
         available: 0,
-        isIdle: false,
       });
 
       permit.release();
@@ -9953,7 +10137,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
   });
@@ -9970,7 +10153,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
 
       const firstPermit = await run.ok(semaphore.take(1));
@@ -9985,7 +10167,6 @@ describe("Semaphore", () => {
         taken: 1,
         waiters: [{ permits: 2 }],
         available: 0,
-        isIdle: false,
       });
 
       firstPermit.release();
@@ -9997,7 +10178,6 @@ describe("Semaphore", () => {
         taken: 0,
         waiters: [],
         available: 2,
-        isIdle: true,
       });
     });
   });
@@ -10075,7 +10255,6 @@ describe("Mutex", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
       assertEqual(events, ["first acquired"]);
 
@@ -10094,7 +10273,6 @@ describe("Mutex", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
 
@@ -10111,7 +10289,6 @@ describe("Mutex", () => {
             taken: 1,
             waiters: [],
             available: 0,
-            isIdle: false,
           });
           return err("error");
         }),
@@ -10124,7 +10301,6 @@ describe("Mutex", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
       assertEqual(await run(mutex.withLock(() => ok("next"))), ok("next"));
     });
@@ -10143,7 +10319,6 @@ describe("Mutex", () => {
             taken: 1,
             waiters: [],
             available: 0,
-            isIdle: false,
           });
           taskStarted.resolve();
           await run.ok(
@@ -10165,7 +10340,6 @@ describe("Mutex", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
       assertEqual(await run(mutex.withLock(() => ok("next"))), ok("next"));
     });
@@ -10183,7 +10357,6 @@ describe("Mutex", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
 
       const completeFirstTask = Promise.withResolvers<void>();
@@ -10207,7 +10380,6 @@ describe("Mutex", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       completeFirstTask.resolve();
@@ -10220,7 +10392,6 @@ describe("Mutex", () => {
         taken: 0,
         waiters: [],
         available: 1,
-        isIdle: true,
       });
     });
   });
@@ -10308,7 +10479,6 @@ describe("SemaphoreByKey", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
       assertEqual(events, ["first acquired"]);
 
@@ -10479,7 +10649,6 @@ describe("SemaphoreByKey", () => {
         taken: 1,
         waiters: [],
         available: 0,
-        isIdle: false,
       });
 
       completeTask.resolve();
@@ -10572,7 +10741,6 @@ describe("SemaphoreByKey", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
 
       secondFiber.abort(testAbortReason);
@@ -10584,7 +10752,6 @@ describe("SemaphoreByKey", () => {
         taken: 1,
         waiters: [],
         available: 0,
-        isIdle: false,
       });
 
       completeFirstTask.resolve();
@@ -10672,7 +10839,6 @@ describe("MutexByKey", () => {
         taken: 1,
         waiters: [{ permits: 1 }],
         available: 0,
-        isIdle: false,
       });
       assertEqual(events, ["first acquired"]);
 
@@ -10782,7 +10948,6 @@ describe("MutexByKey", () => {
         taken: 1,
         waiters: [],
         available: 0,
-        isIdle: false,
       });
 
       completeTask.resolve();
@@ -10927,8 +11092,15 @@ describe("MutexRef", () => {
     const gate = createGate();
     const ref = createMutexRef(0);
     const started = Promise.withResolvers<void>();
+    const idleSnapshot = {
+      policy: "fifo",
+      permits: 1,
+      taken: 0,
+      waiters: [],
+      available: 1,
+    };
 
-    assertTrue(ref.snapshot().isIdle);
+    assertEqual(ref.snapshot(), idleSnapshot);
 
     const fiber = run(
       ref.update((current) => async (run) => {
@@ -10946,13 +11118,12 @@ describe("MutexRef", () => {
       taken: 1,
       waiters: [],
       available: 0,
-      isIdle: false,
     });
 
     gate.open();
 
     assertEqual(await fiber, ok());
-    assertTrue(ref.snapshot().isIdle);
+    assertEqual(ref.snapshot(), idleSnapshot);
   });
 
   it("types: operations infer error and deps from the updater", () => {