JUnit5 Annotation (@Test, @ParameterizedTest, .. etc)

JUnit5 Annotation

• 파파고와 구글을 동원했지만 오역이 있을 수 있습니다. 영어 원문도 같이 봐주시길 바랍니다. ☺️

@Test	Denotes that a method is a test method. Unlike JUnit 4’s @Test annotation, this annotation does not declare any attributes, since test extensions in JUnit Jupiter operate based on their own dedicated annotations. Such methods are inherited unless they are overridden.	- 해당 메소드가 테스트 메소드임을 나타냄. - JUnit 4와 달리 속성 선언 없음
@ParameterizedTest	Denotes that a method is a parameterized test. Such methods are inherited unless they are overridden.	- 메서드에 파라미터를 입력해 사용할 수 있음
@RepeatedTest	Denotes that a method is a test template for a repeated test. Such methods are inherited unless they are overridden.	- 반복 테스트를 할 수 있음
@TestFactory	Denotes that a method is a test factory for dynamic tests. Such methods are inherited unless they are overridden.	- 다이나믹 테스트를 하기 위한 테스트 팩토리임 (정확한 용도 검색 필요)
@TestTemplate	Denotes that a method is a template for test cases designed to be invoked multiple times depending on the number of invocation contexts returned by the registered providers. Such methods are inherited unless they are overridden.	- (정확한 용도 검색 필요)
@TestClassOrder	Used to configure the test class execution order for @Nested test classes in the annotated test class. Such annotations are inherited.	- 테스트 클래스 순서를 지정하는데 사용됨
@TestMethodOrder	Used to configure the test method execution order for the annotated test class; similar to JUnit 4’s @FixMethodOrder. Such annotations are inherited.	- 테스트 메서드 순서를 지정하는데 사용됨
@TestInstance	Used to configure the test instance lifecycle for the annotated test class. Such annotations are inherited.	- 테스트 객체 lifecycle을 지정하는데 사용됨
@DisplayName	Declares a custom display name for the test class or test method. Such annotations are not inherited.	- 테스트 클래스나 메서드의 이름을 부여함
@DisplayNameGeneration	Declares a custom display name generator for the test class. Such annotations are inherited.	- display name generator
@BeforeEach	Denotes that the annotated method should be executed before each @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory method in the current class; analogous to JUnit 4’s @Before. Such methods are inherited – unless they are overridden or superseded (i.e., replaced based on signature only, irrespective of Java’s visibility rules).	- 테스트가 실행되기 전에 실행되어야 하는 메소드
@AfterEach	Denotes that the annotated method should be executed after each @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory method in the current class; analogous to JUnit 4’s @After. Such methods are inherited – unless they are overridden or superseded (i.e., replaced based on signature only, irrespective of Java’s visibility rules).	- 테스트가 실행된 후에 실행되어야 하는 메소드
@BeforeAll	Denotes that the annotated method should be executed before all @Test, @RepeatedTest, @ParameterizedTest, and @TestFactory methods in the current class; analogous to JUnit 4’s @BeforeClass. Such methods are inherited – unless they are hidden, overridden, or superseded, (i.e., replaced based on signature only, irrespective of Java’s visibility rules) – and must be static unless the "per-class" test instance lifecycle is used.	- 해당 테스트 클래스를 초기화할 때 딱 한번 수행됨
@AfterAll	Denotes that the annotated method should be executed after all @Test, @RepeatedTest, @ParameterizedTest, and @TestFactory methods in the current class; analogous to JUnit 4’s @AfterClass. Such methods are inherited – unless they are hidden, overridden, or superseded, (i.e., replaced based on signature only, irrespective of Java’s visibility rules) – and must be static unless the "per-class" test instance lifecycle is used.	- 해당 테스트 클래스를 다 실행시키고 딱 한번 수행됨
@Nested	Denotes that the annotated class is a non-static nested test class. On Java 8 through Java 15, @BeforeAll and @AfterAll methods cannot be used directly in a @Nested test class unless the "per-class" test instance lifecycle is used. Beginning with Java 16, @BeforeAll and @AfterAll methods can be declared as static in a @Nested test class with either test instance lifecycle mode. Such annotations are not inherited.	- 테스트 그룹 간의 계층을 표현할 수 있다
@Tag	Used to declare tags for filtering tests, either at the class or method level; analogous to test groups in TestNG or Categories in JUnit 4. Such annotations are inherited at the class level but not at the method level.	- 테스트 클래스나 메서드에 사용해 테스트들을 필터링하는데 사용된다.
@Disabled	Used to disable a test class or test method; analogous to JUnit 4’s @Ignore. Such annotations are not inherited.	- 테스트를 비활성화한다.
@Timeout	Used to fail a test, test factory, test template, or lifecycle method if its execution exceeds a given duration. Such annotations are inherited.	- 지정된 시간을 초과하는 경우 테스트 실패로 설정한다
@ExtendWith	Used to register extensions declaratively. Such annotations are inherited.	- (정확한 용도 검색 필요)
@RegisterExtension	Used to register extensions programmatically via fields. Such fields are inherited unless they are shadowed.	- (정확한 용도 검색 필요)
@TempDir	Used to supply a temporary directory via field injection or parameter injection in a lifecycle method or test method; located in the org.junit.jupiter.api.io package.	- 임시 디렉토리를 제공하는데 사용된다.

 

