@ersbeth/picoflow 2.0.2 → 2.1.0

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

@@ -1,317 +0,0 @@
-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();
-        });
-    });
-});