TestInfoResources

Instance Constructors

new TestInfoResources(providers: ProcessingTypeDataProvider[TestInfoProvider], processAuthorizer: AuthorizeProcess, processRepository: FetchingProcessRepository[Future])(implicit ec: ExecutionContext)

Type Members

type AsyncAuthenticator[T] = (Credentials) ⇒ Future[Option[T]]

Definition Classes
SecurityDirectives
type AsyncAuthenticatorPF[T] = PartialFunction[Credentials, Future[T]]

Definition Classes
SecurityDirectives
type AuthenticationResult[+T] = Either[HttpChallenge, T]

Definition Classes
SecurityDirectives
type Authenticator[T] = (Credentials) ⇒ Option[T]

Definition Classes
SecurityDirectives
type AuthenticatorPF[T] = PartialFunction[Credentials, T]

Definition Classes
SecurityDirectives
abstract class NumberMatcher[T] extends PathMatcher1[T]

Definition Classes
PathMatchers
type RequestToSourceUnmarshaller[T] = Unmarshaller[HttpRequest, Source[T, NotUsed]]

Definition Classes
FramedEntityStreamingDirectives

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val DoubleNumber: PathMatcher1[Double]

Definition Classes
PathMatchers
object IntNumber extends NumberMatcher[Int]

Definition Classes
PathMatchers
val JavaUUID: PathMatcher1[UUID]

Definition Classes
PathMatchers
object LongNumber extends NumberMatcher[Long]

Definition Classes
PathMatchers
val Neutral: PathMatcher0

Definition Classes
PathMatchers
object Segment extends PathMatcher1[String]

Definition Classes
PathMatchers
def Segments(min: Int, max: Int): PathMatcher1[List[String]]

Definition Classes
PathMatchers
def Segments(count: Int): PathMatcher1[List[String]]

Definition Classes
PathMatchers
val Segments: PathMatcher1[List[String]]

Definition Classes
PathMatchers
def _defaultClassLoader: ClassLoader

Attributes
protected[akka.http]
Definition Classes
FileAndResourceDirectives
implicit def _enhanceRouteWithConcatenation(route: Route): RouteWithConcatenation

Definition Classes
RouteConcatenation
implicit def _regex2PathMatcher(regex: Regex): PathMatcher1[String]

Definition Classes
ImplicitPathMatcherConstruction
implicit def _segmentStringToPathMatcher(segment: String): PathMatcher0

Definition Classes
ImplicitPathMatcherConstruction
implicit def _string2NR(string: String): NameReceptacle[String]

Definition Classes
ToNameReceptacleEnhancements
implicit def _stringExtractionPair2PathMatcher[T](tuple: (String, T)): PathMatcher1[T]

Definition Classes
ImplicitPathMatcherConstruction
implicit def _stringNameOptionReceptacle2PathMatcher(nr: NameOptionReceptacle[String]): PathMatcher0

Definition Classes
ImplicitPathMatcherConstruction
implicit def _symbol2NR(symbol: Symbol): NameReceptacle[String]

Definition Classes
ToNameReceptacleEnhancements
implicit def _valueMap2PathMatcher[T](valueMap: Map[String, T]): PathMatcher1[T]

Definition Classes
ImplicitPathMatcherConstruction
def as[T](implicit um: FromRequestUnmarshaller[T]): FromRequestUnmarshaller[T]

Definition Classes
MarshallingDirectives
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def asSourceOf[T](support: EntityStreamingSupport)(implicit um: FromByteStringUnmarshaller[T]): RequestToSourceUnmarshaller[T]

Definition Classes
FramedEntityStreamingDirectives
final def asSourceOf[T](implicit um: FromByteStringUnmarshaller[T], support: EntityStreamingSupport): RequestToSourceUnmarshaller[T]

Definition Classes
FramedEntityStreamingDirectives
implicit def attachImplicitUserToProcessId(id: ProcessId)(implicit loggedUser: LoggedUser): (ProcessId, LoggedUser)

Attributes
protected
Definition Classes
AuthorizeProcessDirectives
implicit def attachImplicitUserToProcessIdWithName(id: ProcessIdWithName)(implicit loggedUser: LoggedUser): (ProcessId, LoggedUser)

