Мини-фреймворк тестирования: реализация describe/it/expect с матчерами — так работает Vitest под капотом

// Реализуем минимальный тестовый фреймворк,
// аналогичный Vitest/Jest, чтобы понять, как они работают.

// ============================================
// Матчеры (expect)
// ============================================

function expect(received) {
  return {
    toBe(expected) {
      if (received !== expected) {
        throw new Error(
          `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(received)}`
        )
      }
    },
    toEqual(expected) {
      const a = JSON.stringify(received)
      const b = JSON.stringify(expected)
      if (a !== b) {
        throw new Error(`Expected ${b}, got ${a}`)
      }
    },
    toContain(item) {
      const found = Array.isArray(received)
        ? received.includes(item)
        : String(received).includes(item)
      if (!found) {
        throw new Error(`Expected ${JSON.stringify(received)} to contain ${JSON.stringify(item)}`)
      }
    },
    toThrow(msg) {
      let threw = false
      let error = null
      try { received() } catch (e) { threw = true; error = e }
      if (!threw) throw new Error('Expected function to throw, but it did not')
      if (msg && !error.message.includes(msg)) {
        throw new Error(`Expected error message to include "${msg}", got "${error.message}"`)
      }
    },
    toBeTruthy() {
      if (!received) throw new Error(`Expected truthy value, got ${received}`)
    },
    toBeFalsy() {
      if (received) throw new Error(`Expected falsy value, got ${received}`)
    },
    resolves: {
      async toBe(expected) {
        const result = await received
        if (result !== expected) {
          throw new Error(`Promise resolved to ${result}, expected ${expected}`)
        }
      }
    }
  }
}

// ============================================
// describe / it / beforeEach
// ============================================

let stats = { passed: 0, failed: 0 }
let currentSuite = ''
const beforeEachFns = []

function describe(name, fn) {
  currentSuite = name
  console.log(`\n  ${name}`)
  fn()
  currentSuite = ''
}

function it(name, fn) {
  // Выполняем все beforeEach перед каждым тестом
  for (const setup of beforeEachFns) setup()

  try {
    const result = fn()
    // Обрабатываем асинхронные тесты
    if (result && typeof result.then === 'function') {
      result.then(() => {
        stats.passed++
        console.log(`    ✓ ${name}`)
      }).catch(err => {
        stats.failed++
        console.log(`    ✗ ${name}: ${err.message}`)
      })
    } else {
      stats.passed++
      console.log(`    ✓ ${name}`)
    }
  } catch (err) {
    stats.failed++
    console.log(`    ✗ ${name}: ${err.message}`)
  }
}

function beforeEach(fn) {
  beforeEachFns.push(fn)
}

// ============================================
// vi.fn() — мок-функции
// ============================================

function vi_fn() {
  const calls = []
  let implementations = []

  const mock = function(...args) {
    calls.push(args)
    if (implementations.length > 0) {
      const impl = implementations.shift()
      return impl(...args)
    }
  }

  mock.calls = calls
  mock.mockReturnValueOnce = (val) => {
    implementations.push(() => val)
    return mock
  }
  mock.mockResolvedValueOnce = (val) => {
    implementations.push(() => Promise.resolve(val))
    return mock
  }
  mock.toHaveBeenCalled = () => calls.length > 0
  mock.toHaveBeenCalledWith = (...args) =>
    calls.some(c => JSON.stringify(c) === JSON.stringify(args))
  mock.mockClear = () => { calls.length = 0; implementations.length = 0 }

  return mock
}

// ============================================
// Тестируем реальный код с нашим мини-фреймворком
// ============================================

// Тестируемые утилиты
function formatPrice(amount) {
  if (amount === 0) return '0 ₽'
  return amount.toLocaleString('ru-RU') + ' ₽'
}

function sum(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('Оба аргумента должны быть числами')
  }
  return a + b
}

async function fetchData(id, fetcher) {
  const data = await fetcher(id)
  return { ...data, fetched: true }
}

// Тесты
console.log('=== Запуск тестов ===')

describe('formatPrice', () => {
  it('форматирует число', () => {
    const result = formatPrice(1000)
    expect(result).toContain('₽')
  })

  it('обрабатывает ноль', () => {
    expect(formatPrice(0)).toBe('0 ₽')
  })
})

describe('sum', () => {
  it('складывает два числа', () => {
    expect(sum(2, 3)).toBe(5)
  })

  it('бросает ошибку для не-чисел', () => {
    expect(() => sum('a', 1)).toThrow('числами')
  })
})

describe('fetchData с моком', () => {
  const mockFetcher = vi_fn()

  it('добавляет поле fetched: true', async () => {
    mockFetcher.mockResolvedValueOnce({ id: 1, name: 'Alice' })
    const result = await fetchData(1, mockFetcher)
    expect(result).toEqual({ id: 1, name: 'Alice', fetched: true })
  })
})

setTimeout(() => {
  console.log(`\n=== Итог: ${stats.passed} passed, ${stats.failed} failed ===`)
}, 100)