Scala RouteTestTimeout类代码示例

//设置package包名称以及导入依赖的类
package com.flipkart.connekt.receptors.tests.routes

import java.util.concurrent.TimeUnit

import akka.http.scaladsl.model.headers.RawHeader
import akka.http.scaladsl.server
import akka.http.scaladsl.testkit.{RouteTestTimeout, ScalatestRouteTest}
import com.flipkart.connekt.commons.entities.AppUser
import com.flipkart.connekt.receptors.routes.common.ClientRoute
import com.flipkart.connekt.receptors.routes.master.{RegistrationRoute, SendRoute}
import com.flipkart.connekt.receptors.routes.stencils.StencilsRoute
import org.scalatest.Matchers

import scala.concurrent.duration.FiniteDuration

abstract class BaseRouteTest extends BaseReceptorsTest with Matchers with ScalatestRouteTest {

  implicit val routeTestTimeout = RouteTestTimeout(FiniteDuration.apply(30, TimeUnit.SECONDS))
  var stencilRoute: server.Route = null
  var registrationRoute: server.Route = null
  var sendRoute: server.Route = null
  var clientRoute: server.Route = null

  implicit val am = system
  val header = RawHeader("x-api-key", "sandbox-key-01")
  implicit var user: AppUser = null

  override def beforeAll() = {
    super.beforeAll()
    user = new AppUser("test", "test", "", "")
    stencilRoute = new StencilsRoute().route
    registrationRoute = new RegistrationRoute().route
    sendRoute = new SendRoute().route
    clientRoute = new ClientRoute().route
  }
} 

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

import akka.http.scaladsl.testkit.{RouteTestTimeout, ScalatestRouteTest}
import com.acromancer.acromancer.common.api.JsonSupport
import com.acromancer.acromancer.user.application.Session
import com.softwaremill.session.{SessionConfig, SessionManager}
import com.typesafe.config.ConfigFactory
import org.scalatest.Matchers
import scala.concurrent.duration._

trait BaseRoutesSpec extends FlatSpecWithDb with ScalatestRouteTest with Matchers with JsonSupport { spec =>

  lazy val sessionConfig = SessionConfig.fromConfig(ConfigFactory.load()).copy(sessionEncryptData = true)

  implicit def mapCbs = CanBeSerialized[Map[String, String]]

  implicit val timeout = RouteTestTimeout(10 second span)

  trait TestRoutesSupport {
    lazy val sessionConfig = spec.sessionConfig
    implicit def materializer = spec.materializer
    implicit def ec = spec.executor
    implicit def sessionManager = new SessionManager[Session](sessionConfig)
    implicit def refreshTokenStorage = null
  }
} 

//设置package包名称以及导入依赖的类
package com.lonelyplanet.akka.http.extensions

import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.testkit.{RouteTestTimeout, ScalatestRouteTest}
import org.scalatest.{FlatSpec, Matchers}

import scala.concurrent.duration.FiniteDuration

class PaginationSpec extends FlatSpec with PaginationDirectives with Matchers with ScalatestRouteTest {
  implicit val routeTestTimeout: RouteTestTimeout = RouteTestTimeout(FiniteDuration(10, "s"))
  val config = testConfig

  def paginationRoute =
    path("filter-test") {
      withOptionalPagination { page =>
        complete {
          page match {
            case Some(p) => p.toString
            case None    => "NoPage"
          }
        }
      }
    }

  def paginationOrDefaultsRoute =
    path("filter-test") {
      withPagination { page =>
        complete {
          page.toString
        }
      }
    }
} 

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

import akka.http.scaladsl.server.Route
import akka.http.scaladsl.testkit.{RouteTestTimeout, ScalatestRouteTest}
import com.typesafe.config.{Config, ConfigFactory}
import de.choffmeister.microserviceutils.http.JsonWebTokenAuthenticator
import de.choffmeister.microserviceutils.json.JsonHome
import org.scalatest.concurrent.ScalaFutures
import org.scalatest.time.{Millis, Seconds, Span}
import org.scalatest.{FunSpec, Matchers}

import scala.concurrent.duration._

abstract class ServiceTestBase extends FunSpec with ScalatestRouteTest with Matchers with ScalaFutures with JsonProtocol {
  // configure timeouts
  implicit val timeout: RouteTestTimeout = RouteTestTimeout(3.seconds)
  implicit val defaultPatience: PatienceConfig = PatienceConfig(timeout = Span(5, Seconds), interval = Span(100, Millis))

  // common needed values
  val config: Config = ConfigFactory.load()
  val authenticator: JsonWebTokenAuthenticator = new JsonWebTokenAuthenticator()
  val service: Service = new Service()
  val jsonHome: JsonHome = HttpServer.jsonHome
  def routes: Route = service.httpServer.routes
} 

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

