ControlStructuresSpec.scala

package com.evolutiongaming.bootcamp.basics

import ControlStructures._
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers._
import org.scalacheck.Gen._
import org.scalatest.Assertion
import org.scalatestplus.scalacheck.ScalaCheckDrivenPropertyChecks

class ControlStructuresSpec extends AnyFlatSpec with ScalaCheckDrivenPropertyChecks {
  private def checkFizzBuzz(f: Int => String): Assertion = {
    val obtained = (0 to 100).toList map f
    // we're doing it this way here to avoid providing the answer to the exercise by implementing the function
    val expected = List(
      "fizzbuzz",
      "1",
      "2",
      "fizz",
      "4",
      "buzz",
      "fizz",
      "7",
      "8",
      "fizz",
      "buzz",
      "11",
      "fizz",
      "13",
      "14",
      "fizzbuzz",
      "16",
      "17",
      "fizz",
      "19",
      "buzz",
      "fizz",
      "22",
      "23",
      "fizz",
      "buzz",
      "26",
      "fizz",
      "28",
      "29",
      "fizzbuzz",
      "31",
      "32",
      "fizz",
      "34",
      "buzz",
      "fizz",
      "37",
      "38",
      "fizz",
      "buzz",
      "41",
      "fizz",
      "43",
      "44",
      "fizzbuzz",
      "46",
      "47",
      "fizz",
      "49",
      "buzz",
      "fizz",
      "52",
      "53",
      "fizz",
      "buzz",
      "56",
      "fizz",
      "58",
      "59",
      "fizzbuzz",
      "61",
      "62",
      "fizz",
      "64",
      "buzz",
      "fizz",
      "67",
      "68",
      "fizz",
      "buzz",
      "71",
      "fizz",
      "73",
      "74",
      "fizzbuzz",
      "76",
      "77",
      "fizz",
      "79",
      "buzz",
      "fizz",
      "82",
      "83",
      "fizz",
      "buzz",
      "86",
      "fizz",
      "88",
      "89",
      "fizzbuzz",
      "91",
      "92",
      "fizz",
      "94",
      "buzz",
      "fizz",
      "97",
      "98",
      "fizz",
      "buzz",
    )
    obtained shouldEqual expected
  }

  "fizzBuzz1" should "work correctly" in {
    checkFizzBuzz(fizzBuzz1)
  }

  "fizzBuzz2" should "work correctly" in {
    checkFizzBuzz(fizzBuzz2)
  }

  "applyNTimesForInts" should "work correctly" in {
    forAll(choose(1, 1000), choose(1, 1000)) { case (a: Int, b: Int) =>
      applyNTimesForInts(_ + 1, a)(b) shouldEqual a + b
    }
  }

  "applyNTimes" should "work correctly" in {
    forAll(choose(1, 1000), choose(1, 10000), choose(1, 500)) { case (n, a, b) =>
      applyNTimes[Int](_ + b, n)(a) shouldEqual a + n * b
    }
  }

  private class TestUserService extends UserService { // not thread safe
    private var balances: Map[UserId, Amount] = Map.empty

    // test update that doesn't care about previous values
    def updateAccount(name: String, amount: Amount): Either[ErrorMessage, Unit] = {
      for {
        userId  <- findUserId(name)
        balance <- findBalance(userId)
        _       <- updateAccount(userId, balance, balance + amount)
      } yield ()
    }

    def validateUserName(name: String): Either[ErrorMessage, Unit] = {
      if (name.forall(x => x.isLetter)) Right(()) else Left(s"User $name is invalid")
    }

    def findUserId(name: String): Either[ErrorMessage, UserId] = {
      if (name != "invalid") Right(s"userid.$name") else Left(s"User $name not found")
    }

    def validateAmount(amount: Amount): Either[ErrorMessage, Unit] = {
      if (amount > 0) Right(()) else Left(s"Amount $amount is not positive")
    }

    def findBalance(userId: UserId): Either[ErrorMessage, Amount] = {
      if (userId.startsWith("userid.")) {
        Right(balances.getOrElse(userId, 0))
      } else {
        Left(s"Invalid user ID $userId")
      }
    }

    // Upon success, returns the resulting balance
    def updateAccount(userId: UserId, previousBalance: Amount, delta: Amount): Either[ErrorMessage, Amount] = {
      for {
        balance <- findBalance(userId)
        result  <-
          if (balance == previousBalance) {
            val newBalance = previousBalance + delta
            balances = balances + (userId -> newBalance)
            Right[ErrorMessage, Amount](newBalance)
          } else {
            Left(s"previousBalance was expected to be $balance  but was provided as $previousBalance")
          }
      } yield result
    }
  }

  "makeTransfer" should "work correctly in 200 - 50 => 25 + 50" in {
    val service  = new TestUserService
    val obtained = for {
      _      <- service.updateAccount("a", 200)
      _      <- service.updateAccount("b", 25)
      result <- makeTransfer(service, "a", "b", 50)
    } yield result
    obtained shouldEqual Right((150, 75))
  }

  it should "work correctly in 10 - 7 => 20 + 7" in {
    val service  = new TestUserService
    val obtained = for {
      _      <- service.updateAccount("a", 10)
      _      <- service.updateAccount("b", 20)
      result <- makeTransfer(service, "a", "b", 7)
    } yield result
    obtained shouldEqual Right((3, 27))
  }

  it should "detect incorrect userIds" in {
    val service  = new TestUserService
    val obtained = makeTransfer(service, "invalid", "valid", 50)
    obtained shouldBe a[Left[_, _]]
  }

  "AProductB" should "contain all the elements in `A * B`" in {
    AProductB should contain theSameElementsAs Set(
      (0, true),
      (1, true),
      (2, true),
      (0, false),
      (1, false),
      (2, false),
    )
  }

  "ASumB" should "contain all the elements in `A + B`" in {
    ASumB should contain theSameElementsAs Set(
      Left(0),
      Left(1),
      Left(2),
      Right(true),
      Right(false),
    )
  }

}