JUnit5 자세히 알아보기

목차

1. JUnit5란?
2. JUnit5 구성
3. JUnit5 시작하기
4. JUnit5의 어노테이션들
5. JUnit5 테스트 이름 표시하기
6. JUnit5 Assertion
7. 조건에 따라 테스트 실행하기
8. 태깅과 필터링
9. 테스트 반복하기 
10. 테스트 인스턴스
11. 테스트 순서

 

1.  JUnit5란?

Junit란 테스팅 기반 프레임워크로써 자바 개발자가 가장 많이 사용하는 프레임워크입니다.
테스트 주도 개발(Test Driven Development, TDD)을 위해 사용합니다.

• 요구사항을 검증하는 테스트 케이스 작성
• 테스트 통과를 위한 코드 작성
• 이후 리팩토링하여 실제 개발 코드에 적용 

 

2. JUnit5 구성

JUnit5는 Java8버전 이상부터 사용이 가능하며 Platform, Jupiter, Vintage 이 세 가지가 결합한 형태로 이루어져 있습니다.

JUnit5 구성 목록

JUnit Platform

• JVM에서 테스트 프레임워크를 실행하는 런처와 TestEngine API 제공

JUnit Jupiter

• TestEngine API의 구현체로 JUnit5에서 제공

JUnit Vintage

• TestEngine API의 구현체로 JUnit3, JUnit4에서 제공
• 하위 호환성을 위해 JUnit3, JUnit4 기반의 플랫폼에 TestEngine 제공

 

3.  JUnit5 시작하기

2.2+ 버전 이상의 스프링 부트 프로젝트를 만든다면 기본으로 JUnit5 의존성이 추가되기 때문에 따로 설정할 필요는 없습니다.
만약 스프링 부트가 아니라면 아래와 같이 직접 의존성을 추가합니다.

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.5.2</version>
    <scope>test</scope>
</dependency>

 

4.  JUnit5 어노테이션들

@Test: 테스트 Method임을 선언합니다.

@ParameterizedTest: 매개변수를 받는 테스트를 작성합니다.

@RepeatedTest: 반복되는 테스트를 작성합니다.

@TestFactory: @Test로 선언된 정적 테스트가 아닌 동적으로 테스트를 사용합니다.

@TestInstance: 테스트 클래스의 생명 주기를 설정합니다.

@TestTemplate: 공급자에 의해 여러 번 호출될 수 있도록 설계된 테스트 케이스 템플릿임을 나타냅니다.

@TestMethodOrder: 테스트 메소드 실행 순서를 구성하는데 사용합니다.

@DisplayName: 테스트 클래스 또는 테스트 메소드의 이름을 정의할때 사용합니다.

@DisplayNameGeneration: 테스트 클래스에 정의하며, 테스트 메소드의 이름을 치환해줍니다.

@BeforeEach: 각각의 테스트를 실행하기 전에 매번 우선적으로 테스트됩니다.

@AfterEach: 각각의 테스트를 실행한 후에 매번 테스트됩니다.

@BeforeAll: 모든 테스트를 실행하기 전 딱 한번만 호출됩니다. 
반드시 static method로 선언해야 합니다.
private 불가, default 가능, return type 불가능 오직 void만 가능합니다.

@AfterAll: 모든 테스트를 실행한 후 딱 한번만 호출됩니다.
반드시 static method로 선언해야 합니다.
private 불가, default 가능, return type 불가능 오직 void만 가능합니다.

@Nested: 클래스가 정적이 아니라 중첩 테스트 클래스임을 나타냅니다.

@Tag: 클래스 또는 메소드 레벨에서 태그를 선언할 때 사용되며, Mavan을 사용할 경우 태그 설정을 통해 원하는 태그만 실행하거나 제외시킬 수 있습니다.

@Disabled: 이 클래스나 테스트를 사용하지 않습니다.(실행되지 않습니다.)

