PHPエンジニアがTypeScriptのTDDをAIとやってみた

type Rank = "normal" | "silver" | "gold";

const MULTIPLIER: Record<Rank, { normal: number; birth: number }> = {
  normal: { normal: 1, birth: 2 },
  silver: { normal: 2, birth: 4 },
  gold:   { normal: 3, birth: 6 },
};

export function calcPoint(price: number, rank: Rank, isBirthMonth: boolean): number {
  const multiplier = isBirthMonth ? MULTIPLIER[rank].birth : MULTIPLIER[rank].normal;
  return Math.floor(price * multiplier * 0.01);
}

import { describe, it, expect } from "vitest";
import { calcPoint } from "./point";

describe("calcPoint: ポイント計算", () => {
  // 通常会員
  describe("通常会員", () => {
    it("通常月: 1,000円 → 10pt（1倍）", () => {
      expect(calcPoint(1000, "normal", false)).toBe(10);
    });

    it("誕生日月: 1,000円 → 20pt（2倍）", () => {
      expect(calcPoint(1000, "normal", true)).toBe(20);
    });
  });

  // シルバー会員
  describe("シルバー会員", () => {
    it("通常月: 1,000円 → 20pt（2倍）", () => {
      expect(calcPoint(1000, "silver", false)).toBe(20);
    });

    it("誕生日月: 1,000円 → 40pt（4倍）", () => {
      expect(calcPoint(1000, "silver", true)).toBe(40);
    });
  });

  // ゴールド会員
  describe("ゴールド会員", () => {
    it("通常月: 1,000円 → 30pt（3倍）", () => {
      expect(calcPoint(1000, "gold", false)).toBe(30);
    });

    it("誕生日月: 1,000円 → 60pt（6倍）", () => {
      expect(calcPoint(1000, "gold", true)).toBe(60);
    });
  });

  // 金額の境界値
  it("購入金額0円のとき、ポイントは0pt", () => {
    expect(calcPoint(0, "gold", true)).toBe(0);
  });
});

import { describe, it, expect } from "vitest";                                                                                                                                                                                 
import { calcDiscount } from "./calcDiscount";

describe("calcDiscount", () => {                                                                                                                                                                                                
  it("5,000円未満は割引なし（非会員）", () => {                                                                                                                                                                                  
    expect(calcDiscount(4999, false)).toBe(4999);                                                                                                                                                                               
  });

  it("5,000円未満は割引なし（会員）", () => {                                                                                                                                                                                    
    expect(calcDiscount(4999, true)).toBe(4999);                                                                                                                                                                                
  });

  it("5,000円ちょうどは5%割引（非会員）", () => {
    expect(calcDiscount(5000, false)).toBe(5000 * 0.95);                                                                                                                                                                        
  });                                                                                                                                                                                                                           
                                                                                                                                                                                                                                  
  it("5,000円以上は5%割引（非会員）", () => {
    expect(calcDiscount(10000, false)).toBe(10000 * 0.95);                                                                                                                                                                      
  });                                                                                                                                                                                                                           
                                                                                                                                                                                                                                  
  it("5,000円ちょうどは10%割引（会員）", () => {
    expect(calcDiscount(5000, true)).toBe(5000 * 0.9);                                                                                                                                                                          
  });                                                                                                                                                                                                                           
                                                                                                                                                                                                                                  
  it("5,000円以上は10%割引（会員）", () => {
    expect(calcDiscount(10000, true)).toBe(10000 * 0.9);                                                                                                                                                                        
  }); 
});

import { describe, it, expect } from 'vitest'
import { calcDiscount } from './calcDiscount'

