테스트 모킹 Mockito 라이브러리

2021.09.07 - [Backend/Java] - 다양한 테스트와 Test Double (+Mockist)

다양한 테스트와 Test Double (+Mockist)

 

# Mockito란?

https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html

테스트에 필요한 Mock Object를 생성, 검증, 스터빙(Creation, Verification, Stubbing)해주는 자바 라이브러리이다.

gradle에서 다음과 같이 의존성을 추가해 사용할 수 있다.

➡ 보통 Junit, AssertJ, Mockito를 함께 사용한다.

dependencies {
    testImplementation('org.junit.jupiter:junit-jupiter:5.6.0')
    testImplementation('org.assertj:assertj-core:3.11.1')
    testImplementation('org.mockito:mockito-core:3.3.0')
}

 

스프링을 사용한다면, 스프링 부트 테스트 라이브러리에 Mockito가 이미 포함되어있어 바로 사용할 수 있다.

참고로 스프링테스트엔 Junit, assertj, hamcrest, xmlunit 등 많이 사용하는 테스트 라이브러리도 포함되어있다.

testImplementation 'org.springframework.boot:spring-boot-starter-test'

# 1. 기본 동작 (생성-검증-스터빙)

자바의 객체를 mock(...) 메서드로 Stubing할 수 있다. 이렇게 Stubing 한 객체를 이용해 다양한 Mocking을 만든다.

import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.Mockito.*;

class EX1_Mockito {
    @Test
    void stubbing() throws Exception{
        // 1. Mock 객체를 생성함.
        List<String> mockedList = mock(ArrayList.class);

        // 2. when을 이용한 stubbing. 가짜 동작을 지정함.
        when(mockedList.get(0)).thenReturn("First");
        when(mockedList.get(1)).thenThrow(new IndexOutOfBoundsException());

        // 3-1 Junit이나 AssertJ를 이용하여 내가 원하는 동작을 하는지 확인함.
        assertThat(mockedList.get(0)).isEqualTo("First"); // 반환값이 First인가?
        assertThatThrownBy(() -> mockedList.get(1)) // 해당 메서드는 
                .isInstanceOf(IndexOutOfBoundsException.class); // 이 예외를 반환하는가?

        assertThat(mockedList.get(10)).isNull(); // 해당 메서드의 결과가 Null인가?

        // 3-2 반환값이 없는 경우. 해당 메서드가 호출되었는지 여부도 확인가능하다.
        // 파라미터도 검증한다. verify(mockedList).get(2); 만 호출되었다면 실패!
        verify(mockedList, times(1)).get(0);
        verify(mockedList).get(0); // 생략시 1번
    }
}

 

참고로 verify는 BDD Mockito로 아래와 같이 변경할 수 있다.

메서드 이름만 다를 뿐, 동작은 내부 동작은 비슷하다.

@Test
void startBDDStyle(){
    //Given
    Study study = new Study("test", 10);
    Member member = new Member();
    member.setEmail("delusidiot@gmail.com");
    member.setId(1L);
 
    BDDMockito.given(memberServiceMock.findById(1L)).willReturn(Optional.of(member));
    BDDMockito.given(repositoryMock.save(study)).willReturn(study);
    StudyService studyService = new StudyService(memberServiceMock, repositoryMock);
 
    //When
    studyService.createNewStudy(1L, study);
 
    //Then
 
    BDDMockito.then(memberServiceMock).should(times(1)).notify(study);
    BDDMockito.then(memberServiceMock).should().notify(member); // 생략시 1번
    BDDMockito.then(memberServiceMock).shouldHaveNoInteractions();
    // 참고로 특정 시점 이후로 인터렉션이 없는지 확인하고 싶다면 ..NoMoreInteraction()를 쓰자
}

 

 

# 2. Argument Matcher

Mockito는 다양한 ArgumentMatcher를 사용하기 때문에 값 뿐만 아니라 논리적인 타입으로 스터빙 가능하다.