@Timeout: 테스트 실행 시간을 선언한 후, 시간내에 테스트가 종료되지 않으면 실패되도록 합니다.

@ExtendWith: 확장을 선언적으로 등록할 때 사용합니다.

@RegisterExtension: 필드를 통해 프로그래밍 방식으로 활장을 등록할 때 사용합니다.

@TempDir: 필드 주입 또는 매개변수 주입을 통해 임시 디렉토리를 제공하는데 사용합니다.

 

5.  JUnit5 테스트 이름 표시하기

1. @DisplayNameGeneration

• Method와 Class 레퍼런스를 사용해서 테스트 이름을 표기하는 방법을 설정합니다.
• 기본 구현체로 ReplaceUnderscores를 제공합니다.
• 아래의 코드는 애노테이션에 ReplaceUnderScores 속성을 주어 메서드 네임의 언더스코어가 공백으로 바뀌어 출력됩니다.

⭐️ Before

public class JUnit5Test {
    @Test
    void naming_test(){
        System.out.println("테스트");
    }
}

@DisplayNameGeneration 적용 전

⭐️After

@DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
public class JUnit5Test {
    @Test
    void naming_test(){
        System.out.println("테스트");
    }
}

@DisplayNameGeneration 적용 후

---

2. @DisplayName

• 어떤 테스트인지 테스트 이름을 보다 쉽게 표현할 수 있는 방법을 제공하는 애노테이션입니다.
• 따라서 메소드 이름보다 더 쉽게 어떤 테스트인지 확인할 수 있습니다.
• @DisplayNameGeneration보다 우선순위가 높습니다.

⭐️ Before

public class JUnit5Test {
    @Test
    void naming_test(){
        System.out.println("테스트");
    }
}

@DisplayName 적용 전

⭐️ After

public class JUnit5Test {
    @DisplayName("테스트 이름 지정")
    @Test
    void naming_test(){
        System.out.println("테스트");
    }
}

@DisplayName 적용 후

 

6. JUnit5 Assertion

Assertion은 실제 테스트에서 검증하고자 하는 내용을 확인하는 기능을 제공하는 패키지입니다.

1. assertEquals(expected, actual)

실제 값(actual)이 기대한 값(expected)과 같은지 확인하는 메서드입니다. 파라미터의 순서는 아무렇게나 해도 상관없지만 보통 첫 번째에 기댓값을 넣고, 두 번째에 실제 나오는 값을 넣습니다.

    @Test
    @DisplayName("스터디 만들기")
    void create_new_study() {
        Study study = new Study(-10, 25);
        assertEquals(StudyStatus.DRAFT, study.getStatus(), "에러 메세지");
        assertEquals(StudyStatus.DRAFT, study.getStatus(), () -> "에러 메세지");
        assertEquals(StudyStatus.DRAFT, study.getStatus(), String.valueOf(new Supplier<String>() {
            @Override
            public String get() {
                return "에러 메세지";
            }
        }));
	}

assertEquals에서 세 번째 파라미터에는 해당 테스트가 통과하지 못했을 경우 보여주는 메세지를 설정할 수 있습니다. 이때 위의 세 가지 방법으로 작성할 수 있는데, 람다식을 써서 메세지를 구현하는 경우가 가장 효율적입니다.

람다식을 써서 메세지를 구현해야 하는 이유.

• 문자열 연산의 실행을 테스트가 실패했을 때만 한다. 람다식이 아닐 경우에는 항상 연산을 수행한다.
• 따라서 람다식을 사용하는 것이 성능 입장에서 조금 유리할 수 있다.

---

2. assertNotNull(actual)

결과 값(actual)이 null인지 아닌지 확인하는 메서드입니다. 

    @Test
    @DisplayName("스터디 만들기")
    void create_new_study() {
        Study study = new Study(-10, 25);
        assertNotNull(study);
    }

---

3. assertTrue(boolean)

