자바 테스트 라이브러리 - JUnit5, AssertJ

자바의 테스팅을 위한 프레임워크이다.

JUnit5는 Java8 이상부터 사용 가능하며, JUnit3,4와 다른 엔진(5 ➡ Jupiter, ~4 ➡Vintage)으로 구동된다.

# JUnit5 어노테이션 레퍼런스

# 커스텀 어노테이션

참고로 Junit 메서드들은 메타어노테이션으로 사용해도 된다.

스프링처럼 어노테이션 상속이 가능해서, 나만의 어노테이션을 만들 수 있다는 말.

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Tag("fast")
public @interface MyAnno {
}

@MyAnno // 이제 @Tag("fast")와 동일하게 동작한다.
public Test{...}

참고로 테스트에 @Tag로 이름을 붙여놓으면 특정 테스트만 필터링해서 실행할 수 있다.

보통 @Tag("fast"), @Tag("slow") 처럼 시간이 오래걸리는 테스트와 빠른 테스트를 구분해서 사용하기도 한다.

# Test 클래스와 메소드

테스트를 사용하는 클래스는 [추상 클래스가 없으며] [단일 생성자를 가지는] 클래스여야 한다.

따로 어노테이션으로 표시할 필요는 없고, 안에있는 메서드에 JUnit5 어노테이션을 적용시킬 수 있다.

• 테스트 메서드는 반환값이 void이며 non-static한 메서드여야 한다.
• 테스트 메서드는 @Test, @RepeatedTest, @ParameterizedTest, @TestFactory, @TestTemplate 로 만들 수 있다.
• 각 테스트의 생명주기는 @BeforeAll, @AfterAll, @BeforeEach, @AfterEach 로 관리할 수 있다.

class StandardTests {
 
    @BeforeAll // 클래스에 있는 모든 테스트 전에 실행
    static void initAll() {
    }
 
    @BeforeEach // 각각의 테스트 실행전에 실행
    void init() {
    }
 
    @Test
    void succeedingTest() {
    }
 
    @Test
    void failingTest() {
        fail("a failing test");
    }
 
    @Test
    @Disabled("for demonstration purposes")
    void skippedTest() {
        // not executed
    }
 
    @AfterEach
    void tearDown() {
    }
 
    @AfterAll
    static void tearDownAll() {
    }
 
}

# 테스트

@Test
void test() {
    // ...
}
 
@RepeatedTest(3) // 해당 테스트를 3번 반복한다.
void test() {
    // ...
}

@Transactional

메서드에 이 키워드를 붙이면, 해당 메서드에 트랜잭션을 적용시켜, 해당 메서드안에서 일어난 DB조작을 모두 Rollback 시킨다. @Rollback(false)로 끌 수도있긴하다. 

➡ 가끔 JPA, MyBatis도 적용되냐고 물어보는데, 결국 JDBC 트랜잭션(.rollback)을 사용하는거라 전부 똑같이 적용된다.

public class UserTest {
    @Autowired
    UserDao userDao;
    
    UserDto dto;
    
    @Before
    public void setUp() throws Exception {
        dto = new UserDto();
        dto.setId("fasdf");
        dto.setPasswd("dd");
        dto.setName("cjung");
        dto.setEmail("rokking1@naver.com");
        dto.setTel("010-8680-2222");
    }
    
    @Test
    @Transactional
    @Rollback(true)
    public void testUserController() throws Exception {
        userDao.insertUser(dto);
    }
 
}

@TestMethodOrder로 실행 순서를 명시해줄 수 있다.

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class HelloJavaTest {
 
    @Test
    @Order(2)
    void test2() {
        System.out.println("2");
    }
 
    @Test
    @Order(1)
    void test1() {
        System.out.println("1");
    }
}

@DisplayName("설명")

테스트에 설명을 붙일 수 있고, @DisplayNameGeneration으로 자동 생성할수도 있다.

참고로 Generation 옵션은 [Standard, Simple, ReplaceUnderScores, IndicativeSentences ] 가 있다.

import org.junit.jupiter.api.DisplayNameGeneration;
import org.junit.jupiter.api.DisplayNameGenerator;
import org.junit.jupiter.api.Test;
 
@DisplayNameGeneration(DisplayNameGenerator.IndicativeSentences.class)
class HelloJavaTest {
 
    @Test
    void aTest() {
    }
 
}

# 다이나믹 테스트 (@ParameterizedTest, @TestFactory)

@Test 를 사용해도 되지만, 매번 테스트용 파라메타 값을 한땀한땀 박아넣는건 귀찮은 작업이다.

그래서 테스트용 데이터를 유연하게 동적으로 생성할 수 있는 @ParameterizedTest 같은게 존재한다.

• 다이나믹 테스트를 이용하면, 테스트 데이터에 title을 붙일 수 있어 가독성이 높아지는 장점이 있다.
• 다만 다이나믹 테스트는 생명주기 관리는 불가능하다는 단점이 있다. (@BeforeEach, @AfterEach)

@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5}) // 총 5번 실행
void isUnderTenTest(int number) {
    boolean result = isUnderTen(number);
 
    assertThat(result).isTrue();
}

@TestFactory는 private, static이면 안되고, 반환값으로는 Stream, Collection, Iterable를 리턴해줘야 한다.
➡ 이를 어기면 JUnitException이 발생한다. 테스트 개수 == 반환값의 개수라고 보면 된다.

@TestFactory
Collection<DynamicTest> dynamicTestsFromCollection() {
      return Arrays.asList(dynamicTest("1st dynamic test", () -> assertEquals(6, 3 * 2)),
                         dynamicTest("2nd dynamic test", () -> assertEquals(4, 2 * 2)));
}

@TestFactory
Stream<DynamicTest> exampleDynamicTest() {
    return Stream.of(
        dynamicTest("First Dynamic Test", () -> {
            // test code. @Test 안의 내용과 동일
        }),
        dynamicTest("Second Dynamic test", () -> {
            // test code. @Test 안의 내용과 동일
        })
    );
}

@TestFactory
Stream<DynamicTest> isUnderTenTest() {
  List<Integer> numbers = getNumberFromDatabase() // 1, 2, 3, 4, 5, 6, 7, 8, 9
 
  return numbers.stream()
      .map(num -> dynamicTest(num + "가 10미만인지 검사",
          () -> {
               boolean result = isUnderTen(num);
               assertThat(result).isTrue();
          }
    ));
}