describe('calcDiscount', () => {
  // --- 同値クラス A: 0〜4,999円（割引なし） ---
  describe('class A: price < 5000 (no discount)', () => {
    it('代表値: 3,000円・非会員 → 割引なし', () => {
      expect(calcDiscount(3000, false)).toBe(3000)
    })

    it('代表値: 3,000円・会員 → 割引なし', () => {
      expect(calcDiscount(3000, true)).toBe(3000)
    })

    it('境界値: 4,999円・非会員 → 割引なし', () => {
      expect(calcDiscount(4999, false)).toBe(4999)
    })

    it('境界値: 4,999円・会員 → 割引なし', () => {
      expect(calcDiscount(4999, true)).toBe(4999)
    })

    it('下限: 0円 → 割引なし', () => {
      expect(calcDiscount(0, false)).toBe(0)
    })
  })

  // --- 同値クラス B: 5,000円以上 & 非会員（5%） ---
  describe('class B: price >= 5000 & non-member (5% discount)', () => {
    it('代表値: 8,000円・非会員 → 5%割引', () => {
      expect(calcDiscount(8000, false)).toBe(7600)
    })

    it('境界値: 5,000円・非会員 → 5%割引', () => {
      expect(calcDiscount(5000, false)).toBe(4750)
    })
  })

  // --- 同値クラス C: 5,000円以上 & 会員（10%） ---
  describe('class C: price >= 5000 & member (10% discount)', () => {
    it('代表値: 8,000円・会員 → 10%割引', () => {
      expect(calcDiscount(8000, true)).toBe(7200)
    })

    it('境界値: 5,000円・会員 → 10%割引', () => {
      expect(calcDiscount(5000, true)).toBe(4500)
    })
  })
})

type OvertimeParams = {
  hours: number;
  hourlyWage: number;
  isOvertime: boolean; // 法定労働時間(8h)超か
  isNight: boolean;    // 深夜(22〜5時)か
  isHoliday: boolean;  // 法定休日か
  isOver60h: boolean;  // 月60時間超か
};

export function calcOvertimePay(params: OvertimeParams): number {
  const { hours, hourlyWage, isOvertime, isNight, isHoliday, isOver60h } = params;
  if (hours < 0) throw new Error("労働時間は0以上である必要があります");
  if (hourlyWage <= 0) throw new Error("基本時給は1以上である必要があります");

  const multiplier = getMultiplier({ isOvertime, isNight, isHoliday, isOver60h });
  return hours * hourlyWage * multiplier;
}

type MultiplierParams = Pick<OvertimeParams, "isOvertime" | "isNight" | "isHoliday" | "isOver60h">;

function getMultiplier({ isOvertime, isNight, isHoliday, isOver60h }: MultiplierParams): number {
  // 法定休日: 時間外割増は重複しない（35%固定）、深夜は重複適用
  if (isHoliday) { return isNight ? 1.60 : 1.35; }
  // 深夜割増(+25%)は時間外割増と重複適用
  const nightBonus = isNight ? 0.25 : 0;
  // 月60h超は時間外割増が+50%、以内は+25%
  if (isOvertime) {
    const overtimeBonus = isOver60h ? 0.50 : 0.25;
    return 1 + overtimeBonus + nightBonus;
  }
  // 時間外なし（深夜のみ、または通常勤務）
  return 1 + nightBonus;
}

import { describe, it, expect } from "vitest";
import { calcOvertimePay } from "./overtime";

// 基本時給1,000円・1時間で計算（倍率の確認がしやすい）
const BASE_WAGE = 1000;

