[TDD Chapter3] 테스트 코드 작성 순서

💛 테스트 코드 작성 순서

1. 쉬운 경우에서 어려운 경우로 진행
2. 예외적인 경우에서 정상적으로 진행

그렇다면 어려운 경우로 작성하면 안되는 이유는 뭘까?

---

🌱 초반에 복잡한 테스트부터 시작하면 안되는 이유

초반에 복잡하게 시작하면 한 번에 구현해야 하는 코드가 많아진다.

if 문이 늘어날 수도 있고 한번에 많은 코드를 만들다보면 나도 모르게 버그를 만들고 나중에 버그를 잡기 위해 많은 시간을 허비하게 된다.

 

---

🌱 구현하기 쉬운 테스트부터 시작하기

보통 수분 내에 구현을 완료하고 통과할 수 있는 테스트 구현을 선택해야 한다.

 

Chapter 2에서 했던 암호 강도 측정 예에서는 다음 중 하나가 쉬울 것이다.

1. 모든 조건에서 충족하는 경우
2. 모든 조건에서 충족하지 않는 경우

1번의 경우 모든 조건을 충족하지 않는 경우라면 단순히 WEAK를 return 하면 되고, 2번의 경우 모든 조건을 충족하는 경우에는 단순히 STRONG을 return 하면 된다. 

 

1번을 선택하고 테스트 코드 작성을 이어나간다고 가정하자.

 

그럼 다음과 같은 경우의 수가 있을 것이다.

1. 모든 규칙을 충족하지 않는 경우
2. 한 규칙만 충족하는 경우
3. 두 규칙을 충족하는 경우 

1번: 모든 규칙을 충족하는 경우로 코드를 생성했기 때문에 예외처리가 많아져 버그 생성
2번: 한 규칙을 충족하는지 여부를 체크
3번: 한 규칙을 충족하는지 검사하고, 충족하지 않는 규칙이 있기 때문에 둘 다 확인 후 NORMAL을 return 

따라서, 2번과 3번 사이에서 선택

규칙 중에서는

1. 글자 수 충족
2. 대문자 여부 검사
3. 숫자 포함 여부 검사

가 있을 것이고 그 중에서 쉬울 규칙을 선택하여 코드를 설계한다. 

---

🌱 예외 상황을 먼저 테스트해야 하는 이유

예외 사항을 전혀 고려하지 않은 코드에서 예외 상황을 반영하려면 코드의 구조를 뒤집거나 중간에 예외 상황을 처리하기 위해 조건문을 중복해서 추가를 해야한다. 

 

초반에 예외 상황을 테스트하면 위와 같은 상황이 발생할 일이 줄어든다.

 

예를 들면 2 차시에서 진행한 코드에서 값이 없을 때 발생하는 NPE를 사전에 막을 수 있다는 점이다. 

NPE는 에러 발생뿐만 아니라 프로세스를 죽일 수도 있기 때문이다. 

---

🌱 완급 조절

처음에 테스트 코드 작성 시, 어려운 것 중 하나가 한 번에 얼마만큼 코드를 작성하는 것인가이다.

TDD 를 처음 접할 때에는 다음 단계로 거쳐서 연습하자!

 

1. 정해진 값을 return
2. 값 비교를 이용해서 정해진 값을 return
3. 다양한 테스트를 추가하면서 구현을 일반화

public class PasswordStrengthMeterTest {
    @Test
    void meetsOtherCreteria_except_for_length_Then_Normal(){
        testdriven.chap03.PasswordStrengthMeter meter = new PasswordStrengthMeter();
        PasswordStrength result = meter.meter("ab12!@A");
        assertEquals(PasswordStrength.NORMAL, result);
        PasswordStrength result2 = meter.meter("Ab12!c");
        assertEquals(PasswordStrength.NORMAL, result2);
    }

}