@TestFactory의 다양한 예제

class DynamicTestsDemo {
 
    private final Calculator calculator = new Calculator();
 
    // This will result in a JUnitException!
    @TestFactory
    List<String> dynamicTestsWithInvalidReturnType() {
        return Arrays.asList("Hello");
    }
 
    @TestFactory
    Collection<DynamicTest> dynamicTestsFromCollection() {
        return Arrays.asList(
            dynamicTest("1st dynamic test", () -> assertTrue(isPalindrome("madam"))),
            dynamicTest("2nd dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        );
    }
 
    @TestFactory
    Iterable<DynamicTest> dynamicTestsFromIterable() {
        return Arrays.asList(
            dynamicTest("3rd dynamic test", () -> assertTrue(isPalindrome("madam"))),
            dynamicTest("4th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        );
    }
 
    @TestFactory
    Iterator<DynamicTest> dynamicTestsFromIterator() {
        return Arrays.asList(
            dynamicTest("5th dynamic test", () -> assertTrue(isPalindrome("madam"))),
            dynamicTest("6th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        ).iterator();
    }
 
    @TestFactory
    DynamicTest[] dynamicTestsFromArray() {
        return new DynamicTest[] {
            dynamicTest("7th dynamic test", () -> assertTrue(isPalindrome("madam"))),
            dynamicTest("8th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        };
    }
 
    @TestFactory
    Stream<DynamicTest> dynamicTestsFromStream() {
        return Stream.of("racecar", "radar", "mom", "dad")
            .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text))));
    }
 
    @TestFactory
    Stream<DynamicTest> dynamicTestsFromIntStream() {
        // Generates tests for the first 10 even integers.
        return IntStream.iterate(0, n -> n + 2).limit(10)
            .mapToObj(n -> dynamicTest("test" + n, () -> assertTrue(n % 2 == 0)));
    }
 
    @TestFactory
    Stream<DynamicTest> generateRandomNumberOfTestsFromIterator() {
 
        // Generates random positive integers between 0 and 100 until
        // a number evenly divisible by 7 is encountered.
        Iterator<Integer> inputGenerator = new Iterator<Integer>() {
 
            Random random = new Random();
            int current;
 
            @Override
            public boolean hasNext() {
                current = random.nextInt(100);
                return current % 7 != 0;
            }
 
            @Override
            public Integer next() {
                return current;
            }
        };
 
        // Generates display names like: input:5, input:37, input:85, etc.
        Function<Integer, String> displayNameGenerator = (input) -> "input:" + input;
 
        // Executes tests based on the current input value.
        ThrowingConsumer<Integer> testExecutor = (input) -> assertTrue(input % 7 != 0);
 
        // Returns a stream of dynamic tests.
        return DynamicTest.stream(inputGenerator, displayNameGenerator, testExecutor);
    }
 
    @TestFactory
    Stream<DynamicTest> dynamicTestsFromStreamFactoryMethod() {
        // Stream of palindromes to check
        Stream<String> inputStream = Stream.of("racecar", "radar", "mom", "dad");
 
        // Generates display names like: racecar is a palindrome
        Function<String, String> displayNameGenerator = text -> text + " is a palindrome";
 
        // Executes tests based on the current input value.
        ThrowingConsumer<String> testExecutor = text -> assertTrue(isPalindrome(text));
 
        // Returns a stream of dynamic tests.
        return DynamicTest.stream(inputStream, displayNameGenerator, testExecutor);
    }
 
    @TestFactory
    Stream<DynamicNode> dynamicTestsWithContainers() {
        return Stream.of("A", "B", "C")
            .map(input -> dynamicContainer("Container " + input, Stream.of(
                dynamicTest("not null", () -> assertNotNull(input)),
                dynamicContainer("properties", Stream.of(
                    dynamicTest("length > 0", () -> assertTrue(input.length() > 0)),
                    dynamicTest("not empty", () -> assertFalse(input.isEmpty()))
                ))
            )));
    }
 
    @TestFactory
    DynamicNode dynamicNodeSingleTest() {
        return dynamicTest("'pop' is a palindrome", () -> assertTrue(isPalindrome("pop")));
    }
 
    @TestFactory
    DynamicNode dynamicNodeSingleContainer() {
        return dynamicContainer("palindromes",
            Stream.of("racecar", "radar", "mom", "dad")
                .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text)))
        ));
    }
 
}

Mockito를 이용해서 HTTP API 테스트를 하는 예제

@ParameterizedTest
@NullAndEmptySource // args에 null과 빈값을 테스트함. (그래서 총 2번 실행)
@DisplayName("HTTP 파라메타가 비었거나 null인 검증요청을 보낸 경우 400 HTTP Code 리턴한다.")
void http_param_is_empty_or_null(String args) throws Exception {
    // Given
    var request = new ConfirmRegisterAccountRequest();
    request.setToken(args);
    request.setEmail(args); 
    
    // When -> Mockito 사용
    doThrow(IllegalStateException.class).when(accountFacade).registerConfirm(request);
 
    final var actions = mockMvc.perform(get("/api/accounts/authorize")
        .accept(MediaType.APPLICATION_JSON)
        .contentType(MediaType.APPLICATION_JSON)
        .param("token", args)
        .param("email", args)
    );
 
    // Then -> Mockito 사용
    actions
        .andDo(print())
        .andExpect(status().isBadRequest());
}