@ParameterizedTest

• 여러 매개변수를 입력 받아 테스트를 할 수 있다(다건 시 매개변수 개수만큼 테스트 반복 됨)
• ValueSource 와 함께 사용되며, ValueSource 에 테스트에 사용할 매개변수를 입력하면 된다.

@ParameterizedTest
@ValueSource(strings = { "racecar", "radar", "able was I ere I saw elba" })
void palindromes(String candidate) {
    assertTrue(StringUtils.isPalindrome(candidate));
}

// 결과
palindromes(String) ✔
├─ [1] candidate=racecar ✔
├─ [2] candidate=radar ✔
└─ [3] candidate=able was I ere I saw elba ✔

 

@RepeatedTest

• 반복 횟수를 지정하고, 지정된 횟수만큼 테스트를 반복한다.

@RepeatedTest(10)
void repeatedTest() {
    // ...
}

• name 속성에 이와 같은 값들을 이용해 정보를 출력할 수 있다.
  • {displayName}: @RepeatedTest 메서드 의 표시 이름
  • {currentRepetition}: 현재 반복 횟수
  • {totalRepetitions}: 총 반복 횟수
• RepetitionInfo 로 현재 실행 중인 반복 테스트에 대한 정보를 얻을 수 있다.

@BeforeEach
void beforeEach(TestInfo testInfo, RepetitionInfo repetitionInfo) {
    int currentRepetition = repetitionInfo.getCurrentRepetition();
    int totalRepetitions = repetitionInfo.getTotalRepetitions();
    String methodName = testInfo.getTestMethod().get().getName();
    logger.info(String.format("About to execute repetition %d of %d for %s", //
        currentRepetition, totalRepetitions, methodName));
}

@RepeatedTest(10)
void repeatedTest() {
    // ...
}

@RepeatedTest(5)
void repeatedTestWithRepetitionInfo(RepetitionInfo repetitionInfo) {
    assertEquals(5, repetitionInfo.getTotalRepetitions());
}

@RepeatedTest(value = 1, name = "{displayName} {currentRepetition}/{totalRepetitions}")
@DisplayName("Repeat!")
void customDisplayName(TestInfo testInfo) {
    assertEquals("Repeat! 1/1", testInfo.getDisplayName());
}

@RepeatedTest(value = 1, name = RepeatedTest.LONG_DISPLAY_NAME)
// RepeatedTest.LONG_DISPLAY_NAME처럼 미리 정의 된 패턴이 존재한다.
@DisplayName("Details...")
void customDisplayNameWithLongPattern(TestInfo testInfo) {
    assertEquals("Details... :: repetition 1 of 1", testInfo.getDisplayName());
}

@RepeatedTest(value = 5, name = "Wiederholung {currentRepetition} von {totalRepetitions}")
void repeatedTestInGerman() {
    // ...
}