예를 들어 AnyInt(), AnyString()을 파라미터에 전달해서 해당 타입을 주었을 때 예외가 발생하는지 검증가능하다.

@Test
void argument_matchers() throws Exception{
    List<String> mockedList = mock(ArrayList.class);

    when(mockedList.get(anyInt())).thenReturn("AnyInt");

    assertThat(mockedList.get(1010)).isEqualTo("AnyInt");

    verify(mockedList).get(anyInt()); // verify도 사용가능!
}

물론 필요하다면 논리적인 파라미터를 ArgumentMatcher를 직접 구현해서 만들 수 있습니다.

• 파라미터가 들어갈 자리에 argThat 객체를 생성해서 주면 됩니다.

@Test
void matcherSupport() throws Exception {
    final List<String> mockedList = mock(List.class);
    mockedList.add("Hello");
    mockedList.add("Dexter");
    mockedList.add("James");
	
    // when에서 anyInt() 대신에 any[크기가 3 이하인 리스트]를 넣고 싶은 경우
    when(mock.someMethod(argThat(list -> list.size()<3))).thenReturn(null);
    
    // verify도 똑같이 사용하면 된다. 그냥 메서드 파라미터자리에 argThat을 만들면 됨.
    verify(mockedList, times(3))
            .add( // add(..) 메서드에 들어간 파라미터 값의 길이가 3초과, 8미만임을 검증함
                    argThat(string -> (string.length() < 8) && (string.length() > 3))
            );
}

물론 Java8의 람다식 대신에 익명 객체를 사용하셔도 됩니다.

 // JAVA 8 람다를 이용하는 방법
 verify(list, times(2)).add(argThat(string -> string.length() < 5));

 // JAVA 7 익명 클래스를 이용하는 방법
 verify(list, times(2)).add(argThat(new ArgumentMatcher(){
     public boolean matches(String arg) {
         return arg.length() < 5;
     }
 }));

 // 객체를 파라미터로 받는 경우, receiveComplexObject로 파라미터 객체 검증가능.
 verify(target, times(1)).receiveComplexObject(
                                 argThat( obj -> obj.getSubObject().get(0).equals("expected") )
                                 );

 

# 3. verify 추가 기능

verify는 보통 해당 기능이 사용되었는지 여부를 검증한다.

하지만 추가적인 파라미터를 주면 해당 기능이 몇번 사용되었는지, 한번도 사용되지 않았는지도 검증 가능하다.

@Test
void verify_mockito() throws Exception{
    List<String> mockedList = mock(ArrayList.class);

    mockedList.add("once");

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

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

    // 1. add("once")가 몇번 호출되었는지 확인할 수 있다.
    verify(mockedList).add("once"); // time(1)은 기본값이라 생략할 수 있다.
    verify(mockedList, time(1)).add("once");
    verify(mockedList, times(2)).add("twice");
    verify(mockedList, times(3)).add("three times");

    // 2. 그 외 다양한 추가 파라미터를 제공한다. never()는 한번도 호출되지 않은경우 OK
    verify(mockedList, atLeastOnce()).add("once");
    verify(mockedList, atMostOnce()).add("once");
    verify(mockedList, atLeast(1)).add("twice");
    verify(mockedList, atMost(10)).add("three times");
    verify(mockedList, never()).add("mockito");
}

 

## any, 특정 타입이 사용되었는지 확인(자식, 상속등)

참고로 입력값이 아니라 특정 타입인지 검사하고 싶은 경우 any를 사용하면 된다.

위에서 설명한 Argument Matcher를 통해 타입을 검사한다. 단 기본형은 타입 변환이 불가능해서, anyInt() 같은 걸 사용해 Integer로 업캐스팅해서 타입을 검사한다.

verify(mockedList).add(any()); // 입력값이 Object로 변환 가능한가? (primitive 타입 미포함)
verify(mockedList).add(any(MyClass.class)); // 입력값이 MyClass.class로 변환가능한가?
verify(bar).doPrimitiveStuff(anyInt()); // 입력값이 Integer로 변환 가능한가?

