Red-Green-Refactorサイクル完全ガイド - TDDの心臓部を徹底解説

1
2
3
4
5
6
7

割り勘計算機能のテストリスト:
- [ ] 合計金額を人数で割った結果を返す（10000円 / 4人 = 2500円）
- [ ] 端数が出る場合は切り上げる（10000円 / 3人 = 3334円）
- [ ] 人数が1人の場合は合計金額をそのまま返す
- [ ] 人数が0以下の場合はエラーを返す
- [ ] 合計金額が負の場合はエラーを返す
- [ ] 合計金額が0の場合は0を返す

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// JUnit 5での例
class SplitBillCalculatorTest {

    @Test
    @DisplayName("合計金額を人数で割った結果を返す")
    void shouldDivideTotalAmountByNumberOfPeople() {
        // Given: 合計10,000円、4人で割り勘
        SplitBillCalculator calculator = new SplitBillCalculator();
        
        // When: 1人あたりの金額を計算
        int perPerson = calculator.calculate(10000, 4);
        
        // Then: 2,500円になる
        assertEquals(2500, perPerson);
    }
}

1
2
3
4
5
6
7
8

@Test
void shouldCalculateCorrectly() {
    // 複数のケースを1つのテストに詰め込んでいる
    assertEquals(2500, calculator.calculate(10000, 4));
    assertEquals(3334, calculator.calculate(10000, 3)); // 端数処理
    assertThrows(IllegalArgumentException.class, 
        () -> calculator.calculate(10000, 0)); // エラー処理
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@Test
void shouldDivideTotalAmountByNumberOfPeople() {
    assertEquals(2500, calculator.calculate(10000, 4));
}

@Test
void shouldRoundUpWhenThereIsRemainder() {
    assertEquals(3334, calculator.calculate(10000, 3));
}

@Test
void shouldThrowExceptionWhenNumberOfPeopleIsZero() {
    assertThrows(IllegalArgumentException.class, 
        () -> calculator.calculate(10000, 0));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 悪い例
@Test
void test1() { ... }

@Test
void testCalculate() { ... }

// 良い例
@Test
void shouldReturnZeroWhenTotalAmountIsZero() { ... }

@Test
void shouldThrowExceptionWhenNumberOfPeopleIsNegative() { ... }

1
2
3
4
5
6

public class SplitBillCalculator {
    
    public int calculate(int totalAmount, int numberOfPeople) {
        return 2500; // ハードコードでテストを通す
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Test
@DisplayName("合計金額を人数で割った結果を返す - ケース1")
void shouldDivideTotalAmountByNumberOfPeople_case1() {
    assertEquals(2500, calculator.calculate(10000, 4));
}

@Test
@DisplayName("合計金額を人数で割った結果を返す - ケース2")
void shouldDivideTotalAmountByNumberOfPeople_case2() {
    assertEquals(2000, calculator.calculate(10000, 5));
}

1
2
3
4
5
6

public class SplitBillCalculator {
    
    public int calculate(int totalAmount, int numberOfPeople) {
        return totalAmount / numberOfPeople;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 複雑すぎる（Greenフェーズでは不適切）
public int calculate(int totalAmount, int numberOfPeople) {
    if (numberOfPeople <= 0) {
        throw new IllegalArgumentException("人数は1以上である必要があります");
    }
    int base = totalAmount / numberOfPeople;
    int remainder = totalAmount % numberOfPeople;
    return remainder > 0 ? base + 1 : base;
}

// 単純（Greenフェーズに適切）
public int calculate(int totalAmount, int numberOfPeople) {
    return totalAmount / numberOfPeople;
}

1
2
3
4
5
6
7

ステップ1: return 2500; (ハードコード)
    ↓ 2つ目のテスト追加
ステップ2: return totalAmount / numberOfPeople; (基本実装)
    ↓ 端数処理のテスト追加
ステップ3: 端数処理を追加
    ↓ エラー処理のテスト追加
ステップ4: バリデーションを追加

1
2
3
4
5
6

// まずコンパイルを通す
public class SplitBillCalculator {
    public int calculate(int totalAmount, int numberOfPeople) {
        return 0; // 暫定的な値
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class SplitBillCalculator {
    
    public int calculate(int totalAmount, int numberOfPeople) {
        if (numberOfPeople <= 0) {
            throw new IllegalArgumentException("人数は1以上");
        }
        if (totalAmount < 0) {
            throw new IllegalArgumentException("金額は0以上");
        }
        int base = totalAmount / numberOfPeople;
        int remainder = totalAmount % numberOfPeople;
        if (remainder > 0) {
            return base + 1;
        }
        return base;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class SplitBillCalculator {
    
    public int calculate(int totalAmount, int numberOfPeople) {
        validateInputs(totalAmount, numberOfPeople);
        return calculatePerPersonAmount(totalAmount, numberOfPeople);
    }
    
    private void validateInputs(int totalAmount, int numberOfPeople) {
        if (numberOfPeople <= 0) {
            throw new IllegalArgumentException(
                "人数は1以上である必要があります");
        }
        if (totalAmount < 0) {
            throw new IllegalArgumentException(
                "合計金額は0以上である必要があります");
        }
    }
    
    private int calculatePerPersonAmount(int totalAmount, int numberOfPeople) {
        return (int) Math.ceil((double) totalAmount / numberOfPeople);
    }
}

1

変更 → テスト実行 → Green確認 → 次の変更 → テスト実行 → ...

1
2
3
4
5
6
7
8

良い進め方:
1. メソッド名を変更 → テスト実行 → Green
2. メソッドを抽出 → テスト実行 → Green
3. 定数を導入 → テスト実行 → Green

悪い進め方:
1. メソッド名変更 + メソッド抽出 + 定数導入 → テスト実行 → Red
   → どの変更が原因かわからない

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// これはリファクタリング（振る舞いは同じ）
// Before
return totalAmount / numberOfPeople;

// After
return (int) Math.floor((double) totalAmount / numberOfPeople);

// これはリファクタリングではない（振る舞いが変わる）
// Before: 切り捨て
return totalAmount / numberOfPeople;

// After: 切り上げ（新機能）
return (int) Math.ceil((double) totalAmount / numberOfPeople);

1
2
3
4
5
6

パスワード強度チェッカー:
- [ ] 8文字未満は「弱い」を返す
- [ ] 8文字以上で数字を含まない場合は「普通」を返す
- [ ] 8文字以上で数字を含む場合は「強い」を返す
- [ ] 12文字以上で数字と記号を含む場合は「非常に強い」を返す
- [ ] nullまたは空文字の場合は例外を投げる

1
2
3
4
5

@Test
void shouldReturnWeakWhenLessThan8Characters() {
    PasswordStrengthChecker checker = new PasswordStrengthChecker();
    assertEquals("弱い", checker.check("abc"));
}

1
2
3
4
5

public class PasswordStrengthChecker {
    public String check(String password) {
        return "弱い";
    }
}

1
2
3
4

@Test
void shouldReturnNormalWhenAtLeast8CharsWithoutDigit() {
    assertEquals("普通", checker.check("abcdefgh"));
}

1
2
3
4
5
6

public String check(String password) {
    if (password.length() < 8) {
        return "弱い";
    }
    return "普通";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class PasswordStrengthChecker {
    private static final int MIN_LENGTH = 8;
    
    public String check(String password) {
        if (password.length() < MIN_LENGTH) {
            return "弱い";
        }
        return "普通";
    }
}

1
2
3
4

@Test
void shouldReturnStrongWhenAtLeast8CharsWithDigit() {
    assertEquals("強い", checker.check("abcdefg1"));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public String check(String password) {
    if (password.length() < MIN_LENGTH) {
        return "弱い";
    }
    if (containsDigit(password)) {
        return "強い";
    }
    return "普通";
}

private boolean containsDigit(String password) {
    return password.matches(".*\\d.*");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class PasswordStrengthChecker {
    private static final int MIN_LENGTH = 8;
    
    public enum Strength {
        WEAK("弱い"),
        NORMAL("普通"),
        STRONG("強い");
        
        private final String label;
        
        Strength(String label) {
            this.label = label;
        }
        
        public String getLabel() {
            return label;
        }
    }
    
    public String check(String password) {
        return evaluate(password).getLabel();
    }
    
    private Strength evaluate(String password) {
        if (password.length() < MIN_LENGTH) {
            return Strength.WEAK;
        }
        if (containsDigit(password)) {
            return Strength.STRONG;
        }
        return Strength.NORMAL;
    }
    
    private boolean containsDigit(String password) {
        return password.matches(".*\\d.*");
    }
}