// 결과
├─ RepeatedTestsDemo ✔
│  ├─ repeatedTest() ✔
│  │  ├─ repetition 1 of 10 ✔
│  │  ├─ repetition 2 of 10 ✔
│  │  ├─ repetition 3 of 10 ✔
│  │  ├─ repetition 4 of 10 ✔
│  │  ├─ repetition 5 of 10 ✔
│  │  ├─ repetition 6 of 10 ✔
│  │  ├─ repetition 7 of 10 ✔
│  │  ├─ repetition 8 of 10 ✔
│  │  ├─ repetition 9 of 10 ✔
│  │  └─ repetition 10 of 10 ✔
│  ├─ repeatedTestWithRepetitionInfo(RepetitionInfo) ✔
│  │  ├─ repetition 1 of 5 ✔
│  │  ├─ repetition 2 of 5 ✔
│  │  ├─ repetition 3 of 5 ✔
│  │  ├─ repetition 4 of 5 ✔
│  │  └─ repetition 5 of 5 ✔
│  ├─ Repeat! ✔
│  │  └─ Repeat! 1/1 ✔
│  ├─ Details... ✔
│  │  └─ Details... :: repetition 1 of 1 ✔
│  └─ repeatedTestInGerman() ✔
│     ├─ Wiederholung 1 von 5 ✔
│     ├─ Wiederholung 2 von 5 ✔
│     ├─ Wiederholung 3 von 5 ✔
│     ├─ Wiederholung 4 von 5 ✔
│     └─ Wiederholung 5 von 5 ✔

 

@TestClassOrder

• 테스트 클래스는 일반적으로 실행 순서에 의존적이면 안되지만, 특정 테스트 클래스 실행 순서를 적용하는 것이 필요할 때도 있다. (클래스간 순서 지정)
• @TestClassOrder 안에 ClassOrderer구현체를 지정하면 된다.
  • https://junit.org/junit5/docs/current/api/org.junit.jupiter.api/org/junit/jupiter/api/ClassOrderer.html

ClassOrderer.ClassName	Class명 순으로 정렬
ClassOrderer.DisplayName	DisplayName 순으로 정렬
ClassOrderer.OrderAnnotation	@Order 순으로 정렬
ClassOrderer.Random	랜덤

@TestClassOrder(ClassOrderer.OrderAnnotation.class) // @Order 정렬
class OrderedNestedTestClassesDemo {

    @Nested
    @Order(1)
    class PrimaryTests {

        @Test
        void test1() {
        }
    }

    @Nested
    @Order(2)
    class SecondaryTests {

        @Test
        void test2() {
        }
    }
}

 

@TestMethodOrder

• 테스트 메서드는 일반적으로 실행 순서에 의존적이면 안되지만, 특정 테스트 메서드 실행 순서를 적용하는 것이 필요할 때도 있다. (메서드 순서 지정)
• @TestMethodOrder 안에 MethodOrderer 구현체를 지정하면 된다.
  • https://junit.org/junit5/docs/current/api/org.junit.jupiter.api/org/junit/jupiter/api/MethodOrderer.html

MethodOrderer.ClassName	Class명 순으로 정렬
MethodOrderer.DisplayName	DisplayName 순으로 정렬
MethodOrderer.OrderAnnotation	@Order 순으로 정렬
MethodOrderer.Random	랜덤

 

@TestMethodOrder(OrderAnnotation.class) // @Order 정렬
class OrderedTestsDemo {

    @Test
    @Order(1)
    void nullValues() {
        // perform assertions against null values
    }

    @Test
    @Order(2)
    void emptyValues() {
        // perform assertions against empty values
    }

    @Test
    @Order(3)
    void validValues() {
        // perform assertions against valid values
    }

}

 

@TestInstance

• 각 테스트 메서드를 독립적으로 실행하고, 테스트 인스턴스의 변경으로 인해 예기치 않는 부작용을 피하기 위해 JUnit은 각 테스트 메서드를 실행하기 전에 새롭게 인스턴스를 만든다.
• 동일한 테스트 인스턴스에서 모든 테스트 메서드가 실행되게 하려면 @TestInstance(Lifecycle.PER_CLASS) 어노테이션을 사용한다.
• 참고로 JUnit 테스트 인스턴스 생성과 관련한 기본 설정은 PER_METHOD 이다.
  • = 메서드마다 새롭게 생성

 

@DisplayName

