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

import { mock, describe, expect, test } from 'bun:test'
import { logMock } from '../../../tests/mocks/log'

// Mock log.ts to cut the heavy dependency chain (log.ts → bootstrap/state.ts → analytics)
mock.module('src/utils/log.ts', logMock)

const { safeParseJSON, safeParseJSONC, parseJSONL, addItemToJSONCArray } =
  await import('../json')

// ─── safeParseJSON ──────────────────────────────────────────────────────

describe('safeParseJSON', () => {
  test('parses valid object', () => {
    expect(safeParseJSON('{"a":1}')).toEqual({ a: 1 })
  })

  test('parses valid array', () => {
    expect(safeParseJSON('[1,2,3]')).toEqual([1, 2, 3])
  })

  test('parses string value', () => {
    expect(safeParseJSON('"hello"')).toBe('hello')
  })

  test('parses number value', () => {
    expect(safeParseJSON('42')).toBe(42)
  })

  test('parses boolean value', () => {
    expect(safeParseJSON('true')).toBe(true)
  })

  test('parses null value', () => {
    expect(safeParseJSON('null')).toBeNull()
  })

  test('returns null for invalid JSON', () => {
    expect(safeParseJSON('{bad}')).toBeNull()
  })

  test('returns null for empty string', () => {
    expect(safeParseJSON('')).toBeNull()
  })

  test('returns null for undefined input', () => {
    expect(safeParseJSON(undefined as any)).toBeNull()
  })

  test('returns null for null input', () => {
    expect(safeParseJSON(null as any)).toBeNull()
  })

  test('handles JSON with BOM', () => {
    expect(safeParseJSON('\uFEFF{"a":1}')).toEqual({ a: 1 })
  })

  test('parses nested objects', () => {
    const input = '{"a":{"b":{"c":1}}}'
    expect(safeParseJSON(input)).toEqual({ a: { b: { c: 1 } } })
  })
})

// ─── safeParseJSONC ─────────────────────────────────────────────────────

describe('safeParseJSONC', () => {
  test('parses standard JSON', () => {
    expect(safeParseJSONC('{"a":1}')).toEqual({ a: 1 })
  })

  test('parses JSON with single-line comments', () => {
    expect(safeParseJSONC('{\n// comment\n"a":1\n}')).toEqual({ a: 1 })
  })

  test('parses JSON with block comments', () => {
    expect(safeParseJSONC('{\n/* comment */\n"a":1\n}')).toEqual({ a: 1 })
  })

  test('parses JSON with trailing commas', () => {
    expect(safeParseJSONC('{"a":1,}')).toEqual({ a: 1 })
  })

  test('returns null for null input', () => {
    expect(safeParseJSONC(null as any)).toBeNull()
  })

  test('returns null for empty string', () => {
    expect(safeParseJSONC('')).toBeNull()
  })
})

// ─── parseJSONL ─────────────────────────────────────────────────────────

describe('parseJSONL', () => {
  test('parses multiple lines', () => {
    const result = parseJSONL('{"a":1}\n{"b":2}')
    expect(result).toEqual([{ a: 1 }, { b: 2 }])
  })

  test('returns empty array for empty string', () => {
    expect(parseJSONL('')).toEqual([])
  })

  test('parses single line', () => {
    expect(parseJSONL('{"a":1}')).toEqual([{ a: 1 }])
  })

  test('accepts Buffer input', () => {
    const buf = Buffer.from('{"x":1}\n{"y":2}')
    const result = parseJSONL(buf as any)
    expect(result).toEqual([{ x: 1 }, { y: 2 }])
  })

  // NOTE: Skipping malformed-line test — Bun.JSONL.parseChunk hangs
  // indefinitely in its error-recovery loop when encountering bad lines.
})

// ─── addItemToJSONCArray ────────────────────────────────────────────────

describe('addItemToJSONCArray', () => {
  test('appends to existing array', () => {
    const result = addItemToJSONCArray('["a","b"]', 'c')
    const parsed = JSON.parse(result)
    expect(parsed).toEqual(['a', 'b', 'c'])
  })

  test('appends to empty array', () => {
    const result = addItemToJSONCArray('[]', 'item')
    const parsed = JSON.parse(result)
    expect(parsed).toEqual(['item'])
  })

  test('creates array from empty content', () => {
    const result = addItemToJSONCArray('', 'first')
    const parsed = JSON.parse(result)
    expect(parsed).toEqual(['first'])
  })

  test('handles object item', () => {
    const result = addItemToJSONCArray('[]', { key: 'val' })
    const parsed = JSON.parse(result)
    expect(parsed).toEqual([{ key: 'val' }])
  })

  test('wraps item in new array for non-array content', () => {
    const result = addItemToJSONCArray('{"a":1}', 'item')
    const parsed = JSON.parse(result)
    expect(parsed).toEqual(['item'])
  })
})