대역을 활용한 외부 상황 테스트, Mock 객체의 활용을 어떻게 해야하는데? 🤷‍

public class SignUpTest {
    private SignUpService signUpService;
    private StubPasswordLengthChecker stubPasswordLengthChecker = new StubPasswordLengthChecker();

    @BeforeEach
    void setUp() {
        signUpService = new SignUpService(stubPasswordLengthChecker);
    }

    @DisplayName("비밀번호가 약하다면 회원가입에 실패한다.")
    @Test
    void checkUnderLengthPassword() {
        stubPasswordLengthChecker.setIsSuccess(false);

        Assertions.assertThrows(RuntimeException.class, () -> {
            signUpService.register("msung99", "pw1", "msung99@gmail.com");
        });
    }
}

public interface PasswordLengthChecker {
    boolean checkWeekPassword(String password);
}


public class StubPasswordLengthChecker implements PasswordLengthChecker {
    private boolean isSuccess;
    @Override
    public boolean checkWeekPassword(String password) {
        return isSuccess;
    }

    public void setIsSuccess(boolean isSuccess) {
        this.isSuccess = isSuccess;
    }
}

@DisplayName("이미 같은 아이디를 가진 회원이 DB에 존재하면 가입에 실패한다.")
@Test
void duplicateExist() {
	// 이미 같은 ID 가 DB 에 존재하는 상황을 만들기
    fakeRepository.save(new User("msung99", "pw1", "msung99@gmail.com"));

    Assertions.assertThrows(RuntimeException.class, () -> {
            signUpService.register("msung99", "origin-password", "msung1234@gmail.com");
    });
}

public class SignUpService {
    private PasswordLengthChecker passwordLengthChecker;
    private UserRepository userRepository; // 추가

    public SignUpService(PasswordLengthChecker passwordLengthChecker, UserRepository userRepository) {
        this.passwordLengthChecker = passwordLengthChecker;
        this.userRepository = userRepository;
    }

    public void register(String id, String password, String email) {
        if(!passwordLengthChecker.checkWeekPassword(password)) {
            throw new RuntimeException();
        }
        User user = userRepository.findById(id);
        if(user != null) {
            throw new RuntimeException();
        }
        userRepository.save(user);
    }
}

public interface UserRepository {
    void save(User user);
    User findById(String id);
}


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 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 getPassword() {
        return password;
    }

    public String getEmail() {
        return email;
    }
}

public class SignUpTest {
    private SignUpService signUpService;
    private StubPasswordLengthChecker stubPasswordLengthChecker = new StubPasswordLengthChecker();
    private MemoryUserRepository fakeRepository = new MemoryUserRepository();

    @BeforeEach
    void setUp() {
        signUpService = new SignUpService(stubPasswordLengthChecker, fakeRepository);
    }

    @DisplayName("비밀번호가 약하다면 회원가입에 실패한다.")
    @Test
    void checkUnderLengthPassword() {
        stubPasswordLengthChecker.setIsSuccess(false);

        Assertions.assertThrows(RuntimeException.class, () -> {
            signUpService.register("msung99", "pw1", "msung99@gmail.com");
        });
    }

    @DisplayName("이미 같은 아이디가 DB 에 존재하면 가입에 실패한다.")
    @Test
    void duplicateExist() {
        // 이미 같은 ID 가 DB 에 존재하는 상황을 만들기
        fakeRepository.save(new User("msung99", "pw1", "msung99@gmail.com"));

        Assertions.assertThrows(RuntimeException.class, () -> {
            signUpService.register("msung99", "origin-password", "msung1234@gmail.com");
        });
    }
}

@DisplayName("가입하면 메일을 전송함")
@Test
void whenRegisterThenSendEmail() {
	signUpService.register("msung99", "msung1234", "msung99@gmail.com");

    Assertions.assertTrue(spyEmailNotifier.isCalled());
    Assertions.assertEquals("msung99@gmail.com", spyEmailNotifier.getEmail());
}

public class SignUpService {
    private PasswordLengthChecker passwordLengthChecker;
    private UserRepository userRepository; // 추가
    private EmailNotifier emailNotifier;

    public SignUpService(PasswordLengthChecker passwordLengthChecker, UserRepository userRepository, EmailNotifier emailNotifier) {
        this.passwordLengthChecker = passwordLengthChecker;
        this.userRepository = userRepository;
        this.emailNotifier = emailNotifier;
    }

    public void register(String id, String password, String email) {
        if(!passwordLengthChecker.checkWeekPassword(password)) {
            throw new RuntimeException();
        }
        User user = userRepository.findById(id);
        if(user != null) {
            throw new RuntimeException();
        }
        userRepository.save(new User(id, password, email));
        emailNotifier.sendRegisterEmail(email); // 이메일 전송 상태 저장
    }
}

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;
        this.email = email;
    }
}

public class UserRegisterMockTest {
    private SignUpService signUpService;
    private PasswordLengthChecker mockPasswordLengthChecker = Mockito.mock(PasswordLengthChecker.class);
    private MemoryUserRepository fakeRepository = new MemoryUserRepository();
    private EmailNotifier mockEmailNotifier = Mockito.mock(EmailNotifier.class);

    @BeforeEach
    void setUp() {
        signUpService = new SignUpService(mockPasswordLengthChecker, fakeRepository, mockEmailNotifier);
    }

    @DisplayName("비밀번호가 약하다면 회원가입에 실패한다.")
    @Test
    void checkUnderLengthPassword() {
        BDDMockito.given(mockPasswordLengthChecker.checkWeekPassword("pw1"))
                .willReturn(true);

        Assertions.assertThrows(RuntimeException.class, () -> {
            signUpService.register("msung99", "pw1", "msung99@gmail.com");
        });
    }
}

@DisplayName("회원 가입시 비밀번호 검사를 수행한다.")
@Test
void checkPassword() {
	signUpService.register("msung99", "pw", "email");

    BDDMockito.then(mockPasswordLengthChecker) // (1)
    	.should() // (2)
        .checkWeekPassword(BDDMockito.anyString()); // (3)
}

@DisplayName("가입하면 메일을 전송함")
@Test
void whenRegisterThenSendEmail() {
	signUpService.register("msung99", "msung1234", "msung99@gmail.com");

    ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
    BDDMockito.then(mockEmailNotifier)
                   .should().sendRegisterEmail(captor.capture()); // (1)

	String realEmail = captor.getValue(); // (2)
	Assertions.assertEquals("msung99@gmail.com", realEmail);
}