다음 조건이 참인지 확인하는 메서드입니다.

    @Test
    @DisplayName("멤버 만들기")
    void create_new_member() {
        Member member = new Member("고양이");
        assertTrue(member.getName().equals("고양이"), () -> "멤버 이름이 고양이가 아닙니다.")
    }

---

4. assertAll(executable...)

모든 테스트를 실행하는 메서드입니다.

기존에는 이전의 테스트가 실패하면 다음 테스트가 남아있음에도 바로 종료하지만 asserAll을 사용하면 일단 전부 수행합니다.

⭐️ Before

    @DisplayName("assertAll")
    @Test
    void assertAllTest(){
        assertTrue(false, ()->"첫번째 false입니다.");
        assertTrue(false, ()->"두번째 false입니다.");
        assertTrue(false, ()->"세번째 false입니다.");
    }

assertAll 적용 전

⭐️ After

    @DisplayName("assertAll")
    @Test
    void assertAllTest() {
        assertAll(
                () -> assertTrue(false, () -> "첫번째 false입니다."),
                () -> assertTrue(false, () -> "두번째 false입니다."),
                () -> assertTrue(false, () -> "세번째 false입니다.")
        );
    }

assertAll 적용 후

---

5. assertThrows(expectedType, executable)

예외가 발생하는지 확인하는 메서드입니다.

    @DisplayName("assertThrows")
    @Test
    void assertThrowsTest() {
        Member member = new Member();
        member.setName("고양이");
        
        /*
           memberService.join(member)을 수행했을 때 IllegalStateException 에러가 발생해야 테스트가 통과한다.
        */
        assertThrows(IllegalStateException.class, () -> {
            memberService.join(member);
        });
    }

---

6. assertTimeout(duration, executable)

특정 시간 내에 테스트의 실행이 완료되는지 확인하는 메서드입니다.

    @Test
    @DisplayName("특정 시간 안에 실행이 완료되는지 확인")
    void timeout_test() {
        assertTimeout(Duration.ofSeconds(10), () -> new Study(10, 20));

        /*
            시간이 100 millis가 지났더라도 블록안의 모든 구문을 수행하고 종료된다.
         */
        assertTimeout(Duration.ofMillis(100), () -> {
            new Study(10, 20);
            Thread.sleep(300);
            System.out.println("here~");
        });

        /*
            시간이 오버되면 블록안의 구문을 더 이상 수행하지 않고 바로 테스트를 종료시킨다.
            ThreadLocal 을 사용 할 경우 예상치 못한 경우가 발생할 가능성이 있다.
         */
        assertTimeoutPreemptively(Duration.ofMillis(100), () -> {
            new Study(10, 20);
            Thread.sleep(300);
            System.out.println("not here~");
        });
    }

---

Assertion은 가독성이 좋지 않아 AssertThat으로 시작하는 AssertJ를 요즘은 많이 사용한다고 합니다.

AssertJ는 AssertThat("actual").isEqualTo("actual)와 같이 메서드 체이닝 방식을 사용합니다.

AssertJ 같은 경우 이전에 정리한 적이 있으며, 아래의 게시글에서 확인이 가능합니다.

AssertJ 핵심 기능 알아보기

 

7.  조건에 따라 테스트 실행하기

JUnit에서는 특정한 조건을 만족하는 경우에 테스트를 실행할 수 있는 방법을 제공하고 있습니다.

ex) 특정한 OS, 환경변수, 시스템 변수에 따라 테스트를 실행해야 할지 말지를 결정해야 하는 경우

org.junit.jupiter.api.Assumptions.*

• assumeTrue(조건) : 해당 조건이 통과해야 아래 로직들이 수행된다.
• assumingThat(조건, 테스트): 조건이 통과를 해야 두 번째 파라미터로 전달한 테스트(로직)가 수행된다.

    @Test
    @DisplayName("조건에 따라 테스트 실행하기")
    void condition_test() {

        String test_env = System.getenv("TEST_ENV");
        System.out.println(test_env);
        /*
            조건에 만족할 경우에만 다음 테스트로 넘어가라
         */
        assumeFalse("LOCAL".equalsIgnoreCase(test_env));
        System.out.println("출력되지 않음.");

        /*
            조건에 부합한 경우에만 다음의 테스트를 수행하고, 아니라면 넘어가라.
         */
        assumingThat("LOCAL".equalsIgnoreCase(test_env), () -> {
            System.out.println("출력 됨");
        });
    }

