0


[Android]单元测试和模块测试

在 Kotlin 开发中,单元测试和模块测试(有时也称为组件测试或服务测试)是两种关键的测试方法,它们帮助开发者确保代码的各个部分独立和整体上都按预期工作。

1.单元测试

单元测试是测试软件应用中最小单元(通常是方法或函数)的过程。它的目标是验证这些单元在隔离的环境中的行为是否符合预期。

优点

  • 快速执行。
  • 帮助开发者识别和修复问题的精确位置。
  • 通过测试用例作为文档,可以增加代码的可读性和可维护性。

常用工具

  • JUnit: Java和Kotlin中最流行的测试框架。
  • MockK: 为Kotlin特别设计的模拟库,支持协程和扩展函数的模拟。
  • Spek: 使用Kotlin DSL的基于规格的测试框架。

示例 1: 简单的单元测试

假设我们有一个简单的

Calculator

类:

class Calculator {
    fun add(a: Int, b: Int): Int = a + b
    fun multiply(a: Int, b: Int): Int = a * b
}

为这个类编写单元测试:

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals

class CalculatorTest {
    private val calculator = Calculator()

    @Test
    fun `add should correctly add two numbers`() {
        assertEquals(5, calculator.add(2, 3), "Adding 2 and 3 should equal 5")
    }

    @Test
    fun `multiply should correctly multiply two numbers`() {
        assertEquals(6, calculator.multiply(2, 3), "Multiplying 2 by 3 should equal 6")
    }
}

示例 2: 使用 MockK 模拟依赖

假设我们有一个依赖外部服务的

UserService

类:

class UserService(private val userApi: UserApi) {
    fun getUserEmail(userId: Int): String? {
        val user = userApi.fetchUserById(userId)
        return user?.email
    }
}

data class User(val id: Int, val name: String, val email: String)
interface UserApi {
    fun fetchUserById(userId: Int): User?
}

UserService

编写单元测试,使用 MockK 模拟外部 API:

import io.mockk.every
import io.mockk.mockk
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals

class UserServiceTest {
    private val userApi = mockk<UserApi>()
    private val userService = UserService(userApi)

    @Test
    fun `getUserEmail returns correct email`() {
        val user = User(1, "John Doe", "[email protected]")
        every { userApi.fetchUserById(1) } returns user

        val email = userService.getUserEmail(1)

        assertEquals("[email protected]", email)
    }

    @Test
    fun `getUserEmail returns null if user not found`() {
        every { userApi.fetchUserById(any()) } returns null

        val email = userService.getUserEmail(99)

        assertEquals(null, email)
    }
}

2.模块测试

模块测试或组件测试通常涉及一个模块或多个紧密相关的模块(如一个类及其依赖)。这种测试可能涉及数据库、文件系统、网络或其他外部依赖的模拟。

优点

  • 验证模块间的集成是否正确。
  • 检查模块与外部系统的交互。
  • 找到可能在单元测试中被忽略的问题。

常用工具

  • JUnitTestNG: 用于编写和执行测试。
  • MockK: 模拟外部依赖。
  • Testcontainers: 提供真实的外部服务测试环境,如使用Docker容器的数据库。

示例: 模块测试

假设我们有一个

OrderService

类,它依赖于

OrderRepository

PaymentService

class OrderService(private val orderRepository: OrderRepository, private val paymentService: PaymentService) {
    fun processOrder(orderId: Int, paymentDetails: PaymentDetails): Boolean {
        val order = orderRepository.findById(orderId) ?: return false
        return paymentService.processPayment(order, paymentDetails)
    }
}

interface OrderRepository {
    fun findById(orderId: Int): Order?
}

interface PaymentService {
    fun processPayment(order: Order, paymentDetails: PaymentDetails): Boolean
}

data class Order(val id: Int, val amount: Double)
data class PaymentDetails(val method: String, val amount: Double)

OrderService

编写模块测试:

import io.mockk.every
import io.mockk.mockk
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Assertions.assertFalse

class OrderServiceTest {
    private val orderRepository = mockk<OrderRepository>()
    private val paymentService = mockk<PaymentService>()
    private val orderService = OrderService(orderRepository, paymentService)

