RouteTest

abstract def failTest(msg: String): Nothing

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object DefaultHostInfo extends Serializable

val Delete: (RouteTest.this)#RequestBuilder

val Get: (RouteTest.this)#RequestBuilder

val Head: (RouteTest.this)#RequestBuilder

val Options: (RouteTest.this)#RequestBuilder

val Patch: (RouteTest.this)#RequestBuilder

val Post: (RouteTest.this)#RequestBuilder

val Put: (RouteTest.this)#RequestBuilder

object RouteTestTimeout extends Serializable

object TildeArrow

def addCredentials(credentials: HttpCredentials): (HttpRequest) ⇒ HttpRequest

def addHeader(headerName: String, headerValue: String): (HttpRequest) ⇒ HttpRequest

def addHeader(header: HttpHeader): (HttpRequest) ⇒ HttpRequest

def addHeaders(headers: List[HttpHeader]): (HttpRequest) ⇒ HttpRequest

def addHeaders(first: HttpHeader, more: HttpHeader*): (HttpRequest) ⇒ HttpRequest

final def asInstanceOf[T0]: T0

def body: NonEmpty

def charset: HttpCharset

def check[T](body: ⇒ T): ((RouteTest.this)#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): (HttpRequest) ⇒ HttpRequest

def entity: HttpEntity

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def executor: ExecutionContextExecutor

def finalize(): Unit

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): (HttpRequest) ⇒ HttpRequest

def headers: List[HttpHeader]

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 mapHeaders(f: (List[HttpHeader]) ⇒ List[HttpHeader]): (HttpRequest) ⇒ HttpRequest

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]): (HttpRequest) ⇒ HttpRequest

def removeHeader(headerName: String): (HttpRequest) ⇒ HttpRequest

def removeHeaders(names: String*): (HttpRequest) ⇒ HttpRequest

def response: HttpResponse

def responseAs[T](implicit arg0: FromResponseUnmarshaller[T], arg1: ClassTag[T]): T

def runRoute: ((RouteTest.this)#RouteResult) ⇒ (RouteTest.this)#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