Specs2RouteTest

abstract def is: Fragments

final def !=(arg0: Any): Boolean

final def ##(): Int

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 RouteTestTimeout extends Serializable

object TildeArrow

def addCredentials(credentials: HttpCredentials): RequestTransformer

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

def addHeader(header: HttpHeader): RequestTransformer

def addHeaders(headers: List[HttpHeader]): RequestTransformer

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

final def asInstanceOf[T0]: T0

def body: NonEmpty

def charset: HttpCharset

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

def chunks: List[MessageChunk]

def cleanUp(): Unit

def clone(): AnyRef

def closingExtension: String

def contentType: ContentType

def createActorSystem(): ActorSystem

Override to supply a custom ActorSystem

def definedCharset: Option[HttpCharset]

def encode(encoder: Encoder): RequestTransformer

def entity: HttpEntity

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def executor: ExecutionContextExecutor

def failTest(msg: String): Nothing

def finalize(): Unit

def formatFragments: (Fragments) ⇒ Fragments

final def getClass(): Class[_]

def handled: Boolean

def hashCode(): Int

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

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

implicit def header2AddHeader(header: HttpHeader): RequestTransformer

def headers: List[HttpHeader]

def identification: SpecIdentification

implicit def identifySpecificationStructure(s: SpecificationStructure): SpecIdentification

final def isInstanceOf[T0]: 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 mapHeaders(f: (List[HttpHeader]) ⇒ List[HttpHeader]): RequestTransformer

def mediaType: MediaType

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def rejection: Rejection

def rejections: List[Rejection]

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]): T

def runRoute: (RouteResult) ⇒ RouteResult

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

def status: StatusCode

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

implicit val system: ActorSystem

def testConfig: Config

def testConfigSource: String

def toString(): String

def trailer: List[HttpHeader]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def entityAs[T](implicit arg0: Unmarshaller[T], arg1: ClassTag[T]): T