Attributes
protected
Definition Classes
AuthorizeProcessDirectives
def authenticateBasic[T](realm: String, authenticator: Authenticator[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateBasicAsync[T](realm: String, authenticator: AsyncAuthenticator[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateBasicPF[T](realm: String, authenticator: AuthenticatorPF[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateBasicPFAsync[T](realm: String, authenticator: AsyncAuthenticatorPF[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateOAuth2[T](realm: String, authenticator: Authenticator[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateOAuth2Async[T](realm: String, authenticator: AsyncAuthenticator[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateOAuth2PF[T](realm: String, authenticator: AuthenticatorPF[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateOAuth2PFAsync[T](realm: String, authenticator: AsyncAuthenticatorPF[T]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateOrRejectWithChallenge[C <: HttpCredentials, T](authenticator: (Option[C]) ⇒ Future[AuthenticationResult[T]])(implicit arg0: ClassTag[C]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authenticateOrRejectWithChallenge[T](authenticator: (Option[HttpCredentials]) ⇒ Future[AuthenticationResult[T]]): AuthenticationDirective[T]

Definition Classes
SecurityDirectives
def authorize(check: (RequestContext) ⇒ Boolean): Directive0

Definition Classes
SecurityDirectives
def authorize(check: ⇒ Boolean): Directive0

Definition Classes
SecurityDirectives
def authorizeAsync(check: (RequestContext) ⇒ Future[Boolean]): Directive0

Definition Classes
SecurityDirectives
def authorizeAsync(check: ⇒ Future[Boolean]): Directive0

Definition Classes
SecurityDirectives
def canDeploy(processIdAndUser: (ProcessId, LoggedUser)): Directive0

Definition Classes
AuthorizeProcessDirectives
def canWrite(processIdAndUser: (ProcessId, LoggedUser)): Directive0

Definition Classes
AuthorizeProcessDirectives
def cancelRejection(rejection: Rejection): Directive0

Definition Classes
BasicDirectives
def cancelRejections(cancelFilter: (Rejection) ⇒ Boolean): Directive0

Definition Classes
BasicDirectives
def cancelRejections(classes: Class[_]*): Directive0

Definition Classes
BasicDirectives
def checkSameOrigin(allowed: Default): Directive0

Definition Classes
HeaderDirectives
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def complete(m: ⇒ ToResponseMarshallable): StandardRoute

Definition Classes
RouteDirectives
def completeOrRecoverWith(magnet: CompleteOrRecoverWithMagnet): Directive1[Throwable]

Definition Classes
FutureDirectives
def completeWith[T](marshaller: ToResponseMarshaller[T])(inner: ((T) ⇒ Unit) ⇒ Unit): Route

Definition Classes
MarshallingDirectives
def concat(routes: Route*): Route

Definition Classes
RouteConcatenation
def conditional(eTag: Option[EntityTag], lastModified: Option[DateTime]): Directive0

Definition Classes
CacheConditionDirectives
def conditional(eTag: EntityTag, lastModified: DateTime): Directive0

Definition Classes
CacheConditionDirectives
def conditional(lastModified: DateTime): Directive0

Definition Classes
CacheConditionDirectives
def conditional(eTag: EntityTag): Directive0

Definition Classes
CacheConditionDirectives
def cookie(name: String): Directive1[HttpCookiePair]

Definition Classes
CookieDirectives
def decodeRequest: Directive0

Definition Classes
CodingDirectives
def decodeRequestWith(decoders: Decoder*): Directive0

Definition Classes
CodingDirectives
def decodeRequestWith(decoder: Decoder): Directive0

Definition Classes
CodingDirectives
def delete: Directive0

Definition Classes
MethodDirectives
def deleteCookie(name: String, domain: String, path: String): Directive0

Definition Classes
CookieDirectives
def deleteCookie(first: HttpCookie, more: HttpCookie*): Directive0

Definition Classes
CookieDirectives
implicit val ec: ExecutionContext

Definition Classes
TestInfoResources → ProcessDirectives
def encodeResponse: Directive0

Definition Classes
CodingDirectives
def encodeResponseWith(first: Encoder, more: Encoder*): Directive0

Definition Classes
CodingDirectives
def entity[T](um: FromRequestUnmarshaller[T]): Directive1[T]

Definition Classes
MarshallingDirectives
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def extract[T](f: (RequestContext) ⇒ T): Directive1[T]

Definition Classes
BasicDirectives
def extractActorSystem: Directive1[ActorSystem]

Definition Classes
BasicDirectives
def extractClientIP: Directive1[RemoteAddress]

Definition Classes
MiscDirectives
def extractCredentials: Directive1[Option[HttpCredentials]]

Definition Classes
SecurityDirectives
def extractDataBytes: Directive1[Source[ByteString, Any]]

Definition Classes
BasicDirectives
def extractExecutionContext: Directive1[ExecutionContextExecutor]

Definition Classes
BasicDirectives
def extractHost: Directive1[String]

Definition Classes
HostDirectives
def extractLog: Directive1[LoggingAdapter]

Definition Classes
BasicDirectives
def extractMatchedPath: Directive1[Path]

Definition Classes
BasicDirectives
def extractMaterializer: Directive1[Materializer]

Definition Classes
BasicDirectives
def extractMethod: Directive1[HttpMethod]

Definition Classes
MethodDirectives
def extractOfferedWsProtocols: Directive1[Seq[String]]

Definition Classes
WebSocketDirectives
def extractParserSettings: Directive1[ParserSettings]

Definition Classes
BasicDirectives
def extractRequest: Directive1[HttpRequest]

Definition Classes
BasicDirectives
def extractRequestContext: Directive1[RequestContext]

Definition Classes
BasicDirectives
def extractRequestEntity: Directive1[RequestEntity]

Definition Classes
BasicDirectives
def extractRequestTimeout: Directive1[Duration]

Definition Classes
TimeoutDirectives
def extractScheme: Directive1[String]

Definition Classes
SchemeDirectives
def extractSettings: Directive1[RoutingSettings]

Definition Classes
BasicDirectives
def extractStrictEntity(timeout: FiniteDuration, maxBytes: Long): Directive1[Strict]

Definition Classes
BasicDirectives
def extractStrictEntity(timeout: FiniteDuration): Directive1[Strict]

Definition Classes
BasicDirectives
def extractUnmatchedPath: Directive1[Path]

Definition Classes
BasicDirectives
def extractUpgradeToWebSocket: Directive1[UpgradeToWebSocket]

Definition Classes
WebSocketDirectives
def extractUri: Directive1[Uri]

Definition Classes
BasicDirectives
def failWith(error: Throwable): StandardRoute

Definition Classes
RouteDirectives
def fileUpload(fieldName: String): Directive1[(FileInfo, Source[ByteString, Any])]

Definition Classes
FileUploadDirectives
def fileUploadAll(fieldName: String): Directive1[Seq[(FileInfo, Source[ByteString, Any])]]

Definition Classes
FileUploadDirectives
Annotations
@ApiMayChange()
def formField(pdm: FieldMagnet): Out

Definition Classes
FormFieldDirectives
def formFieldMap: Directive1[Map[String, String]]

Definition Classes
FormFieldDirectives
def formFieldMultiMap: Directive1[Map[String, List[String]]]

Definition Classes
FormFieldDirectives
def formFieldSeq: Directive1[Seq[(String, String)]]

Definition Classes
FormFieldDirectives
def formFields(pdm: FieldMagnet): Out

Definition Classes
FormFieldDirectives
def get: Directive0

Definition Classes
MethodDirectives
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def getFromBrowseableDirectories(directories: String*)(implicit renderer: DirectoryRenderer, resolver: ContentTypeResolver): Route

Definition Classes
FileAndResourceDirectives
def getFromBrowseableDirectory(directory: String)(implicit renderer: DirectoryRenderer, resolver: ContentTypeResolver): Route

Definition Classes
FileAndResourceDirectives
def getFromDirectory(directoryName: String)(implicit resolver: ContentTypeResolver): Route

Definition Classes
FileAndResourceDirectives
def getFromFile(file: File, contentType: ContentType): Route

Definition Classes
FileAndResourceDirectives
def getFromFile(file: File)(implicit resolver: ContentTypeResolver): Route

Definition Classes
FileAndResourceDirectives
def getFromFile(fileName: String)(implicit resolver: ContentTypeResolver): Route

Definition Classes
FileAndResourceDirectives
def getFromResource(resourceName: String, contentType: ContentType, classLoader: ClassLoader): Route

Definition Classes
FileAndResourceDirectives
def getFromResource(resourceName: String)(implicit resolver: ContentTypeResolver): Route

Definition Classes
FileAndResourceDirectives
def getFromResourceDirectory(directoryName: String, classLoader: ClassLoader)(implicit resolver: ContentTypeResolver): Route

Definition Classes
FileAndResourceDirectives
def handleExceptions(handler: ExceptionHandler): Directive0

Definition Classes
ExecutionDirectives
def handleRejections(handler: RejectionHandler): Directive0

Definition Classes
ExecutionDirectives
def handleWebSocketMessages(handler: Flow[Message, Message, Any]): Route

Definition Classes
WebSocketDirectives
def handleWebSocketMessagesForOptionalProtocol(handler: Flow[Message, Message, Any], subprotocol: Option[String]): Route

Definition Classes
WebSocketDirectives
def handleWebSocketMessagesForProtocol(handler: Flow[Message, Message, Any], subprotocol: String): Route

Definition Classes
WebSocketDirectives
def handleWith[A, B](f: (A) ⇒ B)(implicit um: FromRequestUnmarshaller[A], m: ToResponseMarshaller[B]): Route

Definition Classes
MarshallingDirectives
def hasAdminPermission(loggedUser: LoggedUser): Directive0

Definition Classes
AuthorizeProcessDirectives
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def head: Directive0

Definition Classes
MethodDirectives
def headerValue[T](f: (HttpHeader) ⇒ Option[T]): Directive1[T]

Definition Classes
HeaderDirectives
def headerValueByName(headerName: String): Directive1[String]

Definition Classes
HeaderDirectives
def headerValueByName(headerName: Symbol): Directive1[String]

Definition Classes
HeaderDirectives
def headerValueByType[T](magnet: HeaderMagnet[T]): Directive1[T]

Definition Classes
HeaderDirectives
def headerValuePF[T](pf: PartialFunction[HttpHeader, T]): Directive1[T]

Definition Classes
HeaderDirectives
def host(regex: Regex): Directive1[String]

Definition Classes
HostDirectives
def host(predicate: (String) ⇒ Boolean): Directive0

Definition Classes
HostDirectives
def host(hostNames: String*): Directive0

Definition Classes
HostDirectives
def ignoreTrailingSlash: Directive0

Definition Classes
PathDirectives
def instanceOf[T](implicit m: ToResponseMarshaller[T]): ToResponseMarshaller[T]

Definition Classes
MarshallingDirectives
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit final def jsonMarshaller(implicit printer: Printer): ToEntityMarshaller[Json]

Definition Classes
BaseCirceSupport
implicit final val jsonUnmarshaller: FromEntityUnmarshaller[Json]

Definition Classes
BaseCirceSupport
def listDirectoryContents(directories: String*)(implicit renderer: DirectoryRenderer): Route

Definition Classes
FileAndResourceDirectives
def logRequest(magnet: LoggingMagnet[(HttpRequest) ⇒ Unit]): Directive0

Definition Classes
DebuggingDirectives
def logRequestResult(magnet: LoggingMagnet[(HttpRequest) ⇒ (RouteResult) ⇒ Unit]): Directive0

Definition Classes
DebuggingDirectives
def logResult(magnet: LoggingMagnet[(RouteResult) ⇒ Unit]): Directive0

Definition Classes
DebuggingDirectives
def mapInnerRoute(f: (Route) ⇒ Route): Directive0

Definition Classes
BasicDirectives
def mapRejections(f: (Seq[Rejection]) ⇒ Seq[Rejection]): Directive0

Definition Classes
BasicDirectives
def mapRequest(f: (HttpRequest) ⇒ HttpRequest): Directive0

Definition Classes
BasicDirectives
def mapRequestContext(f: (RequestContext) ⇒ RequestContext): Directive0

Definition Classes
BasicDirectives
def mapResponse(f: (HttpResponse) ⇒ HttpResponse): Directive0

Definition Classes
BasicDirectives
def mapResponseEntity(f: (ResponseEntity) ⇒ ResponseEntity): Directive0

Definition Classes
BasicDirectives
def mapResponseHeaders(f: (Seq[HttpHeader]) ⇒ Seq[HttpHeader]): Directive0

Definition Classes
BasicDirectives
def mapRouteResult(f: (RouteResult) ⇒ RouteResult): Directive0

Definition Classes
BasicDirectives
def mapRouteResultFuture(f: (Future[RouteResult]) ⇒ Future[RouteResult]): Directive0

Definition Classes
BasicDirectives
def mapRouteResultPF(f: PartialFunction[RouteResult, RouteResult]): Directive0

Definition Classes
BasicDirectives
def mapRouteResultWith(f: (RouteResult) ⇒ Future[RouteResult]): Directive0

Definition Classes
BasicDirectives
def mapRouteResultWithPF(f: PartialFunction[RouteResult, Future[RouteResult]]): Directive0

Definition Classes
BasicDirectives
def mapSettings(f: (RoutingSettings) ⇒ RoutingSettings): Directive0

Definition Classes
BasicDirectives
def mapUnmatchedPath(f: (Path) ⇒ Path): Directive0

Definition Classes
BasicDirectives
implicit final def marshaller[A](implicit arg0: Encoder[A], printer: Printer): ToEntityMarshaller[A]

Definition Classes
BaseCirceSupport
def mediaTypes: Seq[WithFixedCharset]

Definition Classes
BaseCirceSupport
def method(httpMethod: HttpMethod): Directive0

Definition Classes
MethodDirectives
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nothingMatcher[L](implicit arg0: Tuple[L]): PathMatcher[L]

Definition Classes
PathMatchers
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def onComplete[T](future: ⇒ Future[T]): Directive1[Try[T]]

Definition Classes
FutureDirectives
def onCompleteWithBreaker[T](breaker: CircuitBreaker)(future: ⇒ Future[T]): Directive1[Try[T]]

Definition Classes
FutureDirectives
def onSuccess(magnet: OnSuccessMagnet): Directive[Out]

Definition Classes
FutureDirectives
def optionalCookie(name: String): Directive1[Option[HttpCookiePair]]

Definition Classes
CookieDirectives
def optionalHeaderValue[T](f: (HttpHeader) ⇒ Option[T]): Directive1[Option[T]]

Definition Classes
HeaderDirectives
def optionalHeaderValueByName(headerName: String): Directive1[Option[String]]

Definition Classes
HeaderDirectives
def optionalHeaderValueByName(headerName: Symbol): Directive1[Option[String]]

Definition Classes
HeaderDirectives
def optionalHeaderValueByType[T <: HttpHeader](magnet: HeaderMagnet[T]): Directive1[Option[T]]

Definition Classes
HeaderDirectives
def optionalHeaderValuePF[T](pf: PartialFunction[HttpHeader, T]): Directive1[Option[T]]

Definition Classes
HeaderDirectives
def options: Directive0

Definition Classes
MethodDirectives
def overrideMethodWithParameter(paramName: String): Directive0

Definition Classes
MethodDirectives
def parameter(pdm: ParamMagnet): Out

Definition Classes
ParameterDirectives
def parameterMap: Directive1[Map[String, String]]

Definition Classes
ParameterDirectives
def parameterMultiMap: Directive1[Map[String, List[String]]]

Definition Classes
ParameterDirectives
def parameterSeq: Directive1[Seq[(String, String)]]

Definition Classes
ParameterDirectives
def parameters(pdm: ParamMagnet): Out

Definition Classes
ParameterDirectives
def pass: Directive0

Definition Classes
BasicDirectives
def patch: Directive0

Definition Classes
MethodDirectives
def path[L](pm: PathMatcher[L]): Directive[L]

Definition Classes
PathDirectives
def pathEnd: Directive0

Definition Classes
PathDirectives
def pathEndOrSingleSlash: Directive0

Definition Classes
PathDirectives
def pathPrefix[L](pm: PathMatcher[L]): Directive[L]

Definition Classes
PathDirectives
def pathPrefixTest[L](pm: PathMatcher[L]): Directive[L]

Definition Classes
PathDirectives
def pathSingleSlash: Directive0

Definition Classes
PathDirectives
def pathSuffix[L](pm: PathMatcher[L]): Directive[L]

Definition Classes
PathDirectives
def pathSuffixTest[L](pm: PathMatcher[L]): Directive[L]

Definition Classes
PathDirectives
def post: Directive0

Definition Classes
MethodDirectives
val processAuthorizer: AuthorizeProcess

Definition Classes
TestInfoResources → AuthorizeProcessDirectives
def processDetailsForName[PS](processName: String)(implicit arg0: ProcessShapeFetchStrategy[PS], loggedUser: LoggedUser): Directive1[BaseProcessDetails[PS]]

Definition Classes
ProcessDirectives
def processId(processName: String): Directive1[ProcessIdWithName]

Definition Classes
ProcessDirectives
def processIdWithCategory(processName: String): Directive1[ProcessIdWithNameAndCategory]

Definition Classes
ProcessDirectives
val processRepository: FetchingProcessRepository[Future]

Definition Classes
TestInfoResources → ProcessDirectives
def provide[T](value: T): Directive1[T]

Definition Classes
BasicDirectives
def put: Directive0

Definition Classes
MethodDirectives
def rawPathPrefix[L](pm: PathMatcher[L]): Directive[L]

Definition Classes
PathDirectives
def rawPathPrefixTest[L](pm: PathMatcher[L]): Directive[L]

Definition Classes
PathDirectives
def recoverRejections(f: (Seq[Rejection]) ⇒ RouteResult): Directive0

Definition Classes
BasicDirectives
def recoverRejectionsWith(f: (Seq[Rejection]) ⇒ Future[RouteResult]): Directive0

Definition Classes
BasicDirectives
def redirect(uri: Uri, redirectionType: Redirection): StandardRoute

Definition Classes
RouteDirectives
def redirectToNoTrailingSlashIfPresent(redirectionType: Redirection): Directive0

Definition Classes
PathDirectives
def redirectToTrailingSlashIfMissing(redirectionType: Redirection): Directive0

Definition Classes
PathDirectives
def reject(rejections: Rejection*): StandardRoute

Definition Classes
RouteDirectives
def reject: StandardRoute

Definition Classes
RouteDirectives
def rejectEmptyResponse: Directive0

Definition Classes
MiscDirectives
def requestEncodedWith(encoding: HttpEncoding): Directive0

Definition Classes
CodingDirectives
def requestEntityEmpty: Directive0

Definition Classes
MiscDirectives
def requestEntityPresent: Directive0

Definition Classes
MiscDirectives
def respondWithDefaultHeader(responseHeader: HttpHeader): Directive0

Definition Classes
RespondWithDirectives
def respondWithDefaultHeaders(responseHeaders: HttpHeader*): Directive0

Definition Classes
RespondWithDirectives
def respondWithDefaultHeaders(responseHeaders: Seq[HttpHeader]): Directive0

Definition Classes
RespondWithDirectives
def respondWithHeader(responseHeader: HttpHeader): Directive0

Definition Classes
RespondWithDirectives
def respondWithHeaders(responseHeaders: HttpHeader*): Directive0

Definition Classes
RespondWithDirectives
def respondWithHeaders(responseHeaders: Seq[HttpHeader]): Directive0

Definition Classes
RespondWithDirectives
def responseEncodingAccepted(encoding: HttpEncoding): Directive0

Definition Classes
CodingDirectives
implicit final val safeJsonUnmarshaller: FromEntityUnmarshaller[Either[ParsingFailure, Json]]

Definition Classes
BaseCirceSupport
implicit final def safeUnmarshaller[A](implicit arg0: Decoder[A]): FromEntityUnmarshaller[Either[Error, A]]

Definition Classes
FailFastUnmarshaller
def scheme(name: String): Directive0

Definition Classes
SchemeDirectives
def securedRoute(implicit user: LoggedUser): Route

Definition Classes
TestInfoResources → RouteWithUser
def selectPreferredLanguage(first: Language, more: Language*): Directive1[Language]

Definition Classes
MiscDirectives
def separateOnSlashes(string: String): PathMatcher0

Definition Classes
PathMatchers
def setCookie(first: HttpCookie, more: HttpCookie*): Directive0

Definition Classes
CookieDirectives
def storeUploadedFile(fieldName: String, destFn: (FileInfo) ⇒ File): Directive[(FileInfo, File)]

Definition Classes
FileUploadDirectives
Annotations
@ApiMayChange()
def storeUploadedFiles(fieldName: String, destFn: (FileInfo) ⇒ File): Directive1[Seq[(FileInfo, File)]]

Definition Classes
FileUploadDirectives
Annotations
@ApiMayChange()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def textract[L](f: (RequestContext) ⇒ L)(implicit arg0: Tuple[L]): Directive[L]

Definition Classes
BasicDirectives
implicit val timeout: Timeout
def toStrictEntity(timeout: FiniteDuration, maxBytes: Long): Directive0

Definition Classes
BasicDirectives
def toStrictEntity(timeout: FiniteDuration): Directive0

Definition Classes
BasicDirectives
def toString(): String

Definition Classes
AnyRef → Any
def tprovide[L](values: L)(implicit arg0: Tuple[L]): Directive[L]

Definition Classes
BasicDirectives
implicit final def unmarshaller[A](implicit arg0: Decoder[A]): FromEntityUnmarshaller[A]

Definition Classes
FailFastUnmarshaller
def unmarshallerContentTypes: Seq[ContentTypeRange]

Definition Classes
BaseCirceSupport
def validate(check: ⇒ Boolean, errorMsg: String): Directive0

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

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withExecutionContext(ec: ExecutionContextExecutor): Directive0

Definition Classes
BasicDirectives
def withLog(log: LoggingAdapter): Directive0

Definition Classes
BasicDirectives
def withMaterializer(materializer: Materializer): Directive0

Definition Classes
BasicDirectives
def withPrecompressedMediaTypeSupport: Directive0

Definition Classes
CodingDirectives
def withRangeSupport: Directive0

Definition Classes
RangeDirectives
def withRequestTimeout(timeout: Duration, handler: Option[(HttpRequest) ⇒ HttpResponse]): Directive0

Definition Classes
TimeoutDirectives
def withRequestTimeout(timeout: Duration, handler: (HttpRequest) ⇒ HttpResponse): Directive0

Definition Classes
TimeoutDirectives
def withRequestTimeout(timeout: Duration): Directive0

Definition Classes
TimeoutDirectives
def withRequestTimeoutResponse(handler: (HttpRequest) ⇒ HttpResponse): Directive0

Definition Classes
TimeoutDirectives
def withSettings(settings: RoutingSettings): Directive0

Definition Classes
BasicDirectives
def withSizeLimit(maxBytes: Long): Directive0

Definition Classes
MiscDirectives
def withoutRequestTimeout: Directive0

Definition Classes
TimeoutDirectives
def withoutSizeLimit: Directive0

Definition Classes
MiscDirectives

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.
def uploadedFile(fieldName: String): Directive1[(FileInfo, File)]

Definition Classes
FileUploadDirectives
Annotations
@deprecated
Deprecated
(Since version 10.0.11) Deprecated in favor of storeUploadedFile which allows to specify a file to store the upload in.

Related Docs: object TestInfoResources | package api

class TestInfoResources extends Directives with FailFastCirceSupport with RouteWithUser with AuthorizeProcessDirectives with ProcessDirectives

Instance Constructors

new TestInfoResources(providers: ProcessingTypeDataProvider[TestInfoProvider], processAuthorizer: AuthorizeProcess, processRepository: FetchingProcessRepository[Future])(implicit ec: ExecutionContext)

Type Members

type AsyncAuthenticator[T] = (Credentials) ⇒ Future[Option[T]]

type AsyncAuthenticatorPF[T] = PartialFunction[Credentials, Future[T]]

type AuthenticationResult[+T] = Either[HttpChallenge, T]

type Authenticator[T] = (Credentials) ⇒ Option[T]

type AuthenticatorPF[T] = PartialFunction[Credentials, T]

abstract class NumberMatcher[T] extends PathMatcher1[T]

type RequestToSourceUnmarshaller[T] = Unmarshaller[HttpRequest, Source[T, NotUsed]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val DoubleNumber: PathMatcher1[Double]

object IntNumber extends NumberMatcher[Int]

val JavaUUID: PathMatcher1[UUID]

object LongNumber extends NumberMatcher[Long]

val Neutral: PathMatcher0

object Segment extends PathMatcher1[String]

def Segments(min: Int, max: Int): PathMatcher1[List[String]]

def Segments(count: Int): PathMatcher1[List[String]]

val Segments: PathMatcher1[List[String]]

def _defaultClassLoader: ClassLoader

implicit def _enhanceRouteWithConcatenation(route: Route): RouteWithConcatenation

implicit def _regex2PathMatcher(regex: Regex): PathMatcher1[String]

implicit def _segmentStringToPathMatcher(segment: String): PathMatcher0

implicit def _string2NR(string: String): NameReceptacle[String]

implicit def _stringExtractionPair2PathMatcher[T](tuple: (String, T)): PathMatcher1[T]

implicit def _stringNameOptionReceptacle2PathMatcher(nr: NameOptionReceptacle[String]): PathMatcher0

implicit def _symbol2NR(symbol: Symbol): NameReceptacle[String]

implicit def _valueMap2PathMatcher[T](valueMap: Map[String, T]): PathMatcher1[T]

def as[T](implicit um: FromRequestUnmarshaller[T]): FromRequestUnmarshaller[T]

final def asInstanceOf[T0]: T0

final def asSourceOf[T](support: EntityStreamingSupport)(implicit um: FromByteStringUnmarshaller[T]): RequestToSourceUnmarshaller[T]

final def asSourceOf[T](implicit um: FromByteStringUnmarshaller[T], support: EntityStreamingSupport): RequestToSourceUnmarshaller[T]

implicit def attachImplicitUserToProcessId(id: ProcessId)(implicit loggedUser: LoggedUser): (ProcessId, LoggedUser)

implicit def attachImplicitUserToProcessIdWithName(id: ProcessIdWithName)(implicit loggedUser: LoggedUser): (ProcessId, LoggedUser)

def authenticateBasic[T](realm: String, authenticator: Authenticator[T]): AuthenticationDirective[T]

def authenticateBasicAsync[T](realm: String, authenticator: AsyncAuthenticator[T]): AuthenticationDirective[T]

def authenticateBasicPF[T](realm: String, authenticator: AuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateBasicPFAsync[T](realm: String, authenticator: AsyncAuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateOAuth2[T](realm: String, authenticator: Authenticator[T]): AuthenticationDirective[T]

def authenticateOAuth2Async[T](realm: String, authenticator: AsyncAuthenticator[T]): AuthenticationDirective[T]

def authenticateOAuth2PF[T](realm: String, authenticator: AuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateOAuth2PFAsync[T](realm: String, authenticator: AsyncAuthenticatorPF[T]): AuthenticationDirective[T]

def authenticateOrRejectWithChallenge[C <: HttpCredentials, T](authenticator: (Option[C]) ⇒ Future[AuthenticationResult[T]])(implicit arg0: ClassTag[C]): AuthenticationDirective[T]

def authenticateOrRejectWithChallenge[T](authenticator: (Option[HttpCredentials]) ⇒ Future[AuthenticationResult[T]]): AuthenticationDirective[T]

def authorize(check: (RequestContext) ⇒ Boolean): Directive0

def authorize(check: ⇒ Boolean): Directive0

def authorizeAsync(check: (RequestContext) ⇒ Future[Boolean]): Directive0

def authorizeAsync(check: ⇒ Future[Boolean]): Directive0

def canDeploy(processIdAndUser: (ProcessId, LoggedUser)): Directive0

def canWrite(processIdAndUser: (ProcessId, LoggedUser)): Directive0

def cancelRejection(rejection: Rejection): Directive0

def cancelRejections(cancelFilter: (Rejection) ⇒ Boolean): Directive0

def cancelRejections(classes: Class[_]*): Directive0

def checkSameOrigin(allowed: Default): Directive0

def clone(): AnyRef

def complete(m: ⇒ ToResponseMarshallable): StandardRoute

def completeOrRecoverWith(magnet: CompleteOrRecoverWithMagnet): Directive1[Throwable]

def completeWith[T](marshaller: ToResponseMarshaller[T])(inner: ((T) ⇒ Unit) ⇒ Unit): Route

def concat(routes: Route*): Route

def conditional(eTag: Option[EntityTag], lastModified: Option[DateTime]): Directive0

def conditional(eTag: EntityTag, lastModified: DateTime): Directive0

def conditional(lastModified: DateTime): Directive0

def conditional(eTag: EntityTag): Directive0

def cookie(name: String): Directive1[HttpCookiePair]

def decodeRequest: Directive0

def decodeRequestWith(decoders: Decoder*): Directive0

def decodeRequestWith(decoder: Decoder): Directive0

def delete: Directive0

def deleteCookie(name: String, domain: String, path: String): Directive0

def deleteCookie(first: HttpCookie, more: HttpCookie*): Directive0

implicit val ec: ExecutionContext

def encodeResponse: Directive0

def encodeResponseWith(first: Encoder, more: Encoder*): Directive0