@ersbeth/picoflow 1.1.1 → 2.0.0

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

@@ -0,0 +1,341 @@
+import { describe, expect, it, vi } from "vitest";
+import { state, subscribe } from "~";
+
+describe("flowState", () => {
+    describe("unit", () => {
+        describe("initialization", () => {
+            it("should initialize with direct value", async () => {
+                const $state = state(1);
+                expect(await $state.pick()).toBe(1);
+            });
+        });
+
+        describe("set", () => {
+            it("should update value with direct value", async () => {
+                const $state = state(1);
+                expect(await $state.pick()).toBe(1);
+
+                $state.set(2);
+                expect(await $state.pick()).toBe(2);
+            });
+
+            it("should update value with updater function", async () => {
+                const $state = state(1);
+                expect(await $state.pick()).toBe(1);
+
+                $state.set((current) => (current !== undefined ? current + 1 : 0));
+                expect(await $state.pick()).toBe(2);
+            });
+
+            it("should not notify when set with same value", async () => {
+                const $state = state(1);
+                const onData = vi.fn();
+                $state.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(1);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+            });
+
+            it("should notify when set with different value", async () => {
+                const $state = state(1);
+                const onData = vi.fn();
+                $state.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+
+            it("should not notify when updater returns same value", async () => {
+                const $state = state(5);
+                const onData = vi.fn();
+                $state.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set((current) => current ?? 0);
+
+                // Wait to ensure no additional calls
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(1);
+            });
+
+            it("should notify when updater returns different value", async () => {
+                const $state = state(5);
+                const onData = vi.fn();
+                $state.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                await $state.set((current) => (current ? current + 1 : 0));
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(6);
+            });
+        });
+
+        describe("subscribe", () => {
+            it("should call onData immediately with current value", async () => {
+                const $state = state(55);
+                const onData = vi.fn();
+
+                $state.subscribe(onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(55);
+            });
+
+            it("should call onData when value is updated", async () => {
+                const $state = state(65);
+                const onData = vi.fn();
+
+                $state.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(70);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(70);
+            });
+
+            it("should not call onData when updated with same value", async () => {
+                const $state = state(75);
+                const onData = vi.fn();
+
+                $state.subscribe(onData);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(80);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                $state.set(80);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("nesting", () => {
+            it("should handle nested states", async () => {
+                const $stateA = state(1);
+                const $stateB = state(2);
+                const $stateC = state({
+                    a: $stateA,
+                    b: $stateB,
+                });
+
+                const value = await $stateC.pick();
+                expect(value.a).toBe($stateA);
+                expect(value.b).toBe($stateB);
+            });
+
+            it("should handle state with complex object values", async () => {
+                const complexObj = {
+                    nested: { deep: { value: 42 } },
+                    array: [1, 2, 3],
+                };
+                const $state = state(complexObj);
+                const value = await $state.pick();
+                expect(value).toBe(complexObj);
+                expect(value.nested.deep.value).toBe(42);
+                expect(value.array).toEqual([1, 2, 3]);
+            });
+        });
+
+        describe("error handling", () => {
+            describe("disposed state", () => {
+                it("should throw error when set is called after disposal", async () => {
+                    const $state = state(1);
+
+                    await $state.pick();
+                    await $state.set(2);
+                    $state.dispose();
+
+                    expect(() => $state.set(3)).toThrow("[PicoFlow] Primitive is disposed");
+                });
+
+                it("should throw error when trigger is called after disposal", () => {
+                    const $state = state(1);
+                    $state.dispose();
+                    expect(() => $state.trigger()).toThrow("[PicoFlow] Primitive is disposed");
+                });
+            });
+        });
+    });
+
+    describe("with effect", () => {
+        describe("get", () => {
+            it("should call effect with initial value", async () => {
+                const $state = state(1);
+                const onData = vi.fn();
+                subscribe((t) => $state.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+            });
+
+            it("should call effect when value is updated", async () => {
+                const $state = state(1);
+                const onData = vi.fn();
+                subscribe((t) => $state.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+            });
+
+            it("should not call effect when updated with same value", async () => {
+                const $state = state(1);
+                const onData = vi.fn();
+                subscribe((t) => $state.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $state.set(2);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should not call effect after effect is disposed", async () => {
+                const $state = state(1);
+                const onData = vi.fn();
+                const $effect = subscribe((t) => $state.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                $state.set(2);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(2);
+
+                $effect.dispose();
+
+                $state.set(3);
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                expect(onData).toHaveBeenCalledTimes(2);
+            });
+
+            it("should support effect depending on multiple states", async () => {
+                const $stateA = state(5);
+                const $stateB = state(10);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => ({ a: $stateA.get(t), b: $stateB.get(t) }),
+                    (data) => onData(data.a, data.b),
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(5, 10);
+
+                $stateA.set(6);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(6, 10);
+
+                $stateB.set(11);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(6, 11);
+            });
+        });
+
+        describe("watch", () => {
+            it("should register dependency when watch is used in effect", async () => {
+                const $state = state(400);
+                const onData = vi.fn();
+
+                subscribe((t) => $state.watch(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+            });
+
+            it("should trigger re-runs when state changes after watch", async () => {
+                const $state = state(500);
+                const onData = vi.fn();
+
+                subscribe((t) => $state.watch(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                await $state.set(600);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+            });
+        });
+
+        describe("error handling", () => {
+            describe("disposed state", () => {
+                it("should throw error when triggering a disposed state", () => {
+                    const $state = state(1);
+
+                    $state.dispose();
+
+                    expect(() => $state.trigger()).toThrow("[PicoFlow] Primitive is disposed");
+                });
+
+                it("should throw error when setting a disposed state", () => {
+                    const $state = state(1);
+
+                    $state.dispose();
+
+                    expect(() => $state.set(2)).toThrow("[PicoFlow] Primitive is disposed");
+                });
+            });
+        });
+
+        describe("complex cases", () => {
+            it("should handle nested states in effects", async () => {
+                const $stateA = state(1);
+                const $stateB = state(2);
+                const $stateC = state({
+                    a: $stateA,
+                    b: $stateB,
+                });
+
+                const onData = vi.fn();
+                subscribe((t) => $stateC.get(t).a.get(t), onData);
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(1);
+
+                await $stateA.set(3);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(3);
+            });
+
+            it("should handle effect depending on multiple states", async () => {
+                const $stateA = state(10);
+                const $stateB = state(20);
+                const $stateC = state(30);
+                const onData = vi.fn();
+
+                subscribe(
+                    (t) => ({
+                        a: $stateA.get(t),
+                        b: $stateB.get(t),
+                        c: $stateC.get(t),
+                    }),
+                    (data) => onData(data.a, data.b, data.c),
+                );
+
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                expect(onData).toHaveBeenLastCalledWith(10, 20, 30);
+
+                $stateA.set(11);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                expect(onData).toHaveBeenLastCalledWith(11, 20, 30);
+
+                $stateB.set(21);
+                await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                expect(onData).toHaveBeenLastCalledWith(11, 21, 30);
+            });
+        });
+    });
+});