@ersbeth/picoflow 1.1.2 → 2.0.0

package/test/base/flowGraph.test.ts

@@ -1,485 +0,0 @@
-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));
-			});
-		});
-	});
-});