[TDD Chapter7] 대역

🔒 대역의 필요성

[외부 요인이 테스트에 관여하는 주요 예]

• 테스트 대상에서 파일 시스템 사용
• 테스트 대상에서 DB로부터 데이터를 조회하거나 데이터를 추가
• 테스트 대상에서 외부의 HTTP 서버와 통신

테스트 대상이 위와 같은 외부 요인에 의존하여 사용하는 외부 API 서버가 일시적으로 장애가 발생하면 테스트를 원활하게 수행할 수 없다. 또한, 내부 DB를 사용하더라도 데이터 구성을 항상 같게 진행하기는 어렵다.

 

다음과 같은 외부 요인은 테스트 작성을 어렵게 만들 뿐만 아니라 테스트 결과도 예측할 수 없게 만든다.

 

테스트 대상에서 의존하는 요인 때문에 테스트가 어려울 때에는 대역을 써서 테스트를 진행한다. 외부 요인으로 인해 테스트가 어려울 때, 외부 요인을 대신하는 대역이 외부 요인을 대신하여 테스트에 참여한다.

 

package testdriven.chap07;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static testdriven.chap07.CardValidity.THEFT;
import static testdriven.chap07.CardValidity.VALID;

public class AutoDebitRegisterTest {
    private AutoDebitRegister register;

    @BeforeEach
    void setUp(){
        CardNumberValidator validator = new CardNumberValidator();
        AutoDebitInfoRepository repository = new JPAAutoDebitInfoRepository();
        register = new AutoDebitRegister(validator, repository);
    }

    @Test
    void validCard(){
        // 외부 업체에서 받은 테스트용 유효한 카드번호 사용
        // 대역을 사용하여 테스트 진행
        AutoDebitReq req = new AutoDebitReq("user1", "123412341234");
        RegisterResult result = this.register.register(req);
        assertEquals(VALID, result.getValidity());
    }

    @Test
    void theftCard(){
        // 외부 업체에서 받은 도난 테스트용 카드 번호 사용
        // 대역을 사용하여 테스트 진행
        AutoDebitReq req = new AutoDebitReq("user1", "1234567890123456");
        RegisterResult result = this.register.register(req);
        assertEquals(THEFT, result.getValidity());
    }
}

 

 

🔒 대역을 사용한 외부 상황 흉내와 결과 검증 

예를 들어,

외부상황 흉내의 경우에는 카드 정보 API를 대신하여 유효한 카드 정보인지, 도난 카드 정보인지와 같은 상황을 흉내내거나 특정 사용자에 대한 자동 이체 정보가 이미 등록되어 있거나 등록되어 있지 않은 상황을 흉내낸다. 

package testdriven.chap07;

import java.util.HashMap;
import java.util.Map;

/**
 * 외부 상황 흉내: 특정 사용자에 대한 자동 이체 정보가 이미 등록되어 있거나, 있지 않은 상황을 흉내냄.
 */
// AutoDebitInfoRepository 의 대역
public class MemoryAutoDebitRepository implements AutoDebitInfoRepository{

    // 영속성을 제공하지는 않지만, 테스트에서 사용할 수 있을 만큼의 기능을 제공
    private Map<String, AutoDebitInfo> infos = new HashMap<>();
    @Override
    public void save(AutoDebitInfo info) {
        infos.put(info.getUserIdx(), info);
    }

    @Override
    public AutoDebitInfo findOne(String userId) {
        return infos.get(userId);
    }
}

package testdriven.chap07;

/**
 * 외부 상황 흉내: 카드 정보 API 를 대신하여 유효한 카드 번호, 도난 카드 번호와 같은 상황을 흉내냄.
 */
public class StubCardNumberValidator extends CardNumberValidator{
    private String invalidNo;
    private String theftNo;

    // setInvalidNo로 지정된 카드 번호에 대해서는 invalid, 나머지는 valid
    public void setInvalidNo(String invalidNo){
        this.invalidNo = invalidNo;
    }

    public void setTheftNo(String theftNo){
        this.theftNo = theftNo;
    }

    @Override
    public CardValidity validate(String cardNumber) {
        // 유효하지 않은 카드 번호인 경우
        if(invalidNo != null && invalidNo.equals(cardNumber)){
            return CardValidity.INVALID;
        }

        // 도난 카드 번호인 경우
        if(theftNo != null && theftNo.equals(cardNumber)){
            return CardValidity.THEFT;
        }
        return CardValidity.VALID;
    }
}

 

이 뿐만 아니라, 결과 검증으로 대역을 사용할 때, 메모리를 이용해 저장 결과를 확인할 수 있다. 

 

 

🔒 대역의 종류

대역 종류	설명
스텁(Stub)	구현을 단순한 것으로 대체, 테스트에 맞게 단순히 원하는 동작을 수행
가짜(Fake)	제품에는 적합하지 않지만, 실제 동작하는 구현 제공 예] DB 대신 Map 사용하여 데이터 저장하는 테스트 진행
스파이(Spy)	호출된 내역 기록, 기록한 내용은 테스트 결과를 검증할 때 사용하는 스텁
모의 (Mock)	기대한 대로 상호작용하는지 행위 검증, 기대한대로 동작하지 않으면 익셉셥 발생

 

