Тестирование чистых функций: валидаторы, калькуляторы и test.each

┌────────────────────────────────────────────────────────┐
 │        Матрица тестовых сценариев (Data Table)         │
 ├─────────────────────────┬──────────────────────────────┤
 │ Входные аргументы       │ Ожидаемый результат / Ошибка │
 ├─────────────────────────┼──────────────────────────────┤
 │ ("[email protected]")     │ true                         │
 │ ("invalid-email")       │ false                        │
 │ ("")                    │ false                        │
 │ ("   ")                 │ false                        │
 │ (null as unknown)       │ throws TypeError             │
 └─────────────────────────┴──────────────────────────────┘
                             │
                             ▼  Автоматическая итерация test.each
 ┌────────────────────────────────────────────────────────┐
 │ Vitest Runner: N изолированных тестов с выводом аргументов│
 │   ✓ validateEmail("[email protected]") -> true           │
 │   ✓ validateEmail("invalid-email") -> false            │
 │   ✓ validateEmail("") -> false                         │
 │   ✓ validateEmail("   ") -> false                      │
 │   ✓ validateEmail(null) -> throws TypeError            │
 └────────────────────────────────────────────────────────┘

test.each([
  ['[email protected]', true],
  ['invalid-mail', false],
  ['@domain.com', false],
])('validateEmail("%s") возвращает %s', (input, expected) => {
  expect(validateEmail(input)).toBe(expected);
});

test.each`
  email                 | expected
  ${'[email protected]'}   | ${true}
  ${'[email protected]'} | ${true}
  ${'no-at-sign'}       | ${false}
  ${''}                 | ${false}
`('email "$email" -> $expected', ({ email, expected }) => {
  expect(validateEmail(email)).toBe(expected);
});

В стандартном JavaScript:
0.1 + 0.2 === 0.30000000000000004  // Ошибка округления в продакшене!

export interface TaxCalculationResult {
  readonly netAmountInCents: number;
  readonly taxAmountInCents: number;
  readonly grossAmountInCents: number;
}

export function calculateGrossWithTax(
  netAmountInCents: number,
  taxRatePercent: number
): TaxCalculationResult {
  if (!Number.isSafeInteger(netAmountInCents) || netAmountInCents < 0) {
    throw new TypeError('Чистая сумма должна быть неотрицательным безопасным целым числом');
  }
  if (!Number.isFinite(taxRatePercent) || taxRatePercent < 0 || taxRatePercent > 100) {
    throw new RangeError('Налоговая ставка должна быть числом от 0 до 100%');
  }

  // Расчет налога с математическим округлением до ближайшего цента
  const rawTax = (netAmountInCents * taxRatePercent) / 100;
  const taxAmountInCents = Math.round(rawTax);
  const grossAmountInCents = netAmountInCents + taxAmountInCents;

  if (!Number.isSafeInteger(grossAmountInCents)) {
    throw new OverflowError('Превышен безопасный лимит целочисленных вычислений');
  }

  return {
    netAmountInCents,
    taxAmountInCents,
    grossAmountInCents,
  };
}

export class OverflowError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'OverflowError';
  }
}

import { describe, it, expect } from 'vitest';
import { calculateGrossWithTax, OverflowError } from './moneyCalculator';

describe('calculateGrossWithTax (Чистые финансовые расчеты)', () => {
  describe('Параметризованная проверка корректных расчетов', () => {
    // Таблица тестов с проверкой округления центов
    test.each`
      netInCents | taxRate | expectedTax | expectedGross | description
      ${10000}   | ${20}   | ${2000}     | ${12000}      | ${'Стандартная ставка 20% для 100 рублей'}
      ${1000}    | ${0}    | ${0}        | ${1000}       | ${'Нулевая налоговая ставка'}
      ${0}       | ${15}   | ${0}        | ${0}          | ${'Нулевая сумма заказа'}
      ${99}      | ${10}   | ${10}       | ${109}        | ${'Округление 9.9 центов вверх до 10'}
      ${105}     | ${10}   | ${11}       | ${116}        | ${'Округление 10.5 центов вверх до 11'}
      ${104}     | ${10}   | ${10}       | ${114}        | ${'Округление 10.4 центов вниз до 10'}
      ${3333}    | ${7.5}  | ${250}      | ${3583}       | ${'Дробная налоговая ставка 7.5% (249.975 -> 250)'}
    `(
      '$description: net=$netInCents + tax($taxRate%) = gross($expectedGross)',
      ({ netInCents, taxRate, expectedTax, expectedGross }) => {
        const result = calculateGrossWithTax(netInCents, taxRate);

        expect(result.netAmountInCents).toBe(netInCents);
        expect(result.taxAmountInCents).toBe(expectedTax);
        expect(result.grossAmountInCents).toBe(expectedGross);
      }
    );
  });

  describe('Проверка граничных значений и исключений (Edge Cases)', () => {
    test.each([
      [-1, 20, TypeError, 'отрицательная сумма net'],
      [100.5, 20, TypeError, 'дробная сумма центов (не целое число)'],
      [Number.NaN, 20, TypeError, 'NaN в сумме'],
      [Number.POSITIVE_INFINITY, 20, TypeError, 'бесконечность в сумме'],
      [1000, -5, RangeError, 'отрицательная ставка налога'],
      [1000, 105, RangeError, 'ставка налога свыше 100%'],
    ])(
      'выбрасывает %s при некорректных аргументах (%s, %s): %s',
      (net, tax, expectedErrorClass) => {
        expect(() => calculateGrossWithTax(net as number, tax as number)).toThrow(
          expectedErrorClass
        );
      }
    );

    it('корректно обрабатывает предельно допустимое безопасное число JavaScript', () => {
      // 9007199254740991 центов при 0% налоге должно успешно пройти
      const maxSafe = Number.MAX_SAFE_INTEGER;
      const result = calculateGrossWithTax(maxSafe, 0);
      expect(result.grossAmountInCents).toBe(maxSafe);
    });

    it('выбрасывает OverflowError при превышении MAX_SAFE_INTEGER после начисления налога', () => {
      const nearMax = Number.MAX_SAFE_INTEGER - 100;
      expect(() => calculateGrossWithTax(nearMax, 50)).toThrow(OverflowError);
    });
  });
});