@planet-matrix/mobius-model 0.1.3 → 0.3.0

package/tests/unit/reactor/alien-signals-topology.spec.ts

@@ -0,0 +1,361 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { computed, effect, signal } from '#Source/reactor/index.ts';
+
+/**
+ * 这个测试文件应该与 https://github.com/stackblitz/alien-signals/blob/master/tests/topology.spec.ts 保持同步。
+ */
+
+describe("graph updates", () => {
+  test('should drop A->B->A updates', () => {
+    //     A
+    //   / |
+    //  B  | <- Looks like a flag doesn't it? :D
+    //   \ |
+    //     C
+    //     |
+    //     D
+    const a = signal(() => 2);
+
+    const b = computed(() => a.get() - 1);
+    const c = computed(() => a.get() + b.get());
+
+    const compute = vi.fn(() => `d: ${c.get()}`);
+    const d = computed(compute);
+
+    // Trigger read
+    expect(d.get()).toBe("d: 3");
+    expect(compute).toHaveBeenCalledOnce();
+    compute.mockClear();
+
+    a.set(4);
+    d.get();
+    expect(compute).toHaveBeenCalledOnce();
+  });
+
+  test('should only update every signal once (diamond graph)', () => {
+    // In this scenario "D" should only update once when "A" receives
+    // an update. This is sometimes referred to as the "diamond" scenario.
+    //     A
+    //   /   \
+    //  B     C
+    //   \   /
+    //     D
+
+    const a = signal(() => "a");
+    const b = computed(() => a.get());
+    const c = computed(() => a.get());
+
+    const spy = vi.fn(() => `${b.get()} ${c.get()}`);
+    const d = computed(spy);
+
+    expect(d.get()).toBe("a a");
+    expect(spy).toHaveBeenCalledOnce();
+
+    a.set("aa");
+    expect(d.get()).toBe("aa aa");
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  test('should only update every signal once (diamond graph + tail)', () => {
+    // "E" will be likely updated twice if our mark+sweep logic is buggy.
+    //     A
+    //   /   \
+    //  B     C
+    //   \   /
+    //     D
+    //     |
+    //     E
+
+    const a = signal(() => "a");
+    const b = computed(() => a.get());
+    const c = computed(() => a.get());
+
+    const d = computed(() => `${b.get()} ${c.get()}`);
+
+    const spy = vi.fn(() => d.get());
+    const e = computed(spy);
+
+    expect(e.get()).toBe("a a");
+    expect(spy).toHaveBeenCalledOnce();
+
+    a.set("aa");
+    expect(e.get()).toBe("aa aa");
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  test('should bail out if result is the same', () => {
+    // Bail out if value of "B" never changes
+    // A->B->C
+    const a = signal(() => "a");
+    const b = computed(() => {
+      a.get();
+      return "foo";
+    });
+
+    const spy = vi.fn(() => b.get());
+    const c = computed(spy);
+
+    expect(c.get()).toBe("foo");
+    expect(spy).toHaveBeenCalledOnce();
+
+    a.set("aa");
+    expect(c.get()).toBe("foo");
+    expect(spy).toHaveBeenCalledOnce();
+  });
+
+  test('should only update every signal once (jagged diamond graph + tails)', () => {
+    // "F" and "G" will be likely updated twice if our mark+sweep logic is buggy.
+    //     A
+    //   /   \
+    //  B     C
+    //  |     |
+    //  |     D
+    //   \   /
+    //     E
+    //   /   \
+    //  F     G
+    const a = signal(() => "a");
+
+    const b = computed(() => a.get());
+    const c = computed(() => a.get());
+
+    const d = computed(() => c.get());
+
+    const eSpy = vi.fn(() => `${b.get()} ${d.get()}`);
+    const e = computed(eSpy);
+
+    const fSpy = vi.fn(() => e.get());
+    const f = computed(fSpy);
+    const gSpy = vi.fn(() => e.get());
+    const g = computed(gSpy);
+
+    expect(f.get()).toBe("a a");
+    expect(fSpy).toHaveBeenCalledTimes(1);
+
+    expect(g.get()).toBe("a a");
+    expect(gSpy).toHaveBeenCalledTimes(1);
+
+    eSpy.mockClear();
+    fSpy.mockClear();
+    gSpy.mockClear();
+
+    a.set("b");
+
+    expect(e.get()).toBe("b b");
+    expect(eSpy).toHaveBeenCalledTimes(1);
+
+    expect(f.get()).toBe("b b");
+    expect(fSpy).toHaveBeenCalledTimes(1);
+
+    expect(g.get()).toBe("b b");
+    expect(gSpy).toHaveBeenCalledTimes(1);
+
+    eSpy.mockClear();
+    fSpy.mockClear();
+    gSpy.mockClear();
+
+    a.set("c");
+
+    expect(e.get()).toBe("c c");
+    expect(eSpy).toHaveBeenCalledTimes(1);
+
+    expect(f.get()).toBe("c c");
+    expect(fSpy).toHaveBeenCalledTimes(1);
+
+    expect(g.get()).toBe("c c");
+    expect(gSpy).toHaveBeenCalledTimes(1);
+
+    // top to bottom
+    expect(eSpy).toHaveBeenCalledBefore(fSpy);
+    // left to right
+    expect(fSpy).toHaveBeenCalledBefore(gSpy);
+  });
+
+  test('should only subscribe to signals listened to', () => {
+    //    *A
+    //   /   \
+    // *B     C <- we don't listen to C
+    const a = signal(() => "a");
+
+    const b = computed(() => a.get());
+    const spy = vi.fn(() => a.get());
+    computed(spy);
+
+    expect(b.get()).toBe("a");
+    expect(spy).not.toHaveBeenCalled();
+
+    a.set("aa");
+    expect(b.get()).toBe("aa");
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  test('should only subscribe to signals listened to II', () => {
+    // Here both "B" and "C" are active in the beginning, but
+    // "B" becomes inactive later. At that point it should
+    // not receive any updates anymore.
+    //    *A
+    //   /   \
+    // *B     D <- we don't listen to C
+    //  |
+    // *C
+    const a = signal(() => "a");
+    const spyB = vi.fn(() => a.get());
+    const b = computed(spyB);
+
+    const spyC = vi.fn(() => b.get());
+    const c = computed(spyC);
+
+    const d = computed(() => a.get());
+
+    let result = "";
+    const e = effect(() => {
+      result = c.get();
+    });
+
+    expect(result).toBe("a");
+    expect(d.get()).toBe("a");
+
+    spyB.mockClear();
+    spyC.mockClear();
+    e.dispose();
+
+    a.set("aa");
+
+    expect(spyB).not.toHaveBeenCalled();
+    expect(spyC).not.toHaveBeenCalled();
+    expect(d.get()).toBe("aa");
+  });
+
+  test('should ensure subs update even if one dep unmarks it', () => {
+    // In this scenario "C" always returns the same value. When "A"
+    // changes, "B" will update, then "C" at which point its update
+    // to "D" will be unmarked. But "D" must still update because
+    // "B" marked it. If "D" isn't updated, then we have a bug.
+    //     A
+    //   /   \
+    //  B     *C <- returns same value every time
+    //   \   /
+    //     D
+    const a = signal(() => "a");
+    const b = computed(() => a.get());
+    const c = computed(() => {
+      a.get();
+      return "c";
+    });
+    const spy = vi.fn(() => `${b.get()} ${c.get()}`);
+    const d = computed(spy);
+
+    expect(d.get()).toBe("a c");
+    spy.mockClear();
+
+    a.set("aa");
+    d.get();
+    expect(spy).toHaveReturnedWith("aa c");
+  });
+
+  test('should ensure subs update even if two deps unmark it', () => {
+    // In this scenario both "C" and "D" always return the same
+    // value. But "E" must still update because "A" marked it.
+    // If "E" isn't updated, then we have a bug.
+    //     A
+    //   / | \
+    //  B *C *D
+    //   \ | /
+    //     E
+    const a = signal(() => "a");
+    const b = computed(() => a.get());
+    const c = computed(() => {
+      a.get();
+      return "c";
+    });
+    const d = computed(() => {
+      a.get();
+      return "d";
+    });
+    const spy = vi.fn(() => `${b.get()} ${c.get()} ${d.get()}`);
+    const e = computed(spy);
+
+    expect(e.get()).toBe("a c d");
+    spy.mockClear();
+
+    a.set("aa");
+    e.get();
+    expect(spy).toHaveReturnedWith("aa c d");
+  });
+
+  test('should support lazy branches', () => {
+    const a = signal(() => 0);
+    const b = computed(() => a.get());
+    const c = computed(() => (a.get() > 0 ? a.get() : b.get()));
+
+    expect(c.get()).toBe(0);
+    a.set(1);
+    expect(c.get()).toBe(1);
+
+    a.set(0);
+    expect(c.get()).toBe(0);
+  });
+
+  test('should not update a sub if all deps unmark it', () => {
+    // In this scenario "B" and "C" always return the same value. When "A"
+    // changes, "D" should not update.
+    //     A
+    //   /   \
+    // *B     *C
+    //   \   /
+    //     D
+    const a = signal(() => "a");
+    const b = computed(() => {
+      a.get();
+      return "b";
+    });
+    const c = computed(() => {
+      a.get();
+      return "c";
+    });
+    const spy = vi.fn(() => `${b.get()} ${c.get()}`);
+    const d = computed(spy);
+
+    expect(d.get()).toBe("b c");
+    spy.mockClear();
+
+    a.set("aa");
+    expect(spy).not.toHaveBeenCalled();
+  });
+});
+
+
+describe("error handling", () => {
+  test('should keep graph consistent on errors during activation', () => {
+    const a = signal(() => 0);
+    const b = computed(() => {
+      throw new Error("fail");
+    });
+    const c = computed(() => a.get());
+
+    expect(() => b.get()).toThrow("fail");
+
+    a.set(1);
+    expect(c.get()).toBe(1);
+  });
+
+  test('should keep graph consistent on errors in computeds', () => {
+    const a = signal(() => 0);
+    const b = computed(() => {
+      if (a.get() === 1) {
+        throw new Error("fail");
+      }
+      return a.get();
+    });
+    const c = computed(() => b.get());
+
+    expect(c.get()).toBe(0);
+
+    a.set(1);
+    expect(() => b.get()).toThrow("fail");
+
+    a.set(2);
+    expect(c.get()).toBe(2);
+  });
+});

package/tests/unit/reactor/alien-signals-trigger.spec.ts

@@ -0,0 +1,75 @@
+import { expect, test } from 'vitest';
+
+import { computed, effect, signal, trigger } from '#Source/reactor/index.ts';
+
+/**
+ * 这个测试文件应该与 https://github.com/stackblitz/alien-signals/blob/master/tests/trigger.spec.ts 保持同步。
+ */
+
+test('should not throw when triggering with no dependencies', () => {
+  trigger(() => {
+    // no op
+  });
+});
+
+test('should trigger updates for dependent computed signals', () => {
+  const arr = signal<number[]>(() => []);
+  const length = computed(() => arr.get().length);
+
+  expect(length.get()).toBe(0);
+  arr.get().push(1);
+  expect(length.get()).toBe(0);
+  trigger(() => {
+    arr.get();
+  });
+  expect(length.get()).toBe(1);
+});
+
+test('should trigger updates for the second source signal', () => {
+  const src1 = signal<number[]>(() => []);
+  const src2 = signal<number[]>(() => []);
+  const length = computed(() => src2.get().length);
+
+  expect(length.get()).toBe(0);
+  src2.get().push(1);
+  expect(length.get()).toBe(0);
+  trigger(() => {
+    src1.get();
+    src2.get();
+  });
+  expect(length.get()).toBe(1);
+});
+
+test('should trigger effect once', () => {
+  const src1 = signal<number[]>(() => []);
+  const src2 = signal<number[]>(() => []);
+
+  let effectRunTimes = 0;
+
+  effect(() => {
+    effectRunTimes = effectRunTimes + 1;
+    src1.get();
+    src2.get();
+  });
+  expect(effectRunTimes).toBe(1);
+
+  trigger(() => {
+    src1.get();
+    src2.get();
+  });
+  expect(effectRunTimes).toBe(2);
+});
+
+test('should not notify the trigger function sub', () => {
+  const src1 = signal<number[]>(() => []);
+  const src2 = computed(() => src1.get());
+
+  effect(() => {
+    src1.get();
+    src2.get();
+  });
+  trigger(() => {
+    src1.get();
+    src2.get();
+  });
+});

package/tests/unit/reactor/alien-signals-untrack.spec.ts

@@ -0,0 +1,91 @@
+import { expect, test } from 'vitest';
+
+import { computed, effect, effectScope, reactiveSystem, signal } from '#Source/reactor/index.ts';
+
+/**
+ * 这个测试文件应该与 https://github.com/stackblitz/alien-signals/blob/master/tests/untrack.spec.ts 保持同步。
+ */
+
+test('should pause tracking in computed', () => {
+  const src = signal(() => 0);
+
+  let computedRunTimes = 0;
+  const c = computed(() => {
+    computedRunTimes = computedRunTimes + 1;
+    reactiveSystem.setNoActiveNodeAsSub();
+    const value = src.get();
+    reactiveSystem.resetActiveNodeAsSub();
+    return value;
+  });
+
+  expect(c.get()).toBe(0);
+  expect(computedRunTimes).toBe(1);
+
+  src.set(1);
+  src.set(2);
+  src.set(3);
+  expect(c.get()).toBe(0);
+  expect(computedRunTimes).toBe(1);
+});
+
+test('should pause tracking in effect', () => {
+  const src = signal(() => 0);
+  const is = signal(() => 0);
+
+  let effectRunTimes = 0;
+  effect(() => {
+    effectRunTimes = effectRunTimes + 1;
+    if (is.get() !== 0) {
+      reactiveSystem.setNoActiveNodeAsSub();
+      src.get();
+      reactiveSystem.resetActiveNodeAsSub();
+    }
+  });
+
+  expect(effectRunTimes).toBe(1);
+
+  is.set(1);
+  expect(effectRunTimes).toBe(2);
+
+  src.set(1);
+  src.set(2);
+  src.set(3);
+  expect(effectRunTimes).toBe(2);
+
+  is.set(2);
+  expect(effectRunTimes).toBe(3);
+
+  src.set(4);
+  src.set(5);
+  src.set(6);
+  expect(effectRunTimes).toBe(3);
+
+  is.set(0);
+  expect(effectRunTimes).toBe(4);
+
+  src.set(7);
+  src.set(8);
+  src.set(9);
+  expect(effectRunTimes).toBe(4);
+});
+
+test('should pause tracking in effect scope', () => {
+  const src = signal(() => 0);
+
+  let effectRunTimes = 0;
+  effectScope(() => {
+    effect(() => {
+      effectRunTimes = effectRunTimes + 1;
+      reactiveSystem.setNoActiveNodeAsSub();
+      src.get();
+      reactiveSystem.resetActiveNodeAsSub();
+    });
+  });
+
+  expect(effectRunTimes).toBe(1);
+
+  src.set(1);
+  src.set(2);
+  src.set(3);
+  expect(effectRunTimes).toBe(1);
+});

package/tests/unit/reactor/preact-signal.spec.ts

@@ -0,0 +1,73 @@
+import { describe, it, vi, expect } from "vitest";
+
+import type { Effect } from '#Source/index.ts';
+import { Signal, computed, effect, effectScope, endBatch, reactiveSystem, signal, startBatch } from '#Source/reactor/index.ts';
+
+/**
+ * 这个测试文件应该与 https://github.com/preactjs/signals/blob/main/packages/core/test/signal.test.tsx 保持同步。
+ */
+
+describe("signal", () => {
+  it("should return value", () => {
+    const v = [1, 2];
+    const s = signal(() => v);
+    expect(s.get()).to.equal(v);
+  });
+
+  it("should inherit from Signal", () => {
+    expect(signal(() => 0)).to.be.instanceOf(Signal);
+  });
+
+  it("should support .toString()", () => {
+    // const s = signal(123);
+    // expect(s.toString()).equal("123");
+  });
+
+  it("should support .toJSON()", () => {
+    // const s = signal(123);
+    // expect(s.toJSON()).equal(123);
+  });
+
+  it("should support JSON.Stringify()", () => {
+    // const s = signal(123);
+    // expect(JSON.stringify({ s })).equal(JSON.stringify({ s: 123 }));
+  });
+
+  it("should support .valueOf()", () => {
+    // const s = signal(123);
+    // expect(s).to.have.property("valueOf");
+    // expect(s.valueOf).to.be.a("function");
+    // expect(s.valueOf()).equal(123);
+    // expect(+s).equal(123);
+
+    // const a = signal(1);
+    // const b = signal(2);
+    // expect(a + b).to.equal(3);
+  });
+
+  it("should notify other listeners of changes after one listener is disposed", () => {
+    const s = signal(() => 0);
+    const spy1 = vi.fn(() => {
+      s.get();
+    });
+    const spy2 = vi.fn(() => {
+      s.get();
+    });
+    const spy3 = vi.fn(() => {
+      s.get();
+    });
+
+    effect(spy1);
+    const e2 = effect(spy2);
+    effect(spy3);
+    expect(spy1).toHaveBeenCalledOnce();
+    expect(spy2).toHaveBeenCalledOnce();
+    expect(spy3).toHaveBeenCalledOnce();
+
+    e2.dispose();
+    s.set(1);
+    expect(spy1).toHaveBeenCalledTimes(2);
+    expect(spy2).toHaveBeenCalledOnce();
+    expect(spy3).toHaveBeenCalledTimes(2);
+  });
+});