Merge branch 'master' into wip-sync-2.4.10-patriknw

akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/TimeoutDirectivesExamplesSpec.scala

@@ -18,25 +18,23 @@ import scala.concurrent.duration._
 import scala.concurrent.{ Future, Promise }
 import akka.testkit.AkkaSpec
 
-private[this] object TimeoutDirectivesTestConfig {
+private[this] object TimeoutDirectivesInfiniteTimeoutTestConfig {
   val testConf: Config = ConfigFactory.parseString("""
     akka.loggers = ["akka.testkit.TestEventListener"]
     akka.loglevel = ERROR
     akka.stdout-loglevel = ERROR
     windows-connection-abort-workaround-enabled = auto
     akka.log-dead-letters = OFF
-    akka.http.server.request-timeout = 1000s""")
-  // large timeout - 1000s (please note - setting to infinite will disable Timeout-Access header
-  // and withRequestTimeout will not work)
+    akka.http.server.request-timeout = infinite""")
 }
 
-class TimeoutDirectivesExamplesSpec extends AkkaSpec(TimeoutDirectivesTestConfig.testConf)
+class TimeoutDirectivesExamplesSpec extends AkkaSpec(TimeoutDirectivesInfiniteTimeoutTestConfig.testConf)
   with ScalaFutures with CompileOnlySpec {
   //#testSetup
   import system.dispatcher
   implicit val materializer = ActorMaterializer()
 
-  def slowFuture(): Future[String] = Promise[String].future // move to Future.never in Scala 2.12
+  def slowFuture(): Future[String] = Promise[String].future // TODO: move to Future.never in Scala 2.12
 
   def runRoute(route: Route, routePath: String): HttpResponse = {
     val (_, hostname, port) = TestUtils.temporaryServerHostnameAndPort()
@@ -51,8 +49,9 @@ class TimeoutDirectivesExamplesSpec extends AkkaSpec(TimeoutDirectivesTestConfig
 
   //#
 
+  // demonstrates that timeout is correctly set despite infinite initial value of akka.http.server.request-timeout
   "Request Timeout" should {
-    "be configurable in routing layer" in {
+    "be configurable in routing layer despite infinite initial value of request-timeout" in {
       //#withRequestTimeout-plain
       val route =
         path("timeout") {
@@ -124,3 +123,47 @@ class TimeoutDirectivesExamplesSpec extends AkkaSpec(TimeoutDirectivesTestConfig
   }
 
 }
+
+private[this] object TimeoutDirectivesFiniteTimeoutTestConfig {
+  val testConf: Config = ConfigFactory.parseString("""
+    akka.loggers = ["akka.testkit.TestEventListener"]
+    akka.loglevel = ERROR
+    akka.stdout-loglevel = ERROR
+    windows-connection-abort-workaround-enabled = auto
+    akka.log-dead-letters = OFF
+    akka.http.server.request-timeout = 1000s""")
+}
+
+class TimeoutDirectivesFiniteTimeoutExamplesSpec extends AkkaSpec(TimeoutDirectivesFiniteTimeoutTestConfig.testConf)
+  with ScalaFutures with CompileOnlySpec {
+  import system.dispatcher
+  implicit val materializer = ActorMaterializer()
+
+  def slowFuture(): Future[String] = Promise[String].future // TODO: move to Future.never in Scala 2.12
+
+  def runRoute(route: Route, routePath: String): HttpResponse = {
+    val (_, hostname, port) = TestUtils.temporaryServerHostnameAndPort()
+    val binding = Http().bindAndHandle(route, hostname, port)
+
+    val response = Http().singleRequest(HttpRequest(uri = s"http://$hostname:$port/$routePath")).futureValue
+
+    binding.flatMap(_.unbind()).futureValue
+
+    response
+  }
+
+  // demonstrates that timeout is correctly modified for finite initial values of akka.http.server.request-timeout
+  "Request Timeout" should {
+    "be configurable in routing layer for finite initial value of request-timeout" in {
+      val route =
+        path("timeout") {
+          withRequestTimeout(1.seconds) { // modifies the global akka.http.server.request-timeout for this request
+            val response: Future[String] = slowFuture() // very slow
+            complete(response)
+          }
+        }
+      runRoute(route, "timeout").status should ===(StatusCodes.ServiceUnavailable) // the timeout response
+    }
+  }
+
+}

akka-docs/rst/scala/code/docs/stream/StreamTestKitDocSpec.scala

@@ -22,7 +22,7 @@ class StreamTestKitDocSpec extends AkkaSpec {
     val sinkUnderTest = Flow[Int].map(_ * 2).toMat(Sink.fold(0)(_ + _))(Keep.right)
 
     val future = Source(1 to 4).runWith(sinkUnderTest)
-    val result = Await.result(future, 100.millis)
+    val result = Await.result(future, 3.seconds)
     assert(result == 20)
     //#strict-collection
   }
@@ -34,8 +34,8 @@ class StreamTestKitDocSpec extends AkkaSpec {
 
     val sourceUnderTest = Source.repeat(1).map(_ * 2)
 
-    val future = sourceUnderTest.grouped(10).runWith(Sink.head)
-    val result = Await.result(future, 100.millis)
+    val future = sourceUnderTest.take(10).runWith(Sink.seq)
+    val result = Await.result(future, 3.seconds)
     assert(result == Seq.fill(10)(2))
     //#grouped-infinite
   }
@@ -45,7 +45,7 @@ class StreamTestKitDocSpec extends AkkaSpec {
     val flowUnderTest = Flow[Int].takeWhile(_ < 5)
 
     val future = Source(1 to 10).via(flowUnderTest).runWith(Sink.fold(Seq.empty[Int])(_ :+ _))
-    val result = Await.result(future, 100.millis)
+    val result = Await.result(future, 3.seconds)
     assert(result == (1 to 4))
     //#folded-stream
   }
@@ -58,8 +58,8 @@ class StreamTestKitDocSpec extends AkkaSpec {
     val sourceUnderTest = Source(1 to 4).grouped(2)
 
     val probe = TestProbe()
-    sourceUnderTest.grouped(2).runWith(Sink.head).pipeTo(probe.ref)
-    probe.expectMsg(100.millis, Seq(Seq(1, 2), Seq(3, 4)))
+    sourceUnderTest.runWith(Sink.seq).pipeTo(probe.ref)
+    probe.expectMsg(3.seconds, Seq(Seq(1, 2), Seq(3, 4)))
     //#pipeto-testprobe
   }
 
@@ -73,9 +73,9 @@ class StreamTestKitDocSpec extends AkkaSpec {
 
     probe.expectMsg(1.second, Tick)
     probe.expectNoMsg(100.millis)
-    probe.expectMsg(200.millis, Tick)
+    probe.expectMsg(3.seconds, Tick)
     cancellable.cancel()
-    probe.expectMsg(200.millis, "completed")
+    probe.expectMsg(3.seconds, "completed")
     //#sink-actorref
   }
 
@@ -91,7 +91,7 @@ class StreamTestKitDocSpec extends AkkaSpec {
     ref ! 3
     ref ! akka.actor.Status.Success("done")
 
-    val result = Await.result(future, 100.millis)
+    val result = Await.result(future, 3.seconds)
     assert(result == "123")
     //#source-actorref
   }
@@ -128,7 +128,7 @@ class StreamTestKitDocSpec extends AkkaSpec {
       .run()
     probe.sendError(new Exception("boom"))
 
-    Await.ready(future, 100.millis)
+    Await.ready(future, 3.seconds)
     val Failure(exception) = future.value.get
     assert(exception.getMessage == "boom")
     //#injecting-failure

akka-docs/rst/scala/code/docs/testkit/ParentChildSpec.scala

@@ -121,6 +121,17 @@ class ParentChildSpec extends WordSpec with Matchers with TestKitBase with Befor
     }
   }
 
+  //#test-TestProbe-parent
+  "A TestProbe serving as parent" should {
+    "test its child responses" in {
+      val parent = TestProbe()
+      val child = parent.childActorOf(Props[Child])
+      parent.send(child, "ping")
+      parent.expectMsg("pong")
+    }
+  }
+  //#test-TestProbe-parent
+
   //#test-fabricated-parent
   "A fabricated parent" should {
     "test its child responses" in {