describe("calcOvertimePay: 残業代計算", () => {
  // クラス1: 通常勤務 → 100%
  describe("クラス1: 通常勤務（割増なし）", () => {
    it("時間外・深夜・休日すべてなし → 1,000円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: false,
          isNight: false,
          isHoliday: false,
          isOver60h: false,
        })
      ).toBe(1000);
    });
  });

  // クラス2: 時間外のみ（月60h以内）→ 125%
  describe("クラス2: 時間外のみ（月60h以内）", () => {
    it("時間外あり・月60h以内 → 1,250円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: true,
          isNight: false,
          isHoliday: false,
          isOver60h: false,
        })
      ).toBe(1250);
    });
  });

  // クラス3: 時間外のみ（月60h超）→ 150%
  describe("クラス3: 時間外のみ（月60h超）", () => {
    it("時間外あり・月60h超 → 1,500円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: true,
          isNight: false,
          isHoliday: false,
          isOver60h: true,
        })
      ).toBe(1500);
    });
  });

  // クラス4: 深夜のみ（8h以内）→ 125%
  describe("クラス4: 深夜のみ（8h以内）", () => {
    it("深夜・時間外なし → 1,250円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: false,
          isNight: true,
          isHoliday: false,
          isOver60h: false,
        })
      ).toBe(1250);
    });
  });

  // クラス5: 時間外＋深夜（月60h以内）→ 150%
  describe("クラス5: 時間外＋深夜（月60h以内）", () => {
    it("時間外あり・深夜・月60h以内 → 1,500円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: true,
          isNight: true,
          isHoliday: false,
          isOver60h: false,
        })
      ).toBe(1500);
    });
  });

  // クラス6: 時間外＋深夜（月60h超）→ 175%
  describe("クラス6: 時間外＋深夜（月60h超）", () => {
    it("時間外あり・深夜・月60h超 → 1,750円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: true,
          isNight: true,
          isHoliday: false,
          isOver60h: true,
        })
      ).toBe(1750);
    });
  });

  // クラス7: 休日のみ（昼間）→ 135%
  describe("クラス7: 休日のみ（昼間）", () => {
    it("法定休日・深夜なし → 1,350円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: false,
          isNight: false,
          isHoliday: true,
          isOver60h: false,
        })
      ).toBe(1350);
    });

    it("法定休日・8h超でも割増率は同じ135%（時間外割増は重複しない）", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: true,
          isNight: false,
          isHoliday: true,
          isOver60h: false,
        })
      ).toBe(1350);
    });
  });

  // クラス8: 休日＋深夜 → 160%
  describe("クラス8: 休日＋深夜", () => {
    it("法定休日・深夜 → 1,600円/h", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: false,
          isNight: true,
          isHoliday: true,
          isOver60h: false,
        })
      ).toBe(1600);
    });
  });

  // 境界値
  describe("境界値", () => {
    it("B3: 月60hちょうどは125%（超えていない）", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: true,
          isNight: false,
          isHoliday: false,
          isOver60h: false,
        })
      ).toBe(1250);
    });

    it("B4: 月60h超は150%", () => {
      expect(
        calcOvertimePay({
          hours: 1,
          hourlyWage: BASE_WAGE,
          isOvertime: true,
          isNight: false,
          isHoliday: false,
          isOver60h: true,
        })
      ).toBe(1500);
    });
  });

  // 異常系
  describe("異常系", () => {
    it("E1: 労働時間0hは0円", () => {
      expect(
        calcOvertimePay({
          hours: 0,
          hourlyWage: BASE_WAGE,
          isOvertime: false,
          isNight: false,
          isHoliday: false,
          isOver60h: false,
        })
      ).toBe(0);
    });

    it("E2: 負の労働時間はエラー", () => {
      expect(() =>
        calcOvertimePay({
          hours: -1,
          hourlyWage: BASE_WAGE,
          isOvertime: false,
          isNight: false,
          isHoliday: false,
          isOver60h: false,
        })
      ).toThrow();
    });

    it("E3: 基本時給0以下はエラー", () => {
      expect(() =>
        calcOvertimePay({
          hours: 1,
          hourlyWage: 0,
          isOvertime: false,
          isNight: false,
          isHoliday: false,
          isOver60h: false,
        })
      ).toThrow();
    });
  });
});

type WorkSession = {
  startMinutes: number;           // 開始時刻（分）例: 9:00 → 540
  endMinutes: number;             // 終了時刻（分）例: 翌2:00 → 1560
  hourlyWage: number;             // 基本時給（円）
  isHoliday: boolean;             // 法定休日か
  monthlyOvertimeMinutes: number; // 月の累計残業時間（分）
};

const LEGAL_DAILY_MINUTES = 480;         // 法定労働時間: 8h
const MONTHLY_OT_THRESHOLD = 60 * 60;   // 月60h = 3600分
const NIGHT_START = 22 * 60;             // 深夜開始: 22:00 = 1320分
const NIGHT_END = 5 * 60;               // 深夜終了: 5:00 = 300分