@TestFactory
@DisplayName("이메일 검증 시나리오")
Collection<DynamicTest> verify_account_scenarios() {
    var account = accountRepository.save(
        Account.of("jiwonDev@gmail.com", "jiwon", "password!"));
 
    return Arrays.asList(
        DynamicTest.dynamicTest("회원 이메일 토큰검증에 성공한다.", () -> {
            //Arrange
            var command = new ConfirmRegisterAccountCommand(account.getEmailCheckToken(),
                account.getEmail());
 
            // Act
            confirmRegisterAccountProcessor.registerConfirm(command);
            Account updatedAccount = accountRepository.findByEmail(account.getEmail());
 
            // Assert
            assertThat(updatedAccount.isEmailVerified()).isTrue();
        }),
        DynamicTest.dynamicTest("이메일이나 토큰의 값이 null인 경우 예외를 리턴한다.",
            () -> {
                //Arrange
                var command = new ConfirmRegisterAccountCommand(null, null);
 
                // Act & Assert
                assertThatExceptionOfType(NullPointerException.class)
                    .isThrownBy(() -> confirmRegisterAccountProcessor.registerConfirm(command));
            }),
        DynamicTest.dynamicTest("이메일 검증에 실패하여 예외를 리턴한다.",
            () -> {
                //Arrange
                var command = new ConfirmRegisterAccountCommand(account.getEmailCheckToken(),
                    "HiIamNotExistEmail@naver.com");
 
                // Act & Assert
                assertThatExceptionOfType(IllegalStateException.class)
                    .isThrownBy(() -> confirmRegisterAccountProcessor.registerConfirm(command));
            }),
        DynamicTest.dynamicTest("토큰 검증에 실패하여 예외를 리턴한다.",
            () -> {
                //Arrange
                var command = new ConfirmRegisterAccountCommand("안녕난가짜토큰이라고해",
                    account.getEmail());
 
                // Act & Assert
                assertThatExceptionOfType(IllegalStateException.class)
                    .isThrownBy(() -> confirmRegisterAccountProcessor.registerConfirm(command));
            })
    );
}

# 다이나믹 테스트에 사용하는 값 생성 @어노테이션

@ValueSource ( types = {...} )

하나의 타입의 값을 순서대로 전달하여 여러번 테스트한다.

types는 [ short, byte, int, long, float, double, char, java.lang.String, java.lang.Class ], 즉 모든 타입을 제공해준다.

@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5}) // 총 5번 실행
void isUnderTenTest(int number) {
    boolean result = isUnderTen(number);
 
    assertThat(result).isTrue();
}
 
@ParameterizedTest
@ValueSource(strings = {"", "  "}) // 총 2번 실행
void isBlank_ShouldReturnTrueForNullOrBlankStrings(String input) {
    assertTrue(Strings.isBlank(input));
}

@NullSoruce, @EmptySource, @NullAndEmptySource

참고로 NullSoruce는 기본타입 (primitive)에 사용할 수 없다. 당연한 사실.

@ParameterizedTest
@NullAndEmptySource
void isBlank_ShouldReturnTrueForNullAndEmptyStrings(String input) {
    assertTrue(Strings.isBlank(input));
}

@EnumSoruce

@ParameterizedTest // names가 없다면 ENUM에 존재하는 모든 값을 테스트한다.
@EnumSource(value = Month.class, names = {"APRIL", "JUNE", "SEPTEMBER", "NOVEMBER"})
void someMonths_Are30DaysLong(Month month) {
    final boolean isALeapYear = false;
    assertEquals(30, month.length(isALeapYear));
}
 
 
@ParameterizedTest
@EnumSource(
    value = Month.class,
    names = {"APRIL", "JUNE", "SEPTEMBER", "NOVEMBER", "FEBRUARY"},
    mode = EnumSource.Mode.EXCLUDE) // names에 있는 값을 제외한 나머지를 테스트한다.
void exceptFourMonths_OthersAre31DaysLong(Month month) {
    final boolean isALeapYear = false;
    assertEquals(31, month.length(isALeapYear));
}

@ MethodSource (직접 테스트 데이터 만들기)

Stream, Iterable을 반환하는 static method를 만들어 직접 테스트 데이터를 입력할 수 있다.

참고로 junit.ArgumentsProvider를 상속해서 객체를 만들어두고 @ArgumentSource(my.class)를 사용하는 방법도 있다.

private static Stream<Arguments> provideStringsForIsBlank() { // argument source method
      return Stream.of(
        Arguments.of(null, true),
        Arguments.of("", true),
        Arguments.of("  ", true),
        Arguments.of("not blank", false)
      );
}

@ParameterizedTest
@MethodSource("provideStringsForIsBlank") // 테스트 객체안에 해당 메서드가 있어야함.
void isBlank_ShouldReturnTrueForNullOrBlankStrings(String input, boolean expected) {
    assertEquals(expected, Strings.isBlank(input));
}
 
 
// 테스트 클래스안에 있는 메서드가 아니라면, 패키지명.객체명#메서드명 으로 적어야 한다.
@ParameterizedTest
@MethodSource("com.baeldung.parameterized.StringParams#provideStringsForIsBlank")
void isBlank_ShouldReturnTrueForNullOrBlankStringsExternalSource(String input) {
    assertTrue(Strings.isBlank(input));
}

@CSVSource

CSV를 생성한다. value, delimiter, delimiterString, emptyValue(대체값), nullValue(대체값)등을 지정할 수 있다.

# JUnit5.Assertions 메서드를 이용한 테스트

Assertions 안에는 테스트 검증을 위한 다양한 메서드가 존재한다.

    @Test
    void standardAssertions() {
        assertEquals(2, calculator.add(1, 1));
        assertEquals(4, calculator.multiply(2, 2),
                "The optional failure message is now the last parameter");
        assertTrue('a' < 'b', () -> "Assertion messages can be lazily evaluated -- "
                + "to avoid constructing complex messages unnecessarily.");
    }

근데 사용법을 보면 알겠지만 JUnit 기본 Assertions는 구리다.

JUnit5.Assertions는 함수 체이닝이 안되서 읽기도 힘들고, IDE가 자동완성도 지원하지 않는다.

그래서 보통 서드파티 라이브러리 (AssertJ.Assertions)를 대신 사용한다.

# AssertJ.Assertions 메서드 알아보기

JUnit5와 호환가능한 Thrid-Party Assertion 라이브러리들이 존재한다. 

그중 대표적인게 AssertJ로 추가적인 테스트 문법과 메서드 체이닝을 제공해주는 오픈소스 라이브러리이다.

참고로 Hamcrest, Truth라고 비슷한게 있긴한데, 보통 AssertJ를 많이 사용한다. 제일 직관적이고 편하다.

참고로 이는 JUnit5 팀에서도 공식적으로 추천하는 라이브러리라서, 호환성은 걱정하지 않아도 된다.

@ assertThat, assertAll

assertThat(...)은 해당 값의 검증이 실패하면 테스트 실패를 알리고, 해당 메서드의 테스트를 중지시킨다.

assertThat(actual).isEqualTo(expected);

기존에는 assertEqual, assertTrue, assertFalse, assertNull 같이 다양한 메서드를 사용했었다.

하지만 assertThat를 중간에 추가했는데, 그 이유는 아래와 같이 쓰는게 훨씬 간결하고 읽기좋기 때문이다.

