JavaScriptにおける単体テスト：本番環境のバグを実際に防ぐ実践的なパターン

// ❌ ANTI-PATTERN: Multi-scenario test with vague intent
test('user checkout flow works', async () => {
  const cart = new Cart();
  cart.add({ id: 'item_1', price: 50 });
  expect(cart.total).toBe(50);

  cart.applyDiscount('SUMMER10');
  expect(cart.total).toBe(45);

  cart.remove('item_1');
  expect(cart.total).toBe(0);
});

// ✅ PATTERN: Focused, isolated behavioral assertions
describe('Cart Discount Engine', () => {
  it('applies percentage discount to non-empty cart', () => {
    // Arrange
    const cart = createCartWithItems([{ price: 100, quantity: 1 }]);
    const coupon = { code: 'SAVE20', discountPercent: 20 };

    // Act
    cart.applyCoupon(coupon);

    // Assert
    expect(cart.total).toBe(80);
  });

  it('rejects expired coupon codes without mutating total', () => {
    // Arrange
    const cart = createCartWithItems([{ price: 100, quantity: 1 }]);
    const expiredCoupon = { code: 'EXPIRED', discountPercent: 50, expiresAt: new Date(2020, 1, 1) };

    // Act & Assert
    expect(() => cart.applyCoupon(expiredCoupon)).toThrowError(/expired/i);
    expect(cart.total).toBe(100);
  });
});

// ❌ BRITTLE: Mocking internal implementation details
jest.spyOn(paymentService, '_calculateTaxRate').mockReturnValue(0.08);
jest.spyOn(paymentService, '_validateZipCode').mockReturnValue(true);

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { processSubscriptionPayment } from './payment';

// Mock the network transport boundary
vi.mock('@/lib/stripe-client', () => ({
  stripe: {
    charges: {
      create: vi.fn(),
    },
  },
}));

import { stripe } from '@/lib/stripe-client';

describe('processSubscriptionPayment', () => {
  it('charges customer card and marks subscription active', async () => {
    vi.mocked(stripe.charges.create).mockResolvedValueOnce({
      id: 'ch_123',
      status: 'succeeded',
    });

    const result = await processSubscriptionPayment({
      customerId: 'cus_999',
      amountInCents: 2000,
    });

    expect(result.status).toBe('active');
    expect(stripe.charges.create).toHaveBeenCalledWith({
      customer: 'cus_999',
      amount: 2000,
      currency: 'usd',
    });
  });
});

import { test } from 'vitest';
import fc from 'fast-check';
import { encodeBase64Url, decodeBase64Url } from './crypto-utils';

test('round-trip encoding invariant: decode(encode(x)) === x for all UTF-8 strings', () => {
  fc.assert(
    fc.property(fc.fullUnicodeString(), (rawText) => {
      const encoded = encodeBase64Url(rawText);
      const decoded = decodeBase64Url(encoded);
      return decoded === rawText;
    }),
    { numRuns: 500 } // Runs 500 distinct randomized variations
  );
});

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { debounce } from './debounce';

describe('debounce utility', () => {
  beforeEach(() => {
    vi.useFakeTimers();
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('delays execution until inactivity window elapses', () => {
    const callback = vi.fn();
    const debouncedFn = debounce(callback, 300);

    debouncedFn();
    debouncedFn();
    debouncedFn();

    // Fast-forward time by 200ms - should not execute yet
    vi.advanceTimersByTime(200);
    expect(callback).not.toHaveBeenCalled();

    // Advance past the 300ms threshold
    vi.advanceTimersByTime(150);
    expect(callback).toHaveBeenCalledTimes(1);
  });
});

// ❌ Obscure test name
test('calculate() error', () => ...)

// ✅ Clear, self-documenting test name
test('throws InsufficientInventoryError when requested quantity exceeds available stock', () => ...)