Mockito: 모킹 프레임워크 완전 정복! 🎭

안녕, 친구들! 오늘은 Java 개발자들의 필수 도구인 Mockito에 대해 재미있게 알아볼 거야. 🚀 Mockito는 단위 테스트를 위한 모킹 프레임워크로, 테스트 더블(Test Double)을 쉽게 만들 수 있게 해주는 강력한 도구야. 이 글을 통해 Mockito의 세계로 깊숙이 들어가 보자고!

1. Mockito란 뭐야? 🤔

Mockito는 Java에서 가장 인기 있는 모킹 프레임워크 중 하나야. "모킹"이라고 하면 뭔가 복잡하고 어려울 것 같지? 하지만 걱정 마! Mockito를 사용하면 테스트 더블을 만드는 게 정말 쉬워진다고.

모킹(Mocking)이란 실제 객체를 흉내 내는 가짜 객체를 만드는 것을 말해. 이렇게 만든 가짜 객체를 "목(Mock)" 또는 "모의 객체"라고 불러. Mockito를 사용하면 이런 목 객체를 아주 간단하게 만들 수 있어서, 복잡한 의존성이 있는 코드도 쉽게 테스트할 수 있게 되는 거지.

1.1 Mockito가 필요한 이유

왜 Mockito 같은 모킹 프레임워크가 필요할까? 여기 몇 가지 이유를 들어볼게:

• 👉 의존성 제거: 복잡한 외부 시스템에 의존하지 않고도 테스트를 할 수 있어.
• 👉 테스트 속도 향상: 실제 객체 대신 가벼운 목 객체를 사용하면 테스트 실행 속도가 빨라져.
• 👉 예측 가능한 테스트: 목 객체의 동작을 정확히 제어할 수 있어서 테스트 결과를 예측하기 쉬워.
• 👉 특정 상황 테스트: 실제로 만들기 어려운 특정 상황을 쉽게 시뮬레이션할 수 있어.

이런 이유들 때문에 Mockito는 Java 개발자들 사이에서 정말 인기 있는 도구가 됐어. 재능넷에서 Java 개발 관련 프로젝트를 진행할 때도 Mockito 사용 경험이 있으면 큰 플러스 포인트가 될 거야!

1.2 Mockito의 역사

Mockito는 2008년에 Szczepan Faber에 의해 처음 만들어졌어. 그 당시 존재하던 다른 모킹 프레임워크들이 너무 복잡하고 사용하기 어렵다는 문제를 해결하기 위해 탄생했지. Mockito의 목표는 간단하고 직관적인 API를 제공하는 것이었어.

Mockito의 이름은 "Mock"과 "Mosquito"를 합친 말이야. 작지만 강력하다는 의미를 담고 있지. 모기처럼 작은 존재지만, 그 영향력은 엄청나다는 뜻이겠지?

2. Mockito 시작하기 🚀

자, 이제 Mockito를 실제로 사용해보자! 먼저 프로젝트에 Mockito를 추가하는 방법부터 알아볼게.

2.1 Mockito 설치하기

Maven을 사용한다면 pom.xml 파일에 다음 의존성을 추가해:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>3.11.2</version>
    <scope>test</scope>
</dependency>

Gradle을 사용한다면 build.gradle 파일에 이렇게 추가해:

testImplementation 'org.mockito:mockito-core:3.11.2'

버전 번호는 항상 최신 버전을 확인해서 사용하는 게 좋아! Mockito 공식 웹사이트나 Maven Central에서 최신 버전을 확인할 수 있어.

2.2 첫 번째 Mock 만들기

Mockito를 설치했다면 이제 첫 번째 Mock을 만들어볼 차례야. 아주 간단한 예제로 시작해볼게:

import static org.mockito.Mockito.*;

// List 인터페이스의 mock 객체 생성
List mockedList = mock(List.class);

// mock 객체 사용
mockedList.add("one");
mockedList.clear();

// 검증
verify(mockedList).add("one");
verify(mockedList).clear();

이 코드에서 우리는 List 인터페이스의 mock 객체를 만들고, 그 객체에 대해 몇 가지 메소드를 호출한 다음, 그 호출이 실제로 일어났는지 검증하고 있어.

