Kiểm tra các ngoại lệ dự kiến ​​trong Kotlin

Trong Java, lập trình viên có thể chỉ định các ngoại lệ dự kiến ​​cho các trường hợp thử nghiệm JUnit như sau:

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

Tôi sẽ làm điều này như thế nào trong Kotlin? Tôi đã thử hai biến thể cú pháp, nhưng không có biến thể nào trong số chúng hoạt động:

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 ')'

Bản dịch Kotlin của ví dụ Java cho JUnit 4.12 là:

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

Tuy nhiên, JUnit 4.13 đã giới thiệu hai assertThrowsphương pháp cho các phạm vi ngoại lệ chi tiết hơn:

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

Cả hai assertThrowsphương pháp đều trả về ngoại lệ mong đợi cho các xác nhận bổ sung:

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

Kotlin có gói trình trợ giúp kiểm tra của riêng mình có thể giúp thực hiện loại thú vị nhất này.

Bài kiểm tra của bạn có thể rất biểu cảm bằng cách sử dụng assertFailWith:

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

Bạn có thể sử dụng @Test(expected = ArithmeticException::class)hoặc thậm chí tốt hơn một trong các phương pháp thư viện của Kotlin như failsWith().

Bạn có thể làm cho nó ngắn hơn nữa bằng cách sử dụng các generic đã được sửa đổi và một phương pháp trợ giúp như sau:

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

Và ví dụ bằng cách sử dụng chú thích:

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

}

Bạn có thể sử dụng KotlinTest cho việc này.

Trong thử nghiệm của mình, bạn có thể bọc mã trọng tài bằng khối shouldThrow:

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

JUnit5 có hỗ trợ kotlin được tích hợp sẵn.

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 }
    }
}

Bạn cũng có thể sử dụng generic với gói kotlin.test:

import kotlin.test.assertFailsWith 

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

Phần mở rộng xác nhận xác minh lớp ngoại lệ và cả khi thông báo lỗi khớp.

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}")

}

ví dụ:

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

Không ai đề cập rằng khẳng định FailsWith () trả về giá trị và bạn có thể kiểm tra các thuộc tính ngoại lệ:

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

Một phiên bản khác của cú pháp sử dụng kluent :

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

Bước Firt là thêm (expected = YourException::class)vào chú thích thử nghiệm

@Test(expected = YourException::class)

Bước thứ hai là thêm chức năng này

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

Cuối cùng bạn sẽ có một cái gì đó như thế này:

@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)