    @Test
    fun `processOrder returns true when payment is successful`() {
        val order = Order(1, 100.0)
        val paymentDetails = PaymentDetails("credit",100.0)
        every { orderRepository.findById(1) } returns order
        every { paymentService.processPayment(order, paymentDetails) } returns true

        val result = orderService.processOrder(1, paymentDetails)

        assertTrue(result, "Order processing should succeed when payment is successful")
    }

    @Test
    fun `processOrder returns false when order not found`() {
        every { orderRepository.findById(any()) } returns null

        val result = orderService.processOrder(99, PaymentDetails("credit", 50.0))

        assertFalse(result, "Order processing should fail when order is not found")
    }

    @Test
    fun `processOrder returns false when payment fails`() {
        val order = Order(1, 100.0)
        val paymentDetails = PaymentDetails("debit", 100.0)
        every { orderRepository.findById(1) } returns order
        every { paymentService.processPayment(order, paymentDetails) } returns false

        val result = orderService.processOrder(1, paymentDetails)

        assertFalse(result, "Order processing should fail when payment fails")
    }
}

3.断言方法

在 Kotlin 开发中,单元测试和模块测试通常使用测试框架,如 JUnit,Kotlin Test,或 Spek 等。这些框架提供了一系列的断言方法,这些方法是用来验证代码的行为是否符合预期的关键组件。我将重点介绍 JUnit 和 Kotlin Test 中常用的断言方法。

(1).JUnit 断言方法

JUnit 是 Java 和 Kotlin 中最常用的测试框架之一。JUnit 5 提供了一个

Assertions

类,其中包含多种静态方法用于断言测试结果。

基本断言
  • assertEquals(expected, actual, message): 验证两个值是否相等。
  • assertNotEquals(unexpected, actual, message): 验证两个值是否不等。
  • assertTrue(condition, message): 验证条件是否为真。
  • assertFalse(condition, message): 验证条件是否为假。
  • assertNull(value, message): 验证对象是否为 null
  • assertNotNull(value, message): 验证对象是否非 null
对象和类断言
  • assertSame(expected, actual, message): 验证两个引用是否指向同一个对象。
  • assertNotSame(unexpected, actual, message): 验证两个引用是否不指向同一个对象。
数组和集合断言
  • assertArrayEquals(expected, actual, message): 验证两个数组是否相等。
异常断言
  • assertThrows(exceptionType, executable, message): 验证预期的异常是否被抛出。
组合断言
  • assertAll(executables): 同时执行多个断言,只有当所有断言都通过时,测试才会通过。
示例
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test

class AssertionsExample {
    @Test
    fun testAssertions() {
        assertEquals(4, 2 + 2, "Addition should work")
        assertTrue(5 > 2, "5 is greater than 2")
        assertAll("multiple",
            { assertNotNull("Hello", "Should not be null") },
            { assertThrows(ArithmeticException::class.java, { val result = 2 / 0 }, "Should throw ArithmeticException") }
        )
    }
}

(2).Kotlin Test 断言方法

Kotlin Test 是另一种专为 Kotlin 设计的测试库,它提供了一些额外的断言功能。

基本断言
  • shouldBe: 用于任何类型,比较是否相等。
  • shouldNotBe: 用于任何类型,比较是否不等。
  • shouldBeNull: 检查对象是否为 null
  • shouldNotBeNull: 检查对象是否非 null
  • shouldThrow: 检查是否抛出异常。
集合断言
  • shouldContain: 检查集合是否包含元素。
  • shouldNotContain: 检查集合是否不包含元素。
字符串断言
  • shouldStartWith: 检查字符串是否以特定前缀开始。
  • shouldEndWith: 检查字符串是否以特定后缀结束。
示例
import io.kotest.matchers.shouldBe
import io.kotest.matchers.nulls.shouldBeNull
import io.kotest.matchers.string.startWith
import io.kotest.core.spec.style.StringSpec

class KotlinTestExample : StringSpec({
    "addition works" {
        (2 + 2) shouldBe 4
    }
    "null checks" {
        val str: String? = null
        str.shouldBeNull()
    }
    "string should start with" {
        "hello world".shouldStartWith("hello")
    }
})

本文转载自: https://blog.csdn.net/u012881779/article/details/138544904
版权归原作者 风浅月明 所有, 如有侵权,请联系我们删除。

“[Android]单元测试和模块测试”的评论:

还没有评论