//设置package包名称以及导入依赖的类
package au.csiro.data61.magda.registry

import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
import akka.http.scaladsl.testkit.ScalatestRouteTest
import akka.testkit.TestProbe
import ch.qos.logback.classic.{Level, Logger}
import org.flywaydb.core.Flyway
import org.scalatest.Matchers
import org.scalatest.fixture.FunSpec
import org.slf4j.LoggerFactory

import scala.concurrent.duration._
import scalikejdbc._

abstract class ApiSpec extends FunSpec with ScalatestRouteTest with Matchers with Protocols with SprayJsonSupport {
  case class FixtureParam(api: Api, webHookActorProbe: TestProbe)

  val databaseUrl = Option(System.getenv("npm_package_config_databaseUrl")).getOrElse("jdbc:postgresql://localhost:5432/postgres")

  // Stop Flyway from producing so much spam that Travis terminates the process.
  LoggerFactory.getLogger("org.flywaydb").asInstanceOf[Logger].setLevel(Level.WARN)

  val flyway = new Flyway()
  flyway.setDataSource(databaseUrl, "postgres", "")
  flyway.setSchemas("test")
  flyway.setLocations("classpath:/sql")

  override def testConfigSource =
    s"""
      |db.default.url = "${databaseUrl}?currentSchema=test"
      |authorization.skip = true
      |akka.loglevel = INFO
    """.stripMargin

  override def withFixture(test: OneArgTest) = {
    val webHookActorProbe = TestProbe()
    val api = new Api(webHookActorProbe.ref, testConfig, system, executor, materializer)

    webHookActorProbe.expectMsg(1 millis, WebHookActor.Process)

    DB localTx { implicit session =>
      sql"DROP SCHEMA IF EXISTS test CASCADE".update.apply()
      sql"CREATE SCHEMA test".update.apply()
    }

    flyway.migrate()

    super.withFixture(test.toNoArgTest(FixtureParam(api, webHookActorProbe)))
  }
} 

//设置package包名称以及导入依赖的类
package mesosphere.marathon.test

import ch.qos.logback.classic.Logger
import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.core.{ Context, AppenderBase }
import org.slf4j.LoggerFactory

object CaptureLogEvents {
  def forBlock(block: => Unit): Vector[ILoggingEvent] = {

    val capturingAppender = new CapturingAppender
    capturingAppender.appendToRootLogger()
    try block finally capturingAppender.detachFromRootLogger()
    capturingAppender.getEvents
  }

  private class CapturingAppender extends AppenderBase[ILoggingEvent] {
    setName("capture")

    private[this] var events = Vector.empty[ILoggingEvent]
    private[this] def rootLogger: Logger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME).asInstanceOf[Logger]

    def appendToRootLogger(): Unit = {
      // Waiting for Logback to be ready.
      // See https://gist.github.com/mbknor/34944ea4589a5fc6974c
      // Should actually have been fixed with http://jira.qos.ch/browse/SLF4J-167
      while (LoggerFactory.getILoggerFactory.isInstanceOf[org.slf4j.helpers.SubstituteLoggerFactory]) {
        Thread.sleep(50)
      }
      setContext(LoggerFactory.getILoggerFactory.asInstanceOf[Context])
      start()
      rootLogger.addAppender(this)
    }

    def detachFromRootLogger(): Unit = rootLogger.detachAppender(this)

    def clearEvents(): Unit = synchronized { events = Vector.empty }
    def getEvents: Vector[ILoggingEvent] = synchronized { events }

    override def append(eventObject: ILoggingEvent): Unit = synchronized { events :+= eventObject }
  }
} 

//设置package包名称以及导入依赖的类
package com.dwolla.testutils.logging

import ch.qos.logback.classic.{Level, Logger}
import org.slf4j.helpers.SubstituteLogger
import org.slf4j.{Logger => SLF4JLogger, LoggerFactory}
import org.specs2.matcher.{Expectable, Matcher}
import org.specs2.mutable.SpecificationLike
import org.specs2.text.Sentences._

trait LoggingTest extends SpecificationLike {
  protected val logAppenderName = "inMemory"
  private val appender = findInMemoryAppender(logAppenderName)

  def haveBeenLoggedAtLevel(logLevel: Level): Matcher[String] = new Matcher[String] {
    def apply[S <: String](s: Expectable[S]) = {
      val containsAtLevel = appender.containsAtLevel(s.value, logLevel)
      val errorMessage =
        if (containsAtLevel)
          "The expected logging occurred"
        else if (appender.contains(s.value))
          s"“${s.value}” was logged at the wrong level"
        else
          s"“${s.value}” was never logged"
      result(containsAtLevel, negateSentence(errorMessage), errorMessage, s)
    }
  }

  def resetCapturedLogs(): Unit = appender.reset()
  def dumpCapturedLogsToSysOut(): Unit = appender.dumpLogs()

  private def findInMemoryAppender(s: String): InMemoryAppender = {
    LoggerFactory.getLogger(SLF4JLogger.ROOT_LOGGER_NAME) match {
      case logger: Logger => logger.getAppender(s) match {
        case inMemoryAppender: InMemoryAppender => inMemoryAppender
        case _ => throw new IllegalStateException(s"Is the InMemoryAppender registered with logback in its configuration file with the name $s?")
      }
      case sub: SubstituteLogger => throw new IllegalStateException("SLF4J is probably still initializing. Is LoggingTest part of the outermost class wrapping your tests?")
      case _ => throw new IllegalStateException("Are you using LogBack logging?")
    }
  }
}