面试题：Kotlin与MockK框架的复杂场景测试

Question

假设有一个Kotlin的电商应用，存在订单服务（OrderService），该服务依赖于用户服务（UserService）和支付服务（PaymentService）。OrderService有一个方法`placeOrder`用于创建订单，会调用UserService的`checkUser`方法校验用户信息，调用PaymentService的`processPayment`方法处理支付。请使用MockK框架编写集成测试，确保`placeOrder`方法在不同的用户和支付结果场景下能正确执行，并对异常情况进行处理，同时要验证相关依赖方法的调用。

Answer 1

import io.mockk.*
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

class OrderServiceIntegrationTest {

    @Test
    fun `test placeOrder with valid user and payment`() {
        // 模拟依赖
        val userService = mockk<UserService>()
        val paymentService = mockk<PaymentService>()
        val orderService = OrderService(userService, paymentService)

        // 模拟方法调用结果
        every { userService.checkUser() } returns true
        every { paymentService.processPayment() } returns true

        // 执行方法
        val result = orderService.placeOrder()

        // 验证结果
        assertEquals(true, result)
        // 验证依赖方法调用
        verify { userService.checkUser() }
        verify { paymentService.processPayment() }
    }

    @Test
    fun `test placeOrder with invalid user`() {
        val userService = mockk<UserService>()
        val paymentService = mockk<PaymentService>()
        val orderService = OrderService(userService, paymentService)

        every { userService.checkUser() } returns false

        val result = orderService.placeOrder()

        assertEquals(false, result)
        verify { userService.checkUser() }
        // 因为用户校验失败，不应调用支付服务
        verify(exactly = 0) { paymentService.processPayment() }
    }

    @Test
    fun `test placeOrder with valid user but payment failure`() {
        val userService = mockk<UserService>()
        val paymentService = mockk<PaymentService>()
        val orderService = OrderService(userService, paymentService)

        every { userService.checkUser() } returns true
        every { paymentService.processPayment() } returns false

        val result = orderService.placeOrder()

        assertEquals(false, result)
        verify { userService.checkUser() }
        verify { paymentService.processPayment() }
    }

    @Test
    fun `test placeOrder with user service exception`() {
        val userService = mockk<UserService>()
        val paymentService = mockk<PaymentService>()
        val orderService = OrderService(userService, paymentService)

        every { userService.checkUser() } throws RuntimeException("User service error")

        try {
            orderService.placeOrder()
        } catch (e: RuntimeException) {
            assertEquals("User service error", e.message)
        }
        verify { userService.checkUser() }
        // 因为用户服务异常，不应调用支付服务
        verify(exactly = 0) { paymentService.processPayment() }
    }

    @Test
    fun `test placeOrder with payment service exception`() {
        val userService = mockk<UserService>()
        val paymentService = mockk<PaymentService>()
        val orderService = OrderService(userService, paymentService)

        every { userService.checkUser() } returns true
        every { paymentService.processPayment() } throws RuntimeException("Payment service error")

        try {
            orderService.placeOrder()
        } catch (e: RuntimeException) {
            assertEquals("Payment service error", e.message)
        }
        verify { userService.checkUser() }
        verify { paymentService.processPayment() }
    }
}

class OrderService(private val userService: UserService, private val paymentService: PaymentService) {
    fun placeOrder(): Boolean {
        try {
            if (!userService.checkUser()) {
                return false
            }
            return paymentService.processPayment()
        } catch (e: Exception) {
            // 处理异常
            return false
        }
    }
}

interface UserService {
    fun checkUser(): Boolean
}

interface PaymentService {
    fun processPayment(): Boolean
}