@ersbeth/picoflow 1.0.1 → 1.1.0

package/test/nodes/await/flowConstantAwait.test.ts

@@ -0,0 +1,643 @@
+import { describe, expect, it, vi } from "vitest";
+import { constantAwait, effect, state } from "#package";
+
+describe("flowConstantAwait", () => {
+	describe("unit", () => {
+		describe("initialization", () => {
+			it("should initialize with direct Promise", async () => {
+				const $constant = constantAwait(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 = constantAwait(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 not call lazy function on creation", () => {
+				const initFn = vi.fn(() => Promise.resolve(100));
+				constantAwait(initFn);
+
+				expect(initFn).not.toHaveBeenCalled();
+			});
+
+			it("should call lazy function on first access", async () => {
+				const initFn = vi.fn(() => Promise.resolve(200));
+				const $constant = constantAwait(initFn);
+
+				expect(initFn).not.toHaveBeenCalled();
+				await $constant.pick();
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should call lazy function only once", async () => {
+				const initFn = vi.fn(() => Promise.resolve(300));
+				const $constant = constantAwait(initFn);
+
+				// Multiple accesses should only call init once
+				await $constant.pick();
+				await $constant.pick();
+				await $constant.pick();
+
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should cache value after lazy initialization", async () => {
+				const initFn = vi.fn(() => Promise.resolve("cached"));
+				const $constant = constantAwait(initFn);
+
+				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(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should handle number values", async () => {
+				const $constant = constantAwait(Promise.resolve(42));
+				expect(await $constant.pick()).toBe(42);
+			});
+
+			it("should handle string values", async () => {
+				const $constant = constantAwait(Promise.resolve("hello"));
+				expect(await $constant.pick()).toBe("hello");
+			});
+
+			it("should handle object values", async () => {
+				const obj = { a: 1, b: 2 };
+				const $constant = constantAwait(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 = constantAwait(Promise.resolve(arr));
+				const value = await $constant.pick();
+				expect(value).toBe(arr);
+				expect(value).toEqual([1, 2, 3]);
+			});
+
+			it("should handle null values", async () => {
+				const $constant = constantAwait(Promise.resolve(null));
+				const value = await $constant.pick();
+				expect(value).toBeNull();
+			});
+
+			it("should handle undefined values", async () => {
+				const $constant = constantAwait(Promise.resolve(undefined));
+				const value = await $constant.pick();
+				expect(value).toBeUndefined();
+			});
+		});
+
+		describe("get", () => {
+			it("should return resolved value with tracking context", async () => {
+				const $constant = constantAwait(Promise.resolve(5));
+				const $tracker = state(0); // Use state as FlowTracker
+
+				// Wait for Promise to resolve first
+				await $constant.pick();
+
+				const value = $constant.get($tracker);
+				expect(value).toBe(5);
+			});
+
+			it("should return undefined if Promise not yet resolved", () => {
+				// Create a Promise that resolves after a delay
+				const $constant = constantAwait(
+					new Promise<number>((resolve) => setTimeout(() => resolve(10), 100)),
+				);
+				const $tracker = state(0);
+
+				// Before Promise resolves, get() should return undefined
+				const value = $constant.get($tracker);
+				expect(value).toBeUndefined();
+			});
+
+			it("should compute lazy value on first get call", async () => {
+				const initFn = vi.fn(() => Promise.resolve(10));
+				const $constant = constantAwait(initFn);
+				const $tracker = state(0);
+
+				expect(initFn).not.toHaveBeenCalled();
+
+				// First get() may return undefined, but triggers computation
+				$constant.get($tracker);
+				// Wait for Promise to resolve
+				await $constant.pick();
+
+				const value2 = $constant.get($tracker);
+				expect(value2).toBe(10);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should return cached value on subsequent get calls", async () => {
+				const initFn = vi.fn(() => Promise.resolve(20));
+				const $constant = constantAwait(initFn);
+				const $tracker = state(0);
+
+				// Wait for initial resolution
+				await $constant.pick();
+
+				const value1 = $constant.get($tracker);
+				const value2 = $constant.get($tracker);
+				const value3 = $constant.get($tracker);
+
+				expect(value1).toBe(20);
+				expect(value2).toBe(20);
+				expect(value3).toBe(20);
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should throw error when get is called after disposal", async () => {
+				const $constant = constantAwait(Promise.resolve(1));
+				const $tracker = state(0);
+
+				await $constant.pick();
+				$constant.get($tracker);
+				$constant.dispose();
+
+				expect(() => $constant.get($tracker)).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("pick", () => {
+			it("should return Promise without tracking", async () => {
+				const $constant = constantAwait(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 = constantAwait(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 = constantAwait(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 = constantAwait(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 = constantAwait(Promise.resolve(1));
+
+				expect(await $constant.pick()).toBe(1);
+
+				$constant.dispose();
+
+				await expect($constant.pick()).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("watch", () => {
+			it("should register dependency when watch is called", () => {
+				const $constant = constantAwait(Promise.resolve(35));
+				const $tracker = state(0);
+
+				expect(() => $constant.watch($tracker)).not.toThrow();
+			});
+
+			it("should compute lazy value when watch is called", async () => {
+				const initFn = vi.fn(() => Promise.resolve(40));
+				const $constant = constantAwait(initFn);
+				const $tracker = state(0);
+
+				expect(initFn).not.toHaveBeenCalled();
+				$constant.watch($tracker);
+				// Wait a bit for the computation to complete
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				expect(initFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should throw error when watch is called after disposal", () => {
+				const $constant = constantAwait(Promise.resolve(1));
+				const $tracker = state(0);
+
+				$constant.watch($tracker);
+				$constant.dispose();
+
+				expect(() => $constant.watch($tracker)).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("subscribe", () => {
+			it("should return a disposer function", () => {
+				const $constant = constantAwait(Promise.resolve(50));
+				const listener = vi.fn();
+				const disposer = $constant.subscribe(listener);
+
+				expect(typeof disposer).toBe("function");
+			});
+
+			it("should call listener immediately with resolved value (T | undefined)", async () => {
+				const $constant = constantAwait(Promise.resolve(55));
+				const listener = vi.fn();
+
+				$constant.subscribe(listener);
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+				expect(listener).toHaveBeenLastCalledWith(55);
+			});
+
+			it("should not call listener after constant disposal", async () => {
+				const $constant = constantAwait(Promise.resolve(65));
+				const listener = vi.fn();
+
+				$constant.subscribe(listener);
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				$constant.dispose();
+
+				// Wait to ensure listener is not called again
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(listener).toHaveBeenCalledTimes(1);
+			});
+
+			it("should not call listener after disposer is called", async () => {
+				const $constant = constantAwait(Promise.resolve(70));
+				const listener = vi.fn();
+
+				const disposer = $constant.subscribe(listener);
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				disposer();
+
+				// Wait to ensure listener is not called again
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(listener).toHaveBeenCalledTimes(1);
+			});
+
+			it("should support multiple subscriptions", async () => {
+				const $constant = constantAwait(Promise.resolve(75));
+				const listener1 = vi.fn();
+				const listener2 = vi.fn();
+				const listener3 = vi.fn();
+
+				$constant.subscribe(listener1);
+				$constant.subscribe(listener2);
+				$constant.subscribe(listener3);
+
+				await vi.waitFor(() => {
+					expect(listener1).toHaveBeenCalledTimes(1);
+					expect(listener2).toHaveBeenCalledTimes(1);
+					expect(listener3).toHaveBeenCalledTimes(1);
+				});
+
+				// All listeners receive the resolved value (T | undefined), not Promise
+				const value1 = listener1.mock.calls[0][0];
+				const value2 = listener2.mock.calls[0][0];
+				const value3 = listener3.mock.calls[0][0];
+				expect(value1).toBe(75);
+				expect(value2).toBe(75);
+				expect(value3).toBe(75);
+				expect(value1).not.toBeInstanceOf(Promise);
+			});
+
+			it("should throw error when subscribe is called after disposal", () => {
+				const $constant = constantAwait(Promise.resolve(1));
+				const listener = vi.fn();
+
+				$constant.dispose();
+
+				expect(() => $constant.subscribe(listener)).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("disposal", () => {
+			it("should have disposed property set to false initially", () => {
+				const $constant = constantAwait(Promise.resolve(1));
+				expect($constant.disposed).toBe(false);
+			});
+
+			it("should have disposed property set to true after disposal", () => {
+				const $constant = constantAwait(Promise.resolve(1));
+				$constant.dispose();
+				expect($constant.disposed).toBe(true);
+			});
+
+			it("should throw error when disposed twice", () => {
+				const $constant = constantAwait(Promise.resolve(1));
+				$constant.dispose();
+				expect(() => $constant.dispose()).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+
+		describe("special cases", () => {
+			// TODO: Fix this test
+			it.skip("should handle Promise that rejects", async () => {
+				const error = new Error("Promise rejected");
+				const $constant = constantAwait(Promise.reject(error));
+
+				await expect($constant.pick()).rejects.toThrow("Promise rejected");
+			});
+
+			// TODO: Fix this test
+			it.skip("should handle lazy function that rejects", async () => {
+				const error = new Error("Lazy function rejected");
+				const $constant = constantAwait(() => Promise.reject(error));
+
+				await expect($constant.pick()).rejects.toThrow(
+					"Lazy function rejected",
+				);
+			});
+
+			it("should handle Promise that resolves to null", async () => {
+				const $constant = constantAwait(Promise.resolve(null));
+				const value = await $constant.pick();
+				expect(value).toBeNull();
+			});
+
+			it("should handle Promise that resolves to undefined", async () => {
+				const $constant = constantAwait(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 = constantAwait(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("integration", () => {
+		describe("with effects - get", () => {
+			it("should create reactive dependency when get is used in effect", async () => {
+				const $constant = constantAwait(Promise.resolve(100));
+				const effectFn = vi.fn();
+
+				effect((t) => {
+					$constant.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+			});
+
+			it("should call effect with initial value", async () => {
+				const $constant = constantAwait(Promise.resolve(1));
+				const effectFn = vi.fn();
+
+				effect((t) => {
+					const value = $constant.get(t);
+					effectFn(value);
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				// Value might be undefined on first call if Promise hasn't resolved
+				// Wait a bit more for Promise to resolve
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				// Check that eventually the value is correct
+				const lastCall = effectFn.mock.calls[effectFn.mock.calls.length - 1];
+				expect(lastCall[0]).toBe(1);
+			});
+
+			it("should call effect with lazy init value", async () => {
+				const $constant = constantAwait(() => Promise.resolve(1));
+				const effectFn = vi.fn();
+
+				effect((t) => {
+					effectFn($constant.get(t));
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect(effectFn).toHaveBeenLastCalledWith(1);
+			});
+
+			it("should not re-execute effect when constant value does not change", async () => {
+				const $constant = constantAwait(Promise.resolve(300));
+				const effectFn = vi.fn();
+
+				effect((t) => {
+					$constant.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				// Wait to ensure effect doesn't re-run (constant is immutable)
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(effectFn).toHaveBeenCalledTimes(1);
+			});
+
+			it("should support multiple effects depending on same constant", async () => {
+				const $constant = constantAwait(Promise.resolve(400));
+				const effectFn1 = vi.fn();
+				const effectFn2 = vi.fn();
+				const effectFn3 = vi.fn();
+
+				effect((t) => {
+					$constant.get(t);
+					effectFn1();
+				});
+
+				effect((t) => {
+					$constant.get(t);
+					effectFn2();
+				});
+
+				effect((t) => {
+					$constant.get(t);
+					effectFn3();
+				});
+
+				await vi.waitFor(() => {
+					expect(effectFn1).toHaveBeenCalledTimes(1);
+					expect(effectFn2).toHaveBeenCalledTimes(1);
+					expect(effectFn3).toHaveBeenCalledTimes(1);
+				});
+			});
+		});
+
+		describe("with effects - watch", () => {
+			it("should register dependency when watch is used in effect", async () => {
+				const $constant = constantAwait(Promise.resolve(500));
+				const effectFn = vi.fn();
+
+				effect((t) => {
+					$constant.watch(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+			});
+
+			it("should not trigger re-runs when constant is watched (immutable)", async () => {
+				const $constant = constantAwait(Promise.resolve(600));
+				const effectFn = vi.fn();
+
+				effect((t) => {
+					$constant.watch(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				// Wait to ensure effect doesn't re-run
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(effectFn).toHaveBeenCalledTimes(1);
+			});
+		});
+
+		describe("with effects - subscribe", () => {
+			it("should call listener immediately when subscribe is used", async () => {
+				const $constant = constantAwait(Promise.resolve(700));
+				const listener = vi.fn();
+
+				$constant.subscribe(listener);
+
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+				expect(listener).toHaveBeenCalledTimes(1);
+
+				// Listener receives T | undefined, not Promise<T>
+				const receivedValue = listener.mock.calls[0][0];
+				expect(receivedValue).toBe(700);
+				expect(receivedValue).not.toBeInstanceOf(Promise);
+			});
+
+			it("should support multiple subscriptions with effects", async () => {
+				const $constant = constantAwait(Promise.resolve(900));
+				const listener1 = vi.fn();
+				const listener2 = vi.fn();
+
+				$constant.subscribe(listener1);
+				$constant.subscribe(listener2);
+
+				await vi.waitFor(() => {
+					expect(listener1).toHaveBeenCalledTimes(1);
+					expect(listener2).toHaveBeenCalledTimes(1);
+				});
+			});
+
+			it("should dispose effect when disposer is called", async () => {
+				const $constant = constantAwait(Promise.resolve(1000));
+				const listener = vi.fn();
+
+				const unsubscribe = $constant.subscribe(listener);
+				await vi.waitFor(() => expect(listener).toHaveBeenCalledTimes(1));
+
+				unsubscribe();
+
+				// Wait to ensure listener is not called again
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				expect(listener).toHaveBeenCalledTimes(1);
+			});
+		});
+
+		describe("with effects - disposal", () => {
+			it("should dispose effects when constant is disposed", async () => {
+				const $constant = constantAwait(Promise.resolve(1100));
+				const effectFn = vi.fn();
+				const $effect = effect((t) => {
+					$constant.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect($effect.disposed).toBe(false);
+
+				$constant.dispose();
+
+				expect($effect.disposed).toBe(true);
+			});
+
+			it("should not dispose effects when constant is disposed with self option", async () => {
+				const $constant = constantAwait(Promise.resolve(1200));
+				const effectFn = vi.fn();
+				const $effect = effect((t) => {
+					$constant.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+				expect($effect.disposed).toBe(false);
+
+				$constant.dispose({ self: true });
+
+				expect($effect.disposed).toBe(false);
+				expect($constant.disposed).toBe(true);
+			});
+
+			it("should unregister effects when constant is disposed with self option", async () => {
+				const $constant = constantAwait(Promise.resolve(1300));
+				const effectFn = vi.fn();
+				const $effect = effect((t) => {
+					$constant.get(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				$constant.dispose({ self: true });
+
+				// Effect should still be active but not notified
+				expect($effect.disposed).toBe(false);
+
+				// But constant is disposed so operations should fail
+				const $tracker = state(0);
+				expect(() => $constant.get($tracker)).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+	});
+});