1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
package akka.http.scaladsl.testkit
import akka.actor.ActorSystem
import akka.http.javadsl.testkit.DefaultHostInfo
import akka.http.scaladsl.model._
import akka.http.scaladsl.model.headers.{Host, RawHeader}
import akka.http.scaladsl.server._
import akka.http.scaladsl.settings.RoutingSettings
import akka.http.scaladsl.unmarshalling.Unmarshal
import akka.stream.{ActorMaterializer, Materializer}
import org.slf4j.MDC
import xyz.driver.core.rest.errors.ExternalServiceException
import xyz.driver.core.rest.{ContextHeaders, ServiceRequestContext, ServiceTransport}
import scala.concurrent.{ExecutionContextExecutor, Future}
import scala.concurrent.duration._
class TestRouteServiceTransport(route: Route, routeTimeout: FiniteDuration = 10 seconds)(
implicit executor: ExecutionContextExecutor,
system: ActorSystem)
extends ServiceTransport with RouteTestResultComponent {
def defaultHost: DefaultHostInfo = DefaultHostInfo(Host("example.com"), securedConnection = false)
def routingLog: RoutingLog = RoutingLog(system.log)
def routingSettings: RoutingSettings = RoutingSettings.apply(system)
implicit val materializer = ActorMaterializer()
override def sendRequestGetResponse(context: ServiceRequestContext)(
requestStub: HttpRequest): Future[HttpResponse] = {
val request = requestStub
.withHeaders(requestStub.headers ++ context.contextHeaders.toSeq.map {
case (ContextHeaders.TrackingIdHeader, _) =>
RawHeader(ContextHeaders.TrackingIdHeader, context.trackingId)
case (ContextHeaders.StacktraceHeader, _) =>
RawHeader(
ContextHeaders.StacktraceHeader,
Option(MDC.get("stack"))
.orElse(context.contextHeaders.get(ContextHeaders.StacktraceHeader))
.getOrElse(""))
case (header, headerValue) => RawHeader(header, headerValue)
}: _*)
// Code below is forked from `akka.http.scaladsl.testkit.RouteTest.TildeArrow.injectIntoRoute`,
// because it doesn't allow to call just this code outside of the DSL for testkit tests
val routeTestResult = new RouteTestResult(routeTimeout)
val effectiveRequest = request
val log = routingLog.requestLog(effectiveRequest)
val ctx = new RequestContextImpl(effectiveRequest, log, routingSettings)(executor, materializer)
val sealedExceptionHandler = ExceptionHandler.default(routingSettings)
val semiSealedRoute = Directives.handleExceptions(sealedExceptionHandler)(route)
val deferrableRouteResult = semiSealedRoute(ctx)
deferrableRouteResult.map(r => { routeTestResult.handleResult(r); routeTestResult.response })
}
override def sendRequest(context: ServiceRequestContext)(requestStub: HttpRequest)(
implicit mat: Materializer): Future[Unmarshal[ResponseEntity]] = {
sendRequestGetResponse(context)(requestStub) flatMap { response =>
if (response.status == StatusCodes.NotFound) {
Future.successful(Unmarshal(HttpEntity.Empty: ResponseEntity))
} else if (response.status.isFailure()) {
val serviceCalled = s"${requestStub.method} ${requestStub.uri}"
Unmarshal(response.entity).to[String] flatMap { errorString =>
import spray.json._
import xyz.driver.core.json._
val serviceException = scala.util.Try(serviceExceptionFormat.read(errorString.parseJson)).toOption
Future.failed(ExternalServiceException(serviceCalled, errorString, serviceException))
}
} else {
Future.successful(Unmarshal(response.entity))
}
}
}
override def failTest(msg: String): Nothing = throw new Exception(msg)
}
|