🔒 회원 가입 기능 구현 (+ 대역 사용)

구현하기 전 모든 기능을 설게하는 것은 불가능하다. 하지만 단위 기능을 구현하기에 앞서 어떤 구성 요소가 필요한지 고민하는 것은 의존 대상을 도출할 때 도움이 된다. 

 

🖤 약한 암호에서 확인 기능에 스텁 사용

// 테스트 코드 

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertThrows;

public class UserRegisterTest {
    private UserRegister userRegister;
    private StubWeakPasswordChecker stubWeakPasswordChecker = new StubWeakPasswordChecker();

    @BeforeEach
    void setUp(){
        userRegister = new UserRegister(stubWeakPasswordChecker);
    }

    @DisplayName("약한 암호면 실패")
    @Test
    void weakPassword(){
        stubWeakPasswordChecker.setWeak(true); // 암호가 약하도록 응답

        assertThrows(WeakPasswordException.class, () ->
                userRegister.register("id", "pw", "email"));
    }
}

public class WeakPasswordException extends RuntimeException{
}

public interface WeakPasswordChecker {
    boolean checkPasswordWeak(String pw);
}

public class StubWeakPasswordChecker implements WeakPasswordChecker{
    private boolean weak;

    public void setWeak(boolean weak){
        this.weak = weak;
    }

    @Override
    public boolean checkPasswordWeak(String pw) {
        return weak;
    }
}

public class UserRegister {
    private WeakPasswordChecker passwordChecker;

    public UserRegister(WeakPasswordChecker passwordChecker){
        this.passwordChecker = passwordChecker;
    }
    public void register(String id, String pw, String email){
        if(passwordChecker.checkPasswordWeak(pw)){
            throw new WeakPasswordException();
        }
    }
}

 

🖤 리포지토리를 가짜로 구현

대역의 결과 검증으로 Map을 이용하여 실제 DB 접근 대신, 코드 내에서 정보를 저장한 후 저장이 되어 있다면 에러처리를 하는 테스트 코드를 작성한 것이다.

// 저장할 정보를 담고 있는 Class
public class User {
    private String id;
    private String password;
    private String email;

    public User(String id, String password, String email){
        this.id = id;
        this.password = password;
        this.email = email;
    }

    public String getId() {
        return id;
    }

    public String getEmail() {
        return email;
    }
}

// DB 접근 명령어
public interface UserRepository {
    void save(User user);
    User findById(String id);
}

// DB 접근 코드
public class MemoryUserRepository implements UserRepository{
    private Map<String, User> users = new HashMap<>();
    @Override
    public void save(User user) {
        users.put(user.getId(), user);
    }

    @Override
    public User findById(String id) {
        return users.get(id);
    }
}


public class UserRegister {
    private WeakPasswordChecker passwordChecker;
    private UserRepository userRepository;

    public UserRegister(WeakPasswordChecker passwordChecker, UserRepository userRepository){
        this.passwordChecker = passwordChecker;
        this.userRepository = userRepository;
    }
    public void register(String id, String pw, String email){
        if(passwordChecker.checkPasswordWeak(pw)){
            throw new WeakPasswordException();
        }
        // 추가된 코드 
        User user = userRepository.findById(id);
        if(user == null){
            throw new DupIdException();
        }
        userRepository.save(new User(id, pw, email));
    }
}

// 테스트 코드
@DisplayName("이미 같은 아이디가 존재하면 가입 실패")
    void dupIdExists(){
        // 이미 같은 아이디가 있는 상황으로 만들기
        fakeRepository.save(new User("id", "pw1", "email"));
        assertThrows(DupIdException.class,
                () -> userRegister.register("id", "pw2", "email"));
}

@DisplayName("같은 ID가 없으면 가입 성공함")
    void noDupId_RegisterSuccess(){
        userRegister.register("id", "pw", "email");

        User savedUser = fakeRepository.findById("id");
        assertEquals("id", savedUser.getId());
        assertEquals("email", savedUser.getEmail());
}

 

🖤 이메일 발송 여부를 확인하기 위해 스파이 사용

public interface EmailNotifier {
    void sendRegisterEmail(String email);
}

public class SpyEmailNotifier implements EmailNotifier {

    private boolean called;
    private String email;

    public boolean isCalled() {
        return called;
    }

    public String getEmail() {
        return email;
    }

    @Override
    public void sendRegisterEmail(String email) {
        this.called = true; // test 코드의 assert True 를 통과시키기 위함
        this.email = email;
    }
}

public class UserRegisterTest {
    private UserRegister userRegister;
    private StubWeakPasswordChecker stubWeakPasswordChecker = new StubWeakPasswordChecker();
    private MemoryUserRepository fakeRepository = new MemoryUserRepository();
    private SpyEmailNotifier spyEmailNotifier = new SpyEmailNotifier(); // 추가

    @BeforeEach
    void setUp(){
        userRegister = new UserRegister(stubWeakPasswordChecker, fakeRepository, spyEmailNotifier);
    }

