chore: add error managment kata

Author: damiengouyette

errormanagment/.scalafmt.conf

@@ -0,0 +1,41 @@
+version=3.5.8
+
+# Only format files tracked by git.
+project.git = true
+
+maxColumn = 120
+
+runner.dialect = scala213
+
+trailingCommas = preserve
+
+literals.long = Upper
+literals.float = Upper
+literals.double = Upper
+
+continuationIndent {
+  callSite = 2
+  defnSite = 2
+}
+
+danglingParentheses.preset = true
+
+newlines {
+  avoidAfterYield = false
+  sometimesBeforeColonInMethodReturnType = false
+}
+
+spaces {
+  inImportCurlyBraces = true
+}
+
+align.preset = none
+
+docstrings {
+  style = SpaceAsterisk
+  wrap = no
+}
+
+rewrite {
+  rules = [SortImports, RedundantParens, SortModifiers]
+}

errormanagment/build.sbt

@@ -0,0 +1,80 @@
+
+// The simplest possible sbt build file is just one line:
+
+scalaVersion := "2.13.8"
+// That is, to create a valid sbt build, all you've got to do is define the
+// version of Scala you'd like your project to use.
+
+// ============================================================================
+
+// Lines like the above defining `scalaVersion` are called "settings". Settings
+// are key/value pairs. In the case of `scalaVersion`, the key is "scalaVersion"
+// and the value is "2.13.8"
+
+// It's possible to define many kinds of settings, such as:
+
+name := "errorManagement"
+organization := "ch.epfl.scala"
+version := "1.0"
+
+// Note, it's not required for you to define these three settings. These are
+// mostly only necessary if you intend to publish your library's binaries on a
+// place like Sonatype.
+
+
+// Want to use a published library in your project?
+// You can define other libraries as dependencies in your build like this:
+
+libraryDependencies += "org.scala-lang.modules" %% "scala-parser-combinators" % "2.1.1"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.15" % Test
+libraryDependencies +="org.typelevel" %% "cats-core" % "2.10.0"
+
+
+// Here, `libraryDependencies` is a set of dependencies, and by using `+=`,
+// we're adding the scala-parser-combinators dependency to the set of dependencies
+// that sbt will go and fetch when it starts up.
+// Now, in any Scala file, you can import classes, objects, etc., from
+// scala-parser-combinators with a regular import.
+
+// TIP: To find the "dependency" that you need to add to the
+// `libraryDependencies` set, which in the above example looks like this:
+
+// "org.scala-lang.modules" %% "scala-parser-combinators" % "2.1.1"
+
+// You can use Scaladex, an index of all known published Scala libraries. There,
+// after you find the library you want, you can just copy/paste the dependency
+// information that you need into your build file. For example, on the
+// scala/scala-parser-combinators Scaladex page,
+// https://index.scala-lang.org/scala/scala-parser-combinators, you can copy/paste
+// the sbt dependency from the sbt box on the right-hand side of the screen.
+
+// IMPORTANT NOTE: while build files look _kind of_ like regular Scala, it's
+// important to note that syntax in *.sbt files doesn't always behave like
+// regular Scala. For example, notice in this build file that it's not required
+// to put our settings into an enclosing object or class. Always remember that
+// sbt is a bit different, semantically, than vanilla Scala.
+
+// ============================================================================
+
+// Most moderately interesting Scala projects don't make use of the very simple
+// build file style (called "bare style") used in this build.sbt file. Most
+// intermediate Scala projects make use of so-called "multi-project" builds. A
+// multi-project build makes it possible to have different folders which sbt can
+// be configured differently for. That is, you may wish to have different
+// dependencies or different testing frameworks defined for different parts of
+// your codebase. Multi-project builds make this possible.
+
+// Here's a quick glimpse of what a multi-project build looks like for this
+// build, with only one "subproject" defined, called `root`:
+
+// lazy val root = (project in file(".")).
+//   settings(
+//     inThisBuild(List(
+//       organization := "ch.epfl.scala",
+//       scalaVersion := "2.13.8"
+//     )),
+//     name := "hello-world"
+//   )
+
+// To learn more about multi-project builds, head over to the official sbt
+// documentation at http://www.scala-sbt.org/documentation.html

errormanagment/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.9.7

errormanagment/src/main/scala/Main.scala

@@ -0,0 +1,3 @@
+object Main extends App {
+  println("Hello, World!")
+}

errormanagment/src/test/scala/ErrorManagementWithBooleanSpec.scala

