//设置package包名称以及导入依赖的类
package controllers

import java.io.File

import loader.{AppApplicationLoader, AppComponents}
import mqtt.MqttConnector
import play.api.test.Helpers._
import play.api.ApplicationLoader.Context
import play.api._
import play.api.test.FakeRequest
import play.api.test.Helpers.{GET, contentAsString, route}
import play.core.{DefaultWebCommands, SourceMapper, WebCommands}
import play.filters.csrf.CSRF.Token

trait IntegrationTest {

  var appComponents:BuiltInComponentsFromContext with WithoutMqttAppComponents = null

  trait WithoutMqttAppComponents extends AppComponents {
    override lazy val mqttConnector = new MqttConnector(null, null, actorSystem) {
      override val reconnect = new Runnable {
        override def run() = {}
      }
    }
  }

  class WithoutMqttApp extends AppApplicationLoader {
    override def createApp(context: Context) = {
      appComponents = new BuiltInComponentsFromContext(context) with WithoutMqttAppComponents
      appComponents
    }
  }

  implicit val app = new WithoutMqttApp()
    .load(ApplicationLoader.Context(environment, sourceMapper, webCommands, configuration))

  Play.start(app)

  def getCsrfToken() = {
    val request = FakeRequest(GET, "/data").withHeaders()
    val page = route(app, request).get
    val content = contentAsString(page)
    val name = ("""<input type="hidden" id="csrf_token_name" value="([\w]+)">""".r).findFirstMatchIn(content).get.group(1)
    val value = ("""<input type="hidden" id="csrf_token_value" value="([\w-]+)">""".r).findFirstMatchIn(content).get.group(1)
    Token(name, value)
  }

  def sourceMapper: Option[SourceMapper] = None
  def environment: Environment = Environment(new File("."), ClassLoader.getSystemClassLoader, Mode.Test)
  def webCommands: WebCommands = new DefaultWebCommands
  def configuration: Configuration = Configuration.load(Environment(new File("."), ClassLoader.getSystemClassLoader, Mode.Test))
} 

//设置package包名称以及导入依赖的类
import java.util.concurrent.TimeUnit
import scala.concurrent.Await
import scala.concurrent.TimeoutException
import scala.concurrent.duration.Duration
import org.junit.runner.RunWith
import org.mongodb.scala.ScalaObservable
import org.mongodb.scala.bson.collection.immutable.Document
import org.mongodb.scala.model.Filters.and
import org.mongodb.scala.model.Filters.equal
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner
import core.database.DatabaseComponent
import models.User
import play.api.libs.json.Json
import play.api.test.FakeRequest
import play.api.test.Helpers.GET
import play.api.test.Helpers.NOT_FOUND
import play.api.test.Helpers.OK
import play.api.test.Helpers.contentAsString
import play.api.test.Helpers.contentType
import play.api.test.Helpers.defaultAwaitTimeout
import play.api.test.Helpers.route
import play.api.test.Helpers.status
import play.api.test.Helpers.writeableOf_AnyContentAsEmpty
import play.api.test.WithApplication
import core.database.JsonValueImplicits._
import play.api.libs.json.JsValue
import play.api.test.WithApplication


@RunWith(classOf[JUnitRunner])
class ApplicationSpec extends Specification with DatabaseComponent {

  "Application" should {

    "Be able to create a user" in new WithApplication {
      Await.ready(dropAllCollections(), Duration(10, TimeUnit.SECONDS))
      
      val resultObservable = User.create(User("TEST_USER", "TEST_PASSWORD"))
      Await.ready(resultObservable, Duration(10, TimeUnit.SECONDS))
      
      val result:Boolean = Await.result(User.authenticate("TEST_USER", "TEST_PASSWORD"), Duration(10, TimeUnit.SECONDS))
      
      assert(result)
    }

    "send 404 on a bad request" in new WithApplication {
      route(FakeRequest(GET, "/boum")) must beSome.which(status(_) == NOT_FOUND)
    }

    "render the index page" in new WithApplication {
      val home = route(FakeRequest(GET, "/")).get

      status(home) must equalTo(OK)
      contentType(home) must beSome.which(_ == "text/html")
      contentAsString(home) must contain("Your new application is ready.")
    }
  }
} 

//设置package包名称以及导入依赖的类
package RestSpec

import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner
import org.junit.runner.RunWith
import play.api.test.FakeRequest
import play.api.test.WithApplication
import play.api.test.Helpers.{GET, OK, route, status, contentAsString, contentType,
writeableOf_AnyContentAsEmpty, defaultAwaitTimeout}



@RunWith(classOf[JUnitRunner])
class ApiSpec extends Specification {

  "Api" should {

    "respond with a json representation" in new WithApplication {
      val response = route(FakeRequest(GET, "/api")).get
      status(response) must equalTo(OK)
      contentType(response) must beSome.which(_ == "application/json")
       contentAsString(response) must beEqualTo(
       """{"links":[{"rel":"self","href":"http:///api","method":"GET"},""" +
         """{"rel":"users","href":"http:///api/users","method":"GET"}]}""".stripMargin)
    }
  }
} 

//设置package包名称以及导入依赖的类
package uk.co.telegraph.utils.server.routes

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.util.Timeout
import com.typesafe.config.{Config, ConfigFactory}
import org.scalatest._
import play.api.Configuration
import play.api.http.{MimeTypes, Status}
import play.api.test.FakeRequest
import play.api.test.Helpers.{GET, await, contentAsString, stubControllerComponents}
import uk.co.telegraph.utils.server.routes.AdminEndpointsTest._

import scala.concurrent.duration._
import scala.language.postfixOps

class AdminEndpointsTest
  extends FreeSpec
  with Matchers
  with BeforeAndAfter
  with BeforeAndAfterAll
{
  val endpoint = new AdminEndpoints(Configuration(ConfigTest), stubControllerComponents())

  implicit val TimeoutTest:Timeout = 3 seconds

  "Given the admin endpoint," - {

    "I should be able to get a JSON version of my config" in {
      val request = FakeRequest(GET, "/admin")
      val response = endpoint.getConfig.apply(request)

      val content = contentAsString(response)
      val result = await(response)

      result.body.contentType shouldBe Some(MimeTypes.JSON)
      result.header.status shouldBe Status.OK
      content shouldBe """{"app":{"param1":"value1","param2":["value21","value22"],"param3":"30 seconds"}}"""
    }
  }
}

object AdminEndpointsTest{
  val ConfigTest: Config = ConfigFactory.parseString(
    """
      |app {
      |   param1: "value1"
      |   param2: [
      |     "value21"
      |     "value22"
      |   ]
      |   param3: 30 seconds
      |}
    """.stripMargin)
  implicit val ActorSystemTest = ActorSystem("sample-system", ConfigTest)
  implicit val MaterializerTest = ActorMaterializer()
}