export function calcOvertimePay(session: WorkSession): number {
  const { startMinutes, endMinutes, hourlyWage, isHoliday, monthlyOvertimeMinutes } = session;

  if (endMinutes <= startMinutes) throw new Error("終了時刻は開始時刻より後にしてください");
  if (hourlyWage <= 0) throw new Error("基本時給は1以上にしてください");
  if (monthlyOvertimeMinutes < 0) throw new Error("月累計残業時間は0以上にしてください");

  const totalMinutes = endMinutes - startMinutes;

  // 法定内（最初の8h）と残業（8h超）に分ける
  const regularEnd = startMinutes + Math.min(totalMinutes, LEGAL_DAILY_MINUTES);
  const regularNight = calcNightMinutes(startMinutes, regularEnd);
  const regularDay = (regularEnd - startMinutes) - regularNight;

  let overtimeDay = 0;
  let overtimeNight = 0;
  if (totalMinutes > LEGAL_DAILY_MINUTES) {
    const overtimeStart = startMinutes + LEGAL_DAILY_MINUTES;
    overtimeNight = calcNightMinutes(overtimeStart, endMinutes);
    overtimeDay = (endMinutes - overtimeStart) - overtimeNight;
  }

  // 月60hを「超えた」場合に150%（3600分ちょうどはまだ超えていない）
  const isOver60h = monthlyOvertimeMinutes > MONTHLY_OT_THRESHOLD;
  const ratePerMin = hourlyWage / 60;

  let total = 0;
  if (isHoliday) {
    // 休日: 時間外割増は重複しない（35%固定）、深夜のみ+25%追加
    total += regularDay * ratePerMin * 1.35;
    total += regularNight * ratePerMin * 1.60;
    total += overtimeDay * ratePerMin * 1.35;
    total += overtimeNight * ratePerMin * 1.60;
  } else {
    const otRate = isOver60h ? 1.50 : 1.25;
    const otNightRate = isOver60h ? 1.75 : 1.50;

    total += regularDay * ratePerMin * 1.00;
    total += regularNight * ratePerMin * 1.25;
    total += overtimeDay * ratePerMin * otRate;
    total += overtimeNight * ratePerMin * otNightRate;
  }

  return Math.floor(total);
}

// 指定範囲（分）のうち深夜帯（22:00-5:00）に含まれる分数を返す
function calcNightMinutes(start: number, end: number): number {
  let nightMins = 0;
  let pos = start;
  while (pos < end) {
    const dayBase = Math.floor(pos / 1440) * 1440;
    const dayOffset = pos - dayBase;
    const chunkEnd = Math.min(end, dayBase + 1440);
    const chunkEndOffset = chunkEnd - dayBase;

    // 深夜帯: 0:00-5:00 (0-300) と 22:00-24:00 (1320-1440)
    nightMins += overlap(dayOffset, chunkEndOffset, 0, NIGHT_END);
    nightMins += overlap(dayOffset, chunkEndOffset, NIGHT_START, 1440);

    pos = chunkEnd;
  }
  return nightMins;
}

function overlap(a: number, b: number, c: number, d: number): number {
  return Math.max(0, Math.min(b, d) - Math.max(a, c));
}

import { describe, it, expect } from "vitest";
import { calcOvertimePay } from "./overtime";

// 時刻は分で表す。例: 9:00 → H(9)=540、翌2:00 → NEXT(2)=1560
const H = (h: number, m = 0) => h * 60 + m;
const NEXT = (h: number, m = 0) => (24 + h) * 60 + m;

const WAGE = 1000;

