test: add more unit tests for Atom functionalities

Author: lifeiscontent

packages/atom/test/Atom.test.ts

@@ -1348,6 +1348,294 @@ describe("Atom", () => {
     const result = r.get(atom)
     expect(Result.isInterrupted(result)).toBeTruthy()
   })
+
+  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)
+    expect(Result.isSuccess(result)).toBe(true)
+    if (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("writable direct", () => {
+    const r = Registry.make()
+    let value = 0
+
+    const atom = Atom.writable(
+      () => value,
+      (_, newValue: number) => {
+        value = newValue
+      }
+    )
+
+    expect(r.get(atom)).toBe(0)
+    r.set(atom, 42)
+    r.refresh(atom) // Need to refresh to see the new value
+    expect(r.get(atom)).toBe(42)
+    expect(value).toBe(42)
+  })
+
+  it("readable direct", () => {
+    const r = Registry.make()
+    let value = 0
+
+    const atom = Atom.readable(() => value)
+
+    expect(r.get(atom)).toBe(0)
+    value = 42
+    r.refresh(atom) // Need to refresh to see the new value
+    expect(r.get(atom)).toBe(42)
+  })
+
+  it("effect failure", () => {
+    const r = Registry.make()
+    const failing = Atom.make(Effect.fail("error"))
+
+    const result = r.get(failing)
+    expect(Result.isFailure(result)).toBe(true)
+    if (Result.isFailure(result)) {
+      expect(Cause.isFailType(result.cause) && 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)
+    expect(Result.isSuccess(result)).toBe(true)
+    if (Result.isSuccess(result)) {
+      expect(result.value).toBe(42)
+    }
+
+    // Then failure - should keep previous success
+    r.set(atom, true)
+    result = r.get(atom)
+    expect(Result.isFailure(result)).toBe(true)
+    const value = Result.value(result)
+    expect(Option.isSome(value)).toBe(true)
+    if (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.mount", () => {
+    const r = Registry.make()
+    let mounted = false
+    let unmounted = false
+
+    const atom = Atom.make((get) => {
+      const other = Atom.make(Effect.sync(() => {
+        mounted = true
+        return "value"
+      }))
+
+      get.addFinalizer(() => {
+        unmounted = true
+      })
+
+      get.mount(other)
+      return get(other)
+    })
+
+    const result = r.get(atom)
+    expect(Result.isSuccess(result)).toBe(true)
+    expect(mounted).toBe(true)
+    expect(unmounted).toBe(false)
+  })
+
+  it("context.refresh", () => {
+    const r = Registry.make()
+    let counter = 0
+    const state = Atom.make(() => ++counter)
+
+    const derived = Atom.make((get) => {
+      get(state) // Access state first
+      get.refresh(state) // Force refresh of dependency
+      return get(state) // Get the refreshed value
+    })
+
+    expect(r.get(derived)).toBe(2)
+    expect(counter).toBe(2) // Should have been called twice due to refresh
+  })
+
+  it("custom refresh function", () => {
+    const r = Registry.make()
+    let refreshCalled = false
+    const otherValue = "initial"
+
+    const otherAtom = Atom.make(otherValue)
+    const atom = Atom.readable(
+      () => "value",
+      (refresh) => {
+        refreshCalled = true
+        refresh(otherAtom) // Refresh a different atom to avoid recursion
+      }
+    )
+
+    r.get(atom)
+    expect(refreshCalled).toBe(false)
+
+    r.refresh(atom)
+    expect(refreshCalled).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)
+    // Should interrupt the running effect
+  })
 })
 
 interface BuildCounter {