1 files changed, 48 insertions, 38 deletions
diff --git a/tests/src/test/scala/com/softwaremill/sttp/testHelpers.scala b/tests/src/test/scala/com/softwaremill/sttp/testHelpers.scala
index 59e1612..407aaca 100644
--- a/tests/src/test/scala/com/softwaremill/sttp/testHelpers.scala
+++ b/tests/src/test/scala/com/softwaremill/sttp/testHelpers.scala
@@ -7,12 +7,13 @@ 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 org.scalatest.exceptions.TestFailedException
 import org.scalatest.matchers.{MatchResult, Matcher}
+import org.scalatest.{BeforeAndAfterAll, Suite}
 
 import scala.concurrent.Future
+import scala.concurrent.duration._
 import scala.language.higherKinds
 import scalaz._
 
@@ -36,45 +37,54 @@ trait TestHttpServer extends BeforeAndAfterAll with ScalaFutures {
   def port: Int
 }
 
-trait ForceWrapped extends ScalaFutures { this: Suite =>
-  trait ForceWrappedValue[R[_]] {
-    def force[T](wrapped: R[T]): T
+trait ForceWrappedValue[R[_]] {
+  def force[T](wrapped: R[T]): T
+}
+
+object ForceWrappedValue extends ScalaFutures {
+  override implicit val patienceConfig: PatienceConfig =
+    PatienceConfig(timeout = 5.seconds, interval = 150.milliseconds)
+
+  val id = new ForceWrappedValue[Id] {
+    override def force[T](wrapped: Id[T]): T =
+      wrapped
   }
-  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 =
-        try {
-          wrapped.futureValue
-        } catch {
-          case e: TestFailedException if e.getCause != null => throw e.getCause
-        }
-    }
-    val scalazTask = new ForceWrappedValue[scalaz.concurrent.Task] {
-      override def force[T](wrapped: scalaz.concurrent.Task[T]): T =
-        wrapped.unsafePerformSyncAttempt match {
-          case -\/(error) => throw error
-          case \/-(value) => value
-        }
-    }
-    val monixTask = new ForceWrappedValue[monix.eval.Task] {
-      import monix.execution.Scheduler.Implicits.global
-
-      override def force[T](wrapped: monix.eval.Task[T]): T =
-        try {
-          wrapped.runAsync.futureValue
-        } catch {
-          case e: TestFailedException => throw e.getCause
-        }
-    }
-    val catsIo = new ForceWrappedValue[cats.effect.IO] {
-      override def force[T](wrapped: cats.effect.IO[T]): T =
-        wrapped.unsafeRunSync
-    }
+  val future = new ForceWrappedValue[Future] {
+
+    override def force[T](wrapped: Future[T]): T =
+      try {
+        wrapped.futureValue
+      } catch {
+        case e: TestFailedException if e.getCause != null => throw e.getCause
+      }
+  }
+  val scalazTask = new ForceWrappedValue[scalaz.concurrent.Task] {
+    override def force[T](wrapped: scalaz.concurrent.Task[T]): T =
+      wrapped.unsafePerformSyncAttempt match {
+        case -\/(error) => throw error
+        case \/-(value) => value
+      }
+  }
+  val monixTask = new ForceWrappedValue[monix.eval.Task] {
+    import monix.execution.Scheduler.Implicits.global
+
+    override def force[T](wrapped: monix.eval.Task[T]): T =
+      try {
+        wrapped.runAsync.futureValue
+      } catch {
+        case e: TestFailedException => throw e.getCause
+      }
   }
+  val catsIo = new ForceWrappedValue[cats.effect.IO] {
+    override def force[T](wrapped: cats.effect.IO[T]): T =
+      wrapped.unsafeRunSync
+  }
+}
+
+trait ForceWrapped extends ScalaFutures { this: Suite =>
+  type ForceWrappedValue[R[_]] = com.softwaremill.sttp.ForceWrappedValue[R]
+  val ForceWrappedValue: com.softwaremill.sttp.ForceWrappedValue.type =
+    com.softwaremill.sttp.ForceWrappedValue
 
   implicit class ForceDecorator[R[_], T](wrapped: R[T]) {
     def force()(implicit fwv: ForceWrappedValue[R]): T = fwv.force(wrapped)