describe("calcOvertimePay: 残業代計算", () => {
  // --- 正常系 ---

  describe("クラス1: 通常勤務（割増なし）", () => {
    it("平日9:00-15:00（6h, 代表値）→ 6,000円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(15), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(6000);
    });

    it("平日9:00-17:00（8hちょうど, 上限境界）→ 8,000円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(17), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(8000);
    });

    it("21:00-22:00（深夜開始の直前まで）→ 割増なし 1,000円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(21), endMinutes: H(22), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(1000);
    });

    it("5:00-6:00（深夜終了の直後から）→ 割増なし 1,000円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(5), endMinutes: H(6), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(1000);
    });
  });

  describe("クラス2: 時間外のみ（月60h以内）→ 125%", () => {
    it("平日9:00-17:01（8h+1分, 下限境界）→ 8,020円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(17, 1), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(8020);
    });

    it("平日9:00-20:00（11h, 代表値）→ 11,750円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(20), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(11750);
    });

    it("平日9:00-20:00（月累計60hちょうど, 上限境界）→ 125%のまま 11,750円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(20), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 3600 })
      ).toBe(11750);
    });
  });

  describe("クラス3: 時間外のみ（月60h超）→ 150%", () => {
    it("平日9:00-20:00（月累計60h+1分, 下限境界）→ 150%に切り替わる 12,500円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(20), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 3601 })
      ).toBe(12500);
    });

    it("平日9:00-20:00（月累計100h, 代表値）→ 12,500円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(20), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 6000 })
      ).toBe(12500);
    });
  });

  describe("クラス4: 深夜のみ（8h以内）→ 125%", () => {
    it("22:00-23:00（深夜開始直後）→ 深夜割増 1,250円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(22), endMinutes: H(23), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(1250);
    });

    it("22:00-翌1:00（3h, 代表値）→ 3,750円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(22), endMinutes: NEXT(1), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(3750);
    });

    it("4:00-5:00（深夜終了の直前まで）→ 深夜割増 1,250円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(4), endMinutes: H(5), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(1250);
    });
  });

  describe("クラス5: 時間外＋深夜（月60h以内）→ 昼間125% / 深夜150%", () => {
    it("平日9:00-翌0:00（15h, 代表値）→ 17,250円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: NEXT(0), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(17250);
    });
  });

  describe("クラス6: 時間外＋深夜（月60h超）→ 昼間150% / 深夜175%", () => {
    it("平日9:00-翌0:00（月累計3601分, 代表値）→ 19,000円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: NEXT(0), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 3601 })
      ).toBe(19000);
    });
  });

  describe("クラス7: 休日のみ → 135%（時間外割増は重複しない）", () => {
    it("法定休日9:00-17:00（8h, 代表値）→ 10,800円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(17), hourlyWage: WAGE, isHoliday: true, monthlyOvertimeMinutes: 0 })
      ).toBe(10800);
    });

    it("法定休日9:00-20:00（11h, 8h超でも135%のまま）→ 14,850円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(20), hourlyWage: WAGE, isHoliday: true, monthlyOvertimeMinutes: 0 })
      ).toBe(14850);
    });
  });

  describe("クラス8: 休日＋深夜 → 160%", () => {
    it("法定休日22:00-翌2:00（4h, 代表値）→ 6,400円", () => {
      expect(
        calcOvertimePay({ startMinutes: H(22), endMinutes: NEXT(2), hourlyWage: WAGE, isHoliday: true, monthlyOvertimeMinutes: 0 })
      ).toBe(6400);
    });
  });

  // --- 時間帯をまたぐケース ---

  describe("時間帯をまたぐケース", () => {
    it("20:00-23:00（22時をまたぐ, 昼2h+深夜1h）→ 3,250円", () => {
      // 昼間2h: 2,000円 + 深夜1h: 1,250円
      expect(
        calcOvertimePay({ startMinutes: H(20), endMinutes: H(23), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(3250);
    });

    it("4:00-6:00（5時をまたぐ, 深夜1h+昼1h）→ 2,250円", () => {
      // 深夜1h: 1,250円 + 昼間1h: 1,000円
      expect(
        calcOvertimePay({ startMinutes: H(4), endMinutes: H(6), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toBe(2250);
    });
  });

  // --- 異常系 ---

  describe("異常系", () => {
    it("E2: 終了時刻 <= 開始時刻 → エラー", () => {
      expect(() =>
        calcOvertimePay({ startMinutes: H(17), endMinutes: H(9), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toThrow();
    });

    it("E3: 基本時給0円 → エラー", () => {
      expect(() =>
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(17), hourlyWage: 0, isHoliday: false, monthlyOvertimeMinutes: 0 })
      ).toThrow();
    });

    it("E4: 月累計残業時間が負 → エラー", () => {
      expect(() =>
        calcOvertimePay({ startMinutes: H(9), endMinutes: H(17), hourlyWage: WAGE, isHoliday: false, monthlyOvertimeMinutes: -1 })
      ).toThrow();
    });
  });
});