@MockBean
private JavaMailSender mockMailSender;

// mockMailSender.send( ..해당 타입.. ) 메서드가 1번 실행되었는지를 확인한다.
verify(mockMailSender).send( any(SimpleMailMessage.class) );

then(mockMailSender).should().send( any(SimpleMailMessage.class) );

옛날에 만들어진 isA(..) 메서드도 있는데, 이름이 애매해서 any(), anyString()으로 많이 사용한다. (기능은 같다)

 

 

# 4. void method 예외 스터빙

반환값이 void인 경우 Mockito.when( ).method... 처럼 사용할 수 없어 답답하다. ➡ 이 때는 doThorw, doNothing 사용

@Test
void doThrow_mockito() throws Exception {
    List<String> mockedList = mock(ArrayList.class);
	
    // void clear(); 가 호출될 때 예외를 던지도록 Stubing한다.
    doThrow(new RuntimeException("Boom!")).when(mockedList).clear();

    // clear 메서드가 예외를 반환하는지 검증
    assertThatThrownBy(() -> mockedList.clear())
            .isInstanceOf(RuntimeException.class)
            .hasMessage("Boom!");
            
            
    // 아니면 doNothing()을 사용해도 된다.
     Person p = mock(Person.class);

     doNothing().when(p).setName("mike");
     p.setName("mike");
     verify(p).setName("mike");
}

 

 

# 5. 호출된 순서 검증하기 - inOrder

@Test
void verify_in_order() throws Exception {
    List<String> firstMockedList = mock(ArrayList.class);
    List<String> secondMockedList = mock(ArrayList.class);

    firstMockedList.add("firstMockList add first");
    firstMockedList.add("firstMockList add second");

    secondMockedList.add("secondMockList add first");
    secondMockedList.add("secondMockList add second");

    // 1. inOrder로 Mock 객체를 묶어서 메서드의 호출 순서도 검증할 수 있다.
    final InOrder inOrder = inOrder(firstMockedList, secondMockedList);

    // 2. 사용은 inOrder.verify 등을 이용하면 된다.
    inOrder.verify(firstMockedList).add("firstMockList add first"); // 1번쨰
    inOrder.verify(firstMockedList).add("firstMockList add second"); // 2번쨰
    inOrder.verify(secondMockedList).add("secondMockList add first"); // 3번쨰
    inOrder.verify(secondMockedList).add("secondMockList add second"); // 4번째
}

 

 

# 6. @Mock Annotaion

Mockito.mock() 을 이용하지 않고, 어노테이션으로 편하게 Mock 객체를 만들 수 있다.

다만 Mockito의 특성상, 파라미터가 없는 기본생성자가 존재해야 Mock 객체를 만들어서 사용할 수 있다.

• 참고로 어노테이션을 사용하려면 MockitoAnnotation.openMocks(현재 테스트 클래스)를 반드시 해주어야한다.
  ➡ JUnit5 - MockitoJUnitRunner에 해당 메서드가 포함되어있어 신경쓰지 않아도 상관 없긴 하다.

// Product.java
public class Product {
    private Long id;
    private String name;
    private int price;

    public Product() { // 이거 필수.
    }

