//设置package包名称以及导入依赖的类
package com.criteo.qwebmon

import com.criteo.qwebmon.drivers.FakeDbDriver
import com.twitter.finagle.http.Status._
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class QwebmonControllerTest extends FeatureTest {

  override val server = new EmbeddedHttpServer(new FinatraServer {
    override def dbDrivers: Map[String, DbDriver] = Map("fake-db" -> new FakeDbDriver("fake-db"))
  })

  "Qwebmon" should {
    "Provide a refresh for fake-db" in {
      val response = server.httpGet(
        path = "/refresh/fake-db",
        andExpect = Ok
      ).contentString

      response should startWith(
        """{"running_queries":[{"user":"johndoe","run_seconds":350,"query":"select distinct 1","hostname":"127.0.0.1"},"""
      )

      response should include(""""running_query_count":5""")
    }
  }

} 

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

import com.twitter.finagle.http.Status.Ok
import com.twitter.finatra.http.test.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class ExampleFeatureTest extends FeatureTest {

  override val server = new EmbeddedHttpServer(new ExampleServer)

  "Server" should {
    "ping" in {
      server.httpGet(
        path = "/ping",
        andExpect = Ok,
        withBody = "pong")
    }
  }
} 

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

import com.twitter.finagle.http.Status.Ok
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest
import $package$.Server

class MainControllerFeatureTest extends FeatureTest {

  override val server = new EmbeddedHttpServer(new Server)

  "Server" should {
    "respond" in {
      server.httpGet(
        path = "/",
        andExpect = Ok,
        withBody = "{\"message\":\"success\"}")
    }
  }
} 

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

import com.twitter.finagle.http.Status.Ok
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest
import $package$.Server

class $className$ControllerFeatureTest extends FeatureTest {

  override val server = new EmbeddedHttpServer(new Server)