import akka.http.scaladsl.testkit.{RouteTestTimeout, ScalatestRouteTest}
import com.softwaremill.bootzooka.common.api.JsonSupport
import com.softwaremill.bootzooka.user.application.Session
import com.softwaremill.session.{SessionConfig, SessionManager}
import com.typesafe.config.ConfigFactory
import org.scalatest.Matchers
import scala.concurrent.duration._

trait BaseRoutesSpec extends FlatSpecWithDb with ScalatestRouteTest with Matchers with JsonSupport { spec =>

  lazy val sessionConfig = SessionConfig.fromConfig(ConfigFactory.load()).copy(sessionEncryptData = true)

  implicit def mapCbs = CanBeSerialized[Map[String, String]]

  implicit val timeout = RouteTestTimeout(10 second span)

  trait TestRoutesSupport {
    lazy val sessionConfig           = spec.sessionConfig
    implicit def materializer        = spec.materializer
    implicit def ec                  = spec.executor
    implicit def sessionManager      = new SessionManager[Session](sessionConfig)
    implicit def refreshTokenStorage = null
  }
} 

//设置package包名称以及导入依赖的类
package net.hvieira.orchestrator.service

import akka.http.scaladsl.Http
import akka.http.scaladsl.model.{HttpRequest, StatusCodes}
import akka.http.scaladsl.testkit.{RouteTestTimeout, ScalatestRouteTest}
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpec}

import scala.concurrent.duration._

class OrchestratorRestServiceSpec
  extends WordSpec
    with Matchers
    with BeforeAndAfterAll
    with ScalatestRouteTest {

  val route = new OrchestratorRestService().route

  "The service" should {

    "orchestrate requests in as a transaction" in {

      implicit val explicitTimeout = RouteTestTimeout(3 seconds)

      val request: HttpRequest = Get("/orchestrate/transaction")
      request ~> route ~> check {
        status shouldBe StatusCodes.OK
        handled shouldBe true
        entityAs[String]  should include regex "Google|DuckDuckGo|Yahoo"
      }
    }

    "orchestrate requests in parallel" in {

      implicit val explicitTimeout = RouteTestTimeout(3 seconds)

      val request: HttpRequest = Get("/orchestrate/parallel")
      request ~> route ~> check {
        status shouldBe StatusCodes.OK
        handled shouldBe true
        entityAs[String]  should include regex "<title>Google<\\/title>|<title>DuckDuckGo<\\/title>|<title>Yahoo<\\/title>"
      }
    }
  }

  override def afterAll(): Unit = {
    Http().shutdownAllConnectionPools()
  }

} 

//设置package包名称以及导入依赖的类
package com.landoop.kafka.ws.routes

import akka.actor.ActorSystem
import akka.http.scaladsl.model.ws.TextMessage
import akka.http.scaladsl.testkit.{RouteTestTimeout, WSProbe}
import akka.util.Timeout
import com.landoop.kafka.ws.cluster.ClusterTestingCapabilities
import com.landoop.kafka.ws.core.ExtractValue
import com.landoop.kafka.ws.domain.responses._
import com.landoop.kafka.ws.{KafkaWSConfig, KafkaWSContext}

import scala.concurrent.duration._

class WebSocketRoutesHeartbeatTest extends BaseRouteTesting with ClusterTestingCapabilities {
  implicit val timeout = Timeout(10.seconds)
  implicit val routeTestTimeout = RouteTestTimeout(10.seconds)


  "WS heartbeat" should {

    "send heartbeat messages every 1 second" in {

      implicit val config: KafkaWSConfig = new KafkaWSConfig(
        "subscription-test",
        kafkaCluster.ZookeeperConnection,
        kafkaCluster.BrokersList,
        kafkaCluster.SchemaRegistryService.get.Endpoint,
        8787,
        heartbeatIntervalMs = 1000)

      implicit val context: KafkaWSContext = KafkaWSContext(config)
      implicit val extract = new ExtractValue()

      implicit val system = ActorSystem("testingActors")
      val wsClient = WSProbe()


      WS(s"/api/kafka/client1", wsClient.flow) ~>
        WebSocketRoutes().routes ~> check {
        isWebSocketUpgrade shouldEqual true

        val probe = wsClient.inProbe
        probe.ensureSubscription()


        val messages = probe.request(2).receiveWithin(2500.millis, 2)
        messages.size >=2  shouldBe true
        messages.foreach {
          case m: TextMessage.Strict =>
            m.text shouldBe HeartBeatResponse.Message.getStrictText
          case _ => fail("should have received heartbeats")
        }
      }

    }
  }
}