MockK 没有找到答案：

Question

我正在尝试使用 JUnit 和 MockK 库在我的服务实现中测试一个方法。

PlanServiceFeatureImplTest.kt

@Test
  fun `storeInstallmentPlan`(@MockK user: User) {
    val debtId = 123L
    val amount = BigDecimal.valueOf(1000)
    val interval = Repeat.monthly

    val firstPaymentDate = LocalDate.of(
      2021, 11, 4
    ).atStartOfDay(Time.DEFAULT_TIME_ZONE).toOffsetDateTime()

    val planDTO = InstallmentPlanDTO(
      interval = interval,
      firstPaymentDate = firstPaymentDate,
      amount = amount,
      installments = listOf()
    )
    val debt = Debt(
      userId = 32L,
      title = "debt1",
      amount = amount,
      category = DebtCategory.credit
    )
    val plan = InstallmentPlan(
      id = 122L,
      debtId = debtId,
      interval = interval,
      firstPaymentDate = firstPaymentDate,
      amount = amount
    )
    val installment1 = Installment(
      id = 34,
      debtId = debtId,
      recordId = 13
    )
    val installment2 = Installment(
      id = 35,
      debtId = debtId,
      recordId = 14
    )


    val newStartDate = ZonedDateTime.parse("2021-10-05T00:00+02:00[Europe/Berlin]")
    val newEndDate = ZonedDateTime.parse("2021-11-04T00:00+01:00[Europe/Berlin]")
    val installments = listOf(
      WalletRecord(
        userId = debt.userId,
        type = RecordType.debt_rate,
        amount = plan.amount,
        title = debt.title,
        category = RecordCategory.debt_rate,
        repeat = plan.interval,
        startDate = newStartDate.toOffsetDateTime(),
        endDate = newEndDate.toOffsetDateTime(),
      )
    )

    val records = flowOf(
      WalletRecord(
        id = 43,
        userId = debt.userId,
        type = RecordType.debt_rate,
        amount = plan.amount,
        title = debt.title,
        category = RecordCategory.debt_rate,
        repeat = plan.interval,
        startDate = newStartDate.toOffsetDateTime(),
        endDate = newEndDate.toOffsetDateTime(),
      )
    )


    every { user.tz } returns "Europe/Berlin"
    coEvery { debtRepository.findById(debtId) } returns debt
    coEvery { installmentPlanRepository.findByDebtId(debtId) } returns plan
    coEvery {
      installmentPlanRepository.save(
        planDTO.copy(
          amount = amount
        ).toEntity(
          id = plan.id,
          debtId = debtId
        )
      )
    } returns InstallmentPlan(plan.id, debtId, interval, firstPaymentDate, amount )
    coEvery { installmentRepository.findByDebtId(debtId) } returns flowOf(installment1, installment2)
    coEvery {
      installmentRepository.deleteAllById(listOf(installment1.id!!, installment2.id!!).asIterable())
    } just Runs
    coEvery { recordService.deleteAll(listOf(installment1.recordId, installment2.recordId)) } just Runs
    coEvery { userService.findById(debt.userId) } returns user
    coEvery { recordService.saveAll(installments) } returns records
    coEvery {
      installmentRepository.saveAll(
        records.map {
          Installment(
            debtId = debtId,
            recordId = it.id!!
          )
        }
      ).map { it.recordId }
    } returns flowOf(43)

    runBlocking { planService.storeInstallmentPlan(debtId, planDTO) }
  }

PlanServiceFeatureImpl.kt