2.3 Stubbing: 행동 정의하기

Mock 객체를 만들었다면, 이제 그 객체가 어떻게 행동해야 할지 정의해줄 수 있어. 이걸 "Stubbing"이라고 해. 예를 들어보자:

// mock 객체 생성
List mockedList = mock(List.class);

// stubbing
when(mockedList.get(0)).thenReturn("first");
when(mockedList.get(1)).thenThrow(new RuntimeException());

// 다음 줄은 "first"를 출력할 거야
System.out.println(mockedList.get(0));

// 다음 줄은 RuntimeException을 던질 거야
System.out.println(mockedList.get(1));

// 다음 줄은 null을 출력할 거야 (stub되지 않았기 때문)
System.out.println(mockedList.get(999));

여기서 우리는 when().thenReturn() 메소드를 사용해서 mock 객체의 행동을 정의하고 있어. get(0)이 호출되면 "first"를 반환하고, get(1)이 호출되면 예외를 던지도록 설정한 거지.

이렇게 Stubbing을 하면 mock 객체가 실제 객체처럼 동작하게 만들 수 있어. 이게 바로 Mockito의 강력한 기능 중 하나야!

3. Mockito의 핵심 기능들 🛠️

자, 이제 Mockito의 기본을 알았으니 좀 더 깊이 들어가 볼까? Mockito에는 정말 많은 유용한 기능들이 있어. 그 중에서 꼭 알아야 할 핵심 기능들을 살펴보자!

3.1 verify() 메소드

verify() 메소드는 mock 객체에 특정 메소드가 호출되었는지, 몇 번 호출되었는지 확인할 때 사용해. 예를 들어볼게:

List mockedList = mock(List.class);

mockedList.add("once");

mockedList.add("twice");
mockedList.add("twice");

mockedList.add("three times");
mockedList.add("three times");
mockedList.add("three times");

// 다음의 검증은 모두 통과할 거야
verify(mockedList).add("once");
verify(mockedList, times(1)).add("once");

verify(mockedList, times(2)).add("twice");
verify(mockedList, times(3)).add("three times");

// 다음 검증은 실패할 거야
verify(mockedList).add("never happened");

verify() 메소드를 사용하면 mock 객체의 메소드가 정확히 우리가 예상한 대로 호출되었는지 확인할 수 있어. 이는 테스트의 정확성을 높이는 데 큰 도움이 돼!

3.2 argument matchers

때로는 메소드 호출 시 전달되는 인자의 정확한 값보다는 그 인자의 타입이나 특성이 중요할 때가 있어. 이럴 때 사용하는 게 바로 argument matchers야. Mockito는 다양한 argument matchers를 제공해:

List mockedList = mock(List.class);

// anyInt()를 사용해 어떤 정수든 받아들이도록 설정
when(mockedList.get(anyInt())).thenReturn("element");

// 다음 줄들은 모두 "element"를 출력할 거야
System.out.println(mockedList.get(0));
System.out.println(mockedList.get(1));
System.out.println(mockedList.get(999));

// 문자열 인자에 대한 matcher 사용
verify(mockedList).add(startsWith("ele"));
verify(mockedList).add(endsWith("ment"));
verify(mockedList).add(contains("eme"));

Argument matchers를 사용하면 더 유연한 stubbing과 검증이 가능해져. 정확한 값이 아니라 패턴이나 조건을 지정할 수 있으니까 테스트가 훨씬 강력해지는 거지!

3.3 Spy 사용하기

Spy는 실제 객체를 부분적으로 mock하는 방법이야. 실제 객체의 일부 메소드는 그대로 동작하게 하고, 일부 메소드만 mock하고 싶을 때 사용해. 예를 들어보자:

List<string> list = new ArrayList<>();
List<string> spy = spy(list);

// 실제 메소드 사용
spy.add("one");
spy.add("two");

// stubbing a method
when(spy.size()).thenReturn(100);

// 다음 줄은 1을 출력할 거야 (실제 리스트에는 요소가 2개 있으니까)
System.out.println(spy.get(0));

// 다음 줄은 100을 출력할 거야 (위에서 stub했으니까)
System.out.println(spy.size());
</string></string>