  "/$className$" should {
    "respond" in {
      server.httpGet(
        path = "/$className$",
        andExpect = Ok,
        withBody = "{\"message\":\"success\"}")
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.github.ikhoon.test

import com.github.ikhoon.FinatraServer
import com.twitter.finagle.http.Status.Ok
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class FinatraFeatureTest extends FeatureTest {

  override val server = new EmbeddedHttpServer(new FinatraServer)

  test("Server#ping") {
    server.httpGet(
      path = "/ping",
      andExpect = Ok,
      withBody = """{"pong":"pong"}"""
    )
  }
} 

//设置package包名称以及导入依赖的类
package me.kamkor.wishlists

import com.twitter.finagle.http.Status
import com.twitter.finatra.http.test.{EmbeddedHttpServer, HttpTest}
import com.twitter.inject.Mockito
import com.twitter.inject.server.FeatureTest

object WishListsFeatureTest {

  val TestTenant = "TestTenant"
  val Headers = Map("hybris-tenant" -> TestTenant)

}

class WishListsFeatureTest extends FeatureTest with Mockito with HttpTest {

  import WishListsFeatureTest._

  override val server = new EmbeddedHttpServer(new WishListsServer)

  "A WishLists endpoint" should {

    "GET wishlist" in {
      //mock document repository client
      //server.httpGet(path = s"/$TestTenant/wishlists/1", headers = Headers, andExpect = Status.Ok)
    }

    "GET NotFound" in {

    }

    "PUT wishlist" in {
      server.httpPut(
        path = s"/$TestTenant/wishlists/1",
        headers = Headers,
        putBody =
          """
            |{
            |  "owner":"kamil",
            |  "title":"food list",
            |  "description":"Food for the weekend"
            |}
          """.stripMargin,
        andExpect = Status.NoContent
      )
    }

    "DELETE wishlist" in {
      server.httpDelete(path = s"/$TestTenant/wishlists/1", headers = Headers, andExpect = Status.NoContent)
    }
  }


} 

//设置package包名称以及导入依赖的类
package com.swissguard.featuretest

import com.swissguard.SwissGuardThriftServer
import com.swissguard.authentication.thriftscala.{AuthenticationService, LoginRequest}
import com.twitter.finatra.thrift.EmbeddedThriftServer
import com.twitter.inject.Mockito
import com.twitter.inject.server.FeatureTest
import com.twitter.util.{Await, Future}

class LoginFeatureTest extends FeatureTest with Mockito {

  override val server = new EmbeddedThriftServer(new SwissGuardThriftServer)

  val client = server.thriftClient[AuthenticationService[Future]](clientId = "login")


  "login with correct password" should {
    "respond with token" in {
      client.login(
        LoginRequest("bob","bobby123")
      ).value.length should be > 20
    }
  }

  "login with incorrect password" should {
    "throw Invalid password exception" in {

      val thrown = the [Exception] thrownBy {
        Await.result(client.login(
          LoginRequest("bob", "sarah123")
        ))
      }
      thrown.toString should include ("Invalid password")
    }
  }

  "login with incorrect username" should {
    "throw invalid Username exception" in {
      val thrown = the [Exception] thrownBy {
        Await.result(client.login(
          LoginRequest("alan-nowhere", "wont-matter")
        ))
      }
      thrown.toString should include ("User not found")
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.swissguard.featuretest

import com.swissguard.SwissGuardThriftServer
import com.swissguard.authentication.thriftscala.{AuthenticationService, RegistrationRequest}
import com.twitter.finatra.thrift.EmbeddedThriftServer
import com.twitter.inject.Mockito
import com.twitter.inject.server.FeatureTest
import com.twitter.util.{Await, Future}

class CreateUserFeatureTest extends FeatureTest with Mockito {

  override val server = new EmbeddedThriftServer(new SwissGuardThriftServer)

  val client = server.thriftClient[AuthenticationService[Future]](clientId = "register")

  "register user bob " should {
    "throw user exists" in {

      val thrown = the[Exception] thrownBy {
        Await.result(client.register(
          RegistrationRequest(
            username = "bob",
            password = "bob",
            email = "[email protected]"
          )
        ))
      }
      thrown.toString should include("User exists")
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.swissguard.featuretest

import com.swissguard.SwissGuardThriftServer
import com.swissguard.authentication.thriftscala.AuthenticationService
import com.twitter.finatra.thrift.EmbeddedThriftServer
import com.twitter.inject.server.FeatureTest
import com.twitter.util.Future

class AuthenticationFeatureTest extends FeatureTest {

  override val server = new EmbeddedThriftServer(new SwissGuardThriftServer)

  val client = server.thriftClient[AuthenticationService[Future]](clientId = "loginClient")

  "user service" should {
    "respond to validation with true" in {
      client.validateToken("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImJvYmEifQ.fQ2PO8HbCgGzmVoyM6RBrzXjYseUgv1VgpwWx9FCBxY")
        .value should be (true)
    }
  }

  "user service" should {
    "respond to validation with false" in {
      client.validateToken("bad-token")
        .value should be (false)
    }
  }
} 

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

import com.google.inject.Stage
import com.twitter.finatra.thrift.EmbeddedThriftServer
import com.twitter.inject.server.FeatureTest
import com.swissguard.SwissGuardThriftServer

class ExampleServerStartupTest extends FeatureTest {

  val server = new EmbeddedThriftServer(
    twitterServer = new SwissGuardThriftServer,
    stage = Stage.PRODUCTION)

  "server" should {
    "startup" in {
      server.assertHealthy()
    }
  }
} 

//设置package包名称以及导入依赖的类
import com.twitter.finagle.http.Status
import com.twitter.finatra.http.test.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class HelloControllerFeatureTest extends FeatureTest {
  override val server: EmbeddedHttpServer = new EmbeddedHttpServer(
    twitterServer = new FitmanServer)

  "Say Hello" in {
    server.httpGet(
      path = "/hello",
      andExpect = Status.Ok,
      withBody = "Fitman says hello"
    )
  }
} 

//设置package包名称以及导入依赖的类
package net.songpon.controller

import com.twitter.finagle.http.Status
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.{EmbeddedTwitterServer, FeatureTest}
import net.songpon.QuoteAPIServer


class PingControllerFeatureTest extends FeatureTest {
  override val server: EmbeddedHttpServer = new EmbeddedHttpServer( twitterServer = new QuoteAPIServer)

  "Tests - ping" in {
    server.httpGet(
      path = "/scalaquote/ping",
      andExpect = Status.Ok,
      withBody = "pong"
    )
  }
} 

//设置package包名称以及导入依赖的类
package com.jensraaby.feeder.api

import com.twitter.finagle.http.Status
import com.twitter.finatra.http.test.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class FeederApiIndexFeatureTest extends FeatureTest {
  override val server = new EmbeddedHttpServer(
    new FeederApiServer,
    verbose = false,
    disableTestLogging = true
  )

  "Server" should {
    "return an index page" in {
      server.httpGet(
        path = "/",
        andExpect = Status.Ok,
        withBody = "Hello")
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.buysomegames.controller

import com.buysomegames.kernel.BuysomegamesServer
import com.buysomegames.test.FreshDatabase
import com.buysomegames.test.TestUtilities.readResource
import com.twitter.finagle.http.Status
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class GameControllerFeatureTest extends FeatureTest with FreshDatabase {
  override protected def server: EmbeddedHttpServer = new EmbeddedHttpServer(new BuysomegamesServer)

  "/games endpoint" should {
    "respond with information about all games" in {
      server.httpGet(
        path = "/games",
        andExpect = Status.Ok,
        withJsonBody = readResource("/controller/games/games.json")
      )
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.buysomegames.controller

import com.buysomegames.kernel.BuysomegamesServer
import com.buysomegames.test.FreshDatabase
import com.buysomegames.test.TestUtilities.readResource
import com.twitter.finagle.http.Status
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class PlatformControllerFeatureTest extends FeatureTest with FreshDatabase {
  override protected def server: EmbeddedHttpServer = new EmbeddedHttpServer(new BuysomegamesServer)
  "/platforms endpoint" should {
    "respond with information about all platforms" in {
      server.httpGet(
        path = "/platforms",
        andExpect = Status.Ok,
        withJsonBody = readResource("/controller/platforms/platforms-response.json")
      )
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.buysomegames.controller

import com.buysomegames.kernel.BuysomegamesServer
import com.buysomegames.test.FreshDatabase
import com.buysomegames.test.TestUtilities.readResource
import com.twitter.finagle.http.Status
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest

class GameEditionControllerFeatureTest extends FeatureTest with FreshDatabase {
  override protected def server: EmbeddedHttpServer = new EmbeddedHttpServer(new BuysomegamesServer)

  "/game_editions endpoint" should {
    "respond with information about all available game editions" in {
      server.httpGet(
        path = "/game_editions",
        andExpect = Status.Ok,
        withJsonBody = readResource("/controller/game_editions/game_editions.json")
      )
    }
  }
} 

//设置package包名称以及导入依赖的类
package uk.ac.wellcome.platform.idminter
import com.twitter.finagle.http.Status._
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest
import uk.ac.wellcome.platform.idminter.utils.{
  IdentifiersTableInfo,
  MysqlLocal
}
import uk.ac.wellcome.test.utils.{AmazonCloudWatchFlag, SNSLocal, SQSLocal}

class ServerTest
    extends FeatureTest
    with SNSLocal
    with MysqlLocal
    with IdentifiersTableInfo
    with AmazonCloudWatchFlag
    with SQSLocal {

  val server = new EmbeddedHttpServer(
    new Server(),
    flags = snsLocalEndpointFlags ++
      sqsLocalFlags ++
      identifiersMySqlLocalFlags ++
      cloudWatchLocalEndpointFlag
  )

  test("it should show the healthcheck message") {
    server.httpGet(path = "/management/healthcheck",
                   andExpect = Ok,
                   withJsonBody = """{"message": "ok"}""")
  }
} 

//设置package包名称以及导入依赖的类
package uk.ac.wellcome.platform.idminter

import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest
import uk.ac.wellcome.platform.idminter.utils.{
  IdentifiersTableInfo,
  MysqlLocal
}
import uk.ac.wellcome.test.utils._

class StartupTest
    extends FeatureTest
    with StartupLogbackOverride
    with SNSLocal
    with MysqlLocal
    with IdentifiersTableInfo
    with AmazonCloudWatchFlag
    with SQSLocal {
  val server = new EmbeddedHttpServer(
    new Server(),
    flags = snsLocalEndpointFlags ++
      sqsLocalFlags ++
      identifiersMySqlLocalFlags ++
      cloudWatchLocalEndpointFlag
  )

  test("server starts up correctly") {
    server.assertHealthy()
  }
} 

//设置package包名称以及导入依赖的类
package uk.ac.wellcome.platform.reindexer

import com.google.inject.Stage
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest
import uk.ac.wellcome.test.utils.{
  AmazonCloudWatchFlag,
  DynamoDBLocal,
  StartupLogbackOverride
}

class StartupTest
    extends FeatureTest
    with StartupLogbackOverride
    with DynamoDBLocal
    with AmazonCloudWatchFlag {

  val server = new EmbeddedHttpServer(
    stage = Stage.PRODUCTION,
    twitterServer = new Server,
    flags = Map(
      "aws.dynamo.reindexTracker.tableName" -> "ReindexTracker",
      "aws.dynamo.miroData.tableName" -> "MiroData",
      "reindex.target.tableName" -> "MiroData"
    ) ++ dynamoDbLocalEndpointFlags ++ cloudWatchLocalEndpointFlag
  )

  test("server starts up correctly") {
    server.assertHealthy()
  }
} 

//设置package包名称以及导入依赖的类
package uk.ac.wellcome.platform.ingestor

import com.google.inject.Stage
import com.twitter.finatra.http.EmbeddedHttpServer
import com.twitter.inject.server.FeatureTest
import uk.ac.wellcome.test.utils.{
  AmazonCloudWatchFlag,
  SQSLocal,
  StartupLogbackOverride
}

class StartupTest
    extends FeatureTest
    with StartupLogbackOverride
    with SQSLocal
    with AmazonCloudWatchFlag {

  val server = new EmbeddedHttpServer(
    stage = Stage.PRODUCTION,
    twitterServer = new Server,
    flags = sqsLocalFlags ++ cloudWatchLocalEndpointFlag)

  test("server starts up correctly") {
    server.assertHealthy()
  }
}