@cplieger/reactive 1.0.1 → 1.0.2

package/src/redteam3.test.ts

@@ -1,771 +0,0 @@
-// @vitest-environment happy-dom
-// RED-TEAM round-3 final convergence sweep
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import {
-  signal,
-  effect,
-  batch,
-  computed,
-  untracked,
-  subscribe,
-  setEffectErrorHandler,
-  createStore,
-  reconcile,
-  patch,
-  reconcileChildren,
-} from "./index.js";
-import type { EffectErrorHandler, ReadonlySignal } from "./index.js";
-
-// ---------------------------------------------------------------------------
-// 1. Verify round-1/2 fixes are sound
-// ---------------------------------------------------------------------------
-
-describe("round-1/2 fix verification", () => {
-  let prevHandler: EffectErrorHandler;
-  beforeEach(() => {
-    prevHandler = setEffectErrorHandler(() => {
-      /* swallow */
-    });
-  });
-  afterEach(() => {
-    setEffectErrorHandler(prevHandler);
-  });
-
-  it("drainPending try/finally: flushing resets even with cascading throws", () => {
-    const s = signal(0);
-    // Create 3 effects that all throw
-    effect(() => {
-      if (s.value > 0) {
-        throw new Error("e1");
-      }
-      return undefined;
-    });
-    effect(() => {
-      if (s.value > 0) {
-        throw new Error("e2");
-      }
-      return undefined;
-    });
-    effect(() => {
-      if (s.value > 0) {
-        throw new Error("e3");
-      }
-      return undefined;
-    });
-    s.value = 1;
-    // System must still work
-    const spy = vi.fn();
-    effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    s.value = 2;
-    expect(spy).toHaveBeenCalledWith(2);
-  });
-
-  it("dispose re-entrancy guard: rapid dispose-dispose-dispose", () => {
-    const s = signal(0);
-    let cleanups = 0;
-    const dispose = effect(() => {
-      void s.value;
-      return () => {
-        cleanups++;
-      };
-    });
-    dispose();
-    dispose();
-    dispose();
-    expect(cleanups).toBe(1);
-  });
-
-  it("cleanup cleared before invocation prevents double-call on re-trigger", () => {
-    const s = signal(0);
-    let cleanups = 0;
-    effect(() => {
-      void s.value;
-      return () => {
-        cleanups++;
-      };
-    });
-    s.value = 1;
-    s.value = 2;
-    s.value = 3;
-    expect(cleanups).toBe(3); // exactly one per re-run
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. Pathological diamond/fan-out graphs
-// ---------------------------------------------------------------------------
-
-describe("pathological graphs", () => {
-  it("deep diamond (10 levels) fires leaf effect exactly once per change", () => {
-    const root = signal(0);
-    // Build diamond: each level splits into 2 computeds that merge at next level
-    let nodes: ReadonlySignal<number>[] = [computed(() => root.value)];
-    for (let level = 0; level < 10; level++) {
-      const next: ReadonlySignal<number>[] = [];
-      for (const n of nodes) {
-        next.push(computed(() => n.value + 1));
-        next.push(computed(() => n.value + 2));
-      }
-      // Merge pairs
-      const merged: ReadonlySignal<number>[] = [];
-      for (let i = 0; i < next.length; i += 2) {
-        merged.push(computed(() => next[i]!.value + next[i + 1]!.value));
-      }
-      nodes = merged;
-    }
-    const leaf = nodes[0]!;
-    const spy = vi.fn();
-    effect(() => {
-      spy(leaf.value);
-      return undefined;
-    });
-    spy.mockClear();
-    root.value = 1;
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it("fan-out: 100 effects on same signal, all fire exactly once", () => {
-    const s = signal(0);
-    const spies = Array.from({ length: 100 }, () => vi.fn());
-    for (const spy of spies) {
-      effect(() => {
-        spy(s.value);
-        return undefined;
-      });
-    }
-    for (const spy of spies) {
-      spy.mockClear();
-    }
-    s.value = 1;
-    for (const spy of spies) {
-      expect(spy).toHaveBeenCalledTimes(1);
-      expect(spy).toHaveBeenCalledWith(1);
-    }
-  });
-
-  it("fan-in: 50 signals → 1 computed → 1 effect, batch update all", () => {
-    const signals = Array.from({ length: 50 }, (_, i) => signal(i));
-    const sum = computed(() => signals.reduce((acc, s) => acc + s.value, 0));
-    const spy = vi.fn();
-    effect(() => {
-      spy(sum.value);
-      return undefined;
-    });
-    spy.mockClear();
-    batch(() => {
-      for (const s of signals) {
-        s.value = s.peek() + 1;
-      }
-    });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy).toHaveBeenCalledWith(1275); // original sum(0..49)=1225, each +1 → sum(1..50)=1275
-  });
-
-  it("computed cycle detection throws", () => {
-    // eslint-disable-next-line prefer-const
-    let b: ReadonlySignal<number>;
-    const a = computed(() => b.value + 1);
-    b = computed(() => a.value + 1);
-    expect(() => a.value).toThrow("Cycle detected");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. Exception in every callback type
-// ---------------------------------------------------------------------------
-
-describe("exception in every callback type", () => {
-  let prevHandler: EffectErrorHandler;
-  const errors: unknown[] = [];
-  beforeEach(() => {
-    errors.length = 0;
-    prevHandler = setEffectErrorHandler((e) => {
-      errors.push(e);
-    });
-  });
-  afterEach(() => {
-    setEffectErrorHandler(prevHandler);
-  });
-
-  it("exception in effect cleanup does not prevent re-execution", () => {
-    const s = signal(0);
-    const values: number[] = [];
-    effect(() => {
-      values.push(s.value);
-      return () => {
-        throw new Error("cleanup boom");
-      };
-    });
-    s.value = 1;
-    s.value = 2;
-    // Effect should still track and re-run despite cleanup throwing
-    expect(values).toContain(0);
-    expect(values).toContain(1);
-    expect(values).toContain(2);
-  });
-
-  it("exception in computed fn is cached and re-thrown on read", () => {
-    const s = signal(0);
-    const c = computed(() => {
-      if (s.value === 1) {
-        throw new Error("computed boom");
-      }
-      return s.value * 2;
-    });
-    expect(c.value).toBe(0);
-    s.value = 1;
-    expect(() => c.value).toThrow("computed boom");
-    // Recovery
-    s.value = 2;
-    expect(c.value).toBe(4);
-  });
-
-  it("exception in subscribe callback is caught by error handler", () => {
-    const s = signal(0);
-    subscribe(s, (v) => {
-      if (v === 1) {
-        throw new Error("subscribe boom");
-      }
-    });
-    s.value = 1;
-    expect(errors.some((e) => (e as Error).message === "subscribe boom")).toBe(true);
-  });
-
-  it("exception in batch fn propagates but effects still flush", () => {
-    const s = signal(0);
-    const spy = vi.fn();
-    effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    expect(() => {
-      batch(() => {
-        s.value = 99;
-        throw new Error("batch boom");
-      });
-    }).toThrow("batch boom");
-    // Effect should have flushed due to try/finally in batch
-    expect(spy).toHaveBeenCalledWith(99);
-  });
-
-  it("exception in on() body is caught by error handler", () => {
-    const s = signal(0);
-    const fn = vi.fn();
-    effect(() => {
-      const v = s.value;
-      if (v === 1) {
-        throw new Error("on body boom");
-      }
-      fn(v);
-      return undefined;
-    });
-    fn.mockClear();
-    s.value = 1;
-    expect(errors.some((e) => (e as Error).message === "on body boom")).toBe(true);
-    // Recovery
-    s.value = 2;
-    expect(fn).toHaveBeenCalledWith(2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. Dispose ordering
-// ---------------------------------------------------------------------------
-
-describe("dispose ordering", () => {
-  it("disposing effects in reverse order of creation", () => {
-    const s = signal(0);
-    const order: string[] = [];
-    const disposers = Array.from({ length: 5 }, (_, i) =>
-      effect(() => {
-        order.push(`e${i}:${s.value}`);
-        return () => {
-          order.push(`c${i}`);
-        };
-      }),
-    );
-    order.length = 0;
-    // Dispose in reverse
-    for (let i = 4; i >= 0; i--) {
-      disposers[i]!();
-    }
-    expect(order).toEqual(["c4", "c3", "c2", "c1", "c0"]);
-    // No effects should fire
-    order.length = 0;
-    s.value = 1;
-    expect(order).toEqual([]);
-  });
-
-  it("disposing during flush does not corrupt iteration", () => {
-    const s = signal(0);
-    const spy = vi.fn();
-    const disposers: (() => void)[] = [];
-    // Effect 0 disposes effects 1 and 2 when triggered
-    disposers.push(
-      effect(() => {
-        if (s.value === 1) {
-          disposers[1]?.();
-          disposers[2]?.();
-        }
-        return undefined;
-      }),
-    );
-    disposers.push(
-      effect(() => {
-        spy("e1:" + s.value);
-        return undefined;
-      }),
-    );
-    disposers.push(
-      effect(() => {
-        spy("e2:" + s.value);
-        return undefined;
-      }),
-    );
-    disposers.push(
-      effect(() => {
-        spy("e3:" + s.value);
-        return undefined;
-      }),
-    );
-    spy.mockClear();
-    s.value = 1;
-    // e3 should still fire; e1 and e2 may or may not depending on order
-    expect(spy).toHaveBeenCalledWith("e3:1");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 5. Memory leak check after mass dispose
-// ---------------------------------------------------------------------------
-
-describe("memory leak after mass dispose", () => {
-  it("disposed effects are fully unlinked from signal subscriber sets", () => {
-    const s = signal(0);
-    const disposers: (() => void)[] = [];
-    for (let i = 0; i < 1000; i++) {
-      disposers.push(
-        effect(() => {
-          void s.value;
-          return undefined;
-        }),
-      );
-    }
-    // Dispose all
-    for (const d of disposers) {
-      d();
-    }
-    // Verify: setting signal should not trigger anything
-    const spy = vi.fn();
-    const d2 = effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    s.value = 1;
-    expect(spy).toHaveBeenCalledTimes(1);
-    d2();
-  });
-
-  it("disposed computed does not retain references to source signals", () => {
-    const s = signal(0);
-    const computeds: ReturnType<typeof computed>[] = [];
-    const disposers: (() => void)[] = [];
-    for (let i = 0; i < 100; i++) {
-      const c = computed(() => s.value + i);
-      computeds.push(c);
-      disposers.push(
-        effect(() => {
-          void c.value;
-          return undefined;
-        }),
-      );
-    }
-    // Dispose all effects (computeds become lazy/unsubscribed)
-    for (const d of disposers) {
-      d();
-    }
-    // Signal update should not trigger any computation
-    const spy = vi.fn();
-    const d2 = effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    s.value = 99;
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy).toHaveBeenCalledWith(99);
-    d2();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 6. Batch + computed + effect interleaving
-// ---------------------------------------------------------------------------
-
-describe("batch + computed + effect interleaving", () => {
-  it("batch with computed read mid-batch sees consistent state after flush", () => {
-    const a = signal(1);
-    const b = signal(2);
-    const sum = computed(() => a.value + b.value);
-    const values: number[] = [];
-    effect(() => {
-      values.push(sum.value);
-      return undefined;
-    });
-    values.length = 0;
-    batch(() => {
-      a.value = 10;
-      b.value = 20;
-    });
-    // After batch: effect fires with final value
-    expect(values).toContain(30); // 10 + 20
-  });
-
-  it("nested batch: inner batch does not flush", () => {
-    const s = signal(0);
-    const spy = vi.fn();
-    effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    batch(() => {
-      batch(() => {
-        s.value = 1;
-      });
-      // Inner batch ended but outer still active - no flush yet
-      expect(spy).not.toHaveBeenCalled();
-      s.value = 2;
-    });
-    // Only final value should be seen
-    expect(spy).toHaveBeenCalledWith(2);
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it("effect creating new effect during batch flush", () => {
-    const s = signal(0);
-    const inner = vi.fn();
-    effect(() => {
-      if (s.value === 1) {
-        // Create new effect during flush
-        effect(() => {
-          inner(s.value);
-          return undefined;
-        });
-      }
-      return undefined;
-    });
-    batch(() => {
-      s.value = 1;
-    });
-    expect(inner).toHaveBeenCalledWith(1);
-  });
-
-  it("computed invalidation during batch does not cause double-fire", () => {
-    const a = signal(0);
-    const b = signal(0);
-    const c = computed(() => a.value + b.value);
-    const spy = vi.fn();
-    effect(() => {
-      spy(c.value);
-      return undefined;
-    });
-    spy.mockClear();
-    batch(() => {
-      a.value = 1;
-      b.value = 1;
-    });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy).toHaveBeenCalledWith(2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 7. Reconcile fuzz
-// ---------------------------------------------------------------------------
-
-describe("reconcile fuzz", () => {
-  function makeSpec() {
-    return {
-      key: (i: { id: string }) => i.id,
-      mount: (i: { id: string; v: number }) => {
-        const el = document.createElement("div");
-        el.textContent = String(i.v);
-        return el;
-      },
-      update: (el: HTMLElement, i: { id: string; v: number }) => {
-        el.textContent = String(i.v);
-      },
-      onRemove: vi.fn(),
-    };
-  }
-
-  it("random insert/remove/reorder 50 iterations", () => {
-    const parent = document.createElement("div");
-    const spec = makeSpec();
-    const items: { id: string; v: number }[] = [];
-    let nextId = 0;
-    let seed = 42;
-    const rng = () => {
-      seed = (seed * 1664525 + 1013904223) >>> 0;
-      return seed / 0x100000000;
-    };
-
-    for (let iter = 0; iter < 50; iter++) {
-      const action = rng();
-      if (action < 0.3 && items.length > 0) {
-        // Remove random
-        const idx = Math.floor(rng() * items.length);
-        items.splice(idx, 1);
-      } else if (action < 0.6) {
-        // Insert random
-        const idx = Math.floor(rng() * (items.length + 1));
-        items.splice(idx, 0, { id: `id${nextId++}`, v: iter });
-      } else if (items.length > 1) {
-        // Swap two random
-        const i = Math.floor(rng() * items.length);
-        let j = Math.floor(rng() * items.length);
-        if (j === i) {
-          j = (j + 1) % items.length;
-        }
-        [items[i], items[j]] = [items[j]!, items[i]!];
-      }
-      reconcile(parent, items, spec);
-      expect(parent.children.length).toBe(items.length);
-      // Verify order
-      for (let k = 0; k < items.length; k++) {
-        expect(parent.children[k]!.getAttribute("data-reconcile-key")).toBe(items[k]!.id);
-      }
-    }
-  });
-
-  it("reconcile with empty list clears all", () => {
-    const parent = document.createElement("div");
-    const spec = makeSpec();
-    const items = Array.from({ length: 20 }, (_, i) => ({ id: `k${i}`, v: i }));
-    reconcile(parent, items, spec);
-    expect(parent.children.length).toBe(20);
-    reconcile(parent, [], spec);
-    expect(parent.children.length).toBe(0);
-    expect(spec.onRemove).toHaveBeenCalledTimes(20);
-  });
-
-  it("reconcile with duplicate keys (pathological input)", () => {
-    const parent = document.createElement("div");
-    const spec = makeSpec();
-    // Duplicate keys - library should handle gracefully (last wins or first wins)
-    const items = [
-      { id: "dup", v: 1 },
-      { id: "dup", v: 2 },
-      { id: "unique", v: 3 },
-    ];
-    // Should not throw
-    expect(() => reconcile(parent, items, spec)).not.toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 8. Fake timers: effect scheduling is synchronous (no microtask leaks)
-// ---------------------------------------------------------------------------
-
-describe("synchronous semantics (fake timers)", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("signal write + effect is fully synchronous, no pending microtasks", () => {
-    const s = signal(0);
-    const spy = vi.fn();
-    effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    s.value = 1;
-    // Should already have fired - no need to advance timers
-    expect(spy).toHaveBeenCalledWith(1);
-  });
-
-  it("batch flush is synchronous", () => {
-    const s = signal(0);
-    const spy = vi.fn();
-    effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    batch(() => {
-      s.value = 42;
-    });
-    expect(spy).toHaveBeenCalledWith(42);
-  });
-
-  it("computed is evaluated lazily and synchronously", () => {
-    const s = signal(1);
-    const c = computed(() => s.value * 2);
-    s.value = 5;
-    expect(c.value).toBe(10); // No timer needed
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 9. untracked edge cases
-// ---------------------------------------------------------------------------
-
-describe("untracked edge cases", () => {
-  it("untracked inside effect prevents tracking", () => {
-    const a = signal(0);
-    const b = signal(0);
-    const spy = vi.fn();
-    effect(() => {
-      const av = a.value; // tracked
-      const bv = untracked(() => b.value); // not tracked
-      spy(av, bv);
-      return undefined;
-    });
-    spy.mockClear();
-    b.value = 99;
-    expect(spy).not.toHaveBeenCalled();
-    a.value = 1;
-    expect(spy).toHaveBeenCalledWith(1, 99);
-  });
-
-  it("untracked with throwing fn restores tracking context", () => {
-    const s = signal(0);
-    const spy = vi.fn();
-    effect(() => {
-      try {
-        untracked(() => {
-          throw new Error("boom");
-        });
-      } catch {
-        /* swallow */
-      }
-      spy(s.value); // should still be tracked
-      return undefined;
-    });
-    spy.mockClear();
-    s.value = 1;
-    expect(spy).toHaveBeenCalledWith(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 10. Store: batch + effect + computed interleaving
-// ---------------------------------------------------------------------------
-
-describe("store: batch + effect + computed interleaving", () => {
-  it("store computed updates atomically in batch", () => {
-    const store = createStore<{ a: number; b: number; sum: number }>();
-    store.set("a", 1);
-    store.set("b", 2);
-    store.computed("sum", () => store.get("a") + store.get("b"));
-    expect(store.get("sum")).toBe(3);
-    const spy = vi.fn();
-    store.subscribe("sum", spy);
-    store.batch(() => {
-      store.set("a", 10);
-      store.set("b", 20);
-    });
-    // sum should update to 30
-    expect(store.get("sum")).toBe(30);
-  });
-
-  it("store effect throwing does not break subsequent effects", () => {
-    const store = createStore<{ x: number }>();
-    store.set("x", 0);
-    const spy = vi.fn();
-    store.effect(() => {
-      if (store.get("x") === 1) {
-        throw new Error("store effect boom");
-      }
-      return undefined;
-    });
-    store.effect(() => {
-      spy(store.get("x"));
-      return undefined;
-    });
-    spy.mockClear();
-    // The throwing effect will console.error but shouldn't prevent spy effect
-    const origError = console.error;
-    console.error = vi.fn();
-    store.set("x", 1);
-    console.error = origError;
-    expect(spy).toHaveBeenCalledWith(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 11. Signal equality: custom equals with side effects (adversarial)
-// ---------------------------------------------------------------------------
-
-describe("adversarial equals", () => {
-  it("equals that reads another signal does not corrupt tracking", () => {
-    const a = signal(0);
-    const b = signal(0, {
-      equals: (prev, next) => {
-        // Adversarial: read another signal inside equals
-        void a.peek(); // peek is safe
-        return prev === next;
-      },
-    });
-    const spy = vi.fn();
-    effect(() => {
-      spy(b.value);
-      return undefined;
-    });
-    spy.mockClear();
-    b.value = 1;
-    expect(spy).toHaveBeenCalledWith(1);
-  });
-
-  it("equals returning false always causes notification", () => {
-    const s = signal(0, { equals: false });
-    const spy = vi.fn();
-    effect(() => {
-      spy(s.value);
-      return undefined;
-    });
-    spy.mockClear();
-    s.value = 0; // same value but equals=false means always notify
-    expect(spy).toHaveBeenCalledWith(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 12. reconcileChildren / patch edge cases
-// ---------------------------------------------------------------------------
-
-describe("reconcileChildren / patch edge cases", () => {
-  it("patch with null/undefined children is no-op", () => {
-    const parent = document.createElement("div");
-    parent.textContent = "hello";
-    patch(parent, null, undefined);
-    expect(parent.childNodes.length).toBe(0);
-  });
-
-  it("patch with DocumentFragment spreads children", () => {
-    const parent = document.createElement("div");
-    const frag = document.createDocumentFragment();
-    frag.appendChild(document.createElement("span"));
-    frag.appendChild(document.createTextNode("text"));
-    patch(parent, frag);
-    expect(parent.childNodes.length).toBe(2);
-  });
-
-  it("reconcileChildren handles text node update", () => {
-    const parent = document.createElement("div");
-    parent.appendChild(document.createTextNode("old"));
-    reconcileChildren(parent, [document.createTextNode("new")]);
-    expect(parent.textContent).toBe("new");
-  });
-});