Specs2RouteTest

abstract def is: SpecStructure

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Specs2RouteTest, B)

final def ==(arg0: Any): Boolean

object DefaultHostInfo extends Serializable

val Delete: RequestBuilder

val Get: RequestBuilder

val Head: RequestBuilder

val Options: RequestBuilder

val Patch: RequestBuilder

val Post: RequestBuilder

val Put: RequestBuilder

object TildeArrow

def WS(uri: Uri, clientSideHandler: Flow[Message, Message, Any], subprotocols: Seq[String] = Nil)(implicit materializer: Materializer): HttpRequest

def actorSystemNameFrom(clazz: Class[_]): String

def addCredentials(credentials: HttpCredentials): RequestTransformer

def addHeader(headerName: String, headerValue: String): RequestTransformer

def addHeader(header: HttpHeader): RequestTransformer

def addHeaders(first: HttpHeader, more: HttpHeader*): RequestTransformer

def afterAll(): Unit

final def asInstanceOf[T0]: T0

def charset: HttpCharset

def charsetOption: Option[HttpCharset]

def check[T](body: ⇒ T): (RouteTestResult) ⇒ T

def chunks: Seq[ChunkStreamPart]

def cleanUp(): Unit

def clone(): AnyRef

def closingExtension: String

def contentType: ContentType

def createActorSystem(): ActorSystem

Override to supply a custom ActorSystem

def decorate(is: SpecStructure, env: Env): SpecStructure

def ensuring(cond: (Specs2RouteTest) ⇒ Boolean, msg: ⇒ Any): Specs2RouteTest

def ensuring(cond: (Specs2RouteTest) ⇒ Boolean): Specs2RouteTest

def ensuring(cond: Boolean, msg: ⇒ Any): Specs2RouteTest

def ensuring(cond: Boolean): Specs2RouteTest

def entityAs[T](implicit arg0: FromEntityUnmarshaller[T], arg1: ClassTag[T], timeout: Duration = 1.second): T

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaluateTo[T](value: T)(implicit ee: ExecutionEnv): Matcher[Future[T]]

implicit def executor: ExecutionContextExecutor

def expectWebSocketUpgradeWithProtocol(body: (String) ⇒ Unit): Unit

Asserts that the received response is a WebSocket upgrade response and the extracts the chosen subprotocol and passes it to the handler.

def failTest(msg: String): Nothing

def finalize(): Unit

def formatted(fmtstr: String): String

def fragmentFactory: FragmentFactory

def fragments: (Env) ⇒ Fragments

final def getClass(): Class[_]

def handled: Boolean

def hashCode(): Int

def haveFailedWith(t: Throwable)(implicit ee: ExecutionEnv): Matcher[Future[_]]

def header(name: String): Option[HttpHeader]

def header[T >: Null <: HttpHeader](implicit arg0: ClassTag[T]): Option[T]

implicit def header2AddHeader(header: HttpHeader): RequestTransformer

def headers: Seq[HttpHeader]

final def isInstanceOf[T0]: Boolean

def isWebSocketUpgrade: Boolean

def logRequest(logFun: (HttpRequest) ⇒ Unit): (HttpRequest) ⇒ HttpRequest

def logRequest(log: LoggingAdapter, level: LogLevel): (HttpRequest) ⇒ HttpRequest

def logValue[T](logFun: (T) ⇒ Unit): (T) ⇒ T

def logValue[T](log: LoggingAdapter, level: LogLevel): (T) ⇒ T

def map(fs: ⇒ Fragments): Fragments

def map(fs: ⇒ Fragments, env: Env): Fragments

def map(structure: SpecStructure): SpecStructure

def mapHeaders(f: (Seq[HttpHeader]) ⇒ Seq[HttpHeader]): RequestTransformer

def marshal[T](value: T)(implicit arg0: ToEntityMarshaller[T], ec: ExecutionContext, mat: Materializer): Strict

def marshalToResponse[T](value: T, request: HttpRequest = HttpRequest())(implicit arg0: ToResponseMarshaller[T], ec: ExecutionContext): HttpResponse

def marshalToResponseForRequestAccepting[T](value: T, mediaRanges: MediaRange*)(implicit arg0: ToResponseMarshaller[T], ec: ExecutionContext): HttpResponse

def marshallingTimeout: FiniteDuration

implicit val materializer: ActorMaterializer

def mediaType: MediaType

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def rejection: Rejection

def rejections: Seq[Rejection]

def removeHeader(clazz: Class[_]): RequestTransformer

def removeHeader[T <: HttpHeader](implicit arg0: ClassTag[T]): RequestTransformer

def removeHeader(headerName: String): RequestTransformer

def removeHeaders(names: String*): RequestTransformer

def response: HttpResponse

def responseAs[T](implicit arg0: FromResponseUnmarshaller[T], arg1: ClassTag[T], timeout: Duration = 1.second): T

def responseEntity: HttpEntity

def runRoute: (RouteTestResult) ⇒ RouteTestResult

A dummy that can be used as ~> runRoute to run the route but without blocking for the result.

def status: StatusCode

def structure: (Env) ⇒ SpecStructure

final def synchronized[T0](arg0: ⇒ T0): T0

implicit val system: ActorSystem

def testConfig: Config

def testConfigSource: String

def toString(): String

def trailer: Seq[HttpHeader]

def unmarshal[T](entity: HttpEntity)(implicit arg0: FromEntityUnmarshaller[T], ec: ExecutionContext, mat: Materializer): Try[T]

def unmarshalTo[T](value: Try[T])(implicit arg0: FromEntityUnmarshaller[T], ec: ExecutionContext, mat: Materializer): Matcher[HttpEntity]

def unmarshalToValue[T](value: T)(implicit arg0: FromEntityUnmarshaller[T], ec: ExecutionContext, mat: Materializer): Matcher[HttpEntity]

def unmarshalValue[T](entity: HttpEntity)(implicit arg0: FromEntityUnmarshaller[T], ec: ExecutionContext, mat: Materializer): T

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def →[B](y: B): (Specs2RouteTest, B)

def ~>[B](f: (Specs2RouteTest) ⇒ B): B

def ~>[B](f: (Specs2RouteTest) ⇒ B): B