ScalatestRouteTest

abstract def expectedTestCount(filter: Filter): Int

abstract def nestedSuites: IndexedSeq[Suite]

abstract def rerunner: Option[String]

abstract def runNestedSuites(args: Args): Status

abstract def runTest(testName: String, args: Args): Status

abstract def runTests(testName: Option[String], args: Args): Status

abstract val styleName: String

abstract def suiteId: String

abstract def suiteName: String

abstract def tags: Map[String, Set[String]]

abstract def testDataFor(testName: String, theConfigMap: ConfigMap): TestData

abstract def testNames: Set[String]

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

object DefaultHostInfo extends Serializable

val Delete: (ScalatestRouteTest.this)#RequestBuilder

val Get: (ScalatestRouteTest.this)#RequestBuilder

val Head: (ScalatestRouteTest.this)#RequestBuilder

val Options: (ScalatestRouteTest.this)#RequestBuilder

val Patch: (ScalatestRouteTest.this)#RequestBuilder

val Post: (ScalatestRouteTest.this)#RequestBuilder

val Put: (ScalatestRouteTest.this)#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): (ScalatestRouteTest.this)#RequestTransformer

def addHeader(headerName: String, headerValue: String): (ScalatestRouteTest.this)#RequestTransformer

def addHeader(header: HttpHeader): (ScalatestRouteTest.this)#RequestTransformer

def addHeaders(first: HttpHeader, more: HttpHeader*): (ScalatestRouteTest.this)#RequestTransformer

def afterAll(): Unit

final def asInstanceOf[T0]: T0

def beforeAll(): Unit

def charset: HttpCharset

def charsetOption: Option[HttpCharset]

def check[T](body: ⇒ T): ((ScalatestRouteTest.this)#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 ensuring(cond: (ScalatestRouteTest) ⇒ Boolean, msg: ⇒ Any): ScalatestRouteTest

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

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

def ensuring(cond: Boolean): ScalatestRouteTest

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

final def getClass(): Class[_]

def handled: Boolean

def hashCode(): Int

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

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

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

implicit def header2AddHeader(header: HttpHeader): (ScalatestRouteTest.this)#RequestTransformer

def headers: Seq[HttpHeader]

val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean

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 mapHeaders(f: (Seq[HttpHeader]) ⇒ Seq[HttpHeader]): (ScalatestRouteTest.this)#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, mat: Materializer): HttpResponse

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

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[_]): (ScalatestRouteTest.this)#RequestTransformer

def removeHeader[T <: HttpHeader](implicit arg0: ClassTag[T]): (ScalatestRouteTest.this)#RequestTransformer

def removeHeader(headerName: String): (ScalatestRouteTest.this)#RequestTransformer

def removeHeaders(names: String*): (ScalatestRouteTest.this)#RequestTransformer

def response: HttpResponse

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

def responseEntity: HttpEntity

def run(testName: Option[String], args: Args): Status

def runRoute: ((ScalatestRouteTest.this)#RouteTestResult) ⇒ (ScalatestRouteTest.this)#RouteTestResult

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: 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): (ScalatestRouteTest, B)

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

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