claude-code/src/utils/__tests__/lazySchema.test.ts

import { describe, expect, test } from 'bun:test'
import { lazySchema } from '../lazySchema'

describe('lazySchema', () => {
  test('returns a function', () => {
    const factory = lazySchema(() => 42)
    expect(typeof factory).toBe('function')
  })

  test('calls factory on first invocation', () => {
    let callCount = 0
    const factory = lazySchema(() => {
      callCount++
      return 'result'
    })
    factory()
    expect(callCount).toBe(1)
  })

  test('returns cached result on subsequent invocations', () => {
    const factory = lazySchema(() => ({ value: Math.random() }))
    const first = factory()
    const second = factory()
    expect(first).toBe(second)
  })

  test('factory is called only once', () => {
    let callCount = 0
    const factory = lazySchema(() => {
      callCount++
      return 'cached'
    })
    factory()
    factory()
    factory()
    expect(callCount).toBe(1)
  })

  test('works with different return types', () => {
    const numFactory = lazySchema(() => 123)
    expect(numFactory()).toBe(123)

    const arrFactory = lazySchema(() => [1, 2, 3])
    expect(arrFactory()).toEqual([1, 2, 3])
  })

  test('each call to lazySchema returns independent cache', () => {
    const a = lazySchema(() => ({ id: 'a' }))
    const b = lazySchema(() => ({ id: 'b' }))
    expect(a()).not.toBe(b())
    expect(a().id).toBe('a')
    expect(b().id).toBe('b')
  })
})