////////////////////////
    public PasswordStrength meter(String s){
//        if("ab12!@A".equals(s) || "Ab12!c".equals(s)) return PasswordStrength.NORMAL;
        if(s.length()<8) return PasswordStrength.NORMAL;
        else return PasswordStrength.STRONG;
    }

---

🌱 지속적인 리팩토링

테스트가 통과된 후에는 리팩토링을 진행한다.

매번 리펙토링을 진행하는 것은 아니며 적당한 후보가 보이면 리팩토링 진행 (ex. 코드 중복)

 

[리펙토링 장점]

1. 지속적 리팩토링은 코드 가독성이 높아짐

2. 가독성이 높아지면 개발자는 빠르게 코드 분석 가능

3. 수정요청이 있다면 변경 코드를 빠르게 찾을 수 있음 

 

📢 가장 중요: 동작 하는 코드를 만드는 것
📢 SW 생존 기간이 길어질수록 지속적으로 코드 변경 필요
📢 리팩토링: 코드 변경을 위해 변경하기 쉬운 구조로 변경

- 작은 리팩토링은 바로 변경 (변수 이름 변경, 상수를 변수로 변경)
- 매서드 추출과 같은 구조에 영향 주는 것은 흐름이 눈에 들어오기 시작할 때!

---

💛 테스트 코드 작성 순서 연습

매달 비용을 지불해야 사용할 수 있는 유료 서비스가 있고 규칙은 다음과 같다.

1. 서비스를 사용하려며 매달 1만원을 선불로 납부, 납부일 기준 한달 뒤가 서비스 만료일
2. 2개월 이상 요금을 납부 가능
3. 10만원 납부 시, 서비스 1년 제공

 

 

어떤 것부터 테스트를 진행하는 것이 좋을까? 즉, 어떤 것이 가장 쉬운 것일까?

---

🌱 쉬운 것부터 테스트

테스트를 추가할 때는 구현하기 쉽거나, 예외 사항을 먼저 테스트 해야한다는 점을 다시 상기시키자!

 

위 상황에서 가장 쉬운 점은 1번일 것이다. 

 

    @Test
    void 만원_납부하면_한달_뒤가_만료일이_됨(){
        LocalDate billingDate = LocalDate.of(2019, 3, 1);
        int payAmount = 10_000;
        ExpiryDateCalculator cal = new ExpiryDateCalculator();
        LocalDate expiryDate = cal.calculateExpiryDate(billingDate, payAmount);
        assertEquals(expiryDate, LocalDate.of(2019, 4, 1));
    }
    ////
	public LocalDate calculateExpiryDate(LocalDate billingDate, int payAmount){
        return LocalDate.of(2019, 4, 1);
    }

---

🌱 예를 추가하면서 구현을 일반화

위의 코드는 하나의 날짜에만 맞춰진 코드이기 때문에 다른 예시의 날짜를 선택하여 일반적인 날짜에도 test가 성공할 수 있도록 코드로 변경을 하였다.

    @Test
    void 만원_납부하면_한달_뒤가_만료일이_됨(){
        LocalDate billingDate = LocalDate.of(2019, 3, 1);
        int payAmount = 10_000;
        ExpiryDateCalculator cal = new ExpiryDateCalculator();
        LocalDate expiryDate = cal.calculateExpiryDate(billingDate, payAmount);
        assertEquals(expiryDate, LocalDate.of(2019, 4, 1));

        LocalDate billingDate2 = LocalDate.of(2019, 5, 5);
        int payAmount2 = 10_000;
        ExpiryDateCalculator cal2 = new ExpiryDateCalculator();
        LocalDate expiryDate2 = cal2.calculateExpiryDate(billingDate2, payAmount2);
        assertEquals(expiryDate2, LocalDate.of(2019, 6, 5));
    }
    
    ///
	public LocalDate calculateExpiryDate(LocalDate billingDate, int payAmount){
        return billingDate.plusMonths(1);
    }

---

🌱 코드 정리: 중복 제거 & 예외 상황 처리