    public Product(Long id, String name, int price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    // getters, setters...
}

@Mock private Product product; // 알아서 Mock으로 생성.

@Test
void mockAnnotation() throws Exception{
    // 1. product 선언만하고 바로 사용하면 됨.
    MockitoAnnotations.initMocks(this);

    when(product.getId()).thenReturn(3L);

    assertThat(product.getId()).isEqualTo(3L);

    verify(product).getId();
}

 

 

# 7. 연속으로 여러개 스터빙하기

Mock객체에 가짜값을 등록할 때, 한번에 여러개를 체이닝해서 등록할 수 있다.

@Test
void consecutive_call() throws Exception{

    // 1. 함수 체이닝
    List<String> mockedList = mock(List.class);
    when(mockedList.get(0)) // when은 해당 메서드가 동작을 마쳤을 때 반환값을 지정한다.
            .thenReturn("Hello") // 반환값 "Hello" 지정
            .thenReturn("Dexter") // 중복하면 덮어씌우는게 아니라, 다음 호출에 사용된다.
            .thenThrow(new RuntimeException("Boom!")); // 발생할 예외 지정지정

    assertThat(mockedList.get(0)).isEqualTo("Hello");
    assertThat(mockedList.get(0)).isEqualTo("Dexter");
    assertThatThrownBy(() -> mockedList.get(0))
            .isInstanceOf(RuntimeException.class)
            .hasMessage("Boom!");


    // 2. 파라미터 전달
    List<String> mockedList2 = mock(List.class);
    when(mockedList2.get(0))
            .thenReturn("Hello", "Dexter"); // 아니면 이렇게 파라미터로 한꺼번에 줘도 된다.

    assertThat(mockedList2.get(0)).isEqualTo("Hello");
    assertThat(mockedList2.get(0)).isEqualTo("Dexter");


    // 3. 아예 when을 여러번 호출 -> 이는 덮어씌워진다.
    List<String> mockedList3 = mock(List.class);
    when(mockedList3.get(0))
            .thenReturn("Hello");
    when(mockedList3.get(0))
            .thenReturn("Dexter"); // 기존의 when("Hello")가 삭제된다.

    assertThat(mockedList2.get(0)).isEqualTo("Dexter");
    assertThat(mockedList2.get(0)).isEqualTo("Dexter");
}

 

 

# 8. Custom 스터빙 만들기

이미 존재하는 thenRetun, thenThrow만 사용해도 되지만, 필요하다면 아래와 같이 직접 만들수도있다.

➡ thenAnswer을 이용해, 익명 클래스 정의 or Lambda식을 이용해서 구현하면 편하다.

➡ Java에서는 객체의 추상메서드가 단 1개인 경우, 아래와 같이 new 를 생략하고 바로 함수처럼 객체를 만들 수 있다.

// doSomething 메서드가 호출되면 12를 반환하도록 스터빙
doAnswer(invocation -> 12).when(mock).doSomething();
 
// domSomething(str,str,str) 메서드가 호출되면 첫번째 파라미터의 길이를 반환하도록 스터빙 
doAnswer( invocation -> ((String)invocation.getArgument(1)).length() )
     .when(mock)
     .doSomething(anyString(), anyString(), anyString());

@Test
void answer_callback() throws Exception {
    List<String> mockedList = mock(List.class);

    when(mockedList.get(123))
            .thenAnswer(
                    invocation -> { // 해당 메서드로 동작이 대체된다.
                        final Object[] arguments = invocation.getArguments();
                        return "전달된 아규먼트들: " + Arrays.toString(arguments);
                    }
            );

    assertThat(mockedList.get(123)).isEqualTo("전달된 아규먼트들: [123]");
}

 

 

# 9. Spy Mock 객체

실제 객체의 인스턴스를 복사하여 똑같이 동작하는 Mock을 만들 수 있다.

=> 인스턴스가 가지고 있던 값까지 똑같이 복사한다.

@Test
void spy_mock() throws Exception{
    final List<String> nameList = new ArrayList<>();
    final List<String> spy = spy(nameList); // spy 객체 생성

    // 1. 비어있는 리스트를 복사했으므로 불가능한 스터빙이다. (IndexOutOfBoundsException 발생)
    // when(spy.get(0)).thenReturn("Dexter");
	
    // 1.1 물론 이런건 가능하다.
    when(spy.size()).thenReturn(100);
    
    // 2. spy 객체는 이렇게 doReturn을 이용하여 스터빙하면 된다.
    doReturn("Dexter").when(spy).get(0);
    assertThat(spy.get(0)).isEqualTo("Dexter");

    // 3. 실제 객체처럼 동작하지만, 당연히 실제 객체에 적용된 것이 아니다.
    // 그래서 nameList.get()을 호출해도 스터빙된 값이 나오지않음.
    assertThatThrownBy(() -> nameList.get(0))
            .isInstanceOf(IndexOutOfBoundsException.class);
}

 

 

# 10. Mock 객체 생성 전략설정  (거의 사용하지 않음)

mock 객체를 생성하고 따로 스터빙을 해주지 않으면, 기본타입(int,boolean)을 제외하고는 전부 null을 반환하도록 만들어진다. ➡ mock 객체의 생성전략을 지정해주어서 자동으로 반환값을 만들도록 지정할 수 있다.

* 다만 이는 오래된 레거시 시스템을 테스트하는게 아니라면, 이런식으로 사용할 일이 없다. 그냥 알아만 두자

@Test
void default_returnMock() throws Exception {
    // 1. 그냥 mock 객체를 만들면, 기본 반환값은 전부 null이다.
    final Product mock = mock(Product.class);
    assertThat(mock.getName()).isNull();
    assertThatThrownBy(() -> mock.getName().length())
            .isInstanceOf(NullPointerException.class);

    // 2. RETURNS_SMART_NULL을 생성전략으로 지정한 경우.
    // NPE 에러가 발생하지 않도록 만들 수 있다.
    final Product mockWithSmartNulls = mock(Product.class, RETURNS_SMART_NULLS);
    assertThat(mockWithSmartNulls.getName()).isNotNull();
    assertThat(mockWithSmartNulls.getName().length()).isEqualTo(0);
}

 

 

# 11. ArgumentCaptor

verify(Object).method(...) 사용 시 파라미터를 직접 지정하지만, ArgumentCaptor를 이용하면 유연하게 사용할 수 있다.

@Test
void capture() throws Exception{
    // stubbing
    final List<String> mockedList = mock(List.class);
    when(mockedList.get(1)).thenReturn("A");
    when(mockedList.get(2)).thenReturn("B");
    when(mockedList.get(3)).thenReturn("C");

    // 1. Integer 값을 다루는 ArgumentCaptor 생성
    ArgumentCaptor<Integer> integerArgumentCaptor = ArgumentCaptor.forClass(Integer.class);

    assertThat(mockedList.get(1)).isEqualTo("A");
    assertThat(mockedList.get(3)).isEqualTo("C");
    assertThat(mockedList.get(2)).isEqualTo("B");
    
    // 2. 입력된 파라미터를 다시 Captor(획득)해서 재사용할 수 있다.
    final List<Integer> allValues = integerArgumentCaptor.getAllValues();
    assertThat(allValues).isEqualTo(Arrays.asList(1, 3, 2));


    // 3. ArgumentCaptor를 이용하면 times(3) 처럼 동적으로 파라미터를 생성할 수 있다.
    verify(mockedList, times(3)).get(integerArgumentCaptor.capture());
    // verify(mockedList).get(1);
    // verify(mockedList).get(2);
    // verify(mockedList).get(3);

}

 

 

# 12. Resetting Mocks (거의 사용하지 않음)

스터빙 된 값을 mock 객체의 초기상태(null)로 되돌려버릴 수 있다. 다만 테스트를 이따구로 하는건 좋지않은 방법이다.

@Test
void reset_mock() throws Exception{
    final Product mock = mock(Product.class);

    when(mock.getName()).thenReturn("Dexter");
    assertThat(mock.getName()).isEqualTo("Dexter");

    reset(mock);
    assertThat(mock.getName()).isNull();
}

 

 

# 13. Behavior Driven Development (BDD)

행위 주도 설계 BDD라고 불리며  given->when->then 구조를 의미한다.

Mocktio의 기본 메서드들, when().thenReturn()등은 이게 스터빙을 하는건지, 검증을 하는건지 의미가 명확하지 않다.

➡ 나도 처음 공부할때는 when()이 스터빙이 아니라 검증하는 코드로 착각했었다. 나만 그런게 아니었구나 ㅎㅎ;

 

그래서 mockito.BDDMockito라는 추가 패키지를 사용하면 BDD를 구분하기 좋은 확실한 메서드들을 사용할 수 있다.

• given(product.getName()).willReturn("Dexter"); => when과 같은 기능
• then(product).should(times(1)).getName(); => verify와 같은 기능

import org.junit.jupiter.api.*;
import org.mockito.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.*; // 추가 패키지 사용

public class EX2_Mockito_BDD {

