Kotlin에서 예상되는 예외 테스트

Java에서 프로그래머는 다음과 같이 JUnit 테스트 케이스에 대해 예상되는 예외를 지정할 수 있습니다.

@Test(expected = ArithmeticException.class)
public void omg()
{
    int blackHole = 1 / 0;
}

Kotlin에서 어떻게해야하나요? 두 가지 구문 변형을 시도했지만 모두 작동하지 않았습니다.

import org.junit.Test

// ...

@Test(expected = ArithmeticException) fun omg()
    Please specify constructor invocation;
    classifier 'ArithmeticException' does not have a companion object

@Test(expected = ArithmeticException.class) fun omg()
                            name expected ^
                                            ^ expected ')'

JUnit 4.12 용 Java 예제의 Kotlin 번역 은 다음과 같습니다.

@Test(expected = ArithmeticException::class)
fun omg() {
    val blackHole = 1 / 0
}

그러나 JUnit 4.13 은assertThrows 세분화 된 예외 범위를위한 두 가지 방법을 도입했습니다 .

@Test
fun omg() {
    // ...
    assertThrows(ArithmeticException::class.java) {
        val blackHole = 1 / 0
    }
    // ...
}

두 assertThrows메서드 모두 추가 어설 션에 대해 예상되는 예외를 반환합니다.

@Test
fun omg() {
    // ...
    val exception = assertThrows(ArithmeticException::class.java) {
        val blackHole = 1 / 0
    }
    assertEquals("/ by zero", exception.message)
    // ...
}

Kotlin에는 이러한 종류 의 단위 테스트 를 수행하는 데 도움이 될 수 있는 자체 테스트 도우미 패키지 가 있습니다.

테스트는 다음과 같이 사용하여 매우 표현력이 있습니다 assertFailWith.

@Test
fun test_arithmethic() {
    assertFailsWith<ArithmeticException> {
        omg()
    }
}

@Test(expected = ArithmeticException::class).NET과 같은 Kotlin의 라이브러리 메소드 중 하나를 사용 하거나 더 나은 방법을 사용할 수 있습니다 failsWith().

수정 된 제네릭과 다음과 같은 도우미 메서드를 사용하여 더 짧게 만들 수 있습니다.

inline fun <reified T : Throwable> failsWithX(noinline block: () -> Any) {
    kotlin.test.failsWith(javaClass<T>(), block)
}

그리고 주석을 사용한 예 :

@Test(expected = ArithmeticException::class)
fun omg() {

}

이를 위해 KotlinTest 를 사용할 수 있습니다 .

테스트에서 shouldThrow 블록으로 임의 코드를 래핑 할 수 있습니다.

shouldThrow<ArithmeticException> {
  // code in here that you expect to throw a ArithmeticException
}

JUnit5에는 kotlin 지원이 내장되어 있습니다.

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

class MyTests {
    @Test
    fun `division by zero -- should throw ArithmeticException`() {
        assertThrows<ArithmeticException> {  1 / 0 }
    }
}

kotlin.test 패키지와 함께 제네릭을 사용할 수도 있습니다.

import kotlin.test.assertFailsWith 

@Test
fun testFunction() {
    assertFailsWith<MyException> {
         // The code that will throw MyException
    }
}

예외 클래스와 오류 메시지가 일치하는지 확인하는 Assert 확장입니다.

inline fun <reified T : Exception> assertThrows(runnable: () -> Any?, message: String?) {
try {
    runnable.invoke()
} catch (e: Throwable) {
    if (e is T) {
        message?.let {
            Assert.assertEquals(it, "${e.message}")
        }
        return
    }
    Assert.fail("expected ${T::class.qualifiedName} but caught " +
            "${e::class.qualifiedName} instead")
}
Assert.fail("expected ${T::class.qualifiedName}")

}

예를 들면 :

assertThrows<IllegalStateException>({
        throw IllegalStateException("fake error message")
    }, "fake error message")

assertFailsWith ()가 값을 반환한다고 언급 한 사람은 아무도 없으며 예외 속성을 확인할 수 있습니다.

@Test
fun `my test`() {
        val exception = assertFailsWith<MyException> {method()}
        assertThat(exception.message, equalTo("oops!"))
    }
}

다른 버전의 구문은 kluent를 사용 합니다 .

@Test
fun `should throw ArithmeticException`() {
    invoking {
        val backHole = 1 / 0
    } `should throw` ArithmeticException::class
}

올바른 단계는 (expected = YourException::class)테스트 주석 을 추가하는 것 입니다.

@Test(expected = YourException::class)

두 번째 단계는이 기능을 추가하는 것입니다.

private fun throwException(): Boolean = throw YourException()

마지막으로 다음과 같은 내용이 표시됩니다.

@Test(expected = ArithmeticException::class)
fun `get query error from assets`() {
    //Given
    val error = "ArithmeticException"

    //When
    throwException()
    val result =  omg()

    //Then
    Assert.assertEquals(result, error)
}
private fun throwException(): Boolean = throw ArithmeticException()

org.junit.jupiter.api.Assertions.kt

/**
 * Example usage:
 * ```kotlin
 * val exception = assertThrows<IllegalArgumentException>("Should throw an Exception") {
 *     throw IllegalArgumentException("Talk to a duck")
 * }
 * assertEquals("Talk to a duck", exception.message)
 * ```
 * @see Assertions.assertThrows
 */
inline fun <reified T : Throwable> assertThrows(message: String, noinline executable: () -> Unit): T =
        assertThrows({ message }, executable)