리팩토링을 진행하여 중복된 코드를 제거한다.

보통은 중복을 제거하는 것이 좋지만, 테스트 코드의 중복 제거에서는 고민이 필요하다.

왜나하면 각 테스트 메서드는 무엇을 테스트하는지 명확하게 설명이 있어야 하기 때문이다. 

 

-> 중복을 제거해보고 테스트 코드가 여전히 자신을 설명하는지 확인 필요

 

한 달 주기로 날짜를 세면 예외 상황이 발생한다

3월 1일과 4월 1일의 경우 모두 1일에 납부하면 되지만, 말일에 납부하는 경우

1월 31일과 2월 28일인 경우이다. 이 경우는 모두 LocalDate의 함수가 알아서 계산해준다고 한다.

 

    @Test
    void 납부일과_한달_뒤_일자가_같지_않음(){
        assertExpiryDate(LocalDate.of(2019, 1, 31),
                10_000, LocalDate.of(2019, 2, 28));
    }

    private void assertExpiryDate(LocalDate billingDate, int payAmount, LocalDate expectedExpiryDate) {
        ExpiryDateCalculator cal = new ExpiryDateCalculator();
        LocalDate expiryDate = cal.calculateExpiryDate(billingDate, payAmount);
        assertEquals(expiryDate, expectedExpiryDate);
    }
    
    ////
    
	public LocalDate calculateExpiryDate(LocalDate billingDate, int payAmount){
        return billingDate.plusMonths(1); // 메서드가 알아서 날짜 주기를 처리해줌
    }

 

🌱 다음 테스트 선택: 다시 예외 상황

여태까지는 한달에 만원만 납부하는 상황을 가정하여 테스트 코드를 작성했다. 하지만, 두달 이상의 요금을 한번에 납부하는 경우도 있기 때문에 두달을 납부하는 경우의 예외 상황을 살펴보자. 

 

쉬운 상황: 두달 이상의 요금을 한 번에 납부하는 경우
예외 상항: 한 달을 납부하는 경우

현재 한 달을 납부하는 경우의 테스트 코드를 작성했기 때문에 한 달을 납부하는 경우의 예외 상황 처리하고 진행하는 것이 좋다. 

이때, 예외 상황을 처리하려면 첫 납부일을 알아야 한다.

 

 

🌱 다음 테스트를 추가하기 전에 리팩토링

만료일을 계산하는 데 필요한 값이 다음과 같이 늘어났다.

calculateExpiryDate 메소드 파라미터로 첫 납부일 추가
첫 납부일, 납부일, 납부액을 담은 객체를 calculateExpiryDate 메서드에 전달

 

현재 파라미터로 전달해야하는 값은 세 개! -> 첫 납부일, 납부일, 납부액

이기 때문에 파라미터가 3개 이상이 되면 객체로 생성해서 한 번에 전달하는 것이 좋다 .

 

package testdriven.chap03;

import org.springframework.test.web.reactive.server.WebTestClient;

import java.time.LocalDate;

public class PayData {
    private LocalDate billingDate;
    private int payAmount;
    private PayData(){}

    public PayData(LocalDate billingDate, int payAmount){
        this.billingDate = billingDate;
        this.payAmount = payAmount;
    }

    public LocalDate getBillingDate(){
        return billingDate;
    }
    public int getPayAmount(){
        return payAmount;
    }

    public static Builder builder(){
        return new Builder();
    }

    public static class Builder{
        private PayData payData = new PayData();

        public Builder billingDate(LocalDate billingDate){
            payData.billingDate = billingDate;
            return this;
        }

        public Builder payAmount(int payAmount){
            payData.payAmount = payAmount;
            return this;
        }

        public PayData build(){
            return payData;
        }
    }
}

///
    public LocalDate calculateExpiryDate(PayData payData){
        return payData.getBillingDate().plusMonths(1);
    }
}