Spy를 사용하면 실제 객체의 일부 기능은 그대로 사용하면서 일부 기능만 mock할 수 있어. 이는 복잡한 객체를 테스트할 때 특히 유용하지!

3.4 Capturing Arguments

때로는 mock 객체의 메소드가 어떤 인자와 함께 호출되었는지 자세히 알고 싶을 때가 있어. 이럴 때 사용하는 게 바로 ArgumentCaptor야. 예제를 통해 살펴보자:

List mockedList = mock(List.class);
ArgumentCaptor<string> argument = ArgumentCaptor.forClass(String.class);

mockedList.add("John Doe");

// argument 캡처
verify(mockedList).add(argument.capture());

// 캡처된 argument 사용
assertEquals("John Doe", argument.getValue());
</string>

ArgumentCaptor를 사용하면 mock 객체에 전달된 인자를 캡처해서 나중에 검사할 수 있어. 이는 복잡한 객체가 인자로 전달될 때 특히 유용하지!

3.5 Mockito Annotations

Mockito는 애노테이션을 사용해서 더 간편하게 mock 객체를 만들 수 있게 해줘. 주요 애노테이션들을 살펴보자:

• 👉 @Mock: mock 객체를 생성해.
• 👉 @Spy: spy 객체를 생성해.
• 👉 @InjectMocks: 다른 mock이나 spy 객체를 자동으로 주입해.
• 👉 @Captor: ArgumentCaptor를 생성해.

이 애노테이션들을 사용하면 테스트 코드가 훨씬 깔끔해져. 예제를 볼까?

public class MyTest {
    @Mock
    List<string> mockedList;

    @Spy
    ArrayList<string> spiedList;

    @Captor
    ArgumentCaptor<string> argument;

    @Before
    public void init() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testMethod() {
        mockedList.add("one");
        spiedList.add("two");

        verify(mockedList).add(argument.capture());
        assertEquals("one", argument.getValue());

        assertEquals(1, spiedList.size());
    }
}
</string></string></string>

애노테이션을 사용하면 코드가 더 읽기 쉬워지고, mock 객체 생성과 관리가 편리해져. 특히 여러 개의 mock 객체를 사용해야 하는 복잡한 테스트에서 큰 도움이 돼!

4. Mockito의 고급 기능 🚀

자, 이제 Mockito의 기본적인 기능들은 다 알아봤어. 하지만 Mockito는 여기서 끝이 아니야. 더 강력하고 유용한 고급 기능들이 있어. 이 기능들을 마스터하면 네 테스트 코드가 한층 더 강력해질 거야!

4.1 Strict Stubbing

기본적으로 Mockito는 "lenient" 모드로 동작해. 이 모드에서는 stub하지 않은 메소드 호출에 대해서도 에러를 발생시키지 않아. 하지만 때로는 이런 동작이 오히려 문제를 숨길 수 있어. 이럴 때 사용하는 게 바로 Strict Stubbing이야.

@Test
public void strictStubbingTest() {
    List<string> list = mock(List.class, STRICT_STUBS);
    when(list.get(0)).thenReturn("first");
    
    assertEquals("first", list.get(0));
    
    // 다음 줄은 예외를 발생시킬 거야. 왜냐하면 get(1)은 stub되지 않았거든.
    // list.get(1);
}
</string>

Strict Stubbing을 사용하면 stub하지 않은 메소드 호출을 즉시 잡아낼 수 있어. 이는 테스트의 정확성을 높이는 데 도움이 돼!

4.2 Answer 인터페이스 사용하기

때로는 단순히 값을 반환하는 것보다 더 복잡한 동작을 stub하고 싶을 때가 있어. 이럴 때 Answer 인터페이스를 사용할 수 있어. 예를 들어보자:

when(mockedList.get(anyInt())).thenAnswer(new Answer<string>() {
    public String answer(InvocationOnMock invocation) {
        Object[] args = invocation.getArguments();
        int index = (Integer) args[0];
        return "Element at index " + index;
    }
});

// 다음 줄은 "Element at index 0"을 출력할 거야
System.out.println(mockedList.get(0));

// 다음 줄은 "Element at index 999"를 출력할 거야
System.out.println(mockedList.get(999));
</string>