@Test // 우리도 되도록이면 그냥 assertThat으로 통일해서 간결하게 쓰도록 하자.
void a_few_simple_assertions() {
    assertThat("The Lord of the Rings").isNotNull()
                                        .startsWith("The")
                                        .contains("Lord")
                                        .endsWith("Rings");
}

assertAll(...)은 자바의 함수형 인터페이스를 이용해 여러 테스트를 하나로 묶어서 실행할 수 있다.

@Test
void test1() {
    assertAll(
        //A Case
        () -> assertFalse(true, "Exception!!!"),
 
        //B Case
        () -> {
            TestObject tObj = null;
            assertNotNull(tObj, "Object is Null!!");
        }
    );
}

@ String

참고로 String 뿐만 아니라 isTrue, isFalse같이 어지간한 기본 메서드는 다 있으니, 자동완성으로 찾아보도록 하자.

@Test
void 문자열_검증() {
    String expression = "This is a string";
    assertThat(expression).startsWith("This").endsWith("string").contains("a");
}

@ 테스트 실패 메시지 지정 (Description)

@Test
void test() throws Exception {
    String str = "name";
    // .as를 이용하여 해당 테스트가 실패했을 때 보여줄 설명을 지정할 수 있다.
    assertThat(str).as("값을 확인해주세요. 현재 값: %s", str)
            .isEqualTo("name2");
}

@ cotains, containsOnly, containsExactly

contains은 해당 값들이 전부 검증객체에 존재하는지 테스트하는 함수이다.

void containsTest() {
    List<Integer> list = Arrays.asList(1, 2, 3);
 
    // Success: 모든 원소를 입력하지 않아도 성공
    assertThat(list).contains(1, 2);
 
    // Success: 중복된 값이 있어도 포함만 되어 있으면 성공
    assertThat(list).contains(1, 2, 2);
 
    // Success: 순서가 바뀌어도 값만 맞으면 성공
    assertThat(list).contains(3, 2);
 
    // Fail: List 에 없는 값을 입력하면 실패
    assertThat(list).contains(1, 2, 3, 4);
}

만약 안에 있는 값들을 정확하게 검증하고 싶다면 ContainsOnly를 사용하자. (순서와 중복은 고려하지 않는다)

@Test
void containsOnlyTest() {
    List<Integer> list = Arrays.asList(1, 2, 3);
 
    assertThat(list).containsOnly(1, 2, 3);
    assertThat(list).containsOnly(3, 2, 1); // 순서는 고려하지 않는다.
    assertThat(list).containsOnly(1, 2, 3, 3); // 중복은 고려하지 않는다. (1,2,3) 으로 인식
    // (1,2) 나 (1,2,3,4)는 검증에 실패한다.
}

순서와 중복여부까지 고려해서 완벽한 일치를 원한다면 containsExactly를 사용하자

@Test
void containsExactlyTest() {
    List<Integer> list = Arrays.asList(1, 2, 3);
 
    assertThat(list).containsExactly(1, 2, 3);
    // (1,2) (3,2,1) (1,2,3,3) 같은 건 검증 실패
}

@ 테스트 실패 메시지, 코멘트, 주석 (Description, Comment)

* assertThat(...)다음에 바로 적어야 동작한다. 함수 체이닝 구현상 중간에 적으면 동작하지 않고 무시된다.

@Test
void test() throws Exception {
    String str = "name";
    assertThat(str).as("값을 확인해주세요. 현재 값: %s", str)
            .isEqualTo("name2");
}

실패시 메시지를 추가하는게 아니라, 아예 AssertionError의 메시지를 변경하고 싶다면 .withFailMessage()를 사용하자.

assertThat(frodo.getAge()).withFailMessage("should be %s", frodo)
                          .isEqualTo(sam);
// java.lang.AssertionError: should be TolkienCharacter [name=Frodo, age=33, race=HOBBIT]

항상 출력(성공했을 때도 출력)하는 방법은 따로 없으나, .as(..)에 사용된 메시지를 모아두는건 가능하다.

// 1. 메시지를 하나로 합칠 StringBuilder를 만든다. (*String으로 해도 되지만, 불변이라 성능이 나빠진다.)
final StringBuilder descriptions = new StringBuilder(String.format("Assertions:%n"));
 
// 2. assertThat을 하기 전에 as(..msg..)에 등록된 메시지를 처리할 함수를 정의하고 등록한다.
Assertions.setDescriptionConsumer( msg -> descriptions.append(String.format("-- %s%n", msg)) );
 
var frodo = new TolkienCharacter("Frodo", 33, Race.HOBBIT);
assertThat(frodo.getName()).as("check name").isEqualTo("Frodo");
assertThat(frodo.getAge()).as("check age").isEqualTo(33);
 
// 3. 만들어진 문자열을 직접 확인하면 된다.
System.out.println(descriptions);

@ Collection Filtering (필터링)

Array나 iterable에 담긴 값을 꺼내서 비교할 수 있다. stream()과 사용법이 비슷한데, 예제를 살펴보자

@Getter
@AllArgsConstructor
public class Member {
    private String name;
    private int age;
    private MemberType type;
}
 
enum MemberType{
    ADMIN, USER
}

import static org.assertj.core.api.Assertions.*;
import static org.assertj.core.util.Lists.newArrayList;
 
class MemberTest {
    private Member dexter = new Member("dexter", 12, ADMIN);
    private Member james = new Member("james", 30, ADMIN);
    private Member park = new Member("park", 23, USER);
    private Member lee = new Member("lee", 33, USER);
 
    private List<Member> members = newArrayList(dexter, james, park, lee);
 
    @Test
    void sample() throws Exception {
        // 1. filteredOn으로 조건을 걸고, containsOnly로 검증한다.
        assertThat(members)
                .filteredOn("type", ADMIN) // "type"안에 있는 값 타입 == ADMIN
                .containsOnly(dexter, james);
 
        // 2. 람다식 사용
        assertThat(members)
                .filteredOn(m -> m.getType() == USER) // m.getType == USER인건
                .containsOnly(park, lee);
 
        // 3 in 조건 (여러개)
        assertThat(members).
                filteredOn("type", in(ADMIN, USER)) // "type" in(ADMIN,USER)
                .containsOnly(dexter, james, park, lee);
 
        // 4 not 조건
        assertThat(members)
                .filteredOn("type", not(ADMIN)) // not(ADMIN)
                .containsOnly(park, lee);
 
        // 5. 조건이 여러개일 땐 체인해서 걸면 된다.
        assertThat(members)
                .filteredOn("type", ADMIN)
                .filteredOn(m -> m.getAge() > 20)
                .containsOnly(james);
    }
 
}

