๊ฐ์ธ ํ๋ก์ ํธ๋ฅผ ์งํํ๋ฉด์ JUnit5๋ฅผ ํ์ฉํ ๋จ์ํ ์คํธ๋ฅผ ๊ณต๋ถํด๋ณด๊ณ ์๋๋ฐ ์ฌ๋ฌ๊ฐ์ง ๊ธฐ๋ฅ๋ค์ ์ ๋ฆฌํด ๋์ผ๋ ค๊ณ ํฉ๋๋ค.
์๋ฐ ๊ฐ๋ฐ์๊ฐ ์ฌ์ฉํ๋ ํ ์คํ ๊ธฐ๋ฐ ํ๋ ์ ์ํฌ๋ฅผ ์๋ฏธํฉ๋๋ค. JUnit 5๋ ์๋ฐ 8 ์ด์๋ถํฐ ์ฌ์ฉ ๊ฐ๋ฅํฉ๋๋ค. JUnit5์ ์ด๋ ธํ ์ด์ ๋ค์ค ์ผ๋ถ๋ฅผ ํ๋์ฉ ์ดํด๋ณด๋ ค ํฉ๋๋ค.
@Test ์ด๋ ธํ ์ด์ ์ ์ถ๊ฐํจ์ผ๋ก์จ ํ ์คํธ ๋ฉ์๋์์ ์ ์ธํ ์ ์์ต๋๋ค.
@BeforeAll์ ํตํด ๋ชจ๋ ํ ์คํธ ์ฝ๋๊ฐ ์คํ๋๊ธฐ ์ ์ต์ด๋ก ์ํํ ์ฝ๋๋ฅผ ์ ์ํ ์ ์๊ณ , @AfterAll์ ํตํด ๋ชจ๋ ํ ์คํธ ์ฝ๋๊ฐ ์ข ๋ฃ๋ ์ดํ ์คํํ ์ฝ๋๋ฅผ ์ ์ํ ์ ์์ต๋๋ค.
@BeforeAll
static void beforeAll() {
System.out.println("๋ชจ๋ ํ
์คํธ ์ฝ๋๊ฐ ์คํ๋๊ธฐ ์ ์ ์ต์ด๋ก ์ํ");
}
@AfterAll
static void afterAll() {
System.out.println("๋ชจ๋ ํ
์คํธ ์ฝ๋๊ฐ ์คํ๋ ํ ๋ง์ง๋ง์ผ๋ก ์ํ");
}
@BeforeEach๋ฅผ ํตํด ๊ฐ๊ฐ์ ํ ์คํธ ์ฝ๋๊ฐ ์คํ๋๊ธฐ ์ด์ ์ ์ํ์ํฌ ์ฝ๋๋ฅผ ์ ์ํ ์ ์๊ณ , @AfterEach๋ฅผ ํตํด ๊ฐ๊ฐ์ ํ ์คํธ ์ฝ๋๊ฐ ์คํ๋ ์ดํ ์ํ์ํฌ ์ฝ๋๋ฅผ ์ ์ํ ์ ์์ต๋๋ค.
@BeforeEach
void setUp() {
System.out.println("๊ฐ๊ฐ์ ํ
์คํธ ์ฝ๋๊ฐ ์คํ๋๊ธฐ ์ ์ ์ํ");
}
@AfterEach
void tearDown() {
System.out.println("๊ฐ๊ฐ์ ํ
์คํธ ์ฝ๋๊ฐ ์คํ๋ ํ์ ์ํ");
}
@DisplayName ์ด๋ ธํ ์ด์ ์ ํตํด ํ ์คํธ ์คํ์ ํ ์คํธ ๋ฉ์๋์ ์ด๋ฆ์ด ์๋ ์ง์ ํ ๊ฐ์ ๊ฒฐ๊ณผ๋ก ๋ณด์ฌ์ค ์ ์์ต๋๋ค.
์ด๋ ๊ฒ ์์ ๋กญ๊ฒ ํ ์คํธ์ ์ด๋ฆ์ ์ง์ ํด ์ค์ผ๋ก์จ ํ ์คํธ ๋ฉ์๋์ ์ด๋ฆ์ ํฌ๊ฒ๊ณ ๋ฏผํ์ง ์๊ณ ์ง์ ์ ์์ต๋๋ค.
@Test
@DisplayName("์ด ํ
์คํธ์ ๋ํ ์ค๋ช
์
๋๋ค.")
void test1() {
System.out.println("ํ
์คํธ 1");
}
@Disabled ์ด๋ ธํ ์ด์ ์ ํตํด ์คํํ๊ณ ์ถ์ง ์์ ํ ์คํธ๋ฅผ ๋ง์๋์ ์ ์์ต๋๋ค.
@Test
@Disabled
void ํ
์คํธ_1() {
}
@Test
void ํ
์คํธ_2() {
}
@Nested ์ด๋ ธํ ์ด์ ์ ํตํด์๋ ์ํ๋ ์ฃผ์ ๋ณ๋ก ํ ์คํธ๋ฅผ ๋ฌถ์ด์ ์ถ๋ ฅ์ด ๊ฐ๋ฅํฉ๋๋ค.
@Nested
@DisplayName("Test 1 ์ฒซ๋ฒ์งธ ์ฃผ์ ")
class Test1 {
@Test
@DisplayName("Test1 - test1()")
void test1() {
System.out.println("Test1.test1");
}
@Test
@DisplayName("Test1 - test2()")
void test2() {
System.out.println("Test1.test2");
}
}
@Nested
@DisplayName("Test2 ๋ค๋ฅธ ์ฃผ์ ")
class Test2 {
@Test
@DisplayName("Test2 - test1()")
void test1() {
System.out.println("Test2.test1");
}
@Test
@DisplayName("Test2 - test2()")
void test2() {
System.out.println("Test2.test2");
}
}
@TestMethodOrder ์ด๋ ธํ ์ด์ ์ ํตํด ๋ฉ์๋์ ์คํ ์์ ์ค์ ์ด ๊ฐ๋ฅํฉ๋๋ค. ์ดํ @Order ์ด๋ ธํ ์ด์ ์ ๋ฒํธ๋ฅผ ๋ถ์ฌํ์ฌ ์คํ ์์๋ฅผ ๊ฒฐ์ ํ ์ ์์ต๋๋ค.
@Nested
@DisplayName("ํ
์คํธ ์์ ์ ํด์ ์คํํ๊ธฐ")
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class Test0 {
@Order(1)
@Test
@DisplayName("Test 1 - ์ฒซ๋ฒ์งธ")
void test1() {
System.out.println("1");
}
@Order(3)
@Test
@DisplayName("Test2 - ์ธ๋ฒ์งธ")
void test2() {
System.out.println("3");
}
@Order(2)
@Test
@DisplayName("Test3 - ๋๋ฒ์งธ")
void test3() {
System.out.println("2");
}
}
@RepeatedTest๋ฅผ ์ฌ์ฉํ๋ฉด ํ ์คํธ๋ฅผ ๋ฐ๋ณต๋ฌธ์ฒ๋ผ ์ฌ๋ฌ๋ฒ ์คํ ๊ฐ๋ฅํฉ๋๋ค.
value ๊ฐ์ผ๋ก ๋ช๋ฒ ๋ฐ๋ณตํ ๊ฒ์ธ์ง ์ ํ ์ ์๊ณ , name ๋ถ๋ถ์ {currentRepetition} ๋ฅผ ํตํด ๋ช๋ฒ์งธ ๋ฐ๋ณต์ค์ธ์ง, {totalRepetitions} ๋ฅผ ํตํด ์ด ๋ช๋ฒ ๋ฐ๋ณต์ ์ํํ ๊ฒ์ธ์ง ํ ์คํธ ๋ง๋ค ์ด๋ฆ์ ์ ์ํด ์ค ์ ์์ต๋๋ค. ๋ํ RepetitionInfo ๋ฅผ ์ฃผ์ ๋ฐ์ ํ์ฌ ๋ช๋ฒ์งธ ํ ์คํธ ์ํ์ค์ธ์ง, ์ด ๋ช๋ฒ ํ ์คํธ๋ฅผ ์ํํ ๊ฒ์ธ์ง์ ๋ํ ์ ๋ณด๋ ๋ฐ์์ฌ ์ ์์ต๋๋ค.
@RepeatedTest(value = 5, name = "๋ฐ๋ณต ํ
์คํธ {currentRepetition} / {totalRepetitions}")
void repeatTest(RepetitionInfo info) {
System.out.println("ํ
์คํธ ๋ฐ๋ณต : " + info.getCurrentRepetition() + " / " + info.getTotalRepetitions());
}
@ParameterizedTest๋ฅผ ํตํด ๋งค๊ฐ๋ณ์๋ฅผ ๋ฐ๋ ํ
์คํธ๋ฅผ ์์ฑ ํ ์ ์์ต๋๋ค. @ValueSource๋ก ํ๋ผ๋ฏธํฐ๋ฅผ ์ ๋ฌ ๊ฐ๋ฅํ๊ณ , ์ ๋ฌ๋๋ ํ๋ผ๋ฏธํฐ์ ๊ฐ์๋งํผ ํ
์คํธ๊ฐ ๋ฐ๋ณต๋์ด ์คํ๋ฉ๋๋ค.
(์๋์ ๊ฒฝ์ฐ ํ๋ผ๋ฏธํฐ ๋ณ๋ก ํ๋ฒ์ฉ ์ด 9 ๋ฒ ํ
์คํธ ๋ฐ๋ณต ์คํ)
@DisplayName("ํ๋ผ๋ฏธํฐ ๊ฐ ํ์ฉํ์ฌ ํ
์คํธ ํ๊ธฐ")
@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5, 6, 7, 8, 9}) // ํ๋ผ๋ฏธํฐ ์๋งํผ ๋ฐ๋ณต
void parameterTest(int num) {
System.out.println("5 * num = " + 5 * num);
}
์ด์ ์๋ ์ฃผ๋ก assertj ์ Assertions ์์ assertThat() ๋ฉ์๋๋ฅผ ์ฃผ๋ก ์ฌ์ฉํ์์ง๋ง, ์ค๋์ jupiter์ Assertions ๋ฉ์๋๋ฅผ ์ ๋ฆฌ ํด ๋ณด๋ ค ํฉ๋๋ค.
๋ฉ์๋์ ์ฒซ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก ์์ํ๋ ๊ฐ, ๊ทธ๋ฆฌ๊ณ ๋๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก ์ค์ ๋ก ๋์จ ๊ฐ์ ๋ฃ์ด ์์๊ณผ ์ค์ ๊ฐ ๋ง๋์ง ํ๋จํด์ฃผ๋ ๋ฉ์๋ ์ ๋๋ค. ์์ธก๊ณผ ์ค์ ๊ฐ์ด ๋ค๋ฅผ๊ฒฝ์ฐ ์ค์ ์ ์ด๋ป๊ฒ ๋ค๋ฅธ์ง ๊ฐ์ ๋น๊ตํ์ฌ ์ถ๋ ฅํด ์ค๋๋ค.
@Test
@DisplayName("assertEquals")
void test1() {
Double result = 4.0/2;
assertEquals(2.5, result);
}
์ด๋ ๊ฒ ํ ์คํธ ์คํจ ์ ์ํ๋ ๋ฌธ๊ตฌ๋ฅผ ์ง์ ํ์ฌ ์ถ๋ ฅํด ์ค ์๋ ์์ต๋๋ค.
@Test
@DisplayName("assertEquals - Supplier")
void test1_1() {
Double result = calculator.operate(5, "/", 0);
// ํ
์คํธ ์คํจ ์ ๋ฉ์์ง ์ถ๋ ฅ (new Supplier<String>())
assertEquals(2.5, result, () -> "์ฐ์ฐ์ ํน์ ๋ถ๋ชจ๊ฐ 0์ด ์๋์ง ํ์ธํด๋ณด์ธ์!");
}
assertTrue, assertFalse๋ฅผ ํตํด ์ฐธ ๊ฑฐ์ง์ฌ๋ถ๋ฅผ ํ๋จํ ์๋ ์์ต๋๋ค.
@Test
@DisplayName("assertTrue ์ assertFalse")
void test2() {
assertTrue(true); // ๋งค๊ฐ๋ณ์ ์ ๋ฌ ๊ฐ์ด true์ผ ๊ฒฝ์ฐ ํ
์คํธ ํต๊ณผ
assertFalse(false); // ๋งค๊ฐ๋ณ์ ์ ๋ฌ ๊ฐ์ด false์ผ ๊ฒฝ์ฐ ํ
์คํธ ํต๊ณผ
}
assertNull์ ํตํด ์ ๋ฌ๋ฐ์ ๋งค๊ฐ๋ณ์๊ฐ Null์ธ์ง ์๋์ง์ ๋ํ ์ฌ๋ถ๋ ํ๋จ ๊ฐ๋ฅํฉ๋๋ค.
@Test
@DisplayName("assertNotNull ๊ณผ assertNull")
void test3() {
Double result1 = calculator.operate(5, "/", 2);
assertNotNull(result1);
Double result2 = calculator.operate(5, "/", 0);
assertNull(result2);
}
assertThrows๋ฅผ ํตํด ์์ธ๊ฐ ๋ฐ์ํ๋์ง ์ฌ๋ถ๋ฅผ ํ ์คํธ ํ ์ ์์ต๋๋ค. ์ฒซ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก๋ ๋ฐ์ํ ๊ฒ์ผ๋ก ์์๋๋ Exception์ ํ์ ์ ๋ฃ์ด์ฃผ๊ณ , ๋๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก๋ ์์ธ๊ฐ ๋ฐ์ํ ์ํฉ์ ๋ฃ์ด์ ํ ์คํธ ํฉ๋๋ค.
@Test
@DisplayName("assertThrows")
void test4() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
throw new IllegalArgumentException("IllegalArgumentException ๋ฐ์");
});
assertEquals("IllegalArgumentException ๋ฐ์", exception.getMessage());
}
์ด ์ธ์๋ ๋ ๋ค์ํ ์ด๋ ธํ ์ด์ ๊ณผ ๊ธฐ๋ฅ๋ค์ด ์๋๋ฐ์, ์ถ๊ฐ์ ์ผ๋ก ์์๋ณด๊ณ ์ถ์ผ์๋ค๋ฉด ์๋ ์ฐธ๊ณ ๋งํฌ๋ฅผ ํตํด ๋ ๋ค์ํ JUnit5 ๊ธฐ๋ฅ๋ค์ ์ดํด๋ณผ ์ ์์ต๋๋ค.