///
    @Test
    void 만원_납부하면_한달_뒤가_만료일이_됨(){
        assertExpiryDate(PayData.builder()
                .billingDate(LocalDate.of(2019, 3, 1))
                .payAmount(10_000)
                .build(),
                LocalDate.of(2019, 4, 1));
        assertExpiryDate(PayData.builder()
                        .billingDate(LocalDate.of(2019, 1, 31))
                        .payAmount(10_000)
                        .build(),
                LocalDate.of(2019, 2, 28));
    }

 

간단하게 빌더 패턴을 적용하면 상수가 다음 뜻을 나타낸다는 것을 쉽게 알 수 있다.

 

🌱 예외 상황 테스트 진행 계속

여태까지는 첫 납부일을 기준으로 만료일을 게산하는 것이었지만, 이제는 다음과 같은 상황도 고려를 해보아야 한다.

첫 납부일이 2019-01-31이고, 만료되는 2019-02-28에 1만원을 납부하면 다음 만료일은 2019-03-31이다. 

 @Test
    void 첫_납부일과_만료일이_일자가_다를때_만원_납부(){
        PayData payData = PayData.builder()
                .firstBillingDate(LocalDate.of(2019, 5, 31))
                .billingDate(LocalDate.of(2019, 6, 30))
                .payAmount(10_000)
                .build();
        assertExpiryDate(payData, LocalDate.of(2019, 7, 31));
    }
    
    ///
public LocalDate calculateExpiryDate(PayData payData){
    int addedMonths = 1;
    if(payData.getFirstBillingDate() != null){
        LocalDate candidateExp = payData.getBillingDate().plusMonths(addedMonths);
        // 첫 납부 일자(31일)와 후보 만료일의 일자(28일)이 같지 않을때
        if(payData.getFirstBillingDate().getDayOfMonth() != candidateExp.getDayOfMonth()){
            // 첫 납부일의 일자를 후보 만료일의 일자로 사용
            return candidateExp.withDayOfMonth(payData.getFirstBillingDate().getDayOfMonth());
        }
    }
    return payData.getBillingDate().plusMonths(addedMonths);
}

 

🌱 다음 테스트를 선택: 쉬운 테스트

1. 2만원을 지불하면 만료일이 두 달뒤가 된다.
2. 3만원을 지불하면 만료일이 석 달 뒤가 된다.

다음과 같은 상황에서 테스트가 성공할 수 있도록 코드를 변경하자. 

@Test
void 이만원_이상_납부하면_비례해서_만료일_계산(){
    assertExpiryDate(PayData.builder()
            .billingDate(LocalDate.of(2019, 3, 1))
            .payAmount(20_000)
            .build(), LocalDate.of(2019, 5, 1));

    assertExpiryDate(PayData.builder()
            .billingDate(LocalDate.of(2019, 3, 1))
            .payAmount(30_000)
            .build(), LocalDate.of(2019, 6, 1));
}
///
public LocalDate calculateExpiryDate(PayData payData){
        int addedMonths = payData.getPayAmount()/10_000;
        //생략
}

이제는 첫 납부일과 납부일의 일자가 다를 대 2만원 이상 납부한 경우의 예외 상황도 고려를 해보아야 한다. 

 

public LocalDate calculateExpiryDate(PayData payData){
    int addedMonths = payData.getPayAmount()/10_000;
    if(payData.getFirstBillingDate() != null){
        LocalDate candidateExp = payData.getBillingDate().plusMonths(addedMonths);
        // 첫 납부 일자(31일)와 후보 만료일의 일자(28일)이 같지 않을때
        if(payData.getFirstBillingDate().getDayOfMonth() != candidateExp.getDayOfMonth()){
           // 후보 만료일(실제 날짜로 확인)이 첫 돈을 낸 일자보다 더 작은 경우에는 후보 만료일의 일자로 return 
            if(YearMonth.from(candidateExp).lengthOfMonth()<payData.getFirstBillingDate().getDayOfMonth()){
                return candidateExp.withDayOfMonth(YearMonth.from(candidateExp).lengthOfMonth());
            }
            // 첫 납부일의 일자를 후보 만료일의 일자로 사용
            return candidateExp.withDayOfMonth(payData.getFirstBillingDate().getDayOfMonth());
        }
    }
    return payData.getBillingDate().plusMonths(addedMonths);
}