---

애노테이션으로 다음과 같이 조건을 설정할 수도 있습니다.

• @EnabledOnOs: 특정 OS일때만 테스트가 동작하도록 합니다.
• @EnableOnJre: 특정 JRE 버전일때만 테스트가 동작하도록 합니다.

    @Test
    @DisplayName("운영체제가 mac인 경우")
    @EnabledOnOs(OS.MAC)
    void macOS_test() {
        System.out.println("macOS입니다.");
    }

    @Test
    @DisplayName("운영체제가 window인 경우")
    @EnabledOnOs(OS.WINDOWS)
    void windowOS_test() {
        System.out.println("windowOS입니다.");
    }

    @Test
    @DisplayName("운영체제가 window 혹은 mac인 경우")
    @EnabledOnOs({OS.WINDOWS, OS.MAC})
    void windowOS_macOS_test() {
        System.out.println("windowOS 혹은 macOS입니다.");
    }

    @Test
    @DisplayName("특정 자바 버전만 실행해라")
    @EnabledOnJre(JRE.JAVA_11)
    void Jre_test() {
        System.out.println("JAVA_11입니다.");
    }

---

 

8. 태깅과 필터링

JUnit5에서는 테스트 그룹을 만들고 원하는 테스트 그룹만 테스트를 실행할 수 있는 기능을 제공합니다.

@Tag: 태스트 메서드에 추가할 수 있는 태그 애노테이션으로 하나의 테스트 메서드에 여러 태그를 사용할 수도 있습니다.

    /*
        fast 태그는 로컬에서 수행한다고 가정.
     */
    @Test
    @DisplayName("Tag 테스트")
    @Tag("fast")
    void tag1_test() {
        Study actual = new Study(20, 20);
        assertNotNull(actual);
    }

    /*
        slow 태그는 CI 환경에서 수행 한다고 가정.
     */
    @Test
    @DisplayName("Tag 테스트")
    @Tag("slow")
    void tag2_test() {
        Study actual = new Study(20, 20);
        assertNotNull(actual);
    }

위처럼 fast와 slow테스트를 만들고, fast는 로컬에서, 오랜 시간이 소요되는 slow는 CI에서 수행한다고 가정할 수 있습니다. 태그 지정 후 원하는 태그만 실행될 수 있도록 아래와 같이 필터링 작업이 필요합니다.

필터링 방법(MAC 기준)

InteliJ -> Run -> Edit Configurations... -> 좌측의 + 버튼 -> JUnit 선택 -> 원하는 태그 세팅

설정 창

Maven을 사용한다면 아래와 같이 Maven - pom.xml 작성을 통해 필터링 설정이 가능합니다. (| 연산자를 이용해 다수의 태그도 지정 가능합니다.)

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <groups>fast | slow</groups>
    </configuration>
</plugin>

---

 

9. 테스트 반복하기

인자가 랜덤값이거나, 테스트 발생 시점에 따라 달라지는 값 때문에, 테스트 내용이 반복되야하는 경우에는 어떻게 해야 할까요? JUnit에서는 이러한 테스트 반복을 위한 애노테이션을 제공합니다.

1. @RepeatedTest

반복 횟수와 반복 테스트 이름을 설정하는 애노테이션입니다. 

