@ersbeth/picoflow 1.1.1 → 2.0.0

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

@@ -0,0 +1,652 @@
+import { describe, expect, it, vi } from "vitest";
+import { constantAsync, subscribe } from "~";
+import { EffectNode } from "~/nodes";
+
+describe("flowConstantAsync", () => {
+    describe("unit", () => {
+        describe("initialization / pick", () => {
+            it("should initialize with direct Promise", async () => {
+                const $constant = constantAsync(Promise.resolve(1));
+                expect(await $constant.pick()).toBe(1);
+            });
+
+            it("should initialize lazily with function", async () => {
+                const initFn = vi.fn(() => Promise.resolve(42));
+                const $constant = constantAsync(initFn);
+
+                // Function should not be called yet
+                expect(initFn).not.toHaveBeenCalled();
+
+                // First access triggers initialization
+                const value = await $constant.pick();
+                expect(value).toBe(42);
+                expect(initFn).toHaveBeenCalledTimes(1);
+            });
+
+            it("should compute initial value lazily on first access", async () => {
+                const computeFn = vi.fn(() => Promise.resolve(42));
+                const $constant = constantAsync(computeFn);
+
+                // Function should not be called yet
+                expect(computeFn).not.toHaveBeenCalled();
+
+                // First access triggers computation
+                const value = await $constant.pick();
+                expect(value).toBe(42);
+                expect(computeFn).toHaveBeenCalledTimes(1);
+            });
+
+            it("should call initializer function only once", async () => {
+                const computeFn = vi.fn(() => Promise.resolve(100));
+                const $constant = constantAsync(computeFn);
+
+                // Multiple accesses should only call compute once
+                await $constant.pick();
+                await $constant.pick();
+                await $constant.pick();
+
+                expect(computeFn).toHaveBeenCalledTimes(1);
+            });
+
+            it("should cache Promise after initialization", async () => {
+                const computeFn = vi.fn(() => Promise.resolve("cached"));
+                const $constant = constantAsync(computeFn);
+
+                const value1 = await $constant.pick();
+                const value2 = await $constant.pick();
+                const value3 = await $constant.pick();
+
+                expect(value1).toBe("cached");
+                expect(value2).toBe("cached");
+                expect(value3).toBe("cached");
+                expect(computeFn).toHaveBeenCalledTimes(1);
+            });
+
+            it("should handle initializer function using closure to capture values", async () => {
+                let externalValue = 10;
+                const $constant = constantAsync(() => {
+                    // Closure captures external value at computation time
+                    return Promise.resolve(externalValue * 2);
+                });
+
+                // Constant computes once with captured value
+                expect(await $constant.pick()).toBe(20);
+
+                // Changing external value should not affect constant (it's cached)
+                externalValue = 20;
+                expect(await $constant.pick()).toBe(20); // Still cached value
+            });
+
+            it("should handle number values", async () => {
+                const $constant = constantAsync(Promise.resolve(42));
+                expect(await $constant.pick()).toBe(42);
+            });
+
+            it("should handle string values", async () => {
+                const $constant = constantAsync(Promise.resolve("hello"));
+                expect(await $constant.pick()).toBe("hello");
+            });
+
+            it("should handle object values", async () => {
+                const obj = { a: 1, b: 2 };
+                const $constant = constantAsync(Promise.resolve(obj));
+                const value = await $constant.pick();
+                expect(value).toBe(obj);
+                expect(value).toEqual({ a: 1, b: 2 });
+            });
+
+            it("should handle array values", async () => {
+                const arr = [1, 2, 3];
+                const $constant = constantAsync(Promise.resolve(arr));
+                const value = await $constant.pick();
+                expect(value).toBe(arr);
+                expect(value).toEqual([1, 2, 3]);
+            });
+
+            it("should handle undefined values", async () => {
+                const $constant = constantAsync(Promise.resolve(undefined));
+                const value = await $constant.pick();
+                expect(value).toBeUndefined();
+            });
+
+            it("should handle null values", async () => {
+                const $constant = constantAsync(Promise.resolve(null));
+                const value = await $constant.pick();
+                expect(value).toBeNull();
+            });
+
+            describe("error handling", () => {
+                it("pick should throw error when pick is called after disposal", async () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+
+                    expect(await $constant.pick()).toBe(1);
+
+                    $constant.dispose();
+
+                    await expect($constant.pick()).rejects.toThrow("[PicoFlow] Primitive is disposed");
+                });
+
+                it("should throw error when subscribe is called after disposal", () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+                    const onData = vi.fn();
+
+                    $constant.dispose();
+
+                    expect(() => $constant.subscribe(onData)).toThrow("[PicoFlow] Primitive is disposed");
+                });
+
+                it("should propagate error when pick is called on rejecting Promise", async () => {
+                    const error = new Error("Compute error");
+                    const $constant = constantAsync(Promise.reject(error));
+
+                    await expect($constant.pick()).rejects.toThrow("Compute error");
+                });
+
+                it("should propagate error when pick is called on rejecting initializer function", async () => {
+                    const error = new Error("Compute error");
+                    const $constant = constantAsync(() => Promise.reject(error));
+
+                    await expect($constant.pick()).rejects.toThrow("Compute error");
+                });
+            });
+        });
+
+        describe("pick", () => {
+            it("should return Promise without tracking", async () => {
+                const $constant = constantAsync(Promise.resolve(15));
+                const promise = $constant.pick();
+
+                expect(promise).toBeInstanceOf(Promise);
+                const value = await promise;
+                expect(value).toBe(15);
+            });
+
+            it("should compute lazy value on first pick call", async () => {
+                const initFn = vi.fn(() => Promise.resolve(25));
+                const $constant = constantAsync(initFn);
+
+                expect(initFn).not.toHaveBeenCalled();
+                const promise = $constant.pick();
+                expect(promise).toBeInstanceOf(Promise);
+                const value = await promise;
+                expect(value).toBe(25);
+                expect(initFn).toHaveBeenCalledTimes(1);
+            });
+
+            it("should return cached Promise on subsequent pick calls", async () => {
+                const initFn = vi.fn(() => Promise.resolve(30));
+                const $constant = constantAsync(initFn);
+
+                const promise1 = $constant.pick();
+                const promise2 = $constant.pick();
+                const promise3 = $constant.pick();
+
+                const value1 = await promise1;
+                const value2 = await promise2;
+                const value3 = await promise3;
+
+                expect(value1).toBe(30);
+                expect(value2).toBe(30);
+                expect(value3).toBe(30);
+                expect(initFn).toHaveBeenCalledTimes(1);
+            });
+
+            it("should await Promise to get value", async () => {
+                const $constant = constantAsync(Promise.resolve(35));
+                const value = await $constant.pick();
+                expect(value).toBe(35);
+            });
+
+            it("should throw error when pick is called after disposal", async () => {
+                const $constant = constantAsync(Promise.resolve(1));
+
+                expect(await $constant.pick()).toBe(1);
+
+                $constant.dispose();
+
+                await expect($constant.pick()).rejects.toThrow("[PicoFlow] Primitive is disposed");
+            });
+        });
+
+        describe("subscribe", () => {
+            it("should return an effect", () => {
+                const $constant = constantAsync(Promise.resolve(50));
+                const onData = vi.fn();
+                const effect = $constant.subscribe((value) => onData(value));
+                expect(effect).toBeInstanceOf(EffectNode);
+            });
+
+            it("should call onData immediately with T", async () => {
+                const $constant = constantAsync(Promise.resolve(55));
+                const onData = vi.fn();
+
+                $constant.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenCalledTimes(1);
+                expect(onData).toHaveBeenLastCalledWith(55);
+            });
+
+            it("should not call onData after constant disposal", async () => {
+                const $constant = constantAsync(Promise.resolve(65));
+                const onData = vi.fn();
+
+                $constant.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $constant.dispose();
+
+                // Wait to ensure onData is not called again
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+
+            it("should not call onData after disposer is called", async () => {
+                const $constant = constantAsync(Promise.resolve(70));
+                const onData = vi.fn();
+
+                const effect = $constant.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                effect.dispose();
+
+                // Wait to ensure onData is not called again
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+
+            it("should support multiple subscriptions", async () => {
+                const $constant = constantAsync(Promise.resolve(75));
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+                const onData3 = vi.fn();
+
+                $constant.subscribe(onData1);
+                $constant.subscribe(onData2);
+                $constant.subscribe(onData3);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                    expect(onData3).toHaveBeenCalledTimes(1);
+                });
+
+                expect(onData1).toHaveBeenLastCalledWith(75);
+                expect(onData2).toHaveBeenLastCalledWith(75);
+                expect(onData3).toHaveBeenLastCalledWith(75);
+            });
+
+            describe("error handling", () => {
+                it("should throw error when subscribe is called after disposal", () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+                    const onData = vi.fn();
+
+                    $constant.dispose();
+                    expect(() => $constant.subscribe(onData)).toThrow("[PicoFlow] Primitive is disposed");
+                });
+            });
+        });
+
+        describe("disposal", () => {
+            it("should have disposed property set to false initially", () => {
+                const $constant = constantAsync(Promise.resolve(1));
+                expect($constant.disposed).toBe(false);
+            });
+
+            it("should have disposed property set to true after disposal", () => {
+                const $constant = constantAsync(Promise.resolve(1));
+                $constant.dispose();
+                expect($constant.disposed).toBe(true);
+            });
+
+            it("should accept self option without throwing", () => {
+                const $constant = constantAsync(Promise.resolve(1));
+                expect(() => $constant.dispose()).not.toThrow();
+                expect($constant.disposed).toBe(true);
+            });
+
+            it("should accept default options without throwing", () => {
+                const $constant = constantAsync(Promise.resolve(1));
+                expect(() => $constant.dispose()).not.toThrow();
+                expect($constant.disposed).toBe(true);
+            });
+
+            describe("error handling", () => {
+                it("should throw error when disposed twice", () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+                    $constant.dispose();
+                    expect(() => $constant.dispose()).toThrow("[PicoFlow] Primitive is disposed");
+                });
+            });
+        });
+
+        describe("special cases", () => {
+            it("should handle lazy function using closure to capture values", async () => {
+                let externalValue = 10;
+                const $constant = constantAsync(() => Promise.resolve(externalValue * 2));
+
+                const value1 = await $constant.pick();
+                expect(value1).toBe(20);
+
+                // Changing external value should not affect constant (it's cached)
+                externalValue = 20;
+                const value2 = await $constant.pick();
+                expect(value2).toBe(20);
+            });
+
+            it("should handle Promise that rejects", async () => {
+                const error = new Error("Promise rejected");
+                const $constant = constantAsync(Promise.reject(error));
+
+                await expect($constant.pick()).rejects.toThrow("Promise rejected");
+            });
+
+            it("should handle lazy function that rejects", async () => {
+                const error = new Error("Lazy function rejected");
+                const $constant = constantAsync(() => Promise.reject(error));
+
+                await expect($constant.pick()).rejects.toThrow("Lazy function rejected");
+            });
+
+            it("should handle Promise that resolves to null", async () => {
+                const $constant = constantAsync(Promise.resolve(null));
+                const value = await $constant.pick();
+                expect(value).toBeNull();
+            });
+
+            it("should handle Promise that resolves to undefined", async () => {
+                const $constant = constantAsync(Promise.resolve(undefined));
+                const value = await $constant.pick();
+                expect(value).toBeUndefined();
+            });
+
+            it("should handle complex object values in Promise", async () => {
+                const complexObj = {
+                    nested: { deep: { value: 42 } },
+                    array: [1, 2, 3],
+                };
+                const $constant = constantAsync(Promise.resolve(complexObj));
+                const value = await $constant.pick();
+                expect(value).toBe(complexObj);
+                expect(value.nested.deep.value).toBe(42);
+                expect(value.array).toEqual([1, 2, 3]);
+            });
+        });
+
+        describe("error handling", () => {
+            describe("compute function errors", () => {
+                it("should propagate error when pick is called", async () => {
+                    const error = new Error("Compute error");
+                    const $constant = constantAsync(Promise.reject<never>(error));
+
+                    await expect($constant.pick()).rejects.toThrow("Compute error");
+                });
+            });
+
+            describe("disposed constant", () => {
+                it("should throw error when pick is called after disposal", async () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+
+                    $constant.dispose();
+
+                    await expect($constant.pick()).rejects.toThrow("[PicoFlow] Primitive is disposed");
+                });
+            });
+        });
+    });
+
+    describe("with effect", () => {
+        describe("get", () => {
+            it("should create reactive dependency when get is used in effect", async () => {
+                const $constant = constantAsync(Promise.resolve(100));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $constant.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenCalledTimes(0);
+                expect(onData).toHaveBeenLastCalledWith(100);
+            });
+
+            it("should call effect with initial value", async () => {
+                const $constant = constantAsync(Promise.resolve(1));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $constant.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenCalledTimes(0);
+                expect(onData).toHaveBeenLastCalledWith(1);
+            });
+
+            it("should call effect with lazy init value", async () => {
+                const $constant = constantAsync(() => Promise.resolve(1));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $constant.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onError).toHaveBeenCalledTimes(0);
+                expect(onData).toHaveBeenLastCalledWith(1);
+            });
+
+            it("should not re-execute effect when constant value does not change", async () => {
+                const $constant = constantAsync(Promise.resolve(300));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $constant.get(t), onData, onError);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(0));
+                // Wait to ensure effect doesn't re-run (constant is immutable)
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+                expect(onError).toHaveBeenCalledTimes(0);
+            });
+
+            it("should not re-execute effect when async constant value is immutable (closure)", async () => {
+                let capturedValue = 5;
+                const $constant = constantAsync(() => Promise.resolve(capturedValue * 3));
+
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe((t) => $constant.get(t), onData, onError);
+
+                // Initial execution with computed value (5 * 3 = 15)
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(15);
+
+                // Change captured value - constant is cached, so effect should not re-run
+                capturedValue = 10;
+                await new Promise((resolve) => setTimeout(resolve, 50));
+
+                // Effect should not re-run because constant is immutable and cached
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+
+            it("should support multiple effects depending on same constant", async () => {
+                const $constant = constantAsync(Promise.resolve(400));
+                const onData1 = vi.fn();
+                const onData2 = vi.fn();
+                const onData3 = vi.fn();
+
+                const onError1 = vi.fn();
+                const onError2 = vi.fn();
+                const onError3 = vi.fn();
+
+                subscribe((t) => $constant.get(t), onData1, onError1);
+
+                subscribe((t) => $constant.get(t), onData2, onError2);
+
+                subscribe((t) => $constant.get(t), onData3, onError3);
+
+                await vi.waitFor(() => {
+                    expect(onData1).toHaveBeenCalledTimes(1);
+                    expect(onData2).toHaveBeenCalledTimes(1);
+                    expect(onData3).toHaveBeenCalledTimes(1);
+                });
+
+                expect(onError1).toHaveBeenCalledTimes(0);
+                expect(onError2).toHaveBeenCalledTimes(0);
+                expect(onError3).toHaveBeenCalledTimes(0);
+
+                expect(onData1).toHaveBeenLastCalledWith(400);
+                expect(onData2).toHaveBeenLastCalledWith(400);
+                expect(onData3).toHaveBeenLastCalledWith(400);
+            });
+        });
+
+        describe("watch", () => {
+            it("should register dependency when watch is used in effect", async () => {
+                const $constant = constantAsync(Promise.resolve(500));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe(
+                    (t) => {
+                        $constant.watch(t);
+                    },
+                    onData,
+                    onError,
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+            });
+
+            it("should not trigger re-runs when constant is watched (immutable)", async () => {
+                const $constant = constantAsync(Promise.resolve(600));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                subscribe(
+                    (t) => {
+                        $constant.watch(t);
+                    },
+                    onData,
+                    onError,
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                // Wait to ensure effect doesn't re-run
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+        });
+
+        describe("disposal", () => {
+            it("should not dispose effects when constant is disposed", async () => {
+                const $constant = constantAsync(Promise.resolve(1200));
+                const onData = vi.fn();
+                const onError = vi.fn();
+                const $effect = subscribe(
+                    (t) => {
+                        $constant.get(t);
+                    },
+                    onData,
+                    onError,
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect($effect.disposed).toBe(false);
+
+                $constant.dispose();
+
+                expect($effect.disposed).toBe(false);
+                expect($constant.disposed).toBe(true);
+            });
+
+            it("should unregister effects when constant is disposed", async () => {
+                const $constant = constantAsync(Promise.resolve(1300));
+                const onData = vi.fn();
+                const onError = vi.fn();
+
+                const $effect = subscribe(
+                    (t) => {
+                        $constant.get(t);
+                    },
+                    onData,
+                    onError,
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $constant.dispose();
+
+                // Effect should still be active but not notified
+                expect($effect.disposed).toBe(false);
+
+                // But constant is disposed so operations should fail
+                await expect($constant.pick()).rejects.toThrow("[PicoFlow] Primitive is disposed");
+            });
+        });
+
+        describe("error handling", () => {
+            describe("compute function errors", () => {
+                it("should propagate error when used inside an async effect", async () => {
+                    const error = new Error("Effect compute error");
+                    const $constant = constantAsync(() => Promise.reject<never>(error));
+                    const onData = vi.fn();
+                    const onError = vi.fn();
+
+                    subscribe((t) => $constant.get(t), onData, onError);
+
+                    // Wait for the effect to settle and check for error
+                    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenCalledTimes(0);
+                    expect(onError).toHaveBeenCalledTimes(1);
+                    expect(onError).toHaveBeenLastCalledWith(error);
+                });
+            });
+
+            describe("disposed constant", () => {
+                it("should throw error when creating an effect with a disposed async constant", async () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+                    const onData = vi.fn();
+                    const onError = vi.fn();
+
+                    $constant.dispose();
+
+                    subscribe((t) => $constant.get(t), onData, onError);
+
+                    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenCalledTimes(0);
+                    expect(onError).toHaveBeenLastCalledWith(expect.any(Error));
+                });
+
+                it("should throw error when watching a disposed constant", async () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+                    const onData = vi.fn();
+                    const onError = vi.fn();
+
+                    $constant.dispose();
+
+                    subscribe((t) => $constant.watch(t), onData, onError);
+
+                    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenCalledTimes(0);
+                    expect(onError).toHaveBeenLastCalledWith(expect.any(Error));
+                });
+
+                it("should throw error when getting a disposed constant", async () => {
+                    const $constant = constantAsync(Promise.resolve(1));
+                    const onData = vi.fn();
+                    const onError = vi.fn();
+
+                    $constant.dispose();
+
+                    subscribe((t) => $constant.get(t), onData, onError);
+
+                    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenCalledTimes(0);
+                    expect(onError).toHaveBeenLastCalledWith(expect.any(Error));
+                });
+            });
+        });
+    });
+});