@pyreon/state-tree 0.0.1

package/src/tests/model.test.ts

@@ -0,0 +1,718 @@
+import { computed, effect } from '@pyreon/reactivity'
+import type { Patch } from '../index'
+import {
+  addMiddleware,
+  applyPatch,
+  applySnapshot,
+  getSnapshot,
+  model,
+  onPatch,
+  resetAllHooks,
+  resetHook,
+} from '../index'
+import { instanceMeta } from '../registry'
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const Counter = model({
+  state: { count: 0 },
+  views: (self) => ({
+    doubled: computed(() => self.count() * 2),
+    isPositive: computed(() => self.count() > 0),
+  }),
+  actions: (self) => ({
+    inc: () => self.count.update((c: number) => c + 1),
+    dec: () => self.count.update((c: number) => c - 1),
+    add: (n: number) => self.count.update((c: number) => c + n),
+    reset: () => self.count.set(0),
+  }),
+})
+
+const Profile = model({
+  state: { name: '', bio: '' },
+  actions: (self) => ({
+    rename: (n: string) => self.name.set(n),
+    setBio: (b: string) => self.bio.set(b),
+  }),
+})
+
+const App = model({
+  state: { profile: Profile, title: 'My App' },
+  actions: (self) => ({
+    setTitle: (t: string) => self.title.set(t),
+  }),
+})
+
+// ─── State signals ─────────────────────────────────────────────────────────────
+
+describe('state signals', () => {
+  it('create() returns instance with callable signals', () => {
+    const c = Counter.create()
+    expect(typeof c.count).toBe('function')
+    expect(c.count()).toBe(0)
+  })
+
+  it('uses defaults when no initial value supplied', () => {
+    const c = Counter.create()
+    expect(c.count()).toBe(0)
+  })
+
+  it('overrides defaults with supplied initial values', () => {
+    const c = Counter.create({ count: 42 })
+    expect(c.count()).toBe(42)
+  })
+
+  it('partial initial — unspecified keys use defaults', () => {
+    const NamedCounter = model({ state: { count: 0, label: 'default' } })
+    const c = NamedCounter.create({ count: 10 })
+    expect(c.count()).toBe(10)
+    expect(c.label()).toBe('default')
+  })
+})
+
+// ─── Actions ──────────────────────────────────────────────────────────────────
+
+describe('actions', () => {
+  it('actions update state signals', () => {
+    const c = Counter.create()
+    c.inc()
+    expect(c.count()).toBe(1)
+  })
+
+  it('actions with arguments work correctly', () => {
+    const c = Counter.create()
+    c.add(5)
+    expect(c.count()).toBe(5)
+  })
+
+  it('self closure allows reading current signal values', () => {
+    const c = Counter.create({ count: 3 })
+    c.inc()
+    c.inc()
+    expect(c.count()).toBe(5)
+  })
+
+  it('actions can call other actions via self (Proxy)', () => {
+    const M = model({
+      state: { x: 0 },
+      actions: (self) => ({
+        doubleInc: () => {
+          self.inc()
+          self.inc()
+        },
+        inc: () => self.x.update((n: number) => n + 1),
+      }),
+    })
+    const m = M.create()
+    m.doubleInc()
+    expect(m.x()).toBe(2)
+  })
+})
+
+// ─── Views ────────────────────────────────────────────────────────────────────
+
+describe('views', () => {
+  it('views return computed signals', () => {
+    const c = Counter.create({ count: 5 })
+    expect(c.doubled()).toBe(10)
+  })
+
+  it('views recompute when state changes', () => {
+    const c = Counter.create({ count: 3 })
+    expect(c.doubled()).toBe(6)
+    c.inc()
+    expect(c.doubled()).toBe(8)
+  })
+
+  it('views are reactive in effects', () => {
+    const c = Counter.create()
+    const observed: boolean[] = []
+    effect(() => {
+      observed.push(c.isPositive())
+    })
+    c.inc()
+    c.dec()
+    expect(observed).toEqual([false, true, false])
+  })
+})
+
+// ─── asHook ───────────────────────────────────────────────────────────────────
+
+describe('asHook', () => {
+  afterEach(() => resetAllHooks())
+
+  it('returns the same instance for the same id', () => {
+    const useC = Counter.asHook('hook-test')
+    expect(useC()).toBe(useC())
+  })
+
+  it('different ids give independent instances', () => {
+    const useA = Counter.asHook('hook-a')
+    const useB = Counter.asHook('hook-b')
+    useA().inc()
+    expect(useA().count()).toBe(1)
+    expect(useB().count()).toBe(0)
+  })
+
+  it('resetHook clears a singleton so next call creates fresh instance', () => {
+    const useC = Counter.asHook('hook-reset')
+    useC().add(10)
+    expect(useC().count()).toBe(10)
+
+    resetHook('hook-reset')
+    expect(useC().count()).toBe(0)
+  })
+
+  it('resetAllHooks clears all singletons', () => {
+    const useA = Counter.asHook('hook-all-a')
+    const useB = Counter.asHook('hook-all-b')
+    useA().inc()
+    useB().add(5)
+
+    resetAllHooks()
+    expect(useA().count()).toBe(0)
+    expect(useB().count()).toBe(0)
+  })
+
+  it('resetHook on non-existent id is a no-op', () => {
+    expect(() => resetHook('no-such-hook')).not.toThrow()
+  })
+})
+
+// ─── Error guards ────────────────────────────────────────────────────────────
+
+describe('error guards', () => {
+  it('onPatch throws for non-model-instance', () => {
+    expect(() =>
+      onPatch({} as object, () => {
+        /* noop */
+      }),
+    ).toThrow('[@pyreon/state-tree]')
+  })
+
+  it('addMiddleware throws for non-model-instance', () => {
+    expect(() => addMiddleware({} as object, (_c, n) => n(_c))).toThrow(
+      '[@pyreon/state-tree]',
+    )
+  })
+
+  it('applySnapshot throws for non-model-instance', () => {
+    expect(() => applySnapshot({} as object, {})).toThrow(
+      '[@pyreon/state-tree]',
+    )
+  })
+})
+
+// ─── getSnapshot ──────────────────────────────────────────────────────────────
+
+describe('getSnapshot', () => {
+  it('returns a plain JS object', () => {
+    const c = Counter.create({ count: 7 })
+    const snap = getSnapshot(c)
+    expect(snap).toEqual({ count: 7 })
+    expect(typeof snap.count).toBe('number')
+  })
+
+  it('snapshot reflects current state after mutations', () => {
+    const c = Counter.create()
+    c.inc()
+    c.inc()
+    c.inc()
+    expect(getSnapshot(c)).toEqual({ count: 3 })
+  })
+
+  it('throws for non-model-instance values', () => {
+    expect(() => getSnapshot({} as object)).toThrow('[@pyreon/state-tree]')
+  })
+})
+
+// ─── applySnapshot ────────────────────────────────────────────────────────────
+
+describe('applySnapshot', () => {
+  it('restores state from a plain snapshot', () => {
+    const c = Counter.create({ count: 10 })
+    applySnapshot(c, { count: 0 })
+    expect(c.count()).toBe(0)
+  })
+
+  it('partial snapshot — only specified keys are updated', () => {
+    const NamedCounter = model({ state: { count: 0, label: 'x' } })
+    const c = NamedCounter.create({ count: 5, label: 'hello' })
+    applySnapshot(c, { count: 99 })
+    expect(c.count()).toBe(99)
+    expect(c.label()).toBe('hello')
+  })
+
+  it('batch: effects fire once even for multi-field updates', () => {
+    const M = model({ state: { a: 0, b: 0 } })
+    const m = M.create()
+    let effectRuns = 0
+    effect(() => {
+      m.a()
+      m.b()
+      effectRuns++
+    })
+    effectRuns = 0
+    applySnapshot(m, { a: 1, b: 2 })
+    expect(effectRuns).toBe(1)
+    expect(m.a()).toBe(1)
+    expect(m.b()).toBe(2)
+  })
+})
+
+// ─── onPatch ──────────────────────────────────────────────────────────────────
+
+describe('onPatch', () => {
+  it('fires when a signal is written', () => {
+    const c = Counter.create()
+    const patches: Patch[] = []
+    onPatch(c, (p) => patches.push(p))
+    c.inc()
+    expect(patches).toHaveLength(1)
+    expect(patches[0]).toEqual({ op: 'replace', path: '/count', value: 1 })
+  })
+
+  it('does NOT fire when value is unchanged', () => {
+    const c = Counter.create()
+    const patches: Patch[] = []
+    onPatch(c, (p) => patches.push(p))
+    c.count.set(0) // same value
+    expect(patches).toHaveLength(0)
+  })
+
+  it('unsub stops patch events', () => {
+    const c = Counter.create()
+    const patches: Patch[] = []
+    const unsub = onPatch(c, (p) => patches.push(p))
+    unsub()
+    c.inc()
+    expect(patches).toHaveLength(0)
+  })
+
+  it('includes correct value in patch', () => {
+    const c = Counter.create()
+    const values: number[] = []
+    onPatch(c, (p) => values.push(p.value as number))
+    c.add(3)
+    c.add(7)
+    expect(values).toEqual([3, 10])
+  })
+})
+
+// ─── addMiddleware ────────────────────────────────────────────────────────────
+
+describe('addMiddleware', () => {
+  it('intercepts action calls', () => {
+    const c = Counter.create()
+    const intercepted: string[] = []
+    addMiddleware(c, (call, next) => {
+      intercepted.push(call.name)
+      return next(call)
+    })
+    c.inc()
+    expect(intercepted).toContain('inc')
+  })
+
+  it('next() executes the action', () => {
+    const c = Counter.create()
+    addMiddleware(c, (call, next) => next(call))
+    c.add(5)
+    expect(c.count()).toBe(5)
+  })
+
+  it('middleware can prevent action from running by not calling next', () => {
+    const c = Counter.create()
+    addMiddleware(c, (_call, _next) => {
+      /* block */
+    })
+    c.inc()
+    expect(c.count()).toBe(0)
+  })
+
+  it('multiple middlewares run in registration order', () => {
+    const c = Counter.create()
+    const log: string[] = []
+    addMiddleware(c, (call, next) => {
+      log.push('A')
+      next(call)
+      log.push("A'")
+    })
+    addMiddleware(c, (call, next) => {
+      log.push('B')
+      next(call)
+      log.push("B'")
+    })
+    c.inc()
+    // Koa-style: A→B→action→B'→A' (inner middleware unwraps first)
+    expect(log).toEqual(['A', 'B', "B'", "A'"])
+  })
+
+  it('unsub removes the middleware', () => {
+    const c = Counter.create()
+    const log: string[] = []
+    const unsub = addMiddleware(c, (call, next) => {
+      log.push(call.name)
+      return next(call)
+    })
+    unsub()
+    c.inc()
+    expect(log).toHaveLength(0)
+  })
+})
+
+// ─── patch.ts trackedSignal coverage ─────────────────────────────────────────
+
+describe('trackedSignal extra paths', () => {
+  it('subscribe on a state signal works (trackedSignal.subscribe)', () => {
+    const c = Counter.create()
+    const calls: number[] = []
+    const unsub = c.count.subscribe(() => {
+      calls.push(c.count())
+    })
+    c.inc()
+    expect(calls).toContain(1)
+    unsub()
+    c.inc()
+    // After unsub, no more notifications
+    expect(calls).toHaveLength(1)
+  })
+
+  it('update on a state signal uses the updater function (trackedSignal.update)', () => {
+    const c = Counter.create({ count: 5 })
+    c.count.update((n: number) => n * 2)
+    expect(c.count()).toBe(10)
+  })
+
+  it('peek on a state signal reads without tracking (trackedSignal.peek)', () => {
+    const c = Counter.create({ count: 42 })
+    expect(c.count.peek()).toBe(42)
+  })
+})
+
+// ─── patch.ts snapshotValue coverage ─────────────────────────────────────────
+
+describe('patch snapshotValue', () => {
+  it('emits a snapshot (not a live instance) when setting a nested model signal', () => {
+    // When a nested model instance is set as a value and a patch listener is active,
+    // snapshotValue should recursively serialize the nested model.
+    const Inner = model({
+      state: { x: 10, y: 20 },
+      actions: (self) => ({
+        setX: (v: number) => self.x.set(v),
+      }),
+    })
+
+    const Outer = model({
+      state: { child: Inner, label: 'hi' },
+      actions: (self) => ({
+        replaceChild: (newChild: any) => self.child.set(newChild),
+      }),
+    })
+
+    const outer = Outer.create()
+    const patches: Patch[] = []
+    onPatch(outer, (p) => patches.push(p))
+
+    // Create a new inner instance and set it — triggers snapshotValue on a model instance
+    const newInner = Inner.create({ x: 99, y: 42 })
+    outer.replaceChild(newInner)
+
+    expect(patches).toHaveLength(1)
+    expect(patches[0]!.op).toBe('replace')
+    expect(patches[0]!.path).toBe('/child')
+    // The value should be a plain snapshot, not the live model instance
+    expect(patches[0]!.value).toEqual({ x: 99, y: 42 })
+    expect(patches[0]!.value).not.toBe(newInner)
+  })
+
+  it('snapshotValue recursively serializes deeply nested model instances', () => {
+    const Leaf = model({
+      state: { val: 0 },
+    })
+    const Mid = model({
+      state: { leaf: Leaf, tag: 'mid' },
+    })
+    const Root = model({
+      state: { mid: Mid, name: 'root' },
+      actions: (self) => ({
+        replaceMid: (m: any) => self.mid.set(m),
+      }),
+    })
+
+    const root = Root.create()
+    const patches: Patch[] = []
+    onPatch(root, (p) => patches.push(p))
+
+    const newMid = Mid.create({ leaf: { val: 77 }, tag: 'new' })
+    root.replaceMid(newMid)
+
+    expect(patches[0]!.value).toEqual({ leaf: { val: 77 }, tag: 'new' })
+  })
+
+  it('snapshotValue returns the object as-is when it has no meta (!meta branch)', () => {
+    // To trigger the !meta branch in snapshotValue, we need isModelInstance to return true
+    // for an object that has no actual meta. We do this by temporarily registering a
+    // fake object in instanceMeta, making it pass isModelInstance, then deleting the meta
+    // before the snapshot is taken... Actually, we can register a fake object in instanceMeta
+    // to make isModelInstance true, then set it as a signal value.
+    //
+    // Simpler: register an object in instanceMeta with stateKeys pointing to missing props.
+    const Inner = model({
+      state: { x: 10 },
+    })
+
+    const Outer = model({
+      state: { child: Inner },
+      actions: (self) => ({
+        replaceChild: (c: any) => self.child.set(c),
+      }),
+    })
+
+    const outer = Outer.create()
+    const patches: Patch[] = []
+    onPatch(outer, (p) => patches.push(p))
+
+    // Create a fake "model instance" — register in instanceMeta so isModelInstance returns true,
+    // but with stateKeys that reference properties that don't exist on the object (!sig branch)
+    const fakeInstance = {} as any
+    instanceMeta.set(fakeInstance, {
+      stateKeys: ['missing'],
+      patchListeners: new Set(),
+      middlewares: [],
+      emitPatch: () => {
+        /* noop */
+      },
+    })
+
+    outer.replaceChild(fakeInstance)
+    // snapshotValue is called, meta exists, iterates stateKeys ["missing"],
+    // sig = fakeInstance["missing"] = undefined → !sig → continue → returns {}
+    expect(patches[0]!.value).toEqual({})
+  })
+
+  it('snapshotValue handles stateKey with nested model value recursively in patches', () => {
+    // Ensure the recursive path in snapshotValue is covered:
+    // when a stateKey's peek() returns a model instance, it recurses.
+    const Leaf = model({ state: { v: 1 } })
+    const Branch = model({
+      state: { leaf: Leaf, tag: 'a' },
+    })
+    const Root = model({
+      state: { branch: Branch },
+      actions: (self) => ({
+        replaceBranch: (b: any) => self.branch.set(b),
+      }),
+    })
+
+    const root = Root.create()
+    const patches: Patch[] = []
+    onPatch(root, (p) => patches.push(p))
+
+    const newBranch = Branch.create({ leaf: { v: 99 }, tag: 'b' })
+    root.replaceBranch(newBranch)
+
+    expect(patches[0]!.value).toEqual({ leaf: { v: 99 }, tag: 'b' })
+  })
+})
+
+// ─── middleware.ts edge cases ────────────────────────────────────────────────
+
+describe('middleware edge cases', () => {
+  it('action runs directly when middleware array is empty (idx >= length branch)', () => {
+    const c = Counter.create()
+    // No middleware added — dispatch(0, call) hits idx >= meta.middlewares.length immediately
+    c.inc()
+    expect(c.count()).toBe(1)
+  })
+
+  it('skips falsy middleware entries (!mw branch)', () => {
+    const c = Counter.create()
+    // Add a real middleware so the array is non-empty
+    addMiddleware(c, (call, next) => next(call))
+    // Inject a falsy entry at the beginning of the middlewares array
+    const meta = instanceMeta.get(c)!
+    meta.middlewares.unshift(undefined as any)
+    // Action should still run — the !mw guard falls through to fn(...c.args)
+    c.inc()
+    expect(c.count()).toBe(1)
+  })
+
+  it('double-unsub is a no-op (indexOf returns -1 branch)', () => {
+    const c = Counter.create()
+    const unsub = addMiddleware(c, (call, next) => next(call))
+    unsub()
+    // Second unsub — middleware already removed, indexOf returns -1
+    expect(() => unsub()).not.toThrow()
+  })
+})
+
+// ─── snapshot.ts edge cases ──────────────────────────────────────────────────
+
+describe('snapshot edge cases', () => {
+  it('getSnapshot skips keys whose signal does not exist (!sig branch)', () => {
+    // Create an instance then tamper with it to have a missing signal for a state key
+    const c = Counter.create({ count: 5 })
+    // Delete the signal to simulate the !sig branch
+    delete (c as any).count
+    const snap = getSnapshot(c)
+    // The key should be skipped — snapshot is empty
+    expect(snap).toEqual({})
+  })
+
+  it('applySnapshot skips keys not present in the snapshot object', () => {
+    const M = model({ state: { a: 1, b: 2, c: 3 } })
+    const m = M.create({ a: 10, b: 20, c: 30 })
+    // Only apply 'b' — 'a' and 'c' should remain unchanged
+    applySnapshot(m, { b: 99 })
+    expect(m.a()).toBe(10)
+    expect(m.b()).toBe(99)
+    expect(m.c()).toBe(30)
+  })
+
+  it('applySnapshot skips keys whose signal does not exist (!sig branch)', () => {
+    const c = Counter.create({ count: 5 })
+    // Delete the signal to simulate the !sig branch in applySnapshot
+    delete (c as any).count
+    // Should not throw — just skip the key
+    expect(() => applySnapshot(c, { count: 0 })).not.toThrow()
+  })
+})
+
+// ─── Nested models ────────────────────────────────────────────────────────────
+
+describe('nested models', () => {
+  it('creates nested instance from snapshot', () => {
+    const app = App.create({
+      profile: { name: 'Alice', bio: 'dev' },
+      title: 'App',
+    })
+    expect(app.profile().name()).toBe('Alice')
+  })
+
+  it('nested instance has its own actions', () => {
+    const app = App.create({
+      profile: { name: 'Alice', bio: '' },
+      title: 'App',
+    })
+    app.profile().rename('Bob')
+    expect(app.profile().name()).toBe('Bob')
+  })
+
+  it('nested defaults used when no snapshot provided', () => {
+    const app = App.create()
+    expect(app.profile().name()).toBe('')
+    expect(app.title()).toBe('My App')
+  })
+
+  it('getSnapshot recursively serializes nested instances', () => {
+    const app = App.create({
+      profile: { name: 'Alice', bio: 'dev' },
+      title: 'Hello',
+    })
+    const snap = getSnapshot(app)
+    expect(snap).toEqual({
+      profile: { name: 'Alice', bio: 'dev' },
+      title: 'Hello',
+    })
+  })
+
+  it('onPatch emits nested path for nested state change', () => {
+    const app = App.create({ profile: { name: 'Alice', bio: '' }, title: '' })
+    const patches: Patch[] = []
+    onPatch(app, (p) => patches.push(p))
+    app.profile().rename('Bob')
+    expect(patches).toHaveLength(1)
+    expect(patches[0]).toEqual({
+      op: 'replace',
+      path: '/profile/name',
+      value: 'Bob',
+    })
+  })
+
+  it('applySnapshot restores nested state', () => {
+    const app = App.create({
+      profile: { name: 'Alice', bio: '' },
+      title: 'old',
+    })
+    applySnapshot(app, { profile: { name: 'Carol', bio: 'new' }, title: 'new' })
+    expect(app.profile().name()).toBe('Carol')
+    expect(app.title()).toBe('new')
+  })
+})
+
+// ─── applyPatch ──────────────────────────────────────────────────────────────
+
+describe('applyPatch', () => {
+  it('applies a single replace patch', () => {
+    const c = Counter.create({ count: 0 })
+    applyPatch(c, { op: 'replace', path: '/count', value: 42 })
+    expect(c.count()).toBe(42)
+  })
+
+  it('applies an array of patches', () => {
+    const c = Counter.create({ count: 0 })
+    applyPatch(c, [
+      { op: 'replace', path: '/count', value: 1 },
+      { op: 'replace', path: '/count', value: 2 },
+      { op: 'replace', path: '/count', value: 3 },
+    ])
+    expect(c.count()).toBe(3)
+  })
+
+  it('applies patch to nested model instance', () => {
+    const app = App.create({
+      profile: { name: 'Alice', bio: '' },
+      title: 'old',
+    })
+    applyPatch(app, { op: 'replace', path: '/profile/name', value: 'Bob' })
+    expect(app.profile().name()).toBe('Bob')
+  })
+
+  it('roundtrips with onPatch — record and replay', () => {
+    const c = Counter.create({ count: 0 })
+    const patches: Patch[] = []
+    onPatch(c, (p) => patches.push({ ...p }))
+
+    c.inc()
+    c.inc()
+    c.add(10)
+    expect(c.count()).toBe(12)
+    expect(patches).toHaveLength(3)
+    // Verify patches contain the final values at each step
+    expect(patches[0]).toEqual({ op: 'replace', path: '/count', value: 1 })
+    expect(patches[1]).toEqual({ op: 'replace', path: '/count', value: 2 })
+    expect(patches[2]).toEqual({ op: 'replace', path: '/count', value: 12 })
+
+    // Replay on a fresh instance
+    const c2 = Counter.create({ count: 0 })
+    applyPatch(c2, patches)
+    expect(c2.count()).toBe(12)
+  })
+
+  it('throws for non-model instance', () => {
+    expect(() =>
+      applyPatch({}, { op: 'replace', path: '/x', value: 1 }),
+    ).toThrow('not a model instance')
+  })
+
+  it('throws for empty path', () => {
+    const c = Counter.create({ count: 0 })
+    expect(() => applyPatch(c, { op: 'replace', path: '', value: 1 })).toThrow(
+      'empty path',
+    )
+  })
+
+  it('throws for unknown state key', () => {
+    const c = Counter.create({ count: 0 })
+    expect(() =>
+      applyPatch(c, { op: 'replace', path: '/nonexistent', value: 1 }),
+    ).toThrow('unknown state key')
+  })
+
+  it('throws for unsupported op', () => {
+    const c = Counter.create({ count: 0 })
+    expect(() =>
+      applyPatch(c, { op: 'add' as any, path: '/count', value: 1 }),
+    ).toThrow('unsupported op "add"')
+  })
+})