Answer 인터페이스를 사용하면 동적으로 반환값을 생성할 수 있어. 이는 복잡한 로직을 가진 메소드를 stub할 때 특히 유용하지!

4.3 Mockito의 타임아웃 기능

비동기 코드를 테스트할 때는 타임아웃 설정이 중요해. Mockito는 이를 위한 기능도 제공하고 있어:

// 1초 내에 add("foo")가 호출되지 않으면 실패
verify(mockedList, timeout(1000)).add("foo");

// 2초 내에 정확히 2번 호출되어야 함
verify(mockedList, timeout(2000).times(2)).add("bar");

// 500ms마다 폴링하면서 최대 5초 동안 기다림
verify(mockedList, timeout(5000).atMost(3).pollInterval(500)).add("baz");

타임아웃 기능을 사용하면 비동기 코드의 동작을 정확하게 테스트할 수 있어. 특히 멀티스레드 환경에서 동작하는 코드를 테스트할 때 매우 유용하지!

4.4 Mockito의 BDD 스타일 지원

BDD(Behavior-Driven Development)는 테스트를 더 자연스러운 언어로 표현하는 방식이야. Mockito는 BDD 스타일의 테스트 작성을 지원해. 예를 들어볼게:

import static org.mockito.BDDMockito.*;

public void shouldGreetUser() {
    // given
    User user = new User("John");
    given(userService.findByName("John")).willReturn(user);

    // when
    String greeting = greeter.greet("John");

    // then
    then(greeting).isEqualTo("Hello, John!");
}

BDD 스타일을 사용하면 테스트 코드가 마치 스토리를 읽는 것처럼 자연스러워져. 이는 테스트의 의도를 더 명확하게 전달할 수 있게 해줘!

4.5 Mockito의 InOrder 검증

때로는 메소드 호출의 순서가 중요할 때가 있어. 이럴 때 사용하는 게 InOrder 검증이야:

// A와 B를 mock
A a = mock(A.class);
B b = mock(B.class);

// 메소드 호출
a.doSomething();
b.doSomethingElse();
a.doAnotherThing();

// InOrder 객체 생성
InOrder inOrder = inOrder(a, b);

// 순서 검증
inOrder.verify(a).doSomething();
inOrder.verify(b).doSomethingElse();
inOrder.verify(a).doAnotherThing();

InOrder를 사용하면 메소드 호출의 순서를 정확하게 검증할 수 있어. 이는 특정 시나리오에서 메소드 호출 순서가 중요한 경우에 매우 유용하지!

5. Mockito의 Best Practices 🏆

자, 이제 Mockito의 다양한 기능들을 알아봤어. 하지만 이 기능들을 어떻게 잘 활용해야 할까? 여기 Mockito를 사용할 때 알아두면 좋은 몇 가지 best practices를 소개할게!

5. Mockito의 Best Practices 🏆 (계속)

5.1 필요한 것만 Mock하기

모든 것을 Mock하는 것은 좋지 않아. 실제로 필요한 부분만 Mock하고, 나머지는 실제 객체를 사용하는 것이 좋아. 이렇게 하면 테스트가 더 현실적이고 신뢰할 수 있게 돼.

// 좋은 예
@Test
public void testUserService() {
    UserRepository mockRepo = mock(UserRepository.class);
    UserService service = new UserService(mockRepo);
    // 테스트 로직...
}

// 나쁜 예
@Test
public void testUserService() {
    UserRepository mockRepo = mock(UserRepository.class);
    EmailService mockEmail = mock(EmailService.class);
    LoggingService mockLogging = mock(LoggingService.class);
    UserService service = new UserService(mockRepo, mockEmail, mockLogging);
    // 테스트 로직...
}

필요한 것만 Mock하면 테스트가 더 간단해지고, 실제 상황과 더 유사해져. 이는 테스트의 신뢰성을 높이는 데 도움이 돼!

5.2 Stub 대신 Mock 사용하기

Mockito를 사용할 때는 가능한 한 stub 대신 mock을 사용하는 것이 좋아. Mock은 행위를 검증할 수 있지만, stub은 단순히 미리 정의된 응답만 반환하거든.