• {displayName}: @DisplayName으로 설정한 테스트의 이름을 가져옵니다.
• {currentRepetition}: 현재 테스트가 몇 번 반복되었는지 값을 가져옵니다.
• {totalRepetition}: 전체 테스트가 몇번 반복되는지 값을 가져옵니다.

    @DisplayName("테스트 반복하기")
    @RepeatedTest(3)
    void repeat_test_v1() {
        System.out.println("반복");
    }

    @DisplayName("테스트 현재 횟수와 남은 횟수 출력하기")
    @RepeatedTest(3)
    void repeat_test_v2(RepetitionInfo repeatInfo) {
        System.out.println("반복 " + repeatInfo.getCurrentRepetition() + "/" + repeatInfo.getTotalRepetitions());
    }

    @DisplayName("테스트 이름 명시하기")
    @RepeatedTest(value = 3, name = "{currentRepetition}/{totalRepetitions}")
    void repeat_test_v3(RepetitionInfo repeatInfo) {
        System.out.println("반복 " + repeatInfo.getCurrentRepetition() + "/" + repeatInfo.getTotalRepetitions());
    }

수행 결과

---

2. @ParameterizedTest

테스트에 여러 다른 매개변수를 대입해가며 반복 실행하는 애노테이션입니다.

• @ValueSource: 속성에 선언해 준 파라미터를 인자 값으로 전달하는데, String타입뿐 만 아니라 모든 원시 타입을 지원합니다.
• {displayName}: @DisplayName 애노테이션으로 설정한 테스트의 이름
• {index}: 현재 반복된 테스트의 인덱스
• {arguments}: 전달되는 인덱스 전체
• {0}, {1} ...: 파라미터를 인덱스로 조회

    /*
        반복적인 테스트를 할 때 마다 다른 값을 가지고 테스트를 하고 싶다.
     */
    @DisplayName("반복적인 테스트 마다 다른 값을 가지고 테스트하기")
    @ParameterizedTest(name = "{index} {displayName} message={0}")
    @ValueSource(strings = {"날씨가", "많이", "추워지고", "있네요"})
    void parameterizedTest(String message) {
        System.out.println(message);
    }

    @DisplayName("반복적인 테스트 마다 다른 값을 가지고 테스트하기")
    @ParameterizedTest(name = "{index} {displayName} message={0}")
    @ValueSource(ints = {10, 20, 40})
    void parameterizedTest(Integer message) {
        System.out.println(message);
    }

수행 결과

---

3. 인자 값들의 소스

인자 값들을 제공해주는 애노테이션은 더 다양하게 존재합니다.

• @ValueSource: 다양한 기본 타입의 인자 값을 전달할 수 있습니다.
• @NullSource, @EmptySource, @NullAndEmptySource: Null과 공백 문자를 각각 제공해주거나 한 번에 제공해 줄 수 있습니다.
• @EnumSource: Enum의 값을 제공할 수 있습니다.

    /*
       EmptySource를 사용하면 비어있는 문자열을 하나 추가해 준다.
    */
    @DisplayName("반복적인 테스트 마다 다른 값을 가지고 테스트하기")
    @ParameterizedTest(name = "{index} {displayName} message={0}")
    @ValueSource(strings = {"날씨가", "많이", "추워지고", "있네요"})
    @EmptySource
    void parameterizedWithEmptySourceTest(String message) {
        System.out.println(message);
    }

    /*
       NullSource를 사용하면 Null을 하나 추가해 준다.
    */
    @DisplayName("반복적인 테스트 마다 다른 값을 가지고 테스트하기")
    @ParameterizedTest(name = "{index} {displayName} message={0}")
    @ValueSource(strings = {"날씨가", "많이", "추워지고", "있네요"})
    @NullSource
    void parameterizedWithNullSourceTest(String message) {
        System.out.println(message);
    }

    /*
       NullAndEmptySource를 사용하면 Null과 빈 문자열을 하나 추가해 준다.
    */
    @DisplayName("반복적인 테스트 마다 다른 값을 가지고 테스트하기")
    @ParameterizedTest(name = "{index} {displayName} message={0}")
    @ValueSource(strings = {"날씨가", "많이", "추워지고", "있네요"})
    @NullAndEmptySource
    void parameterizedWithNullAndEmptySourceTest(String message) {
        System.out.println(message);
    }