@ Collection Data Extracting

MemberList에서 member를 꺼내 각각의 name을 검증한다고 생각해보자.

@Test
void no_extracting() throws Exception{
    List<String> names = new ArrayList<>();
    for (Member member : members) {
        names.add(member.getName());
    }
 
    assertThat(names).containsOnly("dexter", "james", "park", "lee");
}

더 간결한 방법이 있다. extracting("fieldname")을 사용하는 것이다. 컬렉션 해체 메서드라고 생각하면된다. 

@Test
void extracting_more() throws Exception {
    // 1
    assertThat(members)
            .extracting("name", String.class)
            .contains("dexter", "james", "park", "lee");
 
    // 2
    assertThat(members) // 검증 필드가 여러개라면 tuple을 사용하자.
            .extracting("name", "age")
            .contains(
                    tuple("dexter", 12),
                    tuple("james", 30),
                    tuple("park", 23),
                    tuple("lee", 33)
            );
}

@ Soft Assrtion

앞의 예제에서 사용한 asserThat은 검증에 실패하면 해당 테스트 메서드를 바로 중지시켜서 불편하다.

• assertAll로 람다식으로 모든 테스트를 하나로 묶는 방법도있지만, SoftAssertions을 쓰는 방법도 있다.
• SoftAssertions.assertSoftly(...)를 이용하면 실패하더라도 중지하지 않고 모든 테스트를 다 돌려볼 수 있다.

@Test
void basic_soft_assertions_example() {
  SoftAssertions softly = new SoftAssertions(); 
 
  softly.assertThat("George Martin").as("great authors").isEqualTo("JRR Tolkien");  
  softly.assertThat(42).as("response to Everything").isGreaterThan(100); 
  softly.assertThat("Gandalf").isEqualTo("Sauron"); 
 
  // 🧨주의!! assertAll()을 하지않으면, 검증되지 않는다.
  softly.assertAll(); 
}

@Test
void basic_bdd_soft_assertions_example() {
  BDDSoftAssertions softly = new BDDSoftAssertions();
 
  softly.then("George Martin").as("great authors").isEqualTo("JRR Tolkien");
  softly.then(42).as("response to Everything").isGreaterThan(100);
  softly.then("Gandalf").isEqualTo("Sauron");
 
  // 🧨주의!! assertAll()을 하지않으면, 검증되지 않는다.
  softly.assertAll();
}

매번 SoftAssertions 객체를 만들고, assertAll()을 호출하기 귀찮다면 아래와 같이 @InjectSoftAssertions를 사용하자.
SoftAssertionsExtension 객체가 SoftAssertionsProvider 라는걸 주입해주는데, 이는 BDDSoft와 그냥 Soft를 다 일괄처리해준다.

@ExtendWith(SoftAssertionsExtension.class)
public class JUnit5SoftAssertionsExtensionAssertionsExamples {
 
  @InjectSoftAssertions
  private SoftAssertions softly; // 이렇게하면 코드가 깔끔해진다.
 
  @Test
  public void chained_soft_assertions_example() {
    String name = "Michael Jordan - Bulls";
    softly.assertThat(name).startsWith("Mi")
                           .contains("Bulls");
    // softly.assertAll() 를 따로 호출하지 않아도 된다. 알아서 검증해줌
  }
  
  @ParameterizedTest
  @CsvSource({ "1, 1, 2", "1, 2, 3" })
  void junit5_soft_assertions_parameterized_test_example(int a, int b, int sum, SoftAssertions softly) {
    softly.assertThat(a + b).as("sum").isEqualTo(sum);
    softly.assertThat(a).isLessThan(sum);
    softly.assertThat(b).isLessThan(sum);
  }
}

만약 @InjectSoftAssertion 같이 사용하는게 꼴보기 싫다면, 그냥 assertSoftly를 사용하는 방법도 있다.
대신 아래와 같이 메서드로 반환해줘야함

@Test
void assertSoftly_example() {
  SoftAssertions.assertSoftly(softly -> {
    softly.assertThat("George Martin").as("great authors").isEqualTo("JRR Tolkien");
    softly.assertThat(42).as("response to Everything").isGreaterThan(100);
    softly.assertThat("Gandalf").isEqualTo("Sauron");
    // 이 역시 assertAll() 를 호출할 필요가 없다. assertSoftly 가 알아서 해줌.
  });
}

참고로 assertAll 검증결과는 아래와 같이 구분해서 나온다.
만약 각 테스트 결과를 분리하고 싶다면 Junit의 DynamicTest를 사용해야한다.

@ File Assertions

파일 객체를 테스트 할 수 있다. 사용법은 크게 다르지않다.

@Test
void file() throws Exception{
    File file = writeFile("Temp", "You Know Nothing Jon Snow");
 
    // 1 File 객체를 이용해 존재여부, 파일여부, 상대경로 여부등을 확인할 수 있다.
    assertThat(file).exists().isFile().isRelative();
 
    // 2
    assertThat(contentOf(file)) // 해당 파일의 내용을 읽어서 검증한다.
            .startsWith("You")
            .contains("Know Nothing")
            .endsWith("Jon Snow");
}
 
private File writeFile(String fileName, String fileContent) throws Exception {
    File file = new File(fileName);
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), Charset.defaultCharset()));
    writer.write(fileContent);
    writer.close();
    return file;
}

@ Exception Assertions (예외 검증)

assertThatThrownBy 또는 catchThrowable( () -> {} )로 자바 예외객체를 검증할 수 있다.

private void throwException() throws Exception {
    throw new Exception("예외 던지기!22");
}

// 1
@Test
void exception() throws Exception {
    assertThatThrownBy(() -> throwException())
            .isInstanceOf(Exception.class)
            .hasMessage("예외 던지기!") // Exception 객체가 가지고있는 메시지 검증
            .hasMessageEndingWith("Size: 2")
            .hasMessageMatching("Index: \\d+, Size: \\d+") // String 마냥 이런 검증도 가능.
            .hasStackTraceContaining("Exception");
}
 
