Тестирование на основе свойств с ScalaCheck

val accountNoGen: Gen[AccountNo] =
    Gen.choose(100000, 999999).map(n => AccountNo(BigInt(n)))

moneyGen генерирует произвольное положительное количество денег (с точностью до цента). Имея их, мы можем составить  accountGen , взяв произвольный номер счета и остаток:

val moneyGen = for {
    value <- Gen.chooseNum(0, 100000000)
    valueDecimal = BigDecimal.valueOf(value)
} yield valueDecimal / 100

val accountGen: Gen[Account] = for {
    accNo <- accountNoGen
    balance <- moneyGen
} yield Account(accNo, balance)

Теперь мы готовы генерировать случайные  Bank. Требуется произвольное число ( Gen.containerOf[List, Account]) произвольных счетов ( accountGen), но мы не хотим создавать пустые банки или банки со слишком большим количеством счетов:

implicit val arbitraryBank = Arbitrary(
    for {
        accounts <- Gen.containerOf[List, Account](accountGen)
        if !accounts.isEmpty
        if accounts.size < 10000
    } yield new Bank(accounts)
)

Последний кусок является случайным  Transfer. Эта часть на самом деле более сложная. Для генерации произвольного перевода нам нужны два случайных счета в банке. Но мы еще не знаем счета, так как банк со счетами был создан случайно. Таким образом, наш генератор должен быть параметризован с банком, который был рандомизирован ранее. Разница между  accountNoGen и  accountNoInBankGen заключается в том, что последний выбирает существующий номер счета из данного банка, а не произвольное случайное число. В  arbitraryTransfer мы не должны проходить  в bank явном виде , поскольку она помечена как  implicit:

def accountNoInBankGen(implicit bank: Bank): Gen[AccountNo] = {
    val accNums = bank.accountNumbers.toSeq
    for {
        accNum <- Gen.chooseNum(0, accNums.size - 1)
    } yield accNums(accNum)
}

implicit def arbitraryTransfer(implicit bank: Bank) = Arbitrary {
    for {
        fromAcc <- accountNoInBankGen
        toAcc <- accountNoInBankGen
        amount <- moneyGen
    } yield Transfer(fromAcc, toAcc, amount)
}

К сожалению  check((bank: Bank, transfers: List[Transfer]) не сработает. Bank и  List[Transfer] генерируется «в то же время», так что нет никакого способа , чтобы пройти генерироваться  bank для  transfers генератора. Мы должны пойти глубже, используя другой синтаксис ScalaCheck ( forAll), слегка злоупотребляя им:

test("Total money should not change after arbitrary number of intra-bank transfers") {
    forAll((bank: Bank) => {
        implicit val anyBank = bank
        forAll((transfers: List[Transfer]) => {
            val bankAfterTransfers = transfers.foldLeft(bank) { (curBank, transfer) =>
                curBank.transfer(transfer.from, transfer.to, transfer.amount)
            }
            bank.totalMoney should equal (bankAfterTransfers.totalMoney)
        })
    })
}

Во внешнем  forAll() предложении мы генерируем произвольное  Bank. Мы должны сделать это,  implicit а затем внутри  forAll мы просим случайное  transfers. Это было много работы! Но, эй, мы нашли ошибку, вы ее заметили?

GeneratorDrivenPropertyCheckFailedException was thrown during property evaluation.
  Message: TestFailedException was thrown during property evaluation.
  Message: 467626.69 did not equal 1352118.86
  Location: (BankChecks.scala:53)
  Occurred when passed generated values (
    arg0 = List(Transfer(AccountNo(664482),AccountNo(664482),884492.17)) // 1 shrink
  )
  Location: (GeneratorDrivenPropertyChecks.scala:837)
  Occurred when passed generated values (
    arg0 = Bank[Account(AccountNo(664482),467626.69)]
  )

Деньги не складываются! Внимательно изучив, мы видим, что тест провалился только с одним аккаунтом и одним переводом. Повторяя тест, мы можем легко найти шаблон: один перевод с тем же исходным и целевым аккаунтом (на 664482 этот раз)! Вернитесь к нашей реализации и попытайтесь выяснить, почему (помните об неизменности):

def transfer(from: AccountNo, to: AccountNo, amount: BigDecimal): Bank = {
    val modifiedFrom = accounts(from).withBalanceMinus(amount)
    val modifiedTo = accounts(to).withBalancePlus(amount)
    val newAccounts = accounts
        .updated(from, modifiedFrom)
        .updated(to, modifiedTo)
    new Bank(newAccounts)
}

Если  from == to, изменения в  modifiedFrom перезаписываются изменениями  modifiedTo. Удивительно, но если бы он  Account был изменчив, эта ошибка не возникла бы (!) Давайте сначала перейдем от красного к зеленому:

def transfer(from: AccountNo, to: AccountNo, amount: BigDecimal): Bank = {
    val modifiedFrom = accounts(from).withBalanceMinus(amount)
    val accountsMinusAmount = accounts.updated(from, modifiedFrom)
    val modifiedTo = accountsMinusAmount(to).withBalancePlus(amount)
    val accountsPlusAmount = accountsMinusAmount.updated(to, modifiedTo)
    new Bank(accountsPlusAmount)
}

Убедитесь, что вы понимаете, почему два фрагмента кода принципиально отличаются. Подсказка: сравните и  . Хорошо, это работает, но я вижу слишком много идентификаторов и шума, давайте пойдем более функционально: accounts(to) accountsMinusAmount(to)

def transfer(from: AccountNo, to: AccountNo, amount: BigDecimal): Bank = {
    this.
        update(from)(_.withBalanceMinus(amount)).
        update(to)  (_.withBalancePlus(amount))
}

private def update(accNo: AccountNo)(transformation: Account => Account): Bank = {
    val account = accounts(accNo)
    val modified = transformation(account)
    val updatedAccounts = accounts.updated(accNo, modified)
    new Bank(updatedAccounts)
}