テストを書く

// これをテストしても、何も保証していない
test('getName は name を返す', () => {
  const user = new User({ name: '田中' });
  expect(user.getName()).toBe('田中');
});

// カバレッジ 100%。でも何も検証していない
test('calculateTotal', () => {
  calculateTotal(order); // 呼んだだけ。expect がない
});

test('継続3年の会員には10%の割引が適用される', () => {
  // Arrange: 前提を用意する
  const member = createMember({ years: 3 });
  const order = createOrder({ subtotal: 1000 });
 
  // Act: テスト対象を1回だけ呼ぶ
  const result = applyMemberDiscount(order, member);
 
  // Assert: 結果を検証する
  expect(result.total).toBe(900);
});

// 悪い: 何を検証したいテストなのか分からない
test('注文の処理', () => {
  const order = createOrder();
  addItem(order, itemA);
  expect(order.total).toBe(500);
  addItem(order, itemB);
  expect(order.total).toBe(1200);
  applyCoupon(order, coupon);
  expect(order.total).toBe(1080);
});

// 何が保証されているか分からない
test('applyCoupon のテスト', ...)
test('test1', ...)
 
// 名前が仕様になっている
test('有効期限切れのクーポンは適用できない', ...)
test('同じクーポンは同一注文に2回使えない', ...)
test('割引後の金額が0円未満になることはない', ...)

// テストできない: 実行するたびに結果が変わる
export function isExpired(token: Token): boolean {
  return token.expiresAt < new Date();
}

// 引数で受け取るだけで、急に書けるようになる
export function isExpired(token: Token, now: Date): boolean {
  return token.expiresAt < now;
}

test('有効期限を1秒でも過ぎていたら期限切れと判定する', () => {
  const token = { expiresAt: new Date('2026-01-01T00:00:00Z') };
  const now = new Date('2026-01-01T00:00:01Z');
 
  expect(isExpired(token, now)).toBe(true);
});

// テストできない
func IsExpired(token Token) bool {
    return token.ExpiresAt.Before(time.Now())
}
 
// 引数で受け取る
func IsExpired(token Token, now time.Time) bool {
    return token.ExpiresAt.Before(now)
}

func TestIsExpired(t *testing.T) {
    token := Token{ExpiresAt: time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)}
    now := token.ExpiresAt.Add(time.Second)
 
    if !IsExpired(token, now) {
        t.Error("期限を過ぎたトークンが有効と判定された")
    }
}

// テストできない: 実 DB がないと1行も動かせない
func (s *OrderService) Cancel(ctx context.Context, id string) error {
    order, err := spannerClient.GetOrder(ctx, id) // グローバルなクライアント
    if err != nil {
        return err
    }
    if order.Status == StatusShipped {
        return ErrAlreadyShipped
    }
    return spannerClient.UpdateStatus(ctx, id, StatusCanceled)
}

// 依存をインターフェースで受け取る
type OrderRepository interface {
    Get(ctx context.Context, id string) (*Order, error)
    UpdateStatus(ctx context.Context, id string, s Status) error
}
 
type OrderService struct {
    repo OrderRepository
}
 
func (s *OrderService) Cancel(ctx context.Context, id string) error {
    order, err := s.repo.Get(ctx, id)
    if err != nil {
        return err
    }
    if order.Status == StatusShipped {
        return ErrAlreadyShipped
    }
    return s.repo.UpdateStatus(ctx, id, StatusCanceled)
}

type fakeRepo struct {
    order *Order
}
 
func (f *fakeRepo) Get(ctx context.Context, id string) (*Order, error) {
    return f.order, nil
}
 
func (f *fakeRepo) UpdateStatus(ctx context.Context, id string, s Status) error {
    f.order.Status = s
    return nil
}
 
func TestCancel_発送済みならキャンセルできない(t *testing.T) {
    svc := &OrderService{repo: &fakeRepo{order: &Order{Status: StatusShipped}}}
 
    err := svc.Cancel(context.Background(), "order-1")
 
    if !errors.Is(err, ErrAlreadyShipped) {
        t.Errorf("want ErrAlreadyShipped, got %v", err)
    }
}

func TestDiscountRate(t *testing.T) {
    tests := []struct {
        name  string
        years int
        want  float64
    }{
        {name: "新規会員は割引なし", years: 0, want: 0.00},
        {name: "1年で5%", years: 1, want: 0.05},
        {name: "3年で10%", years: 3, want: 0.10},
        {name: "上限を超えても20%で頭打ち", years: 100, want: 0.20},
        {name: "負の値は0として扱う", years: -1, want: 0.00},
    }
 
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := DiscountRate(tt.years)
            if got != tt.want {
                t.Errorf("DiscountRate(%d) = %v, want %v", tt.years, got, tt.want)
            }
        })
    }
}

{name: "在庫不足", qty: 999, wantErr: ErrOutOfStock},

// 悪い例: 自分のコードまで全部モックしている
test('注文を作成する', () => {
  const validator = { validate: vi.fn().mockReturnValue(true) };
  const calculator = { calc: vi.fn().mockReturnValue(1000) };
  const formatter = { format: vi.fn().mockReturnValue('¥1,000') };
  const repo = { save: vi.fn() };
 
  const service = new OrderService(validator, calculator, formatter, repo);
  service.create(input);
 
  expect(validator.validate).toHaveBeenCalledWith(input);
  expect(calculator.calc).toHaveBeenCalledAfter(validator.validate);
  expect(formatter.format).toHaveBeenCalledWith(1000);
});

// 良い例: 外部決済サービスだけ差し替え、中のロジックは本物を使う
test('決済が失敗した注文は保存されない', async () => {
  const payment = {
    charge: vi.fn().mockRejectedValue(new PaymentDeclinedError()),
  };
  const repo = new InMemoryOrderRepository(); // 本物に近い偽物
  const service = new OrderService(repo, payment);
 
  await expect(service.create(input)).rejects.toThrow(PaymentDeclinedError);
  expect(repo.count()).toBe(0);
});

// 深夜0時をまたぐと落ちる
expect(formatDate(new Date())).toBe('2026-08-05');
 
// 月末に落ちる
expect(nextMonth(new Date()).getDate()).toBe(new Date().getDate());

let userId: string; // テスト間で共有された状態
 
test('ユーザーを作成する', () => {
  userId = createUser().id;
});
 
test('ユーザーを削除する', () => {
  deleteUser(userId); // 上のテストが先に走る前提
});

go test -shuffle=on ./...

// 最悪: マシンが遅い日に落ちる。速い日は無駄に待つ
await new Promise((r) => setTimeout(r, 1000));
expect(await getStatus()).toBe('done');

// 条件が満たされるまで待つ（タイムアウト付き）
await waitFor(() => expect(getStatus()).resolves.toBe('done'), {
  timeout: 5_000,
});

# GitHub Actions の例（要点だけ）
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      # TypeScript
      - run: npm ci          # lock ファイルどおりに入れる（npm install ではない）
      - run: npm run typecheck
      - run: npm run lint
      - run: npm test
 
      # Go
      - run: go vet ./...
      - run: go test -race -count=1 ./...