Merge pull request #40 from omfj/omfj/port-tests

Port tests from different signal implementations

Author: littledan

package.json

@@ -46,5 +46,6 @@
   "volta": {
     "node": "22.0.0",
     "pnpm": "9.0.6"
-  }
+  },
+  "packageManager": "pnpm@9.0.6"
 }

tests/Signal/ported/preact.test.ts

@@ -0,0 +1,79 @@
+import {describe, it, expect, vi} from 'vitest';
+import {Signal} from '../../../src';
+
+describe('Ported - Preact', () => {
+  // https://github.com/preactjs/signals/blob/main/packages/core/test/signal.test.tsx#L1078
+  it('should not leak errors raised by dependencies', () => {
+    const a = new Signal.State(0);
+    const b = new Signal.Computed(() => {
+      a.get();
+      throw new Error('error');
+    });
+    const c = new Signal.Computed(() => {
+      try {
+        b.get();
+      } catch {
+        return 'ok';
+      }
+    });
+    expect(c.get()).to.equal('ok');
+    a.set(1);
+    expect(c.get()).to.equal('ok');
+  });
+
+  // https://github.com/preactjs/signals/blob/main/packages/core/test/signal.test.tsx#L914
+  it('should return updated value', () => {
+    const a = new Signal.State('a');
+    const b = new Signal.State('b');
+
+    const c = new Signal.Computed(() => a.get() + b.get());
+    expect(c.get()).to.equal('ab');
+
+    a.set('aa');
+    expect(c.get()).to.equal('aab');
+  });
+
+  // https://github.com/preactjs/signals/blob/main/packages/core/test/signal.test.tsx#L925
+  it('should be lazily computed on demand', () => {
+    const a = new Signal.State('a');
+    const b = new Signal.State('b');
+    const spy = vi.fn(() => a.get() + b.get());
+    const c = new Signal.Computed(spy);
+    expect(spy).not.toHaveBeenCalled();
+    c.get();
+    expect(spy).toHaveBeenCalledOnce();
+    a.set('x');
+    b.set('y');
+    expect(spy).toHaveBeenCalledOnce();
+    c.get();
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  // https://github.com/preactjs/signals/blob/main/packages/core/test/signal.test.tsx#L940
+  it('should be computed only when a dependency has changed at some point', () => {
+    const a = new Signal.State('a');
+    const spy = vi.fn(() => {
+      return a.get();
+    });
+    const c = new Signal.Computed(spy);
+    c.get();
+    expect(spy).toHaveBeenCalledOnce();
+    a.set('a');
+    c.get();
+    expect(spy).toHaveBeenCalledOnce();
+  });
+
+  // https://github.com/preactjs/signals/blob/main/packages/core/test/signal.test.tsx#L1693
+  it('should support lazy branches', () => {
+    const a = new Signal.State(0);
+    const b = new Signal.Computed(() => a.get());
+    const c = new Signal.Computed(() => (a.get() > 0 ? a.get() : b.get()));
+
+    expect(c.get()).to.equal(0);
+    a.set(1);
+    expect(c.get()).to.equal(1);
+
+    a.set(0);
+    expect(c.get()).to.equal(0);
+  });
+});

tests/Signal/ported/vue.test.ts

@@ -0,0 +1,73 @@
+import {describe, it, expect, vi} from 'vitest';
+import {Signal} from '../../../src';
+
+describe('Ported - Vue', () => {
+  // https://github.com/vuejs/core/blob/main/packages/reactivity/__tests__/computed.spec.ts#L32
+  it('should return updated value', () => {
+    const s = new Signal.State<{foo?: number}>({});
+    const c = new Signal.Computed(() => s.get().foo);
+
+    expect(c.get()).toBe(undefined);
+    s.set({foo: 1});
+    expect(c.get()).toBe(1);
+  });
+
+  // https://github.com/vuejs/core/blob/main/packages/reactivity/__tests__/computed.spec.ts#L54
+  it('should compute lazily', () => {
+    const s = new Signal.State<{foo?: number}>({});
+    const getter = vi.fn(() => s.get().foo);
+    const c = new Signal.Computed(getter);
+
+    // lazy
+    expect(getter).not.toHaveBeenCalled();
+
+    expect(c.get()).toBe(undefined);
+    expect(getter).toHaveBeenCalledTimes(1);
+
+    // should not compute again
+    c.get();
+    expect(getter).toHaveBeenCalledTimes(1);
+
+    // should not compute until needed
+    s.set({foo: 1});
+    expect(getter).toHaveBeenCalledTimes(1);
+
+    // now it should compute
+    expect(c.get()).toBe(1);
+    expect(getter).toHaveBeenCalledTimes(2);
+
+    // should not compute again
+    c.get();
+    expect(getter).toHaveBeenCalledTimes(2);
+  });
+
+  // https://github.com/vuejs/core/blob/main/packages/reactivity/__tests__/computed.spec.ts#L488
+  it('should work when chained(ref+computed)', () => {
+    const v = new Signal.State(0);
+    const c1 = new Signal.Computed(() => {
+      if (v.get() === 0) {
+        v.set(1);
+      }
+      return 'foo';
+    });
+    const c2 = new Signal.Computed(() => v.get() + c1.get());
+    expect(c2.get()).toBe('0foo');
+    expect(c2.get()).toBe('0foo'); // ! In vue it recomputes and becomes '1foo'
+  });
+
+  // https://github.com/vuejs/core/blob/main/packages/reactivity/__tests__/computed.spec.ts#L925
+  it('should be recomputed without being affected by side effects', () => {
+    const v = new Signal.State(0);
+    const c1 = new Signal.Computed(() => {
+      v.set(1);
+      return 0;
+    });
+    const c2 = new Signal.Computed(() => {
+      return v.get() + ',' + c1.get();
+    });
+
+    expect(c2.get()).toBe('0,0');
+    v.set(1);
+    expect(c2.get()).toBe('0,0'); // ! In vue it recomputes and becomes '1,0'
+  });
+});