///
@Test
void 첫_납부일과_만료일_일자가_다를때_이만원_이상_납부(){
    assertExpiryDate(PayData.builder()
            .firstBillingDate(LocalDate.of(2019, 1, 31))
            .billingDate(LocalDate.of(2019, 2, 28))
            .payAmount(20_000)
            .build(), LocalDate.of(2019, 4, 30));

    assertExpiryDate(PayData.builder()
            .firstBillingDate(LocalDate.of(2019, 3, 31))
            .billingDate(LocalDate.of(2019, 4, 30))
            .payAmount(30_000)
            .build(), LocalDate.of(2019, 7, 31));

}

 

🌱 코드 리팩토링

import java.time.LocalDate;
import java.time.YearMonth;

public class ExpiryDateCalculator {
    public LocalDate calculateExpiryDate(PayData payData) {
        int addedMonths = payData.getPayAmount() / 10_000;
        if (payData.getFirstBillingDate() != null) {
            return expiryDateUsingFirstBillingDate(payData, addedMonths);
        } else {
            return payData.getBillingDate().plusMonths(addedMonths);
        }
    }

    private LocalDate expiryDateUsingFirstBillingDate(PayData payData, int addedMonths) {
        LocalDate candidateExp = payData.getBillingDate().plusMonths(addedMonths);
        final int dayOfFirstBilling = payData.getFirstBillingDate().getDayOfMonth();
        // 첫 납부 일자(31일)와 후보 만료일의 일자(28일)이 같지 않을때
        if (isSameDayOfMonth(candidateExp, dayOfFirstBilling)) {
            // 후보 만료일(실제 날짜로 확인)이 첫 돈을 낸 일자보다 더 작은 경우에는 후보 만료일의 일자로 return
            final int dayLenOfCandiMon = lastDayOfMonth(candidateExp);
            if (dayLenOfCandiMon < dayOfFirstBilling) {
                return candidateExp.withDayOfMonth(dayLenOfCandiMon);
            }
            // 첫 납부일의 일자를 후보 만료일의 일자로 사용
            return candidateExp.withDayOfMonth(dayOfFirstBilling);
        }else{
            return candidateExp;
        }
    }

    private boolean isSameDayOfMonth(LocalDate candidateExp, int dayOfFirstBilling) {
        return dayOfFirstBilling != candidateExp.getDayOfMonth();
    }
    private int lastDayOfMonth(LocalDate date) {
        return YearMonth.from(date).lengthOfMonth();
    }
}

 

🌱 10개월 요금을 납부하면 1개월 제공

이제 10개월을 납부하면 서비스를 1년 제공해주는 테스트 코드를 작성해보자.

public LocalDate calculateExpiryDate(PayData payData) {
    int addedMonths = payData.getPayAmount() == 100_000 ? 12: payData.getPayAmount() / 10_000;
    if (payData.getFirstBillingDate() != null) {
        return expiryDateUsingFirstBillingDate(payData, addedMonths);
    } else {
        return payData.getBillingDate().plusMonths(addedMonths);
    }
}

 

🌱 테스트 시 주의 사항

1. 처음부터 모든 테스트 사례를 생각하면 시간도 오래 걸릴 뿐더러 쉽지도 않음

2. 새로 발견한 테스트 사례를 실패하는 테스트로 등록하는 것도 사례를 놓치지 않는 방법

3. '지라나 트렐로' 시스템을 사용하면 테스트 사례를 하위 작업으로 등록 가능 (통과 여부 추적 가능)

4. 테스트 목록을 하나의 테스트로 만들면 안됨