@ersbeth/picoflow 1.1.1 → 2.0.0

package/test/reactivity/flowSignal.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, it, vi } from "vitest";
+import { signal, subscribe } from "~";
+
+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()).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 void when triggered", () => {
+                const $signal = signal();
+                const result = $signal.trigger();
+                expect(result).toBeUndefined();
+            });
+
+            it("should throw error when trigger is called after disposal", () => {
+                const $signal = signal();
+                $signal.dispose();
+                expect(() => $signal.trigger()).toThrow("[PicoFlow] Primitive is disposed");
+            });
+
+            it("should allow multiple triggers", () => {
+                const $signal = signal();
+                $signal.trigger();
+                $signal.trigger();
+                $signal.trigger();
+                // Should not throw
+                expect(true).toBe(true);
+            });
+        });
+    });
+
+    describe("integration", () => {
+        describe("with effects", () => {
+            describe("watch", () => {
+                it("should register effect when watch is called", async () => {
+                    const $signal = signal();
+                    const onData = vi.fn();
+                    subscribe((t) => $signal.watch(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect(onData).toHaveBeenCalledTimes(1);
+                });
+
+                it("should throw error when watch is called after signal disposal", async () => {
+                    const $signal = signal();
+                    const onData1 = vi.fn();
+                    subscribe((t) => $signal.watch(t), onData1);
+
+                    await vi.waitFor(() => expect(onData1).toHaveBeenCalledTimes(1));
+
+                    $signal.dispose();
+
+                    const onData2 = vi.fn();
+                    const onError = vi.fn();
+
+                    subscribe((t) => $signal.watch(t), onData2, onError);
+
+                    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+                    expect(onData2).toHaveBeenCalledTimes(0);
+                    expect(onError).toHaveBeenLastCalledWith(expect.any(Error));
+
+                    expect(() => $signal.trigger()).toThrow("[PicoFlow] Primitive is disposed");
+                });
+            });
+
+            describe("trigger", () => {
+                it("should notify effects when triggered", async () => {
+                    const $signal = signal();
+                    const onData = vi.fn();
+                    subscribe((t) => $signal.watch(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                    $signal.trigger();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                    $signal.trigger();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+                });
+
+                it("should notify multiple effects when triggered", async () => {
+                    const $signal = signal();
+                    const onData1 = vi.fn();
+                    const onData2 = vi.fn();
+                    const onData3 = vi.fn();
+
+                    subscribe((t) => $signal.watch(t), onData1);
+
+                    subscribe((t) => $signal.watch(t), onData2);
+
+                    subscribe((t) => $signal.watch(t), onData3);
+
+                    await vi.waitFor(() => {
+                        expect(onData1).toHaveBeenCalledTimes(1);
+                        expect(onData2).toHaveBeenCalledTimes(1);
+                        expect(onData3).toHaveBeenCalledTimes(1);
+                    });
+
+                    $signal.trigger();
+                    await vi.waitFor(() => {
+                        expect(onData1).toHaveBeenCalledTimes(2);
+                        expect(onData2).toHaveBeenCalledTimes(2);
+                        expect(onData3).toHaveBeenCalledTimes(2);
+                    });
+                });
+
+                it("should not notify effects after they are disposed", async () => {
+                    const $signal = signal();
+                    const onData = vi.fn();
+                    const $effect = subscribe((t) => $signal.watch(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                    $signal.trigger();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                    $effect.dispose();
+
+                    $signal.trigger();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+                });
+
+                it("should notify effects multiple times on multiple triggers", async () => {
+                    const $signal = signal();
+                    const onData = vi.fn();
+                    subscribe((t) => $signal.watch(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                    $signal.trigger();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(2));
+
+                    $signal.trigger();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(3));
+
+                    $signal.trigger();
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+                });
+
+                it("should execute effects asynchronously when triggered", async () => {
+                    const $signal = signal();
+                    const onData = vi.fn();
+
+                    subscribe(
+                        (t) => $signal.watch(t),
+                        () => onData("effect-executed"),
+                    );
+
+                    onData("after-initial-effect");
+                    $signal.trigger();
+                    onData("trigger-called");
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(4));
+
+                    expect(onData).toHaveBeenNthCalledWith(1, "effect-executed");
+                    expect(onData).toHaveBeenNthCalledWith(2, "after-initial-effect");
+                    expect(onData).toHaveBeenNthCalledWith(3, "trigger-called");
+                    expect(onData).toHaveBeenNthCalledWith(4, "effect-executed");
+                });
+            });
+
+            describe("dispose", () => {
+                it("should not dispose effects when signal is disposed", async () => {
+                    const $signal = signal();
+                    const onData = vi.fn();
+                    const $effect = subscribe((t) => $signal.watch(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+                    expect($effect.disposed).toBe(false);
+
+                    $signal.dispose();
+
+                    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 onData = vi.fn();
+                    const $effect = subscribe((t) => $signal.watch(t), onData);
+
+                    await vi.waitFor(() => expect(onData).toHaveBeenCalledTimes(1));
+
+                    $signal.dispose();
+
+                    // Effect should still be active but not notified
+                    expect($effect.disposed).toBe(false);
+
+                    // But signal is disposed so trigger will fail
+                    expect(() => $signal.trigger()).toThrow("[PicoFlow] Primitive is disposed");
+                });
+            });
+        });
+    });
+});