   // ~~~~ 생략 ~~~~

    @DisplayName("가입하면 메일을 전송함")
    @Test
    void whenRegisterThenSendMail(){
        userRegister.register("id", "pw", "email");

        assertTrue(spyEmailNotifier.isCalled());
        assertEquals(
                "email",
                spyEmailNotifier.getEmail()
        );
    }
}


  public void register(String id, String pw, String email){
        if(passwordChecker.checkPasswordWeak(pw)){
            throw new WeakPasswordException();
        }
        User user = userRepository.findById(id);
        if(user != null){
            throw new DupIdException();
        }
        userRepository.save(new User(id, pw, email));

        emailNotifier.sendRegisterEmail(email); // 코드 추가
    }

 

🖤 모의 객체로 스텁과 스파이 대체

모의 객체를 이용하여 앞서 작성한 코드를 다시 작성하고자 한다.

모의 객체는 Mockito 도구를 이용하여 다시 작성할 예정인데, Mockito의 내용은 아래 링크로 정리를 해 두었다. 

https://monynony0203.tistory.com/126

[참고] Mockito 기초 사용법

 

 

package testdriven.chap07.login;

public class UserRegister {
    private WeakPasswordChecker passwordChecker;
    private UserRepository userRepository;
    private EmailNotifier emailNotifier;

    public UserRegister(WeakPasswordChecker passwordChecker, UserRepository userRepository, EmailNotifier spyEmailNotifier){
        this.passwordChecker = passwordChecker;
        this.userRepository = userRepository;
        this.emailNotifier = spyEmailNotifier;
    }


    public void register(String id, String pw, String email){
        if(passwordChecker.checkPasswordWeak(pw)){
            throw new WeakPasswordException();
        }
        User user = userRepository.findById(id);
        if(user != null){
            throw new DupIdException();
        }
        userRepository.save(new User(id, pw, email));

        emailNotifier.sendRegisterEmail(email);
    }
}

// spy: 진짜로 호출되었는지 확인
    @DisplayName("가입하면 메일을 전송함")
    @Test
    void whenRegisterThenSendMail(){
        userRegister.register("id", "pw", "email");

        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class); // String 타입의 인자 보관
        then(mockEmailNotifier)
                .should().sendRegisterEmail(captor.capture());

        String realEmail = captor.getValue();
        assertEquals("email", realEmail);
    }

 

 

🔒 상황과 결과 확인을 위한 협업 대상(의존) 도출과 대역 사용

테스트는 특정한 상황에서 기능을 실행하고 결과를 확인한다. 하지만, 실제 구현을 이용하면 상황을 만들기 어려울 때가 있다. 예를 들면 메소드 내부에 외부 카드 정보 API를 연동하여 retuurn 을 하게 되면 유효하지 않은 카드번호를 위한 상황을 구성하기 어렵다. 

 

이렇기 때문에, 구현/제어하기 힘든 구현상황이 존재하면 다음과 같이 의존을 도출하고 이를 대역으로 대신할 수 있다. 

• 제어하기 힘든 외부 상황을 별도 타입으로 분리
• 테스트 코드는 별도로 분리한 타입의 대역을 생성
• 생성한 대역을 테스트 대상의 생성자 등을 이용하여 전달
• 대역을 이용하여 상황 구성

 

🔒 대역과 개발 속도

TDD 과정에서 대역을 사용하지 않고 실제 구현을 한다면 많은 문제 상황이 발생할 것이다.

 

그렇기 때문에 대역을 사용하면  실제 구현 없이도 다양한 상황에 대해 테스트르 할 수 있다. 외부의 카드 정보 제공 API와 연동할 수 없는 경우에도 테스트를 진행할 수 있는 것이다. 

 

또한, 실제 구현이 없어도 실행 결과를 바로 확인할 수 있다. 

 

대역은 의존하는 대상 (DB, 외부 API 등)을 구현하지 않아도 테스트를 완성할 수 있게 만들어주고, 대기 시간을 줄여주어 개발속도는 향상시킬 수 있다.

 

 

🔒 모의 객체를 과하게 사용하지 않기

모의 객체는 스텁과 스파이를 지원하므로 대역으로 모의 객체를 많이 사용한다. 하지만, 모의 객체를 과하게 사용하면 오히려 테스트 코드가 복잡해지는 경우도 발생할 수 있다. 

 

모의 객체를 이용하면 대역 클래스를 만들지 않아도 되니까 편할 수 있지만, 결과 값을 확인하는 수단으로 모의 객체를 사용하게 되면 결과 검증 코드가 길어지고 복잡해진다. 

 

기본적으로 모의 객체는 메소드 호출 여부를 검증하는 수단이기 때문에 테스트 대상과 모의 객체 간의 상호작용이 조금만 바뀌어도 테스트가 깨지기 쉽다.

 

특히 DAO나 Repository와같이 저장소에 대한 대역은 모의 객체를 사용하는 것보다 메모리를 이용해 가짜 구현을 사용하는 것이 테스트 코드 관리할 때 유리하다.