@ersbeth/picoflow 2.0.1 → 2.0.3

package/test/reactivity/nodes/sync/flowConstant.test.ts

@@ -1,377 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { constant, subscribe } from "~";
-import { EffectNode } from "~/nodes";
-
-describe("flowConstant", () => {
-    describe("unit", () => {
-        describe("initialization / pick", () => {
-            it("should initialize with initializer function", async () => {
-                const $constant = constant(() => 1);
-                expect(await $constant.pick()).toBe(1);
-            });
-
-            it("should compute initial value lazily on first access", async () => {
-                const computeFn = vi.fn(() => 42);
-                const $constant = constant(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(() => 100);
-                const $constant = constant(computeFn);
-
-                // Multiple accesses should only call compute once
-                await $constant.pick();
-                await $constant.pick();
-                await $constant.pick();
-
-                expect(computeFn).toHaveBeenCalledTimes(1);
-            });
-
-            it("should cache i value after initialization", async () => {
-                const computeFn = vi.fn(() => "cached");
-                const $constant = constant(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 = constant(() => {
-                    // Closure captures external value at computation time
-                    return 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 = constant(() => 42);
-                expect(await $constant.pick()).toBe(42);
-            });
-
-            it("should handle string values", async () => {
-                const $constant = constant(() => "hello");
-                expect(await $constant.pick()).toBe("hello");
-            });
-
-            it("should handle object values", async () => {
-                const obj = { a: 1, b: 2 };
-                const $constant = constant(() => 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 = constant(() => arr);
-                const value = await $constant.pick();
-                expect(value).toBe(arr);
-                expect(value).toEqual([1, 2, 3]);
-            });
-
-            it("should handle undefined values", async () => {
-                const $constant = constant(() => undefined);
-                const value = await $constant.pick();
-                expect(value).toBeUndefined();
-            });
-
-            it("should handle null values", async () => {
-                const $constant = constant(() => 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 = constant(() => 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 = constant(() => 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 throwing initializer function", async () => {
-                    const error = new Error("Compute error");
-                    const $constant = constant(() => {
-                        throw error;
-                    });
-
-                    await expect($constant.pick()).rejects.toThrow("Compute error");
-                });
-            });
-        });
-
-        describe("disposal", () => {
-            it("should have disposed property set to false initially", () => {
-                const $constant = constant(() => 1);
-                expect($constant.disposed).toBe(false);
-            });
-
-            it("should have disposed property set to true after disposal", () => {
-                const $constant = constant(() => 1);
-                $constant.dispose();
-                expect($constant.disposed).toBe(true);
-            });
-
-            describe("error handling", () => {
-                it("should throw error when disposed twice", () => {
-                    const $constant = constant(() => 1);
-                    $constant.dispose();
-                    expect(() => $constant.dispose()).toThrow("[PicoFlow] Primitive is disposed");
-                });
-            });
-        });
-
-        describe("subscribe", () => {
-            it("should return an effect", () => {
-                const $constant = constant(() => 50);
-                const onData = vi.fn();
-                const effect = $constant.subscribe(onData);
-
-                expect(effect).toBeInstanceOf(EffectNode);
-            });
-
-            it("should call onData immediately with lazy init value", async () => {
-                const $constant = constant(() => 55);
-                const onData = vi.fn();
-
-                $constant.subscribe(onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(55);
-            });
-
-            it("should not call onData after disposal of constant", async () => {
-                const $constant = constant(() => 60);
-                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 = constant(() => 65);
-                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 = constant(() => 70);
-                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(70);
-                expect(onData2).toHaveBeenLastCalledWith(70);
-                expect(onData3).toHaveBeenLastCalledWith(70);
-            });
-
-            describe("error handling", () => {
-                it("should throw error when subscribe is called after disposal", () => {
-                    const $constant = constant(() => 1);
-                    const onData = vi.fn();
-
-                    $constant.dispose();
-
-                    expect(() => $constant.subscribe(onData)).toThrow("[PicoFlow] Primitive is disposed");
-                });
-            });
-        });
-    });
-
-    describe("with effect", () => {
-        describe("get", () => {
-            it("should call effect with lazy init value", async () => {
-                const $constant = constant(() => 100);
-                const onData = vi.fn();
-
-                subscribe((t) => $constant.get(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(100);
-            });
-
-            it("should not re-execute effect when closure is mutated", async () => {
-                let capturedValue = 5;
-                const $constant = constant(() => capturedValue * 3);
-
-                const onData = vi.fn();
-                subscribe((t) => $constant.get(t), onData);
-
-                // 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 vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-                expect(onData).toHaveBeenLastCalledWith(15);
-            });
-
-            it("should support multiple effects depending on same constant", async () => {
-                const $constant = constant(() => 300);
-                const onData1 = vi.fn();
-                const onData2 = vi.fn();
-                const onData3 = vi.fn();
-
-                subscribe((t) => $constant.get(t), onData1);
-                subscribe((t) => $constant.get(t), onData2);
-                subscribe((t) => $constant.get(t), onData3);
-
-                await vi.waitFor(() => {
-                    expect(onData1).toHaveBeenCalledTimes(1);
-                    expect(onData2).toHaveBeenCalledTimes(1);
-                    expect(onData3).toHaveBeenCalledTimes(1);
-                });
-
-                expect(onData1).toHaveBeenLastCalledWith(300);
-                expect(onData2).toHaveBeenLastCalledWith(300);
-                expect(onData3).toHaveBeenLastCalledWith(300);
-            });
-        });
-
-        describe("watch", () => {
-            it("should register dependency when watch is used in effect", async () => {
-                const $constant = constant(() => 400);
-                const onData = vi.fn();
-
-                subscribe((t) => $constant.watch(t), onData);
-
-                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
-            });
-        });
-
-        describe("disposal", () => {
-            it("should not dispose effects when constant is disposed", async () => {
-                const $constant = constant(() => 1000);
-                const onData = vi.fn();
-                const $effect = subscribe((t) => $constant.get(t), onData);
-
-                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 = constant(() => 1100);
-                const onData = vi.fn();
-                const $effect = subscribe((t) => $constant.get(t), onData);
-
-                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 effect", async () => {
-                    const error = new Error("Effect compute error");
-                    const $constant = constant(() => {
-                        throw error;
-                    });
-
-                    const onData = vi.fn();
-                    const onError = vi.fn();
-                    subscribe((t) => $constant.get(t), onData, onError);
-
-                    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
-                    expect(onError).toHaveBeenLastCalledWith(error);
-                });
-            });
-
-            describe("disposed constant", () => {
-                it("should throw error when watching a disposed constant", async () => {
-                    const $constant = constant(() => 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(onError).toHaveBeenLastCalledWith(expect.any(Error));
-                });
-
-                it("should throw error when getting a disposed constant", async () => {
-                    const $constant = constant(() => 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(onError).toHaveBeenLastCalledWith(expect.any(Error));
-                });
-            });
-        });
-    });
-});