// 2 또는 이렇게 사용하는 방법도 있다. BDD의 When과 Then을 구분할 때 사용한다.
@Test
void thrownTest() throws Exception {
    // When (catchThorwable에 콜백메서드로 전달하여 실행을 늦춘다.)
    Throwable throwable = catchThrowable(() -> throwException());
 
    // Then (지금 실행하고 검증)
    assertThat(throwable).isInstanceOf(Exception.class).hasMessage("예외 던지기!");
}

참고로 자바에서 자주 발생하는 예외들은 아래와 같이 assertThatException이 존재한다.

assertThatIOException().isThrownBy(() -> {})
assertThatIllegalArgumentException.isThrownBy(() -> {})
assertThatIllegalStateException().isThrownBy(() -> {})
assertThatIOException().isThrownBy(() -> {})
assertThatNullPointerException().isThrownBy(() -> {})

@  Compare 함수 (Comparsion) 커스텀하기

비교할때 사용하는 Comparator.compare를 직접 커스텀할 수 있다.

@Test
void equalTest() throws Exception{
    Item item1 = new Item("item1");
    Item item2 = new Item("item1");
 
    // 1. 그냥 사용
    assertThat(item1).isEqualTo(item2);
	
    // 2. unsingComparator를 이용해서 비교하는 함수를 직접 구현
    assertThat(item1)
            .usingComparator(new Comparator<Item>() {
                @Override
                public int compare(Item o1, Item o2) {
                    return o1.getName().compareTo(o2.getName());
                }
            })
            .isEqualTo(item2);
 
    // 3. 익명 객체대신 람다식을 쓰면 좀 더 간결하다.
    assertThat(item1)
            .usingComparator((a, b) -> a.getName().compareTo(b.getName()))
            .isEqualTo(item2);
}

컬렉션에서 사용되는 Comparator도 커스텀 할 수 있긴한데... 사용할 일은 거의 없다.

    assertThat(itemList).contains(item1, item2).doesNotContain(item3);
 
    assertThat(itemList) // 이때는 usingElementComparator 사용
            .usingElementComparator((a, b) -> a.getName().compareTo(b.getName()))
            .contains(item1, item2, item3); // 파라미터 b 에 넣을 값들. 3개니까 총 3번 비교

@ 객체간의 비교(특정 필드값 비교), usingComparsion 사용하기

기존에는 isEqualToComparingFieldByFieldRecursively(...) 이런걸 사용했는데, 2020년 8월 3.17버전에 전부 Deprecated 되었다. 

가독성 개판이라서 어차피 안쓰는 기능이었는데, 역시 나만 그런게 아니었네, 너무좋아!

Deprecated된 메서드 설명 구경하기

@Test
void comparison() throws Exception{
    Item item1 = new Item("item1", 1000);
    Item item2 = new Item("item1", 1000);
    Item item3 = new Item("item1", 3000);
 
    // 1 각각의 필드 값을 비교한다.
    assertThat(item1).isEqualToComparingFieldByField(item2);
    assertThat(item1).isEqualToComparingFieldByField(item3) ➡ price가 달라서 실패 
 
    // 2 주어진 "name" 필드만 비교한다
    assertThat(item1).isEqualToComparingOnlyGivenFields(item2, "name");
    assertThat(item1).isEqualToComparingOnlyGivenFields(item3, "name");
 
    // 3 "name"필드를 제외한 나머지 필드를 비교한다.
    assertThat(item1).isEqualToIgnoringGivenFields(item2, "price");
    assertThat(item1).isEqualToIgnoringGivenFields(item3, "price");
 
    // 4  null인 필드값을 제외하고 나머지를 비교한다.
     Item item4 = new Item(null, 1000);
    assertThat(item1).isEqualToIgnoringNullFields(item4);
}

@Test
void recursively() throws Exception{
    Person person1 = new Person("Dexter");
    Person person2 = new Person("Dexter");
 
    Item item1 = new Item("item1", 1000, person1);
    Item item2 = new Item("item1", 1000, person2);
 
    // 테스트 실패
    // assertThat(item1).isEqualToComparingFieldByField(item2);
	
    
    // 동등성을 비교할 수 있다. 객체가 가진 필드를 재귀적으로 파고들어서 비교한다.
    assertThat(item1).isEqualToComparingFieldByFieldRecursively(item2);
}

이제 객체간의 비교는 usingRecursiveComparison() 과 ignoringFields...()를 사용하면 됩니다!! 와!

딱히 설명이 필요없을 정도로, 가독성이 정말 많이 좋아졌습니다.

Assertions.assertThat(objActual)
                .usingRecursiveComparison() // 재귀적으로 값을 비교합니다.
                .ignoringFields("uniqueId", "otherId") // objActual에 해당 필드는 무시합니다.
                .ignoringFieldsMatchingRegexes(".*someId") // 필드이름이 해당 정규표현식이면 무시합니다.
                .ignoringOverriddenEqualsForTypes(MyData.class, MyDataItem.class) // 🧨 아래에 주의사항 언급
                .isEqualTo(objExpected);

// equals not overridden in TolkienCharacter
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter young = new TolkienCharacter("Frodo", 22, HOBBIT);
 
// 단순히 isEqualTo로 비교하게되면, 값이 아닌 참조값을 비교하게된다
assertThat(frodo).isNotEqualTo(frodoClone);
 
// 두 객체의 값이 같다.
assertThat(frodo).usingRecursiveComparison()
                 .isEqualTo(frodoClone);
 
// 두객체의 값이 다르다.
assertThat(frodo).usingRecursiveComparison()
                 .isNotEqualTo(young);

🧨 주의사항

최신버전(3.17.0이상)에서는 비교할 때 사용자가 재정의한 Equals 메서드를 사용하지 않습니다. (그냥 필드비교함)

하지만 이전버전에서는 Equals를 사용하는게 기본이라서, 버전에 따라 다르게 동작할 수 있어요.

public static class Address {
  int number;
  String street;
 
  // 숫자만 비교하도록 equals를 재정의
  @Override
  public boolean equals(final Object other) {
    if (!(other instanceof Address)) return false;
    
    Address castOther = (Address) other;
    return Objects.equals(number, castOther.number);
  }
}

Person sherlock = new Person("Sherlock", 1.80);
sherlock.home.address.street = "AAA Street";
sherlock.home.address.number = 221;
 
Person sherlock2 = new Person("Sherlock", 1.80);
sherlock2.home.address.street = "BBB Street";
sherlock2.home.address.number = 221;
 
