Testing.scala

import Dependencies._
import sbt.Defaults._
import sbt.Keys._
import sbt._
import complete.DefaultParsers._
import sbt.util.Logger

import scala.sys.process._

object Testing {
  private val AllTests = config("alltests") extend Test
  private val CromwellBenchmarkTest = config("benchmark") extend Test

  private val DockerTestTag = "DockerTest"
  private val CromwellIntegrationTestTag = "CromwellIntegrationTest"
  private val GcsIntegrationTestTag = "GcsIntegrationTest"
  private val AwsIntegrationTestTag = "AwsTest"
  private val DbmsTestTag = "DbmsTest"

  private val AllTestTags = List(
    DockerTestTag,
    CromwellIntegrationTestTag,
    GcsIntegrationTestTag,
    AwsIntegrationTestTag,
    DbmsTestTag
  )

  val minnieKenny = inputKey[Unit]("Run minnie-kenny.")

  private val includeTestTags: Seq[String] =
    sys.env
      .get("CROMWELL_SBT_TEST_INCLUDE_TAGS")
      .filter(_.nonEmpty)
      .map(_.split(",").toList.map(_.trim))
      .getOrElse(Nil)

  private val excludeTestTags: Seq[String] =
    sys.env
      .get("CROMWELL_SBT_TEST_EXCLUDE_TAGS")
      .filter(_.nonEmpty)
      .map(_.split(",").toList.map(_.trim))
      .getOrElse(AllTestTags)

  private val spanScaleFactor: String = sys.env.getOrElse("CROMWELL_SBT_TEST_SPAN_SCALE_FACTOR", "1")

  /*
  The arguments that will be added to the default test config, but removed from all other configs.
  `sbt coverage test` adds other arguments added to generate the coverage reports.
  Tracking the arguments we add to the default allows one to later remove them when building up other configurations.
   */
  private val includeTestArgs = includeTestTags.map(Tests.Argument(TestFrameworks.ScalaTest, "-n", _))
  private val excludeTestArgs = excludeTestTags.map(Tests.Argument(TestFrameworks.ScalaTest, "-l", _))
  private val filterTestArgs = if (includeTestArgs.nonEmpty) includeTestArgs else excludeTestArgs

  private val TestReportArgs =
    Tests.Argument(
      TestFrameworks.ScalaTest,
      "-oDSI",
      "-u",
      "target/test-reports",
      "-F",
      spanScaleFactor,
      "-W",
      "300",
      "300"
    )

  /** Run minnie-kenny only once per sbt invocation. */
  class MinnieKennySingleRunner() {
    private val mutex = new Object
    private var resultOption: Option[Int] = None

    /** Run using the logger, throwing an exception only on the first failure. */
    def runOnce(log: Logger, args: Seq[String]): Unit =
      mutex synchronized {
        if (resultOption.isEmpty) {
          log.debug(s"Running minnie-kenny.sh${args.mkString(" ", " ", "")}")
          val result = ("./minnie-kenny.sh" +: args) ! log
          resultOption = Option(result)
          if (result == 0)
            log.debug("Successfully ran minnie-kenny.sh")
          else
            sys.error("Running minnie-kenny.sh failed. Please double check for errors above.")
        }
      }
  }

  // Only run one minnie-kenny.sh at a time!
  private lazy val minnieKennySingleRunner = new MinnieKennySingleRunner

  private val ScalaMeterFramework = new TestFramework("org.scalameter.ScalaMeterFramework")

  val testSettings = List(
    libraryDependencies ++= testDependencies.map(_ % Test),
    // `test` (or `assembly`) - Run most tests
    Test / testOptions ++= Seq(TestReportArgs) ++ filterTestArgs,
    // `alltests:test` - Run all tests
    AllTests / testOptions := (Test / testOptions).value.diff(filterTestArgs),
    // Reduce the load on SBT by only searching for ScalaTest specs excluding others like JUnit and ScalaCheck
    testFrameworks := List(TestFrameworks.ScalaTest),
    // Add scalameter as a test framework in the CromwellBenchmarkTest scope
    CromwellBenchmarkTest / testFrameworks := List(TestFrameworks.ScalaTest, ScalaMeterFramework),
    // Don't execute benchmarks in parallel
    CromwellBenchmarkTest / parallelExecution := false,
    // Until we move away from Travis do not execute ANY tests in parallel (see also Settings.sharedSettings)
    Test / parallelExecution := false,
    // Since parallelExecution is off do not buffer test results
    Test / logBuffered := false,
    // Make sure no secrets are committed to git
    minnieKenny := {
      val log = streams.value.log
      val args = spaceDelimited("<arg>").parsed
      minnieKennySingleRunner.runOnce(log, args)
    },
    Test / test := {
      minnieKenny.toTask("").value
      (Test / test).value
    }
  )

  private val integrationTestSettings = List(
    libraryDependencies ++= testDependencies.map(_ % IntegrationTest)
  ) ++ itSettings

  def addTestSettings(project: Project) =
    project
      .settings(testSettings)
      .configs(AllTests)
      .settings(inConfig(AllTests)(Defaults.testTasks): _*)
      .configs(CromwellBenchmarkTest)
      .settings(inConfig(CromwellBenchmarkTest)(Defaults.testTasks): _*)

  def addIntegrationTestSettings(project: Project) =
    project
      .settings(integrationTestSettings)
      .configs(IntegrationTest)

}