@Transactional
  override suspend fun storeInstallmentPlan(debtId: Long, installmentPlanDTO: InstallmentPlanDTO): Flow<Long> {
    val debt = debtRepository.findById(debtId) ?: throw NotFoundException("Could not find debt with id $debtId")
    val installmentPlanId = installmentPlanRepository.findByDebtId(debtId)?.id

    val minimumAmount =
      BigDecimal.ONE.max(debt.amount.multiply(MINIMUM_INSTALLMENT_PERCENTAGE_OF_TOTAL_AMOUNT, MathContext.DECIMAL32))
        .setScale(2, RoundingMode.HALF_UP)
        .stripTrailingZeros()
    val maximumAmount = debt.amount
    val clampedAmount = maximumAmount.min(minimumAmount.max(installmentPlanDTO.amount))

    val installmentPlan = installmentPlanDTO.copy(
      amount = clampedAmount,
    ).toEntity(
      id = installmentPlanId,
      debtId = debtId,
    )

    installmentPlanRepository.save(installmentPlan)
    // delete existing records associated with the installment plan
    val existingInstallments = installmentRepository.findByDebtId(debtId).toList()
    installmentRepository.deleteAllById(existingInstallments.map { it.id!! })
    recordService.deleteAll(existingInstallments.map { it.recordId })

    // calculate installments / records
    /*
         This calculation follows this invariant:
          debt.amount = countOfFullInstallments * amount + lastInstallment
       */
    val user = userService.findById(debt.userId)
      ?: throw NotFoundException("Could not find user that owns debt $debtId")
    val zoneId = ZoneId.of(user.tz)
    val firstPaymentDate = installmentPlan.firstPaymentDate.atZoneSameInstant(zoneId)

    val countOfFullInstallments =
      debt.amount.divide(
        (if (installmentPlan.amount <= BigDecimal.ONE) BigDecimal.ONE else installmentPlan.amount),
        MathContext.DECIMAL32
      )
        .setScale(0, RoundingMode.DOWN)
        .intValueExact()
    val lastInstallmentAmount = debt.amount - installmentPlan.amount * countOfFullInstallments.toBigDecimal()
    val countOfInstallments = countOfFullInstallments + if (lastInstallmentAmount > BigDecimal.ZERO) 1 else 0

    val installments = List(countOfInstallments) { i ->
      val endDate =
        addInterval(firstPaymentDate, installmentPlan.interval, i)
      val startDate = addInterval(firstPaymentDate, installmentPlan.interval, i - 1)
        .plusDays(1)
      val recordAmount = if (i < countOfFullInstallments)
        installmentPlan.amount
      else lastInstallmentAmount
      WalletRecord(
        userId = debt.userId,
        type = RecordType.debt_rate,
        amount = recordAmount,
        title = debt.title,
        category = RecordCategory.debt_rate,
        repeat = installmentPlan.interval,
        startDate = startDate.toOffsetDateTime(),
        endDate = endDate.toOffsetDateTime(),
      )
    }

    val recordsFlow = recordService.saveAll(installments)
    return installmentRepository.saveAll(recordsFlow.map {
      Installment(
        debtId = debtId,
        recordId = it.id!!,
      )
    }).map { it.recordId }
  }

我收到这个错误：

no answer found for: InstallmentRepository(installmentRepository#4).saveAll(app.backend.plan.PlanServiceFeatureImpl$storeInstallmentPlan$suspendImpl$$inlined$map@31e1ec3)
io.mockk.MockKException: no answer found for: InstallmentRepository(installmentRepository#4).saveAll(app.backend.plan.PlanServiceFeatureImpl$storeInstallmentPlan$suspendImpl$$inlined$map@31e1ec3)

代码很多，但由于我不知道错误来自哪里，所以我提供了完整的代码。在其他出现错误 'no answer found for' 的情况下，它为我提供了类似“[...]InstallmentRepository(...).saveAll([parameters here])”之类的信息，而不是指向被测单元的路径。希望有人能帮我解决这个问题。

Answer 1

您正在尝试模拟以下调用：

installmentRepository.saveAll(recordsFlow.map {
      Installment(
        debtId = debtId,
        recordId = it.id!!,
      )
    }).map { it.recordId }

但是你真正需要模拟的只是saveAll()，而不是它后面的map()，如下所示：

coEvery { installmentRepository.saveAll(
    records.map {
      Installment(
        debtId = debtId,
        recordId = it.id!!
      )
    }
  )
} returns flowOf(Installment(debtId, 43))

如果这不起作用，请尝试以下方法（使用不太严格的匹配）：

coEvery { installmentRepository.saveAll(ArgumentMatchers.any()) } returns flowOf(Installment(debtId, 43))

MockK 没有找到答案：

MockK no answer found for:

junit

kotlin

spring-boot

mockk