    @Mock Product product;

    @BeforeEach
    void init(){
        MockitoAnnotations.initMocks(this);
    }
    
    @Test
    void BDD_test() throws Exception{
        //given(...).willReturn()으로 좀 더 명확한 이름을 사용한다.
        given(product.getName()).willReturn("Dexter");

        //when
        final String name = product.getName();

        //then
        assertThat(name).isEqualTo("Dexter");

        then(product).should(times(1)).getName(); // verify랑 같은 기능!
    }
}

 

 

# 14. @Captor, @Spy

위에서 @Mock 처럼 어노테이션을 이용해서 ArugmentCaptor, Spy를 만들 수 있다.

@Captor
ArgumentCaptor<Integer> integerArgumentCaptor;

@Test
void capture() throws Exception {
    MockitoAnnotations.initMocks(this);

    final List<String> mockedList = mock(List.class);
    when(mockedList.get(1)).thenReturn("A");
    when(mockedList.get(2)).thenReturn("B");
    when(mockedList.get(3)).thenReturn("C");

    assertThat(mockedList.get(1)).isEqualTo("A");
    assertThat(mockedList.get(3)).isEqualTo("C");
    assertThat(mockedList.get(2)).isEqualTo("B");

    verify(mockedList, times(3)).get(integerArgumentCaptor.capture());

    final List<Integer> allValues = integerArgumentCaptor.getAllValues();
    assertThat(allValues).isEqualTo(Arrays.asList(1, 3, 2));
}

@Spy
Product productSpy = new Product(1L, "Dexter", 1000);

@Spy
Product productSpyWithNoArgCon; // new Product();

@Test
void spy_annotation() throws Exception {
    MockitoAnnotations.initMocks(this);

    assertThat(productSpy.getName()).isEqualTo("Dexter");
    assertThat(productSpyWithNoArgCon.getName()).isNull();

    when(productSpy.getName()).thenReturn("James");
    when(productSpyWithNoArgCon.getName()).thenReturn("James");

    assertThat(productSpy.getName()).isEqualTo("James");
    assertThat(productSpyWithNoArgCon.getName()).isEqualTo("James");
}

 

# 14-1 @InjectMocks

@InjectMocks로 객체를 생성하면, 현재 생성되어있는 Mock, Spy들을 주입해서 만들어준다.

일종의 Mock을 위한 @Autowired라고 생각하면된다. 다만 @Mock이 없다고 해서 실제객체가 주입되지는 않는다.

class Item{...}

class Order{
    private Item item;

