@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/reactivity/nodes/async/asyncScheduler/asyncScheduler.test.ts

@@ -0,0 +1,317 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AsyncScheduler } from "~/schedulers/";
+
+describe("PendingScheduler", () => {
+    describe("initialization", () => {
+        it("should create instance with compute function", () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const scheduler = new AsyncScheduler(
+                compute,
+                () => {},
+                () => {},
+            );
+
+            expect(scheduler).toBeInstanceOf(AsyncScheduler);
+        });
+
+        it("should create internal PendingResolver on construction", () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const scheduler = new AsyncScheduler(
+                compute,
+                () => {},
+                () => {},
+            );
+
+            // Should be able to get settled promise (indicates resolver exists)
+            expect(scheduler.settled).toBeInstanceOf(Promise);
+        });
+
+        it("should return promise from settled getter", () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const scheduler = new AsyncScheduler(
+                compute,
+                () => {},
+                () => {},
+            );
+
+            expect(scheduler.settled).toBeInstanceOf(Promise);
+        });
+    });
+
+    describe("reset() method", () => {
+        it("should transfer current resolver", async () => {
+            vi.useFakeTimers();
+            const compute = vi.fn(() => {
+                return new Promise<number>((resolve) => {
+                    setTimeout(() => resolve(42), 100);
+                });
+            });
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+            const settled1 = scheduler.settled;
+
+            scheduler.compute();
+            vi.advanceTimersByTime(50);
+
+            scheduler.compute();
+            const settled2 = scheduler.settled;
+
+            vi.advanceTimersByTime(100);
+
+            await expect(settled1).resolves.toBe(undefined);
+            await expect(settled2).resolves.toBe(undefined);
+
+            expect(onResolve).toHaveBeenCalledTimes(1);
+            expect(onResolve).toHaveBeenCalledWith(42);
+            expect(onReject).not.toHaveBeenCalled();
+
+            vi.useRealTimers();
+        });
+
+        it("should create new resolver instance when finished", async () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            const firstSettled = scheduler.settled;
+            scheduler.compute();
+            await firstSettled;
+            scheduler.compute();
+            const secondSettled = scheduler.settled;
+            await secondSettled;
+
+            // Should be different promises (different resolver instances)
+            expect(firstSettled).not.toBe(secondSettled);
+        });
+
+        it("should allow new computation to start after reset", async () => {
+            const compute = vi.fn(() => Promise.resolve(100));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            await scheduler.settled;
+            scheduler.compute();
+
+            await scheduler.settled;
+            expect(onResolve).toHaveBeenCalledTimes(2);
+            expect(onResolve).toHaveBeenNthCalledWith(1, 100);
+            expect(onResolve).toHaveBeenNthCalledWith(2, 100);
+            expect(onReject).not.toHaveBeenCalled();
+        });
+
+        it("should discard ongoing computation", async () => {
+            vi.useFakeTimers();
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const compute = vi.fn(() => {
+                return new Promise<number>((resolve) => {
+                    setTimeout(() => resolve(42), 100);
+                });
+            });
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+            const settled1 = scheduler.settled;
+
+            scheduler.compute();
+            vi.advanceTimersByTime(50);
+
+            scheduler.compute();
+            const settled2 = scheduler.settled;
+            vi.advanceTimersByTime(100);
+
+            // Old computation should be discarded
+            await settled1;
+            await settled2;
+            expect(onResolve).toHaveBeenCalledTimes(1);
+            expect(onResolve).toHaveBeenCalledWith(42);
+            expect(onReject).not.toHaveBeenCalled();
+            vi.useRealTimers();
+        });
+    });
+
+    describe("overwrite() method", () => {
+        it("should delegate to resolver's overwrite method", async () => {
+            const compute = vi.fn(() => Promise.resolve(1));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            scheduler.overwrite(Promise.resolve(42));
+
+            await scheduler.settled;
+            expect(onResolve).toHaveBeenCalledTimes(1);
+            expect(onResolve).toHaveBeenCalledWith(42);
+            expect(onReject).not.toHaveBeenCalled();
+        });
+
+        it("should work correctly after reset", async () => {
+            const compute = vi.fn(() => Promise.resolve(1));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            scheduler.compute();
+            scheduler.overwrite(Promise.resolve(100));
+
+            await scheduler.settled;
+            expect(onResolve).toHaveBeenCalledTimes(1);
+            expect(onResolve).toHaveBeenCalledWith(100);
+            expect(onReject).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("restart() method", () => {
+        it("should delegate to resolver's restart method", async () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+
+            await scheduler.settled;
+            expect(onResolve).toHaveBeenCalledTimes(1);
+            expect(onResolve).toHaveBeenCalledWith(42);
+            expect(onReject).not.toHaveBeenCalled();
+            expect(compute).toHaveBeenCalledTimes(1);
+        });
+
+        it("should work correctly after reset", async () => {
+            const compute = vi.fn(() => Promise.resolve(100));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            await scheduler.settled;
+            scheduler.compute();
+
+            await scheduler.settled;
+            expect(onResolve).toHaveBeenCalledTimes(2);
+            expect(onResolve).toHaveBeenNthCalledWith(1, 100);
+            expect(onResolve).toHaveBeenNthCalledWith(2, 100);
+            expect(onReject).not.toHaveBeenCalled();
+            expect(compute).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe("abort() method", () => {
+        it("should delegate to resolver's abort method", async () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            scheduler.dispose();
+
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(compute).toHaveBeenCalledTimes(1);
+            expect(onReject).not.toHaveBeenCalled();
+            expect(onResolve).not.toHaveBeenCalled();
+        });
+
+        it("should work correctly after reset", async () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            scheduler.compute();
+            scheduler.dispose();
+
+            await new Promise((resolve) => setTimeout(resolve, 0));
+
+            expect(compute).toHaveBeenCalledTimes(2);
+            expect(onReject).not.toHaveBeenCalled();
+            expect(onResolve).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("lifecycle management", () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+        });
+
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+
+        it("should maintain independent resolver instances after reset", async () => {
+            const compute = vi.fn(() => {
+                return new Promise<number>((resolve) => {
+                    setTimeout(() => resolve(42), 100);
+                });
+            });
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            const firstSettled = scheduler.settled;
+            vi.advanceTimersByTime(50);
+            scheduler.compute();
+            const secondSettled = scheduler.settled;
+            vi.advanceTimersByTime(100);
+
+            // First should be aborted, second should resolve
+            await firstSettled;
+            await secondSettled;
+            expect(onResolve).toHaveBeenCalledTimes(1);
+            expect(onResolve).toHaveBeenCalledWith(42);
+            expect(onReject).not.toHaveBeenCalled();
+        });
+
+        it("should allow multiple reset/restart cycles", async () => {
+            const compute = vi.fn(() => Promise.resolve(42));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            await scheduler.settled;
+            scheduler.compute();
+            await scheduler.settled;
+            scheduler.compute();
+            await scheduler.settled;
+
+            expect(onResolve).toHaveBeenCalledTimes(3);
+            expect(onResolve).toHaveBeenNthCalledWith(1, 42);
+            expect(onResolve).toHaveBeenNthCalledWith(2, 42);
+            expect(onResolve).toHaveBeenNthCalledWith(3, 42);
+            expect(onReject).not.toHaveBeenCalled();
+            expect(compute).toHaveBeenCalledTimes(3);
+        });
+
+        it("should handle operations after reset correctly", async () => {
+            const compute = vi.fn(() => Promise.resolve(100));
+            const onResolve = vi.fn();
+            const onReject = vi.fn();
+            const scheduler = new AsyncScheduler(compute, onResolve, onReject);
+
+            scheduler.compute();
+            await scheduler.settled;
+            scheduler.compute();
+            scheduler.overwrite(Promise.resolve(200));
+            await scheduler.settled;
+            expect(onResolve).toHaveBeenCalledTimes(2);
+            expect(onResolve).toHaveBeenNthCalledWith(1, 100);
+            expect(onResolve).toHaveBeenNthCalledWith(2, 200);
+            expect(onReject).not.toHaveBeenCalled();
+
+            scheduler.compute();
+            await scheduler.settled;
+            expect(onResolve).toHaveBeenCalledTimes(3);
+            expect(onResolve).toHaveBeenNthCalledWith(3, 100);
+            expect(onReject).not.toHaveBeenCalled();
+        });
+    });
+});