cats.scalatest.ValidatedValues.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cats-scalatest_3 Show documentation
cats-scalatest
The newest version!
package cats.scalatest

import org.scalatest.exceptions.{StackDepthException, TestFailedException}

import cats.data.Validated
import Validated.{Invalid, Valid}
import org.scalactic.source

trait ValidatedValues {
  import scala.language.implicitConversions

  /**
   * Implicit conversion that adds a `value` method to `cats.data.Validated`
   *
   * @param validated
   *   the `cats.data.Validated` on which to add the `value` method
   */
  implicit def convertValidatedToValidatable[E, T](
    validated: Validated[E, T]
  )(implicit pos: source.Position): Validatable[E, T] =
    new Validatable(validated, pos)

  /**
   * Container class for matching success type stuff in `cats.data.Validated` containers, similar to
   * `org.scalatest.OptionValues.Valuable`
   *
   * Meant to allow you to make statements like:
   *
   *  result.value should be > 15 result.valid.value should be(Valid(15)) 
   *
   * Where it only matches if result is `Valid(9)`
   *
   * Otherwise your test will fail, indicating that it was left instead of right
   *
   * @param validated
   *   A `cats.data.Validated` object to try converting to a `Validatable`
   *
   * @see
   *   org.scalatest.OptionValues.Valuable
   */
  final class Validatable[E, T](validated: Validated[E, T], pos: source.Position) {
    def value: T =
      validated match {
        case Valid(valid) => valid
        case Invalid(left) =>
          throw new TestFailedException(
            (_: StackDepthException) => Some(s"'$left' is Invalid, expected Valid."),
            None,
            pos
          )
      }

    /**
     * Allow .invalidValue on an validated to extract the invalid side. Like .value, but for the `Invalid`.
     */
    def invalidValue: E =
      validated match {
        case Valid(valid) =>
          throw new TestFailedException(
            (_: StackDepthException) => Some(s"'$valid' is Valid, expected Invalid."),
            None,
            pos
          )
        case Invalid(left) => left
      }

    /**
     * Returns the Validated passed to the constructor as a Valid, if it is a
     * Valid, else throws TestFailedException with a detail message indicating the
     * Validated was not a Valid.
     */
    def valid: Valid[T] =
      validated match {
        case valid: Valid[T] => valid
        case _ =>
          throw new TestFailedException(
            (_: StackDepthException) => Some("The Validated on which valid was invoked was not a Valid."),
            None,
            pos
          )
      }

    /**
     * Returns the Validated passed to the constructor as an Invalid, if it is an
     * Invalid, else throws TestFailedException with a detail message indicating the
     * Validated was not an Invalid.
     */
    def invalid: Invalid[E] =
      validated match {
        case invalid: Invalid[E] => invalid
        case _ =>
          throw new TestFailedException(
            (_: StackDepthException) => Some("The Validated on which invalid was invoked was not an Invalid."),
            None,
            pos
          )
      }
  }
}

/**
 * Companion object for easy importing – rather than mixing in – to allow `ValidatedValues` operations.
 *
 * This will permit you to invoke a `value` method on an instance of a `cats.data.Validated`, which attempts to unwrap
 * the Validated.Valid
 *
 * Similar to `org.scalatest.OptionValues.Valuable`
 *
 * Meant to allow you to make statements like:
 *
 *  result.value should be > 15 
 *
 * Where it only matches if result is both valid and greater than 15.
 *
 * Otherwise your test will fail, indicating that it was an Invalid instead of Valid
 *
 * @see
 *   org.scalatest.OptionValues.Valuable
 */
object ValidatedValues extends ValidatedValues