@ersbeth/picoflow 2.0.2 → 2.0.3

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

@@ -1,593 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { PendingError } from "~/schedulers";
-import { AsyncResolver } from "~/schedulers/asyncResolver";
-
-describe("PendingResolver", () => {
-    describe("initialization", () => {
-        it("should create instance with compute function", () => {
-            const compute = vi.fn(() => Promise.resolve(42));
-            const resolver = new AsyncResolver(compute);
-
-            expect(resolver).toBeInstanceOf(AsyncResolver);
-        });
-
-        it("should not execute compute function on construction", () => {
-            const compute = vi.fn(() => Promise.resolve(42));
-            new AsyncResolver(compute);
-
-            expect(compute).not.toHaveBeenCalled();
-        });
-
-        it("should return a promise from settled getter", () => {
-            const compute = vi.fn(() => Promise.resolve(42));
-            const resolver = new AsyncResolver(compute);
-
-            expect(resolver.computed).toBeInstanceOf(Promise);
-        });
-    });
-
-    describe("restart() method", () => {
-        it("should execute compute function when restart is called", () => {
-            const compute = vi.fn(() => Promise.resolve(42));
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-
-            expect(compute).toHaveBeenCalledTimes(1);
-        });
-
-        it("should resolve settled promise with computation result", async () => {
-            const compute = vi.fn(() => Promise.resolve(100));
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-
-            expect(await promise).toBe(100);
-            expect(await resolver.computed).toBe(100);
-        });
-
-        it("should ignore results from previous iterations when restarted multiple times", async () => {
-            vi.useFakeTimers();
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => {
-                        callCount++;
-                        resolve(callCount);
-                    }, 100);
-                });
-            });
-
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            // Start first computation
-            resolver.compute();
-
-            // Restart before first completes
-            vi.advanceTimersByTime(50);
-            resolver.compute();
-
-            // Complete both
-            vi.advanceTimersByTime(100);
-
-            expect(await promise).toEqual(2);
-            expect(await resolver.computed).toEqual(2);
-            vi.useRealTimers();
-        });
-
-        it("should handle computation errors by rejecting settled promise", async () => {
-            const error = new Error("computation failed");
-            const compute = vi.fn(() => Promise.reject(error));
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-
-            await expect(resolver.computed).rejects.toThrow("computation failed");
-        });
-
-        it("should handle PendingError by waiting for pending promise then restarting", async () => {
-            vi.useFakeTimers();
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                if (callCount === 1) {
-                    // First call throws PendingError
-                    return Promise.reject(
-                        new PendingError(
-                            new Promise<number>((resolve) => {
-                                setTimeout(() => resolve(42), 100);
-                            }),
-                        ),
-                    );
-                }
-                // Second call (after restart) succeeds
-                return Promise.resolve(100);
-            });
-
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-            resolver.compute();
-
-            expect(await resolver.computed).toBe(100);
-            expect(await promise).toBe(100);
-            vi.useRealTimers();
-        });
-
-        it("should not restart if aborted before pending promise settles", () => {
-            vi.useFakeTimers();
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.reject(
-                        new PendingError(
-                            new Promise<number>((resolve) => {
-                                setTimeout(() => resolve(42), 100);
-                            }),
-                        ),
-                    );
-                }
-                return Promise.resolve(100);
-            });
-            const onResolve = vi.fn();
-            const onReject = vi.fn();
-
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-            promise.then(onResolve).catch(onReject);
-
-            expect(compute).toHaveBeenCalledTimes(0);
-            resolver.compute();
-
-            // Abort before pending promise settles
-            vi.advanceTimersByTime(50);
-            resolver.abort();
-
-            // Advance time - should not restart
-            vi.advanceTimersByTime(100);
-
-            expect(compute).toHaveBeenCalledTimes(1);
-            expect(onResolve).not.toHaveBeenCalled();
-            expect(onReject).not.toHaveBeenCalled();
-
-            // await expect(resolver.computed).rejects.toThrow(AbortError);
-            // await expect(promise).rejects.toThrow(AbortError);
-            vi.useRealTimers();
-        });
-
-        it("should ignore stale results when iteration changes during computation", async () => {
-            vi.useFakeTimers();
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => {
-                        callCount++;
-                        resolve(callCount);
-                    }, 100);
-                });
-            });
-
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-
-            // Restart before first completes
-            vi.advanceTimersByTime(50);
-            resolver.compute();
-
-            // Restart before first completes
-            vi.advanceTimersByTime(50);
-            resolver.compute();
-
-            vi.advanceTimersByTime(100);
-
-            expect(await promise).toBe(3);
-            expect(await resolver.computed).toBe(3);
-            vi.useRealTimers();
-        });
-    });
-
-    describe("overwrite() method", () => {
-        it("should replace current computation with new promise", async () => {
-            const compute = vi.fn(() => Promise.resolve(1));
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-            resolver.compute();
-            const newPromise = Promise.resolve(42);
-            resolver.overwrite(newPromise);
-
-            expect(await promise).toBe(42);
-            expect(await resolver.computed).toBe(42);
-        });
-
-        it("should resolve settled promise with overwrite promise result", async () => {
-            const compute = vi.fn(() => Promise.resolve(1));
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-            resolver.overwrite(Promise.resolve(100));
-
-            const result = await resolver.computed;
-            expect(result).toBe(100);
-        });
-
-        it("should reject settled promise if overwrite promise rejects", async () => {
-            const compute = vi.fn(() => Promise.resolve(1));
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-            const error = new Error("overwrite failed");
-            resolver.overwrite(Promise.reject(error));
-
-            await expect(resolver.computed).rejects.toThrow("overwrite failed");
-            await expect(promise).rejects.toThrow("overwrite failed");
-        });
-
-        it("should ignore results from previous computation after overwrite", async () => {
-            vi.useFakeTimers();
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(1), 100);
-                });
-            });
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-            vi.advanceTimersByTime(50);
-            resolver.overwrite(Promise.resolve(42));
-            vi.advanceTimersByTime(100);
-
-            expect(await promise).toBe(42);
-            expect(await resolver.computed).toBe(42);
-
-            vi.useRealTimers();
-        });
-
-        it("should ignore stale results when iteration changes", async () => {
-            vi.useFakeTimers();
-            const compute = vi.fn(() => Promise.resolve(1));
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-            const promise1 = Promise.resolve(10);
-            resolver.overwrite(promise1);
-            const promise2 = Promise.resolve(20);
-            resolver.overwrite(promise2);
-
-            expect(await resolver.computed).toBe(20);
-            expect(await promise).toBe(20);
-            vi.useRealTimers();
-        });
-    });
-
-    describe("abort() method", () => {
-        it("should reject settled promise with PendingError containing AbortError", async () => {
-            const compute = vi.fn(() => Promise.resolve(42));
-            const onResolve = vi.fn();
-            const onReject = vi.fn();
-            const resolver = new AsyncResolver(compute);
-            resolver.computed.then(onResolve).catch(onReject);
-
-            resolver.compute();
-            resolver.abort();
-
-            expect(resolver.aborted).toBe(true);
-            await new Promise((resolve) => setTimeout(resolve, 0));
-
-            expect(resolver.finished).toBe(false);
-            expect(onResolve).not.toHaveBeenCalled();
-            expect(onReject).not.toHaveBeenCalled();
-        });
-
-        it("should mark resolver as aborted", () => {
-            vi.useFakeTimers();
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(42), 100);
-                });
-            });
-            const onResolve = vi.fn();
-            const onReject = vi.fn();
-
-            const resolver = new AsyncResolver(compute);
-            resolver.computed.then(onResolve).catch(onReject);
-
-            resolver.compute();
-            resolver.abort();
-            vi.advanceTimersByTime(100);
-
-            // Should not resolve even if computation completes
-            expect(resolver.aborted).toBe(true);
-            expect(resolver.finished).toBe(false);
-            expect(onResolve).not.toHaveBeenCalled();
-            expect(onReject).not.toHaveBeenCalled();
-
-            vi.useRealTimers();
-        });
-
-        it("should ignore future computation results after abort", () => {
-            vi.useFakeTimers();
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(42), 100);
-                });
-            });
-            const onResolve = vi.fn();
-            const onReject = vi.fn();
-            const resolver = new AsyncResolver(compute);
-            resolver.computed.then(onResolve).catch(onReject);
-
-            resolver.compute();
-            resolver.abort();
-            vi.advanceTimersByTime(100);
-
-            expect(resolver.aborted).toBe(true);
-            expect(resolver.finished).toBe(false);
-            expect(onResolve).not.toHaveBeenCalled();
-            expect(onReject).not.toHaveBeenCalled();
-
-            vi.useRealTimers();
-        });
-
-        it("should prevent restart after abort", () => {
-            vi.useFakeTimers();
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(42), 100);
-                });
-            });
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-            resolver.abort();
-
-            expect(() => resolver.compute()).toThrow();
-
-            vi.useRealTimers();
-        });
-    });
-
-    describe("race condition scenarios", () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-        });
-
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-
-        it("should handle rapid successive restarts correctly", async () => {
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(callCount * 10), 100);
-                });
-            });
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-            vi.advanceTimersByTime(10);
-            resolver.compute();
-            vi.advanceTimersByTime(10);
-            resolver.compute();
-            vi.advanceTimersByTime(100);
-
-            const result = await resolver.computed;
-            expect(result).toBe(30); // Only last iteration
-        });
-
-        it("should handle restart during ongoing computation", async () => {
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(1), 100);
-                });
-            });
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-            vi.advanceTimersByTime(50);
-            resolver.compute();
-            vi.advanceTimersByTime(100);
-
-            const result = await resolver.computed;
-            expect(result).toBe(1);
-        });
-
-        it("should handle overwrite during ongoing computation", async () => {
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(1), 100);
-                });
-            });
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-            vi.advanceTimersByTime(50);
-            resolver.overwrite(Promise.resolve(42));
-            vi.advanceTimersByTime(100);
-
-            const result = await resolver.computed;
-            expect(result).toBe(42);
-        });
-
-        it("should handle abort during ongoing computation", () => {
-            vi.useFakeTimers();
-            const compute = vi.fn(() => {
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(1), 100);
-                });
-            });
-            const onResolve = vi.fn();
-            const onReject = vi.fn();
-            const resolver = new AsyncResolver(compute);
-            resolver.computed.then(onResolve).catch(onReject);
-
-            resolver.compute();
-            vi.advanceTimersByTime(50);
-            resolver.abort();
-            vi.advanceTimersByTime(100);
-
-            expect(resolver.aborted).toBe(true);
-            expect(resolver.finished).toBe(false);
-            expect(onResolve).not.toHaveBeenCalled();
-            expect(onReject).not.toHaveBeenCalled();
-
-            vi.useRealTimers();
-        });
-
-        it("should only resolve/reject with latest iteration result", async () => {
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                return new Promise<number>((resolve) => {
-                    setTimeout(() => resolve(callCount), 100);
-                });
-            });
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-            vi.advanceTimersByTime(10);
-            resolver.compute();
-            vi.advanceTimersByTime(10);
-            resolver.compute();
-            vi.advanceTimersByTime(100);
-
-            const result = await resolver.computed;
-            expect(result).toBe(3);
-        });
-    });
-
-    describe("PendingError handling", () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-        });
-
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-
-        it("should automatically restart after PendingError's promise settles", async () => {
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.reject(
-                        new PendingError(
-                            new Promise<number>((resolve) => {
-                                setTimeout(() => resolve(42), 100);
-                            }),
-                        ),
-                    );
-                }
-                return Promise.resolve(100);
-            });
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-            resolver.compute();
-
-            const result = await promise;
-            expect(result).toBe(100);
-        });
-
-        it("should not restart if iteration changed while waiting for pending promise", async () => {
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.reject(
-                        new PendingError(
-                            new Promise<number>((resolve) => {
-                                setTimeout(() => resolve(42), 100);
-                            }),
-                        ),
-                    );
-                }
-                return Promise.resolve(100);
-            });
-            const resolver = new AsyncResolver(compute);
-
-            resolver.compute();
-            vi.advanceTimersByTime(50);
-            // Change iteration by restarting
-            resolver.compute();
-            vi.advanceTimersByTime(100);
-
-            // Should not have restarted automatically
-            await vi.waitFor(() => expect(compute).toHaveBeenCalledTimes(2));
-            const result = await resolver.computed;
-            expect(result).toBe(100);
-        });
-
-        it("should not restart if aborted while waiting for pending promise", () => {
-            vi.useFakeTimers();
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.reject(
-                        new PendingError(
-                            new Promise<number>((resolve) => {
-                                setTimeout(() => resolve(42), 100);
-                            }),
-                        ),
-                    );
-                }
-                return Promise.resolve(100);
-            });
-            const onResolve = vi.fn();
-            const onReject = vi.fn();
-            const resolver = new AsyncResolver(compute);
-            resolver.computed.then(onResolve).catch(onReject);
-
-            resolver.compute();
-            vi.advanceTimersByTime(50);
-            resolver.abort();
-            vi.advanceTimersByTime(100);
-
-            // Should not have restarted automatically
-            expect(resolver.aborted).toBe(true);
-            expect(resolver.finished).toBe(false);
-            expect(onResolve).not.toHaveBeenCalled();
-            expect(onReject).not.toHaveBeenCalled();
-
-            vi.useRealTimers();
-        });
-
-        it("should handle multiple PendingErrors in sequence", async () => {
-            let callCount = 0;
-            const compute = vi.fn(() => {
-                callCount++;
-                if (callCount === 1 || callCount === 2) {
-                    return Promise.reject(
-                        new PendingError(
-                            new Promise<number>((resolve) => {
-                                setTimeout(() => resolve(42), 50);
-                            }),
-                        ),
-                    );
-                }
-                return Promise.resolve(100);
-            });
-            const resolver = new AsyncResolver(compute);
-            const promise = resolver.computed;
-
-            resolver.compute();
-            resolver.compute();
-            resolver.compute();
-
-            const result = await promise;
-            expect(result).toBe(100);
-        });
-    });
-});