@ersbeth/picoflow 1.0.1 → 1.1.1

package/test/base/flowSignal.test.ts

@@ -0,0 +1,372 @@
+import { describe, expect, it, vi } from "vitest";
+import { effect, signal } from "#package";
+
+describe("FlowSignal", () => {
+	describe("unit", () => {
+		describe("disposal", () => {
+			it("should have disposed property set to false initially and true after disposal", () => {
+				const $signal = signal();
+				expect($signal.disposed).toBe(false);
+				$signal.dispose();
+				expect($signal.disposed).toBe(true);
+			});
+
+			it("should throw error when disposed twice", () => {
+				const $signal = signal();
+				$signal.dispose();
+				expect(() => $signal.dispose()).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should dispose signal successfully", () => {
+				const $signal = signal();
+				expect(() => $signal.dispose()).not.toThrow();
+				expect($signal.disposed).toBe(true);
+			});
+
+			it("should accept self option without throwing", () => {
+				const $signal = signal();
+				expect(() => $signal.dispose({ self: true })).not.toThrow();
+				expect($signal.disposed).toBe(true);
+			});
+
+			it("should accept default options without throwing", () => {
+				const $signal = signal();
+				expect(() => $signal.dispose()).not.toThrow();
+				expect($signal.disposed).toBe(true);
+			});
+		});
+
+		describe("trigger", () => {
+			it("should return a promise when triggered", () => {
+				const $signal = signal();
+				const result = $signal.trigger();
+				expect(result).toBeInstanceOf(Promise);
+			});
+
+			it("should throw error when trigger is called after disposal", async () => {
+				const $signal = signal();
+				$signal.dispose();
+				await expect($signal.trigger()).rejects.toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+
+			it("should allow multiple triggers", async () => {
+				const $signal = signal();
+				const promise1 = $signal.trigger();
+				const promise2 = $signal.trigger();
+				const promise3 = $signal.trigger();
+
+				expect(promise1).toBeInstanceOf(Promise);
+				expect(promise2).toBeInstanceOf(Promise);
+				expect(promise3).toBeInstanceOf(Promise);
+
+				await Promise.all([promise1, promise2, promise3]);
+			});
+		});
+
+		describe("watch", () => {
+			it("should throw error when watch is called after disposal", () => {
+				const $signal = signal();
+				const $tracker = signal(); // Use another signal as FlowTracker
+				$signal.dispose();
+				expect(() => $signal.watch($tracker)).toThrow(
+					"[PicoFlow] Primitive is disposed",
+				);
+			});
+		});
+	});
+
+	describe("integration", () => {
+		describe("with effects", () => {
+			describe("watch", () => {
+				it("should register effect when watch is called", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+					expect(effectFn).toHaveBeenCalledTimes(1);
+				});
+
+				it("should throw error when watch is called after signal disposal", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$signal.dispose();
+
+					effect((t) => {
+						expect(() => $signal.watch(t)).toThrow(
+							"[PicoFlow] Primitive is disposed",
+						);
+					});
+
+					await expect($signal.trigger()).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+			});
+
+			describe("trigger", () => {
+				it("should notify effects when triggered", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$signal.trigger();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+
+					$signal.trigger();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+				});
+
+				it("should notify multiple effects when triggered", async () => {
+					const $signal = signal();
+					const effectFn1 = vi.fn();
+					const effectFn2 = vi.fn();
+					const effectFn3 = vi.fn();
+
+					effect((t) => {
+						$signal.watch(t);
+						effectFn1();
+					});
+
+					effect((t) => {
+						$signal.watch(t);
+						effectFn2();
+					});
+
+					effect((t) => {
+						$signal.watch(t);
+						effectFn3();
+					});
+
+					await vi.waitFor(() => {
+						expect(effectFn1).toHaveBeenCalledTimes(1);
+						expect(effectFn2).toHaveBeenCalledTimes(1);
+						expect(effectFn3).toHaveBeenCalledTimes(1);
+					});
+
+					$signal.trigger();
+					await vi.waitFor(() => {
+						expect(effectFn1).toHaveBeenCalledTimes(2);
+						expect(effectFn2).toHaveBeenCalledTimes(2);
+						expect(effectFn3).toHaveBeenCalledTimes(2);
+					});
+				});
+
+				it("should not notify effects after they are disposed", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					const $effect = effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$signal.trigger();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+
+					$effect.dispose();
+
+					$signal.trigger();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+				});
+
+				it("should notify effects multiple times on multiple triggers", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$signal.trigger();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+
+					$signal.trigger();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+
+					$signal.trigger();
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(4));
+				});
+
+				it("should await trigger promise before effects complete", async () => {
+					const $signal = signal();
+					const executionOrder: string[] = [];
+					const effectFn = vi.fn();
+
+					effect((t) => {
+						$signal.watch(t);
+						executionOrder.push("effect-executed");
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+					executionOrder.push("after-initial-effect");
+
+					const triggerPromise = $signal.trigger();
+					executionOrder.push("trigger-called");
+
+					await triggerPromise;
+					executionOrder.push("trigger-resolved");
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+
+					expect(executionOrder).toEqual([
+						"effect-executed",
+						"after-initial-effect",
+						"effect-executed",
+						"trigger-called",
+						"trigger-resolved",
+					]);
+				});
+			});
+
+			describe("dispose", () => {
+				it("should dispose effects when signal is disposed", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					const $effect = effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+					expect($effect.disposed).toBe(false);
+
+					$signal.dispose();
+
+					expect($effect.disposed).toBe(true);
+
+					await expect($signal.trigger()).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+
+				it("should not dispose effects when signal is disposed with self option", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					const $effect = effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+					expect($effect.disposed).toBe(false);
+
+					$signal.dispose({ self: true });
+
+					expect($effect.disposed).toBe(false);
+					expect($signal.disposed).toBe(true);
+				});
+
+				it("should unregister effects when signal is disposed with self option", async () => {
+					const $signal = signal();
+					const effectFn = vi.fn();
+					const $effect = effect((t) => {
+						$signal.watch(t);
+						effectFn();
+					});
+
+					await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+					$signal.dispose({ self: true });
+
+					// Effect should still be active but not notified
+					expect($effect.disposed).toBe(false);
+
+					// But signal is disposed so trigger will fail
+					await expect($signal.trigger()).rejects.toThrow(
+						"[PicoFlow] Primitive is disposed",
+					);
+				});
+			});
+		});
+
+		describe("signal chaining", () => {
+			it("should notify listener signals when triggered", async () => {
+				const $signal1 = signal();
+				const $signal2 = signal();
+				const effectFn = vi.fn();
+
+				// signal2 watches signal1
+				effect((t) => {
+					$signal1.watch(t);
+					$signal2.trigger();
+				});
+
+				// effect watches signal2
+				effect((t) => {
+					$signal2.watch(t);
+					effectFn();
+				});
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				$signal1.trigger();
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+			});
+
+			// TODO: Fix this test
+			it.skip("should notify chained signals in correct order", async () => {
+				const $signal1 = signal();
+				const $signal2 = signal();
+				const $signal3 = signal();
+				const executionOrder: string[] = [];
+
+				effect((t) => {
+					$signal1.watch(t);
+					executionOrder.push("signal1-triggered");
+					$signal2.trigger();
+				});
+
+				effect((t) => {
+					$signal2.watch(t);
+					executionOrder.push("signal2-triggered");
+					$signal3.trigger();
+				});
+
+				effect((t) => {
+					$signal3.watch(t);
+					executionOrder.push("signal3-triggered");
+				});
+
+				await vi.waitFor(() =>
+					expect(executionOrder.length).toBeGreaterThan(0),
+				);
+
+				executionOrder.length = 0; // Clear initial execution
+
+				$signal1.trigger();
+				await vi.waitFor(() => expect(executionOrder.length).toBe(5));
+				console.log(executionOrder);
+
+				expect(executionOrder).toEqual([
+					"signal1-triggered",
+					"signal2-triggered",
+					"signal3-triggered",
+				]);
+			});
+		});
+	});
+});