// 객체 내부의 Equals를 사용하는지, 그냥 비교하는지 모릅니다. 버전마다 다름..
assertThat(sherlock).usingRecursiveComparison()
                    .isEqualTo(sherlock2); // 버전마다 검증결과가 다릅니다...뭐라고?

이를 해결하는 방법은 간단합니다. ignoringOverriddenEquals...() 를 이용해서 구버전에서도 Equals를 사용하지 않도록 강제하면 됩니다. 가독성도 올라가는건 덤이구요.

assertThat(sherlock).usingRecursiveComparison()
                    .ignoringOverriddenEquals() // 명시적으로 Equals를 무시함!
                    .isEqualTo(sherlock2);
 
// 만약 특정값만 무시하고 싶다면, 위에서 말한 ..Types, ..Fields, ..Regexes를 사용하면 됩니다.
assertThat(sherlock).usingRecursiveComparison()
                    .ignoringOverriddenEqualsForTypes(Address.class)
                    .isEqualTo(sherlock2);

1. 복잡한 포함 관계(is A)일때

같은 객체간의 값 비교라면, 딱히 신경쓰지 않아도 된다.

예를 들어 아래와 같이 복잡한 Person 객체가 있다고 생각해보자. Person.Home.Address 라는 복잡한 관계이다.

class Person {
    String name;
    double height;
    Home home = new Home();
 
    public Person(String name, double height) {
        this.name = name;
        this.height = height;
    }
}
 
class Home {
    Address address = new Address();
    Date ownedSince;
 
    public static class Address {
 
        int number;
        String street;
    }
}

Recursive는 각 객체의 값을 재귀적으로 검사한다. 즉, 그냥 쓰면 된다. 아래는 성공하는 테스트예제이다.
심지어는 Person { Person myPerson } 이런 재귀적인 포함관계도 비교도 가능하다.

🧨 usingRecursive는 객체의 Equals를 사용하지 않는다. Equals로 비교하고싶다면 usingOverridenEquals를 쓰자

@Test
void myTest() throws Exception {
    Person sherlock = new Person("Sherlock", 1.80);
    sherlock.home.ownedSince = new Date(123); // Person.Home
    sherlock.home.address.street = "Baker Street"; // Person.Home.Address
    sherlock.home.address.number = 221; // Person.Home.Address
 
    Person sherlock2 = new Person("Sherlock", 1.80);
    sherlock2.home.ownedSince = new Date(123); // Person.Home
    sherlock2.home.address.street = "Baker Street"; // Person.Home.Address
    sherlock2.home.address.number = 221; // Person.Home.Address
 
 
    // 이렇게 비교할 수 있다. 참고로 비교할 때 객체의 Equals 를 사용하지 않는다.
    assertThat(sherlock).usingRecursiveComparison()
        .isEqualTo(sherlock2);
 
    // 참고로 isEqualTo로 비교하면, 참조값을 비교하는거라 실패한다.
    assertThat(sherlock).isNotEqualTo(sherlock2);
}

2. 특정 필드값( 또는 특정 타입)은 무시하고 싶을 때

ignoringFields...를 사용하면 된다. 가독성이 좋아서 설명이 없어도 쉽게 알 수 있을듯

Person sherlock = new Person("Sherlock", 1.80); // Person의 이름이 다르다.
sherlock.home.address.street = "Baker Street"; // Person.Home.Address 의 street가 다르다.
sherlock.home.address.number = 221;
 
Person moriarty = new Person("Moriarty", 1.80);
moriarty.home.address.street = "Crime Street";
moriarty.home.address.number = 221;

재귀적으로 동작한다는 걸 이해하면, 쉽게 알 수 있다.

예를 들어 아래의 필드명은 Person.Home.Address.street 를 무시한다.

["home.address.street", "home.adress", "home"]

// 필드 이름중 "name" 과 "home.address.street" 가 무시된다.
assertThat(sherlock).usingRecursiveComparison()
                    .ignoringFields("name", "home.address.street")
                    .isEqualTo(moriarty);
 
// 참고로 "home" 이렇게 적으면, "home" 아래의 모든 필드가 무시된다.(재귀적으로 동작하니까)
assertThat(sherlock).usingRecursiveComparison()
                    .ignoringFields("name", "home")
                    .isEqualTo(moriarty);
 
// 필드명을 정규표현식으로 거를 수 있다. (.*ome) 는 끝부분이 ome로 끝나는 경우.
assertThat(sherlock).usingRecursiveComparison()
                    .ignoringFieldsMatchingRegexes(".*ome") // home, aome, abome...
                    .isEqualTo(moriarty);

이름이 아닌 타입으로도 가능하다. 이 경우 재귀적으로 해당 타입을 다 무시한다.

Person tallSherlock = new Person("sherlock", 2.10);
tallSherlock.home.address.street = "Long Baker Street";
tallSherlock.home.address.number = 222;
 
// Double, Address 타입을 사용하는 "height" 와 "address" 필드가 무시된다.
assertThat(sherlock).usingRecursiveComparison()
                    .ignoringFieldsOfTypes(double.class, Address.class)
                    .isEqualTo(tallSherlock);

3. null 인 필드값만 무시하고 싶을 때

검증대상에 null인 필드 값을 무시하고 싶다면, ignoringActualNullFields()를 사용하면 된다.

@Test
void myTest() throws Exception {
    Person noName = new Person(null, 1.80);
    noName.home.address.street = null;
    noName.home.address.number = 221;
 
    Person sherlock = new Person("Sherlock", 1.80);
    sherlock.home.address.street = "Baker Street";
    sherlock.home.address.number = 221;
 
    // 테스트 성공. name 과 home.address.street 필드가 무시됨.
    assertThat(noName).usingRecursiveComparison()
        .ignoringActualNullFields()
        .isEqualTo(sherlock);
 
    // 테스트 실패. 검증대상에는 null 필드가 없어서, 제외할 필드가 없음.
    assertThat(sherlock).usingRecursiveComparison()
        .ignoringActualNullFields()
        .isEqualTo(noName); // AssertionError
}

assertThat(검증대상)이 아니라, 비교할 객체의 null 이 들어간 필드를 제외하고 싶다면 ExpectedNullFields를 사용하자.

보통 테스트용 객체를 대충만드는 경우가 많아서, 유용하게 쓸 수 있다.