수행 결과

 

10. 테스트 인스턴스

JUnit은 기본적으로 테스트 메서드마다 테스트 인스턴스를 새로 만듭니다.

이것이 기본 전략이며, 테스트 메소드를 독립적으로 실행하여 예상치 못한 다른 테스트로부터의 부작용을 방지하기 위함입니다. 하지만 JUnit5부터는 상황에 따라 이러한 전략을 변경할 수 있습니다.

@TestInstance(Lifecycle.PER_CLASS)

• 테스트 클래스당 인스턴스를 하나만 만들어 사용합니다.
• 경우에 따라 테스트 간에 공유하는 모든 상태를 @BeforeEach 또는 @AfterEach에서 초기화할 필요가 있습니다.
• @BeforeAll과 @AfterAll을 인스턴스 메서드 또는 인터페이스에 정의한 default 메서드로 정의할 수도 있습니다.

⭐️ Before

public class InstanceTest {
    int _instance = 1;

    @AfterEach
    void plus() {
        _instance++;
    }

    @RepeatedTest(10)
    void test() {
        System.out.println(_instance);
    }
}

@TestInstance(Lifecycle.PER_CLASS) 적용 전

@TestInstance(Lifecycle.PER_CLASS) 적용 전의 모습입니다. 분명 @AfterEach를 통해서 매번 테스트가 끝날 때마다 _instance 값을 +1 하도록 설정했지만 매 테스트는 1이 출력되는 모습을 확인할 수 있습니다.

⭐️ After

@TestInstance(Lifecycle.PER_CLASS)
public class InstanceTest {
    int _instance = 1;

    @AfterEach
    void plus() {
        _instance++;
    }

    @RepeatedTest(10)
    void test() {
        System.out.println(_instance);
    }
}

@TestInstance(Lifecycle.PER_CLASS) 적용 후

@TestInstance(Lifecycle.PER_CLASS) 적용 후의 모습입니다. 테스트 클래스의 인스턴스를 모든 테스트가 공유해서 사용합니다. 원하는 대로 _instance값이 증가해서 출력되는 것을 확인할 수 있습니다.

 

11. 테스트 순서

테스트 메서드는 정의 한 순서대로 차례대로 실행되지 않습니다. 왜냐하면 하나의 단위(테스트)는 독립적으로 실행되며 다른 메서드에 영향을 주면 안 되기 때문입니다.(테스트 인스턴스를 테스트마다 새로 만드는 것과 같은 이유)

하지만 특정 순서대로 테스트를 실행해야 하는 경우가 있다면 애노테이션을 통해 이 테스트 메서드의 실행 순서를 컨트롤 할 수 있습니다.

@TestMethodOrder(MethodOrderer.OrderAnnotation.class) // 테스트의 실행 순서를 지정해 줄 수 있다. 기본적으로는 실행순서를 보장하지 않기 때문이다.
public class OrderTest {
    @DisplayName("이 테스트가 두번째 순서로 실행되어야 한다.")
    @Test
    @Order(2)
    void secondTest() {
        System.out.println("두 번째로 실행되어야만 하는 테스트입니다.");
    }

    @DisplayName("이 테스트가 세번째 순서로 실행되어야 한다.")
    @Test
    @Order(3)
    void thirdTest() {
        System.out.println("세 번째로 실행되어야만 하는 테스트입니다.");
    }

    @DisplayName("이 테스트가 첫번째 순서로 실행되어야 한다.")
    @Test
    @Order(1)
    void firstTest() {
        System.out.println("첫 번째로 실행되어야만 하는 테스트입니다.");
    }

수행 결과

 

테스트 관련 같이 보면 좋은 글

• AssertJ 핵심 기능 알아보기
• TestContainer로 통합 테스트 환경 구축하기
• LocalStack을 활용한 AWS S3 테스트 환경 구축하기
• ArchUnit으로 아키텍처 검사하기