blob: 6d83848b421f2bf6b746f23715d6c6f258be1f54 (
plain) (
blame)
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
|
package com.softwaremill.sttp
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.server.Route
import akka.stream.ActorMaterializer
import org.scalatest.{BeforeAndAfterAll, Suite}
import org.scalatest.concurrent.ScalaFutures
import scala.concurrent.Future
import scala.language.higherKinds
trait TestHttpServer extends BeforeAndAfterAll with ScalaFutures {
this: Suite =>
protected implicit val actorSystem: ActorSystem = ActorSystem("sttp-test")
import actorSystem.dispatcher
protected implicit val materializer = ActorMaterializer()
protected val endpoint = uri"http://localhost:$port"
override protected def beforeAll(): Unit = {
Http().bindAndHandle(serverRoutes, "localhost", port).futureValue
}
override protected def afterAll(): Unit = {
actorSystem.terminate().futureValue
}
def serverRoutes: Route
def port: Int
}
trait ForceWrapped extends ScalaFutures { this: Suite =>
trait ForceWrappedValue[R[_]] {
def force[T](wrapped: R[T]): T
}
object ForceWrappedValue {
val id = new ForceWrappedValue[Id] {
override def force[T](wrapped: Id[T]): T =
wrapped
}
val future = new ForceWrappedValue[Future] {
override def force[T](wrapped: Future[T]): T =
wrapped.futureValue
}
}
implicit class ForceDecorator[R[_], T](wrapped: R[T]) {
def force()(implicit fwv: ForceWrappedValue[R]): T = fwv.force(wrapped)
}
}
object EvalScala {
import scala.tools.reflect.ToolBox
def apply(code: String): Any = {
val m = scala.reflect.runtime.currentMirror
val tb = m.mkToolBox()
tb.eval(tb.parse(code))
}
}
|