test: add more unit tests for Atom functionalities

Author: lifeiscontent

packages/atom/test/Atom.test.ts

@@ -1422,6 +1422,241 @@ describe("Atom", () => {
 
     unmount2()
   })
+
+  it("map", () => {
+    const r = Registry.make()
+    const state = Atom.make(1)
+    const doubled = Atom.map(state, (n) => n * 2)
+
+    expect(r.get(doubled)).toBe(2)
+    r.set(state, 5)
+    expect(r.get(doubled)).toBe(10)
+  })
+
+  it("mapResult", () => {
+    const r = Registry.make()
+    const effect = Atom.make(Effect.succeed(42))
+    const mapped = Atom.mapResult(effect, (n) => n * 2)
+
+    const result = r.get(mapped)
+    assert(Result.isSuccess(result))
+    expect(result.value).toBe(84)
+  })
+
+  it("transform", () => {
+    const r = Registry.make()
+    const state = Atom.make(1)
+    const derived = Atom.transform(state, (get) => get(state) * 2 + 1)
+
+    expect(r.get(derived)).toBe(3)
+    r.set(state, 5)
+    expect(r.get(derived)).toBe(11)
+  })
+
+  it("debounce", async () => {
+    const r = Registry.make()
+    const state = Atom.make(0)
+    const debounced = Atom.debounce(state, "100 millis")
+
+    // Mount the debounced atom first
+    const unmount = r.mount(debounced)
+
+    let updates = 0
+    const cancel = r.subscribe(debounced, () => updates++)
+
+    r.set(state, 1)
+    r.set(state, 2)
+    r.set(state, 3)
+
+    expect(updates).toBe(0) // Should not update immediately
+
+    await vitest.advanceTimersByTimeAsync(150)
+    expect(r.get(debounced)).toBe(3)
+    expect(updates).toBe(1)
+
+    cancel()
+    unmount()
+  })
+
+  it("effect failure", () => {
+    const r = Registry.make()
+    const failing = Atom.make(Effect.fail("error"))
+
+    const result = r.get(failing)
+    assert(Result.isFailure(result))
+    assert(Cause.isFailType(result.cause))
+    expect(result.cause.error).toBe("error")
+  })
+
+  it("effect failure with previousSuccess", () => {
+    const r = Registry.make()
+    const atom = Atom.fn((shouldFail: boolean) => shouldFail ? Effect.fail("error") : Effect.succeed(42))
+    // First success
+    r.set(atom, false)
+    let result = r.get(atom)
+    assert(Result.isSuccess(result))
+    expect(result.value).toBe(42)
+
+    // Then failure - should keep previous success
+    r.set(atom, true)
+    result = r.get(atom)
+    assert(Result.isFailure(result))
+    const value = Result.value(result)
+    assert(Option.isSome(value))
+    expect(value.value).toBe(42)
+  })
+
+  it("context.once", () => {
+    const r = Registry.make()
+    const state = Atom.make(1)
+    let getCount = 0
+
+    const derived = Atom.make((get) => {
+      getCount++
+      return get.once(state) * 2
+    })
+
+    expect(r.get(derived)).toBe(2)
+    expect(getCount).toBe(1)
+
+    // Should not trigger rebuild on state change since we used once
+    r.set(state, 5)
+    expect(r.get(derived)).toBe(2) // Still old value
+    expect(getCount).toBe(1) // No rebuild
+  })
+
+  it("context.refresh", () => {
+    const r = Registry.make()
+    let counter = 0
+    const state = Atom.make(() => ++counter)
+    const other = Atom.make(() => counter * 10)
+
+    const derived = Atom.make((get) => {
+      const stateValue = get(state)
+      get.refresh(other) // Refresh a different atom
+      return stateValue
+    })
+
+    expect(r.get(derived)).toBe(1)
+    expect(counter).toBe(1)
+  })
+
+  it("custom refresh function", () => {
+    const r = Registry.make()
+    let refreshCalled = false
+    let otherRefreshed = false
+    const otherAtom = Atom.readable(
+      () => "other",
+      () => {
+        otherRefreshed = true
+      }
+    )
+
+    const atom = Atom.readable(
+      () => "value",
+      (refresh) => {
+        refreshCalled = true
+        refresh(otherAtom)
+      }
+    )
+
+    r.get(atom)
+    expect(refreshCalled).toBe(false)
+    expect(otherRefreshed).toBe(false)
+
+    r.refresh(atom)
+    expect(refreshCalled).toBe(true)
+    expect(otherRefreshed).toBe(true)
+  })
+
+  it("isAtom type guard", () => {
+    const atom = Atom.make(1)
+    const notAtom = { value: 1 }
+
+    expect(Atom.isAtom(atom)).toBe(true)
+    expect(Atom.isAtom(notAtom)).toBe(false)
+    expect(Atom.isAtom(null)).toBe(false)
+    expect(Atom.isAtom(undefined)).toBe(false)
+  })
+
+  it("isWritable type guard", () => {
+    const readable = Atom.readable(() => 1)
+    const writable = Atom.make(1)
+
+    expect(Atom.isWritable(readable)).toBe(false)
+    expect(Atom.isWritable(writable)).toBe(true)
+  })
+
+  it("atom properties", () => {
+    const atom = Atom.make(1)
+
+    expect(atom.keepAlive).toBe(false)
+    expect(atom.lazy).toBe(true)
+    expect(typeof atom.read).toBe("function")
+  })
+
+  it("keepAlive modifier", () => {
+    const atom = Atom.make(1)
+    const keepAliveAtom = Atom.keepAlive(atom)
+
+    expect(atom.keepAlive).toBe(false)
+    expect(keepAliveAtom.keepAlive).toBe(true)
+    expect(atom !== keepAliveAtom).toBe(true) // Should be new instance
+  })
+
+  it("autoDispose modifier", () => {
+    const atom = Atom.keepAlive(Atom.make(1))
+    const autoDisposeAtom = Atom.autoDispose(atom)
+
+    expect(atom.keepAlive).toBe(true)
+    expect(autoDisposeAtom.keepAlive).toBe(false)
+  })
+
+  it("makeRefreshOnSignal", () => {
+    const r = Registry.make()
+    const signal = Atom.make(0)
+    let computations = 0
+
+    const atom = Atom.make(() => {
+      computations++
+      return "value"
+    })
+
+    const refreshing = Atom.makeRefreshOnSignal(signal)(atom)
+
+    expect(r.get(refreshing)).toBe("value")
+    expect(computations).toBe(1)
+
+    // Trigger signal - should cause refresh
+    r.set(signal, 1)
+    expect(r.get(refreshing)).toBe("value")
+    expect(computations).toBe(2) // Should have recomputed
+  })
+
+  it("Reset symbol", () => {
+    const r = Registry.make()
+    const atom = Atom.fn((arg: number) => Effect.succeed(arg * 2))
+
+    r.set(atom, 5)
+    const result1 = r.get(atom)
+    expect(Result.isSuccess(result1)).toBe(true)
+
+    r.set(atom, Atom.Reset)
+    const result2 = r.get(atom)
+    expect(Result.isInitial(result2)).toBe(true)
+  })
+
+  it("Interrupt symbol", () => {
+    const r = Registry.make()
+    const atom = Atom.fn((arg: number) => Effect.delay(Effect.succeed(arg * 2), "100 millis"))
+    r.set(atom, 5)
+    const result1 = r.get(atom)
+    expect(Result.isWaiting(result1)).toBe(true)
+
+    r.set(atom, Atom.Interrupt)
+    const result2 = r.get(atom)
+    expect(Result.isInterrupted(result2)).toBe(true)
+  })
 })
 
 interface BuildCounter {