@ersbeth/picoflow 1.1.2 → 2.0.1

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

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