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

Go to download
package io.kotest.matchers.result

import io.kotest.assertions.collectOrThrow
import io.kotest.assertions.errorCollector
import io.kotest.assertions.failure
import io.kotest.matchers.Matcher
import io.kotest.matchers.MatcherResult
import kotlin.reflect.KClass

fun  Result.shouldBeSuccess(block: ((T?) -> Unit)? = null) {
  test { BeSuccess().test(this) }
  block?.invoke(getOrNull())
}

fun  Result.shouldNotBeSuccess() = test(inverse = true) {
  BeSuccess().test(this)
}

infix fun  Result.shouldBeSuccess(expected: T) = test {
  BeSuccess(expected).test(this)
}

infix fun  Result.shouldNotBeSuccess(expected: T) = test(inverse = true) {
  BeSuccess(expected).test(this)
}
class BeSuccess(val expected: T? = null) : Matcher> {
  override fun test(value: Result): MatcherResult {
    return when {
      !value.isSuccess -> defaultResult(false)
      expected == null -> defaultResult(true)
      else -> MatcherResult(
        value.getOrNull() == expected,
        "Result should be a Success($expected), but instead got Succes(${value.getOrNull()}).",
        "Result should not be a Success($expected)"
      )
    }
  }

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

fun Result.shouldBeFailure(block: ((Throwable?) -> Unit)? = null) {
  test { BeFailure().test(this) }
  block?.invoke(exceptionOrNull())
}

fun Result.shouldNotBeFailure() = test(inverse = true) {
  BeFailure().test(this)
}
class BeFailure : Matcher> {
  override fun test(value: Result) = MatcherResult(
    value.isFailure,
    "Result should be a failure",
    "Result should not be a failure"
  )
}

inline fun  Result.shouldBeFailureOfType() = test {
  BeFailureOfType(A::class).test(this)
}
inline fun  Result.shouldNotBeFailureOfType() = test(inverse = true) {
  BeFailureOfType(A::class).test(this)
}

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", "")
      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})", "")
      }
    }
  }
}

@PublishedApi
internal fun test(inverse: Boolean = false, block: () -> MatcherResult) {
  val result = block()
  if ((inverse && result.passed()) || (!inverse && !result.passed())) {
     errorCollector.collectOrThrow(
      failure(if (inverse) result.negatedFailureMessage() else result.failureMessage())
    )
  }
}