• 테스트 실행기 및 IDE에 의해 표시되는 사용자 지정 표시 이름을 선언
  • 공백, 특수문자, 이모지도 사용할 수 있다.

@DisplayName("A special test case")
class DisplayNameDemo {

    @Test
    @DisplayName("Custom test name containing spaces")
    void testWithDisplayNameContainingSpaces() {
    }

    @Test
    @DisplayName("╯°□°）╯")
    void testWithDisplayNameContainingSpecialCharacters() {
    }

    @Test
    @DisplayName("😱")
    void testWithDisplayNameContainingEmoji() {
    }

}

 

@Nested

• 여러 테스트 그룹 간의 계층을 표현할 수 있다.

@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

 

@Tag

• 테스트 클래스 및 메서드에 사용해 테스트 검색 및 실행 을 필터링하는 데 사용할 수 있다.

@Tag("fast")
@Tag("model")
class TaggingDemo {

    @Test
    @Tag("taxes")
    void testingTaxCalculation() {
    }

}

• 필터링을 하는 방법은 차차 알아보자. 🧐

 

@Disabled

• 전체 테스트 클래스 또는 테스트 메서드, 조건부 실행 테스트를 비활성화 할 수 있다.

@Disabled("Disabled until bug #99 has been fixed")
class DisabledClassDemo {

    @Test
    void testWillBeSkipped() {
    }

}

class DisabledTestsDemo {

    @Disabled("Disabled until bug #42 has been resolved")
    @Test
    void testWillBeSkipped() {
    }

    @Test
    void testWillBeExecuted() {
    }

}

• @Disable(이유) : 이처럼 어노테이션안에 테스트가 비활성화 된 이유를 작성할 수도 있고, 생략할 수도 있는데 JUnit 팀은 비활성화 된 이유를 적는 것을 권장함.

 

@Timeout

• 지정된 시간을 초과하는 경우 테스트 실패로 설정

class TimeoutDemo {

    @BeforeEach
    @Timeout(5) // 기본 설정은 초단위이다. 
    void setUp() {
        // fails if execution time exceeds 5 seconds
    }

    @Test
    @Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
    void failsIfExecutionTimeExceeds500Milliseconds() {
        // fails if execution time exceeds 500 milliseconds
    }

    @Test
    @Timeout(value = 500, unit = TimeUnit.MILLISECONDS, threadMode = ThreadMode.SEPARATE_THREAD)
    void failsIfExecutionTimeExceeds500MillisecondsInSeparateThread() {
        // fails if execution time exceeds 500 milliseconds, the test code is executed in a separate thread
    }

}

 

@TempDir

• 실험적 기능
• 임시 디렉토리를 제공한다.

@Test
void writeItemsToFile(@TempDir Path tempDir) throws IOException {
    Path file = tempDir.resolve("test.txt");

    new ListWriter(file).write("a", "b", "c");

    assertEquals(singletonList("a,b,c"), Files.readAllLines(file));
}

// 여러개가 필요한 경우
@Test
void copyFileFromSourceToTarget(@TempDir Path source, @TempDir Path target) throws IOException {
    Path sourceFile = source.resolve("test.txt");
    new ListWriter(sourceFile).write("a", "b", "c");

    Path targetFile = Files.copy(sourceFile, target.resolve("test.txt"));

    assertNotEquals(sourceFile, targetFile);
    assertEquals(singletonList("a,b,c"), Files.readAllLines(targetFile));
}

// 디렉토리 삭제 여부(성공시에만 삭제)
@Test
void fileTest(@TempDir(cleanup = ON_SUCCESS) Path tempDir) {
    // perform test
}

• 테스트 완료 후 임시 디렉토리 삭제 여부를 지정할 수 있다.
  • The @TempDirannotation has an optional cleanup attribute that can be set to either NEVER, ON_SUCCESS, or ALWAYS

 

🙋‍♀️ 참고

• spring-boot-starter-test는 다음과 같은 라이브러리를 포함하고 있다
  • JUnit 5
  • Spring Test & Spring Boot Test
  • Assertj
  • Hamcrest
  • Mockito
  • JSONassert
  • JsonPath

 

👍 Reference

https://junit.org/junit5/docs/current/user-guide/