Person sherlock = new Person("Sherlock", 1.80); // Person(String name, Double height)
sherlock.home.address.street = "Baker Street";
sherlock.home.address.number = 221;
 
// 비교할 테스트용 데이터 정의
Person testData = new Person(null, 1.80);
noName.home.address.street = null; // String의 기본값은 null 이라서, 이것도 생략가능
noName.home.address.number = 221;
 
// sherlock 검증 성공, 비교대상(testData)에서 null 인 필드는 무시하고 비교한다.
assertThat(sherlock).usingRecursiveComparison()
                    .ignoringExpectedNullFields()
                    .isEqualTo( testData );
 
// testData 검증 실패. 비교대상인 (sherlock)에는 있는 필드가, testData에는 null이기 때문
assertThat(testData).usingRecursiveComparison()
                    .ignoringExpectedNullFields()
                    .isEqualTo( sherlock ); // AssertionError 발생

4. Optional.empty 필드 무시

객체가 Optional 필드를 가지고 있을 일이 없기에 거의 쓸 일은 없다.

null 무시와 사용법은 동일하다. 검증대상에 Optional.empty가 있다면 해당 필드는 무시하고 비교한다.

var OptionalEmptyHome = new Home("kim", "busan", Optional.empty);
var OptionalHome = new Home("kim", "busan", Optional.of(30));
 
// 테스트 성공. OptioanlEmptyHome의 Optional.empty 값은 무시한다.
assertThat(OptionalEmptyHome).usingRecursiveComparison()
                               .ignoringActualEmptyOptionalFields()
                               .isEqualTo(OptionalHome);
 
// 테스트 실패. OptionalHome의 empty는 무시할려고 했으나, empty가 없음.
assertThat(OptionalHome).usingRecursiveComparison()
                            .ignoringActualEmptyOptionalFields()
                            .isEqualTo(OptionalEmptyHome); // AssertError

5. 비교연산을 커스텀하고 싶을 때

3.1.7은 기본적으로 사용자가 정의한 Equals를 사용하지 않고, 필드를 비교한다고 했다.

근데 원한다면 내가 직접 비교함수를 만들수도 있다. 사용법은 간단하다. .withEqualsFor...( 함수, 대상 ) 

@Test
void myTest() throws Exception {
    TolkienCharacter frodo = new TolkienCharacter("Frodo", 1.2);
    TolkienCharacter tallerFrodo = new TolkienCharacter("Frodo", 1.3);
    TolkienCharacter reallyTallFrodo = new TolkienCharacter("Frodo", 1.9);
 
    BiPredicate<Double, Double> myCompare = (d1, d2) -> Math.abs(d1 - d2) <= 0.5;
    // == Comparator<Double> myCompare = (d1, d2) -> Math.abs(d1 - d2) <= 0.5 ? 0 : 1;
    
    // 특정 필드의 커스텀 비교
    assertThat(frodo).usingRecursiveComparison()
        .withEqualsForFields(myCompare, "height")
        .isEqualTo(tallerFrodo);
 
    // 특정 타입의 커스텀 비교
    assertThat(frodo).usingRecursiveComparison()
        .withEqualsForType(myCompare, Double.class)
        .isEqualTo(tallerFrodo);
}

참고로 예외가 터졌을 때 메시지도 커스텀 할 수 있다. 별로 쓸모는 없지만

// 물론 검증에 실패해야 뜬다.
assertThat(frodo).usingRecursiveComparison()
                 .withErrorMessageForFields("🧨height 필드 비교에서 예외터졌다리", "height")
//               .withErrorMessageForType(message, Double.class) 이런거도 가능
                 .isEqualTo(tallerFrodo);

아래와 같이 검증 실패시, 예외 메시지가 변경 된다..ㅋㅋ String 값이니, 내가 원하는 필드를 보여줄 수도 있을듯

Expecting actual:
  TolkienCharacter [name=Frodo, height=1.2]
to be equal to:
  TolkienCharacter [name=Frodon, height=1.4]
when recursively comparing field by field, but found the following 2 differences:
 
// 참고로 기본 메시지는 이러하다
field/property 'name' differ:
- actual value  : "Frodo"
- expected value: "Frodon"
 
// 내가 커스텀한 메시지가 뜬다. 기본메시지는 없어짐..ㅋㅋ
🧨height 필드 비교에서 예외터졌다리
 
The recursive comparison was performed with this configuration:
- no overridden equals methods were used in the comparison (except for java types) 
- these types were compared with the following comparators:
  - java.lang.Double -> DoubleComparator[precision=1.0E-15]
  - java.lang.Float -> FloatComparator[precision=1.0E-6]
  - java.nio.file.Path -> lexicographic comparator (Path natural order)
- actual and expected objects and their fields were compared field by field recursively even if they were not of the same type, this allows for example to compare a Person to a PersonDto (call strictTypeChecking(true) to change that behavior).
- these fields had overridden error messages:
  - height

@ 다른 객체간 비교

RecursiveComparsionConfiguraion 설정객체를 만들고

usingRecursiveFieldByFieldElementComparator 를 사용하면 된다. 좀 복잡하긴하다 ㅋㅋ

var configuration = RecursiveComparisonConfiguration.builder()
                                                    .withIgnoredFields("fieldname") // 이렇게 커스텀
                                                    .build();
                                                    
assertThat(...).usingRecursiveFieldByFieldElementComparator(configuration)
				   .contains(...);

Doctor DoctorA = new Doctor("A", true); // Doctor(String name, boolean isHuman)
Doctor DoctorB = new Doctor("B", true);
Doctor DoctorC = new Doctor("C", true);
 
Person PersonA = new Person("A", false); // Person(String name, boolean isHuman)
Person PersonB = new Person("B", false);
Person PersonC = new Person("C", false);
 
List<Doctor> doctors = List.of(drSheldon, drLeonard, drRaj);
 
var configuration = RecursiveComparisonConfiguration.builder()
                                                    .withIgnoredFields("isHuman")
                                                    .build();
 
// 테스트 성공. Doctor객체와 Person 객체의 필드이름을 기준으로 비교한다.
assertThat(doctors).usingRecursiveFieldByFieldElementComparator(configuration)
                   .contains(personA);
 
// 테스트 실패. 해당 이름은 리스트에 없다.
personA.setName("DDD");
assertThat(doctors).usingRecursiveFieldByFieldElementComparator(configuration)
                   .contains(personA); // AssertionError