    public Order(Item item) {
        this.item = item;
    }
}

public class EX3_Mockito_InjectMocks {

    @Mock
    Item item;

    @InjectMocks // mock(Item.class)가 주입된다.
    Order order;

    @Test
    void injectMocks_Annotation() throws Exception{
        MockitoAnnotations.initMocks(this);

        when(item.isSameName("Book")).thenReturn(true);

        assertThat(order.itemCheck("Book")).isEqualTo("해당 아이템이 주문되었습니다.");
        assertThat(order.itemCheck("Movie")).isEqualTo("주문된 아이템이 아닙니다.");
    }
}

 

참고로 아래와 같이 Mockito.Annotations.openMocks(this) 를 이용해서 @Mock을 주입받는 방법도 있다.

* 참고로 원래 initMocks()였는데 이름이 openMocks로 바뀌었다. 좀 더 명확한 의미로 바뀐듯.

public class EX3_Mockito_InjectMocks {

    @Mock
    Item item;

    @Test
    void non_injectMocks_Annotation() throws Exception{
        MockitoAnnotations.openMocks(this); // Mock 객체 컨테이너 사용

        final Order order = new Order(item); // item은 Mock 객체 컨테이너에서 꺼내와서 등록

        when(item.isSameName("Book")).thenReturn(true);

        assertThat(order.itemCheck("Book")).isEqualTo("해당 아이템이 주문되었습니다.");
        assertThat(order.itemCheck("Movie")).isEqualTo("주문된 아이템이 아닙니다.");

    }
}

 

 

# 15. Ignore Stubbing

보통 verifyNoMoreInteractions(mock);를 쓸 때 종종 사용한다.

verifyNoMoreInteractions(mock); 는 해당 Mock에 모든 스터빙을 사용했는지 확인하는 메서드이다.

@Test
void ignore_stubbing() throws Exception{
    final List<String> mock = mock(List.class);

    when(mock.get(0)).thenReturn("Hello");
    final String s = mock.get(0);

    ignoreStubs(mock);
    
    // verify(mock).get(0); 하지 않아도 통과!. ignore가 남은 스터빙을 다 제거해줌.
    verifyNoMoreInteractions(mock);
}

 

 

# 16. Mocking details

Mock 객체의 세부사항들을 테스트할 때 사용된다. 거의 사용할일은 없긴하지만 예제를 한번 살펴보자.

@Mock
Product mockedProduct;

@Test
void mocking_details() throws Exception {
    MockitoAnnotations.openMocks(this); // mock 컨테이너를 불러온다.
    
    // 원하는 mock에 대한 MockingDetails 객체 생성
    final MockingDetails mockingDetails = mockingDetails(mockedProduct);

    // 1. 해당 Mock이 mock, spy인지 확인 가능하다.
    final boolean isMock = mockingDetails.isMock();
    assertThat(isMock).isTrue();
    final boolean isSpy = mockingDetails.isSpy();
    assertThat(isSpy).isFalse();

    // 2. Mocking 객체의 이름(mockedProduct)와 원본객체의 타입 검증도 가능.
    final MockName mockName = mockingDetails.getMockCreationSettings().getMockName();
    assertThat(mockName.toString()).isEqualTo("mockedProduct");
    final Class<?> typeToMock = mockingDetails.getMockCreationSettings().getTypeToMock();
    assertThat(typeToMock).isSameAs(Product.class);

    // 3. 해당 Mock이 가진 메서드가 내가 생각하는 메서드가 맞는지 비교가능.
    mockedProduct.setPrice(10000);
    final Method setPrice = typeToMock.getMethod("setPrice", int.class);
    mockingDetails.getInvocations().forEach(
            invocation -> assertThat(invocation.getMethod()).isEqualTo(setPrice)
    );

    // 4. 스터빙된 값들의 정보도 가져올 수 있음.
    when(mockedProduct.getName()).thenReturn("Dexter");
    final Method getName = typeToMock.getMethod("getName");
    mockingDetails.getStubbings().forEach(stubbing -> {
                final Method method = stubbing.getInvocation().getMethod();
                assertThat(method).isEqualTo(getName);
            }
    );
}

 

 

#17 Custom Verify Fail-Message

verify 실패 시 원하는 메시지를 커스텀 할 수 있습니다.

@Test
void custom_verify_failure_message() throws Exception{
    verify(mock, description("This will print on failure")).someMethod();
    
    final List<String> mockedList = mock(List.class);
    // times()등과 함께 사용한다면 아래와 같이 메서드 체이닝으로 쓰면 됩니다.
    verify(mockedList, times(2).description("해당 메서드는 두번 호출되어야 한다.")).get(0);
}

 

 

----------

이정도면 충분한 것 같다.

더 궁금한 내용이 있다면 공식문서를 참고하자.