@ersbeth/picoflow 1.0.1 → 1.1.1

package/test/base/flowGraph.test.ts

@@ -0,0 +1,485 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { effect, FlowGraph } from "#package";
+
+describe("FlowGraph", () => {
+	beforeEach(() => {
+		FlowGraph.clear();
+	});
+
+	describe("unit", () => {
+		describe("clear", () => {
+			it("should reset all internal queues and processing state", () => {
+				// Use FlowGraph methods to populate queues
+				const notify = vi.fn();
+				FlowGraph.requestTrigger(notify);
+				FlowGraph.requestRead(() => 42);
+
+				// Clear should reset everything
+				FlowGraph.clear();
+
+				// After clear, new operations should work without interference
+				const newNotify = vi.fn();
+				const promise = FlowGraph.requestTrigger(newNotify);
+				expect(promise).toBeInstanceOf(Promise);
+			});
+
+			it("should allow multiple clear calls without errors", () => {
+				expect(() => {
+					FlowGraph.clear();
+					FlowGraph.clear();
+					FlowGraph.clear();
+				}).not.toThrow();
+			});
+		});
+	});
+
+	describe("integration", () => {
+		describe("requestRead", () => {
+			it("should process read operations synchronously", async () => {
+				const readFn = vi.fn(() => 42);
+				const promise = FlowGraph.requestRead(readFn);
+
+				expect(readFn).toHaveBeenCalled();
+				const result = await promise;
+				expect(result).toBe(42);
+			});
+
+			it("should process read operations asynchronously", async () => {
+				const readFn = vi.fn(async () => {
+					await new Promise((resolve) => setTimeout(resolve, 10));
+					return 100;
+				});
+				const promise = FlowGraph.requestRead(readFn);
+
+				const result = await promise;
+				expect(result).toBe(100);
+			});
+
+			it("should resolve promise with read value", async () => {
+				const value = "test-value";
+				const promise = FlowGraph.requestRead(() => value);
+
+				await expect(promise).resolves.toBe(value);
+			});
+
+			it("should process read operations in order", async () => {
+				const executionOrder: number[] = [];
+
+				const promise1 = FlowGraph.requestRead(() => {
+					executionOrder.push(1);
+					return 1;
+				});
+
+				const promise2 = FlowGraph.requestRead(() => {
+					executionOrder.push(2);
+					return 2;
+				});
+
+				const promise3 = FlowGraph.requestRead(() => {
+					executionOrder.push(3);
+					return 3;
+				});
+
+				await Promise.all([promise1, promise2, promise3]);
+
+				expect(executionOrder).toEqual([1, 2, 3]);
+			});
+
+			it("should stop processing after read operation", async () => {
+				const effectFn = vi.fn();
+				const $effect = effect(() => {
+					effectFn();
+				});
+
+				FlowGraph.pushEffects([$effect]);
+
+				// Read should stop processing, so effects shouldn't execute
+				await FlowGraph.requestRead(() => 42);
+
+				// Wait a bit to ensure effects don't execute
+				await new Promise((resolve) => setTimeout(resolve, 50));
+
+				// Effect should not have been executed by the read operation
+				expect(effectFn).toHaveBeenCalledTimes(1); // Only initial execution
+			});
+		});
+
+		describe("requestTrigger", () => {
+			it("should process trigger operations", async () => {
+				const notify = vi.fn();
+				const promise = FlowGraph.requestTrigger(notify);
+
+				await promise;
+				expect(notify).toHaveBeenCalled();
+			});
+
+			it("should call notify function when processing trigger", async () => {
+				const notify = vi.fn();
+				await FlowGraph.requestTrigger(notify);
+
+				expect(notify).toHaveBeenCalledTimes(1);
+			});
+
+			it("should resolve promise after trigger is processed", async () => {
+				const notify = vi.fn();
+				const promise = FlowGraph.requestTrigger(notify);
+
+				await expect(promise).resolves.toBeUndefined();
+				expect(notify).toHaveBeenCalled();
+			});
+
+			it("should process multiple triggers in order", async () => {
+				const executionOrder: string[] = [];
+				const notify1 = vi.fn(() => executionOrder.push("trigger1"));
+				const notify2 = vi.fn(() => executionOrder.push("trigger2"));
+				const notify3 = vi.fn(() => executionOrder.push("trigger3"));
+
+				const promise1 = FlowGraph.requestTrigger(notify1);
+				const promise2 = FlowGraph.requestTrigger(notify2);
+				const promise3 = FlowGraph.requestTrigger(notify3);
+
+				await Promise.all([promise1, promise2, promise3]);
+
+				expect(executionOrder).toEqual(["trigger1", "trigger2", "trigger3"]);
+			});
+
+			it("should execute effects after trigger notification", async () => {
+				const notify = vi.fn();
+				const effectFn = vi.fn();
+				const $effect = effect(() => {
+					effectFn();
+				});
+
+				FlowGraph.pushEffects([$effect]);
+
+				await FlowGraph.requestTrigger(notify);
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2)); // Initial + after trigger
+			});
+		});
+
+		describe("requestWrite", () => {
+			it("should process write operations with sync update", async () => {
+				const notify = vi.fn();
+				const update = vi.fn(() => true);
+				const promise = FlowGraph.requestWrite(notify, update);
+
+				await promise;
+				expect(update).toHaveBeenCalled();
+				expect(notify).toHaveBeenCalled();
+			});
+
+			it("should process write operations with async update", async () => {
+				const notify = vi.fn();
+				const update = vi.fn(async () => {
+					await new Promise((resolve) => setTimeout(resolve, 10));
+					return true;
+				});
+				const promise = FlowGraph.requestWrite(notify, update);
+
+				await promise;
+				expect(update).toHaveBeenCalled();
+				expect(notify).toHaveBeenCalled();
+			});
+
+			it("should call notify only when update returns true", async () => {
+				const notify1 = vi.fn();
+				const notify2 = vi.fn();
+				const notify3 = vi.fn();
+
+				await FlowGraph.requestWrite(notify1, () => true);
+				await FlowGraph.requestWrite(notify2, () => false);
+				await FlowGraph.requestWrite(notify3, () => true);
+
+				expect(notify1).toHaveBeenCalledTimes(1);
+				expect(notify2).not.toHaveBeenCalled();
+				expect(notify3).toHaveBeenCalledTimes(1);
+			});
+
+			it("should not call notify when update returns false", async () => {
+				const notify = vi.fn();
+				await FlowGraph.requestWrite(notify, () => false);
+
+				expect(notify).not.toHaveBeenCalled();
+			});
+
+			it("should resolve promise after write is processed", async () => {
+				const notify = vi.fn();
+				const update = vi.fn(() => true);
+				const promise = FlowGraph.requestWrite(notify, update);
+
+				await expect(promise).resolves.toBeUndefined();
+			});
+
+			it("should execute effects after write notification", async () => {
+				const notify = vi.fn();
+				const effectFn = vi.fn();
+				const $effect = effect(() => {
+					effectFn();
+				});
+
+				FlowGraph.pushEffects([$effect]);
+
+				await FlowGraph.requestWrite(notify, () => true);
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2)); // Initial + after write
+			});
+
+			it("should not execute effects when update returns false", async () => {
+				const notify = vi.fn();
+				const effectFn = vi.fn();
+				const $effect = effect(() => {
+					effectFn();
+				});
+
+				FlowGraph.pushEffects([$effect]);
+
+				await FlowGraph.requestWrite(notify, () => false);
+
+				// Wait to ensure effects don't execute
+				await new Promise((resolve) => setTimeout(resolve, 50));
+
+				expect(effectFn).toHaveBeenCalledTimes(1); // Only initial execution
+			});
+		});
+
+		describe("pushEffects", () => {
+			it("should queue effects for execution", async () => {
+				const effectFn1 = vi.fn();
+				const effectFn2 = vi.fn();
+				const $effect1 = effect(() => {
+					effectFn1();
+				});
+				const $effect2 = effect(() => {
+					effectFn2();
+				});
+
+				FlowGraph.pushEffects([$effect1, $effect2]);
+
+				const notify = vi.fn();
+				await FlowGraph.requestTrigger(notify);
+
+				await vi.waitFor(() => {
+					expect(effectFn1).toHaveBeenCalledTimes(2); // Initial + queued
+					expect(effectFn2).toHaveBeenCalledTimes(2); // Initial + queued
+				});
+			});
+
+			it("should execute queued effects after current operation", async () => {
+				const effectFn = vi.fn();
+				const $effect = effect(() => {
+					effectFn();
+				});
+
+				FlowGraph.pushEffects([$effect]);
+
+				const notify = vi.fn();
+				await FlowGraph.requestTrigger(notify);
+
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+			});
+
+			it("should execute multiple effects in order", async () => {
+				const executionOrder: string[] = [];
+				const $effect1 = effect(() => {
+					executionOrder.push("effect1");
+				});
+				const $effect2 = effect(() => {
+					executionOrder.push("effect2");
+				});
+				const $effect3 = effect(() => {
+					executionOrder.push("effect3");
+				});
+
+				FlowGraph.pushEffects([$effect1, $effect2, $effect3]);
+
+				const notify = vi.fn();
+				await FlowGraph.requestTrigger(notify);
+
+				await vi.waitFor(() =>
+					expect(executionOrder.length).toBeGreaterThan(3),
+				);
+
+				// Check that effects execute in order (after initial executions)
+				const lastThree = executionOrder.slice(-3);
+				expect(lastThree).toEqual(["effect1", "effect2", "effect3"]);
+			});
+
+			it("should clear effects queue after execution", async () => {
+				const effectFn1 = vi.fn();
+				const effectFn2 = vi.fn();
+				const $effect1 = effect(() => {
+					effectFn1();
+				});
+				const $effect2 = effect(() => {
+					effectFn2();
+				});
+
+				FlowGraph.pushEffects([$effect1, $effect2]);
+
+				const notify1 = vi.fn();
+				await FlowGraph.requestTrigger(notify1);
+
+				await vi.waitFor(() => {
+					expect(effectFn1).toHaveBeenCalledTimes(2);
+					expect(effectFn2).toHaveBeenCalledTimes(2);
+				});
+
+				// Push effects again and trigger - should execute again
+				FlowGraph.pushEffects([$effect1, $effect2]);
+
+				const notify2 = vi.fn();
+				await FlowGraph.requestTrigger(notify2);
+
+				await vi.waitFor(() => {
+					expect(effectFn1).toHaveBeenCalledTimes(3);
+					expect(effectFn2).toHaveBeenCalledTimes(3);
+				});
+			});
+
+			it("should handle async effects", async () => {
+				const executionOrder: string[] = [];
+				const $effect = effect(async () => {
+					executionOrder.push("effect-start");
+					await new Promise((resolve) => setTimeout(resolve, 10));
+					executionOrder.push("effect-end");
+				});
+
+				FlowGraph.pushEffects([$effect]);
+
+				const notify = vi.fn();
+				const promise = FlowGraph.requestTrigger(notify);
+
+				executionOrder.push("trigger-called");
+
+				await promise;
+				executionOrder.push("trigger-resolved");
+
+				await vi.waitFor(() => expect(executionOrder).toContain("effect-end"));
+
+				expect(executionOrder).toContain("effect-start");
+				expect(executionOrder).toContain("effect-end");
+			});
+		});
+
+		describe("operation ordering", () => {
+			it("should process operations in correct order (read stops, write/trigger continue)", async () => {
+				const executionOrder: string[] = [];
+				const effectFn = vi.fn(() => executionOrder.push("effect"));
+				const $effect = effect(() => {
+					effectFn();
+				});
+
+				FlowGraph.pushEffects([$effect]);
+
+				// Read should stop processing
+				await FlowGraph.requestRead(() => {
+					executionOrder.push("read");
+					return 1;
+				});
+
+				executionOrder.push("after-read");
+
+				// Write should continue and execute effects
+				await FlowGraph.requestWrite(
+					() => executionOrder.push("write-notify"),
+					() => {
+						executionOrder.push("write-update");
+						return true;
+					},
+				);
+
+				executionOrder.push("after-write");
+
+				await vi.waitFor(() =>
+					expect(executionOrder.length).toBeGreaterThan(5),
+				);
+
+				// Read should not trigger effects
+				expect(
+					executionOrder.filter((x) => x === "effect").length,
+				).toBeGreaterThan(1); // At least initial + after write
+			});
+
+			it("should handle mixed operation types in queue", async () => {
+				const executionOrder: string[] = [];
+
+				const read1 = FlowGraph.requestRead(() => {
+					executionOrder.push("read1");
+					return 1;
+				});
+
+				const trigger1 = FlowGraph.requestTrigger(() => {
+					executionOrder.push("trigger1");
+				});
+
+				const write1 = FlowGraph.requestWrite(
+					() => executionOrder.push("write1-notify"),
+					() => {
+						executionOrder.push("write1-update");
+						return true;
+					},
+				);
+
+				const read2 = FlowGraph.requestRead(() => {
+					executionOrder.push("read2");
+					return 2;
+				});
+
+				await Promise.all([read1, trigger1, write1, read2]);
+
+				// Reads should execute first (stopping processing), then trigger/write
+				expect(executionOrder).toContain("read1");
+				expect(executionOrder).toContain("read2");
+				expect(executionOrder).toContain("trigger1");
+				expect(executionOrder).toContain("write1-update");
+			});
+
+			it("should prevent concurrent queue processing", async () => {
+				const executionOrder: string[] = [];
+
+				// Start multiple operations rapidly
+				const promises = [];
+				for (let i = 0; i < 5; i++) {
+					promises.push(
+						FlowGraph.requestTrigger(() => {
+							executionOrder.push(`trigger-${i}`);
+						}),
+					);
+				}
+
+				await Promise.all(promises);
+
+				// All triggers should have been processed sequentially
+				expect(executionOrder.length).toBe(5);
+				for (let i = 0; i < 5; i++) {
+					expect(executionOrder).toContain(`trigger-${i}`);
+				}
+			});
+
+			it("should execute effects after each write/trigger but not after read", async () => {
+				const effectFn = vi.fn();
+				const $effect = effect(() => {
+					effectFn();
+				});
+
+				// Initial execution
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				// Read should not trigger effects
+				FlowGraph.pushEffects([$effect]);
+				await FlowGraph.requestRead(() => 1);
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(1));
+
+				// Write should trigger effects
+				await FlowGraph.requestWrite(vi.fn(), () => true);
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(2));
+
+				// Trigger should trigger effects
+				FlowGraph.pushEffects([$effect]);
+				await FlowGraph.requestTrigger(vi.fn());
+				await vi.waitFor(() => expect(effectFn).toHaveBeenCalledTimes(3));
+			});
+		});
+	});
+});