teststate.run.Report.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of core_sjs1_3 Show documentation
core
The newest version!
package teststate.run

import japgolly.microlibs.name_fn._
import scala.annotation.elidable
import scala.util.control.NonFatal
import teststate.data.Failure
import teststate.run.Report._
import teststate.typeclass.DisplayError

case class Report[+E](name: Option[Name], history: History[Failure[E]], stats: Stats) {

  @inline def failure = history.failure
  @inline def failed = history.failed
  @inline def result = history.result

  def failureReason[e >: E](implicit displayError: DisplayError[e]): Option[Failure[String]] =
    failure.map(_ map (err =>
      (history.rootFailurePath.lastOption, Option(displayError display err).filter(_.nonEmpty)) match {
        case (Some(f), Some(e)) => s"${f.name.value} -- $e"
        case (Some(f), None   ) => f.name.value
        case (None   , Some(e)) => e
        case (None   , None   ) => "Failed without an error message."
      }
    ))

  @deprecated("Use .assert(true)", "2.2.0")
  @elidable(elidable.ASSERTION)
  def assertF[EE >: E]()(implicit as: AssertionSettings, se: DisplayError[EE]): Unit =
    assert[EE]()(as.withFailSettingsOnPass, se)

  @elidable(elidable.ASSERTION)
  def assert[EE >: E](useFailSettingsOnPass: Boolean = false)
                     (implicit as: AssertionSettings, de: DisplayError[EE]): Unit = {
    print[EE](useFailSettingsOnPass)
    exception[EE].foreach(throw _)
  }

  /** Print the report to stdout */
  def print[EE >: E](useFailSettingsOnPass: Boolean = false)
                    (implicit as: AssertionSettings, de: DisplayError[EE]): Unit = {
    val fmt = if (useFailSettingsOnPass || failed) as.onFail else as.onPass
    fmt.print[EE](this)
  }

  def exception[EE >: E](implicit de: DisplayError[EE]): Option[Throwable] =
    failureReason(de) map { fe =>
      fe.cause match {
        case Some(NonFatal(e)) =>
          e

        case Some(e) =>
          // Because UndefinedBehaviourErrors (and presumably other fatal errors) freeze Scala.JS
          val x = new RuntimeException(e.getMessage)
          x.setStackTrace(e.getStackTrace)
          x

        case None =>
          new AssertionError(fe.failure)
      }
    }

  def format[EE >: E](implicit as: AssertionSettings, s: DisplayError[EE]): String =
    format[EE]()

  def format[EE >: E](useFailSettingsOnPass: Boolean = false)
                     (implicit as: AssertionSettings, de: DisplayError[EE]): String =
    format[EE](if (failed || useFailSettingsOnPass) as.onFail else as.onPass)(de)

  def format[EE >: E](f: Format)(implicit de: DisplayError[EE]): String =
    f.format[EE](this)(de) getOrElse ""

  @deprecated("Use .format(true)", "2.2.0")
  def formatF[EE >: E](implicit as: AssertionSettings, s: DisplayError[EE]): String =
    format(as.withFailSettingsOnPass, s)
}

object Report {

  // Help keep Exports small

  type History[+E] = teststate.run.History[E]
  val  History     = teststate.run.History

  type Format = teststate.run.ReportFormat
  val  Format = teststate.run.ReportFormat

  type Stats = teststate.run.Stats
  val  Stats = teststate.run.Stats


  final case class AssertionSettings(onPass: Format, onFail: Format) {
    def silenceOnPass: AssertionSettings =
      copy(onPass = Format.quiet)

    @deprecated("Use withFailSettingsOnPass", "2.2.0")
    def failSettingsOnPass: AssertionSettings =
      copy(onPass = onFail)

    def withFailSettingsOnPass: AssertionSettings =
      copy(onPass = onFail)
  }

  object AssertionSettings {
    def uniform(format: Format): AssertionSettings =
      AssertionSettings(format, format)

    def uncoloured = AssertionSettings(
      onPass = Format.Default.uncoloured.apply,
      onFail = Format.Default.uncoloured.alwaysShowChildren.apply)

    def coloured = AssertionSettings(
      onPass = Format.Default.coloured.apply,
      onFail = Format.Default.coloured.alwaysShowChildren.apply)

    def default = coloured
  }
}