commonMain.io.kotest.matchers.result.matchers.kt Maven / Gradle / Ivy

Go to download
package io.kotest.matchers.result

import io.kotest.matchers.Matcher
import io.kotest.matchers.MatcherResult
import io.kotest.matchers.should
import io.kotest.matchers.shouldNot
import kotlin.reflect.KClass

fun  Result.shouldBeSuccess(block: ((T) -> Unit)? = null): T {
   this should beSuccess()
   return getOrThrow().also { block?.invoke(it) }
}

fun  Result.shouldNotBeSuccess() = this shouldNot beSuccess()

infix fun  Result.shouldBeSuccess(expected: T): T {
   this should beSuccess(expected)
   return getOrThrow()
}

infix fun  Result.shouldNotBeSuccess(expected: T) = this shouldNot beSuccess(expected)

fun Result.shouldBeFailure(block: ((Throwable) -> Unit)? = null): Throwable {
   this should BeFailure()
   return exceptionOrNull()!!.also { block?.invoke(it) }
}

fun  Result.shouldNotBeFailure() = this shouldNot BeFailure()

inline fun  Result.shouldBeFailureOfType(): A {
   this should BeFailureOfType(A::class)
   return exceptionOrNull() as A
}

inline fun  Result.shouldNotBeFailureOfType() = this shouldNot BeFailureOfType(A::class)

fun  beSuccess(): Matcher> = object : Matcher> {
   override fun test(value: Result): MatcherResult {
      return MatcherResult(
         value.isSuccess,
         { "Result should be a Success but was $value" },
         { "Result should not be a Success" })
   }
}

fun  beSuccess(expected: T?): BeSuccess = BeSuccess(expected)
class BeSuccess(val expected: T?) : Matcher> {
   override fun test(value: Result): MatcherResult {
      return value.fold(
         {
            MatcherResult(
               it == expected,
               { "Result should be a Success($expected), but instead got Success($it)." },
               { "Result should not be a Success($expected)" })
         },
         {
            defaultResult(false)
         }
      )
   }

   private fun defaultResult(passed: Boolean) =
      MatcherResult(
         passed,
         { "Result should be a success." },
         { "Result should not be a success" })
}

fun beFailure(): BeFailure = BeFailure()
class BeFailure : Matcher> {
   override fun test(value: Result) = MatcherResult(
      value.isFailure,
      { "Result should be a failure but was ${value.getOrNull()}" },
      { "Result should not be a failure" })
}

class BeFailureOfType(private val clazz: KClass) : Matcher> {
   override fun test(value: Result): MatcherResult {
      val error = value.exceptionOrNull()
      return when {
         value.isSuccess -> MatcherResult(
            false,
            { "Result should be a failure but was success" },
            { "" })
         clazz.isInstance(error) -> MatcherResult(
            true,
            { "Result should be a Failure($clazz)" },
            { "Result should not be a Failure($clazz)" })
         else -> {
            MatcherResult(
               false,
               { "Result should be a Failure($clazz) but was Failure(${error!!::class})" },
               { "" })
         }
      }
   }
}