zio assert subtype of algebraic data type

Question

Given algebraic data type

sealed trait Result
case object Success extends Result
case class MyFailure(details: String) extends Result

How to assert in zio-test that particular value is a Failure and it's details contain a particular substring?

For example how to assert that below r is a Failure and with a "mana" substring?

val r: Result = MyFailure("not enough mana")

Answer 1

Assuming the result is produced by an effect (in other words, it's wrapped by ZIO), you can use mapError to use the details in case of failure, then assert effectfully using assertM and fails(containsString):

testM("effectfully") {
  val r = ZIO.fail(MyFailure("not enough mana")).mapError(_.details)
  
  assertM(r.run)(fails(containsString("mana")))
}

Answer 2

It's possible with isCase

snip:

  /**
   * Makes a new assertion that requires the sum type be a specified term.
   *
   * {{{
   * isCase("Some", Some.unapply, anything)
   * }}}
   */
  def isCase[Sum, Proj](
    termName: String,
    term: Sum => Option[Proj],
    assertion: Assertion[Proj]
  )

And my (probably not ideal) solution:

sealed trait Result
case object Success extends Result
case class MyFailure(details: String) extends Result

val r: Result = MyFailure("not enought mana")

test("mana") {
  assert(r)(
    isCase[Result, String](
      "details",
      { 
        case MyFailure(details) => Some(details) 
        case _                  => None
      },
      containsString("mana"))
  )
}

Alternatively it's possible to create a helper function and use it for such cases:

  def matches[A](mf: PartialFunction[A, Boolean]): Assertion[A] =
    Assertion.assertion("matches")() {
      a => mf.orElse[A, Boolean]({ case _ => false })(a)
    }

Now the test might look like:

assert(r)(
  matches {
    case MyFailure(d) => d.contains("mana")
  }
)