@@ -0,0 +1,42 @@
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+class ErrorManagementWithBooleanSpec extends AnyFlatSpec with Matchers {
+
+  trait AccountStatus
+  case object Open extends AccountStatus
+  case object Closed extends AccountStatus
+
+  case class BankAccount(availableMoney : Double, status : AccountStatus)
+  def withDraw(amount: Double, bankAccount: BankAccount): Boolean = {
+    if (amount < 0) {
+      false
+    } else if (amount > bankAccount.availableMoney) {
+      false
+    }else if (bankAccount.status == Closed){
+      false
+    }  else {
+      true
+    }
+  }
+
+  "Withdrawing more money than the bank account holds" should " return false" in {
+    val emptyBankAccount = BankAccount(0, Open)
+    withDraw(amount = 20_000, bankAccount = emptyBankAccount) shouldBe false
+  }
+
+  "Withdrawing negative money" should " return false" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+    withDraw(-100, bankAccountWithMoney) shouldBe false
+  }
+  "Withdrawing on closed money" should "return false" in {
+    val bankAccountWithMoney = BankAccount(0, Closed)
+    withDraw(100, bankAccountWithMoney) shouldBe false
+  }
+
+  "withdrawing money from an adequately funded account" should "return true" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+    withDraw(100, bankAccountWithMoney) shouldBe true
+  }
+
+}

errormanagment/src/test/scala/ErrorManagementWithEitherStringSpec.scala

@@ -0,0 +1,67 @@
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+class ErrorManagementWithEitherStringSpec extends AnyFlatSpec with Matchers {
+
+  trait AccountStatus
+  case object Open extends AccountStatus
+  case object Closed extends AccountStatus
+
+  case class BankAccount(availableMoney : Double, status : AccountStatus)
+  def withDraw(amount: Double, bankAccount: BankAccount): Either[String, BankAccount] = {
+    if (amount < 0) {
+      Left("amount should be greater that 0 ")
+    } else if (amount > bankAccount.availableMoney) {
+      Left("amount should be lower that available money")
+    } else if (bankAccount.status == Closed){
+      Left("Account should be open")
+    } else {
+      Right(bankAccount.copy(availableMoney = bankAccount.availableMoney - amount))
+    }
+  }
+
+  "Withdrawing more money than the bank account holds" should "return Left with error message " in {
+    val emptyBankAccount = BankAccount(0, Open)
+    withDraw(amount = 20_000, bankAccount = emptyBankAccount) shouldBe Left("amount should be lower that available money")
+  }
+
+  "Withdrawing negative money" should " return false" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+    withDraw(-100, bankAccountWithMoney) shouldBe Left("amount should be greater that 0 ")
+  }
+  "Withdrawing on closed money" should "return false" in {
+    val bankAccountWithMoney = BankAccount(10_000, Closed)
+    withDraw(100, bankAccountWithMoney) shouldBe Left("Account should be open")
+  }
+
+  "withdrawing money from an adequately funded account" should "return true" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+    withDraw(100, bankAccountWithMoney) shouldBe Right(BankAccount(9_900, Open))
+  }
+
+  "(using flatMap) multiple cash withdrawals  must work with an adequately funded account" should "return true" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+
+    val bankAccountOneWithdrawOrError: Either[String, BankAccount] =  withDraw(100, bankAccountWithMoney)
+    bankAccountOneWithdrawOrError shouldBe Right(BankAccount(9_900, Open))
+
+    val bankAccountWithTwoWithdraw: Either[String, BankAccount] = bankAccountOneWithdrawOrError.flatMap(bankAccount => withDraw(100, bankAccount))
+    bankAccountWithTwoWithdraw  shouldBe Right(BankAccount(9_800, Open))
+
+    val bankAccountWithThreeWithdraw: Either[String, BankAccount] = bankAccountWithTwoWithdraw.flatMap(bankAccount => withDraw(100, bankAccount))
+    bankAccountWithThreeWithdraw shouldBe Right(BankAccount(9_700, Open))
+  }
+
+  "(using for comprehension) multiple cash withdrawals must work with an adequately funded account" should "return true" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+
+    val bankAccountOrError = for {
+      bankAccountOneWithdraw <- withDraw(100, bankAccountWithMoney)
+      bankAccountTwoWithdraw <- withDraw(100,bankAccountOneWithdraw)
+      bankAccountThreeWithdraw <- withDraw(100,bankAccountTwoWithdraw)
+    } yield bankAccountThreeWithdraw
+
+    bankAccountOrError shouldBe Right(BankAccount(9_700, Open))
+  }
+
+}

errormanagment/src/test/scala/ErrorManagementWithEitherTraitSpec.scala

@@ -0,0 +1,74 @@
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+class ErrorManagementWithEitherTraitSpec extends AnyFlatSpec with Matchers {
+
+  trait AccountStatus
+
+  case object Open extends AccountStatus
+
+  case object Closed extends AccountStatus
+
+  case class BankAccount(availableMoney: Double, status: AccountStatus)
+  trait OperationError 
+  case object AmountShouldPositive extends OperationError
+  case object AmountShouldLowerThanAvailableMoney extends OperationError
+  case object AccountShouldBeOpen extends OperationError
+
+  def withDraw(amount: Double, bankAccount: BankAccount): Either[OperationError, BankAccount] = {
+    if (amount < 0) {
+      Left(AmountShouldPositive)
+    } else if (amount > bankAccount.availableMoney) {
+      Left(AmountShouldLowerThanAvailableMoney)
+    } else if (bankAccount.status == Closed) {
+      Left(AccountShouldBeOpen)
+    } else {
+      Right(bankAccount.copy(availableMoney = bankAccount.availableMoney - amount))
+    }
+  }
+
+  "Withdrawing more money than the bank account holds" should "return Left with error message " in {
+    val emptyBankAccount = BankAccount(0, Open)
+    withDraw(amount = 20_000, bankAccount = emptyBankAccount) shouldBe Left(AmountShouldLowerThanAvailableMoney)
+  }
+
+  "Withdrawing negative money" should " return false" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+    withDraw(-100, bankAccountWithMoney) shouldBe Left(AmountShouldPositive)
+  }
+  "Withdrawing on closed money" should "return false" in {
+    val bankAccountWithMoney = BankAccount(10_000, Closed)
+    withDraw(100, bankAccountWithMoney) shouldBe Left(AccountShouldBeOpen)
+  }
+
+  "withdrawing money from an adequately funded account" should "return true" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+    withDraw(100, bankAccountWithMoney) shouldBe Right(BankAccount(9_900, Open))
+  }
+
+  "(using flatMap) multiple cash withdrawals  must work with an adequately funded account" should "return true" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+
+    val bankAccountOneWithdrawOrError= withDraw(100, bankAccountWithMoney)
+    bankAccountOneWithdrawOrError shouldBe Right(BankAccount(9_900, Open))
+
+    val bankAccountWithTwoWithdraw= bankAccountOneWithdrawOrError.flatMap(bankAccount => withDraw(100, bankAccount))
+    bankAccountWithTwoWithdraw shouldBe Right(BankAccount(9_800, Open))
+
+    val bankAccountWithThreeWithdraw= bankAccountWithTwoWithdraw.flatMap(bankAccount => withDraw(100, bankAccount))
+    bankAccountWithThreeWithdraw shouldBe Right(BankAccount(9_700, Open))
+  }
+
+  "(using for comprehension) multiple cash withdrawals must work with an adequately funded account" should "return true" in {
+    val bankAccountWithMoney = BankAccount(10_000, Open)
+
+    val bankAccountOrError = for {
+      bankAccountOneWithdraw <- withDraw(100, bankAccountWithMoney)
+      bankAccountTwoWithdraw <- withDraw(100, bankAccountOneWithdraw)
+      bankAccountThreeWithdraw <- withDraw(100, bankAccountTwoWithdraw)
+    } yield bankAccountThreeWithdraw
+
+    bankAccountOrError shouldBe Right(BankAccount(9_700, Open))
+  }
+
+}

errormanagment/src/test/scala/ErrorManagementWithValidSpec.scala

@@ -0,0 +1,49 @@
+import cats.data.Validated.Invalid
+import cats.data.{Chain, ValidatedNec}
+import cats.implicits._
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+class ErrorManagementWithValidSpec extends AnyFlatSpec with Matchers {
+
+  trait AccountStatus
+  case object Open extends AccountStatus
+  case object Closed extends AccountStatus
+  case class BankAccount(availableMoney: Double, status: AccountStatus)
+  trait OperationError
+  case object AmountShouldPositive extends OperationError
+  case object AmountShouldLowerThanAvailableMoney extends OperationError
+  case object AccountShouldBeOpen extends OperationError
+
+  def amountShouldBePositive(amount : Double): ValidatedNec[OperationError, Double] = {
+    if (amount < 0) {
+      AmountShouldPositive.invalidNec
+    }else amount.validNec
+  }
+
+  def amountShouldLowerThanAvailableMoney(amount: Double, bankAccount: BankAccount): ValidatedNec[OperationError, Double] = {
+    if (amount  > bankAccount.availableMoney) {
+      AmountShouldLowerThanAvailableMoney.invalidNec
+    } else amount.validNec
+  }
+  def accountShouldBeOpen(bankAccount: BankAccount): ValidatedNec[OperationError, BankAccount] = {
+    if (bankAccount.status == Closed){
+      AccountShouldBeOpen.invalidNec
+    } else bankAccount.validNec
+  }
+
+  def withDraw(amount: Double, bankAccount: BankAccount): ValidatedNec[OperationError, BankAccount] = {
+    val amountIsPositiveOrError: ValidatedNec[OperationError, Double] = amountShouldBePositive(amount)
+    val amountIsLowerOrError: ValidatedNec[OperationError, Double] =  amountShouldLowerThanAvailableMoney(amount, bankAccount)
+    val accountIsOpenOrError: ValidatedNec[OperationError, BankAccount] =  accountShouldBeOpen(bankAccount)
+    ((amountIsPositiveOrError combine amountIsLowerOrError), accountIsOpenOrError).mapN(
+      (validAmount, bankAccount) => bankAccount.copy(availableMoney = bankAccount.availableMoney- validAmount) )
+  }
+
+  "Withdrawing more money than the bank account holds on a close account" should "return all errors " in {
+    val emptyAndClosedBankAccount = BankAccount(0, Closed)
+    val bankAccountOrError = withDraw(amount = 20_000, bankAccount = emptyAndClosedBankAccount)
+
+    bankAccountOrError shouldBe Invalid(Chain(AmountShouldLowerThanAvailableMoney, AccountShouldBeOpen))
+  }
+
+}