Getting Started tutorial improvements (#23210)

akka-docs/src/test/scala/tutorial_6/Device.scala

@@ -0,0 +1,46 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package tutorial_6
+
+import akka.actor.{ Actor, ActorLogging, Props }
+
+object Device {
+
+  def props(groupId: String, deviceId: String): Props = Props(new Device(groupId, deviceId))
+
+  final case class RecordTemperature(requestId: Long, value: Double)
+  final case class TemperatureRecorded(requestId: Long)
+
+  final case class ReadTemperature(requestId: Long)
+  final case class RespondTemperature(requestId: Long, value: Option[Double])
+}
+
+class Device(groupId: String, deviceId: String) extends Actor with ActorLogging {
+  import Device._
+
+  var lastTemperatureReading: Option[Double] = None
+
+  override def preStart(): Unit = log.info("Device actor {}-{} started", groupId, deviceId)
+
+  override def postStop(): Unit = log.info("Device actor {}-{} stopped", groupId, deviceId)
+
+  override def receive: Receive = {
+    case DeviceManager.RequestTrackDevice(`groupId`, `deviceId`) =>
+      sender() ! DeviceManager.DeviceRegistered
+
+    case DeviceManager.RequestTrackDevice(groupId, deviceId) =>
+      log.warning(
+        "Ignoring TrackDevice request for {}-{}.This actor is responsible for {}-{}.",
+        groupId, deviceId, this.groupId, this.deviceId
+      )
+
+    case RecordTemperature(id, value) =>
+      log.info("Recorded temperature reading {} with {}", value, id)
+      lastTemperatureReading = Some(value)
+      sender() ! TemperatureRecorded(id)
+
+    case ReadTemperature(id) =>
+      sender() ! RespondTemperature(id, lastTemperatureReading)
+  }
+}

akka-docs/src/test/scala/tutorial_6/DeviceGroup.scala

@@ -0,0 +1,76 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package tutorial_6
+
+import akka.actor.{ Actor, ActorLogging, ActorRef, Props, Terminated }
+import DeviceGroup._
+import DeviceManager.RequestTrackDevice
+import scala.concurrent.duration._
+
+object DeviceGroup {
+
+  def props(groupId: String): Props = Props(new DeviceGroup(groupId))
+
+  final case class RequestDeviceList(requestId: Long)
+  final case class ReplyDeviceList(requestId: Long, ids: Set[String])
+
+  final case class RequestAllTemperatures(requestId: Long)
+  final case class RespondAllTemperatures(requestId: Long, temperatures: Map[String, TemperatureReading])
+
+  sealed trait TemperatureReading
+  final case class Temperature(value: Double) extends TemperatureReading
+  case object TemperatureNotAvailable extends TemperatureReading
+  case object DeviceNotAvailable extends TemperatureReading
+  case object DeviceTimedOut extends TemperatureReading
+}
+
+class DeviceGroup(groupId: String) extends Actor with ActorLogging {
+  var deviceIdToActor = Map.empty[String, ActorRef]
+  var actorToDeviceId = Map.empty[ActorRef, String]
+  var nextCollectionId = 0L
+
+  override def preStart(): Unit = log.info("DeviceGroup {} started", groupId)
+
+  override def postStop(): Unit = log.info("DeviceGroup {} stopped", groupId)
+
+  override def receive: Receive = {
+    // Note the backticks
+    case trackMsg @ RequestTrackDevice(`groupId`, _) =>
+      deviceIdToActor.get(trackMsg.deviceId) match {
+        case Some(ref) =>
+          ref forward trackMsg
+        case None =>
+          log.info("Creating device actor for {}", trackMsg.deviceId)
+          val deviceActor = context.actorOf(Device.props(groupId, trackMsg.deviceId), "device-" + trackMsg.deviceId)
+          context.watch(deviceActor)
+          deviceActor forward trackMsg
+          deviceIdToActor += trackMsg.deviceId -> deviceActor
+          actorToDeviceId += deviceActor -> trackMsg.deviceId
+      }
+
+    case RequestTrackDevice(groupId, deviceId) =>
+      log.warning(
+        "Ignoring TrackDevice request for {}. This actor is responsible for {}.",
+        groupId, this.groupId
+      )
+
+    case RequestDeviceList(requestId) =>
+      sender() ! ReplyDeviceList(requestId, deviceIdToActor.keySet)
+
+    case Terminated(deviceActor) =>
+      val deviceId = actorToDeviceId(deviceActor)
+      log.info("Device actor for {} has been terminated", deviceId)
+      actorToDeviceId -= deviceActor
+      deviceIdToActor -= deviceId
+
+    case RequestAllTemperatures(requestId) =>
+      context.actorOf(DeviceGroupQuery.props(
+        actorToDeviceId = actorToDeviceId,
+        requestId = requestId,
+        requester = sender(),
+        3.seconds
+      ))
+  }
+
+}

akka-docs/src/test/scala/tutorial_6/DeviceGroupQuery.scala

@@ -0,0 +1,98 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package tutorial_6
+
+import akka.actor.Actor.Receive
+import akka.actor.{ Actor, ActorLogging, ActorRef, Props, Terminated }
+
+import scala.concurrent.duration._
+
+object DeviceGroupQuery {
+
+  case object CollectionTimeout
+
+  def props(
+    actorToDeviceId: Map[ActorRef, String],
+    requestId:       Long,
+    requester:       ActorRef,
+    timeout:         FiniteDuration
+  ): Props = {
+    Props(new DeviceGroupQuery(actorToDeviceId, requestId, requester, timeout))
+  }
+}
+
+class DeviceGroupQuery(
+  actorToDeviceId: Map[ActorRef, String],
+  requestId:       Long,
+  requester:       ActorRef,
+  timeout:         FiniteDuration
+) extends Actor with ActorLogging {
+  import DeviceGroupQuery._
+  import context.dispatcher
+  val queryTimeoutTimer = context.system.scheduler.scheduleOnce(timeout, self, CollectionTimeout)
+
+  override def preStart(): Unit = {
+    actorToDeviceId.keysIterator.foreach { deviceActor =>
+      context.watch(deviceActor)
+      deviceActor ! Device.ReadTemperature(0)
+    }
+
+  }
+
+  override def postStop(): Unit = {
+    queryTimeoutTimer.cancel()
+  }
+
+  override def receive: Receive =
+    waitingForReplies(
+      Map.empty,
+      actorToDeviceId.keySet
+    )
+
+  def waitingForReplies(
+    repliesSoFar: Map[String, DeviceGroup.TemperatureReading],
+    stillWaiting: Set[ActorRef]
+  ): Receive = {
+    case Device.RespondTemperature(0, valueOption) =>
+      val deviceActor = sender()
+      val reading = valueOption match {
+        case Some(value) => DeviceGroup.Temperature(value)
+        case None        => DeviceGroup.TemperatureNotAvailable
+      }
+      receivedResponse(deviceActor, reading, stillWaiting, repliesSoFar)
+
+    case Terminated(deviceActor) =>
+      if (stillWaiting.contains(deviceActor))
+        receivedResponse(deviceActor, DeviceGroup.DeviceNotAvailable, stillWaiting, repliesSoFar)
+    // else ignore
+
+    case CollectionTimeout =>
+      val timedOutReplies =
+        stillWaiting.map { deviceActor =>
+          val deviceId = actorToDeviceId(deviceActor)
+          deviceId -> DeviceGroup.DeviceTimedOut
+        }
+      requester ! DeviceGroup.RespondAllTemperatures(requestId, repliesSoFar ++ timedOutReplies)
+      context.stop(self)
+  }
+
+  def receivedResponse(
+    deviceActor:  ActorRef,
+    reading:      DeviceGroup.TemperatureReading,
+    stillWaiting: Set[ActorRef],
+    repliesSoFar: Map[String, DeviceGroup.TemperatureReading]
+  ): Unit = {
+    val deviceId = actorToDeviceId(deviceActor)
+    val newStillWaiting = stillWaiting - deviceActor
+
+    val newRepliesSoFar = repliesSoFar + (deviceId -> reading)
+    if (newStillWaiting.isEmpty) {
+      requester ! DeviceGroup.RespondAllTemperatures(requestId, newRepliesSoFar)
+      context.stop(self)
+    } else {
+      context.become(waitingForReplies(newRepliesSoFar, newStillWaiting))
+    }
+  }
+
+}

akka-docs/src/test/scala/tutorial_6/DeviceGroupQuerySpec.scala

@@ -0,0 +1,157 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package tutorial_6
+
+import akka.actor.PoisonPill
+import akka.testkit.{ AkkaSpec, TestProbe }
+
+import scala.concurrent.duration._
+
+class DeviceGroupQuerySpec extends AkkaSpec {
+
+  "DeviceGroupQuery" must {
+
+    "return temperature value for working devices" in {
+      val requester = TestProbe()
+
+      val device1 = TestProbe()
+      val device2 = TestProbe()
+
+      val queryActor = system.actorOf(DeviceGroupQuery.props(
+        actorToDeviceId = Map(device1.ref -> "device1", device2.ref -> "device2"),
+        requestId = 1,
+        requester = requester.ref,
+        timeout = 3.seconds
+      ))
+
+      device1.expectMsg(Device.ReadTemperature(requestId = 0))
+      device2.expectMsg(Device.ReadTemperature(requestId = 0))
+
+      queryActor.tell(Device.RespondTemperature(requestId = 0, Some(1.0)), device1.ref)
+      queryActor.tell(Device.RespondTemperature(requestId = 0, Some(2.0)), device2.ref)
+
+      requester.expectMsg(DeviceGroup.RespondAllTemperatures(
+        requestId = 1,
+        temperatures = Map(
+          "device1" -> DeviceGroup.Temperature(1.0),
+          "device2" -> DeviceGroup.Temperature(2.0)
+        )
+      ))
+    }
+
+    "return TemperatureNotAvailable for devices with no readings" in {
+      val requester = TestProbe()
+
+      val device1 = TestProbe()
+      val device2 = TestProbe()
+
+      val queryActor = system.actorOf(DeviceGroupQuery.props(
+        actorToDeviceId = Map(device1.ref -> "device1", device2.ref -> "device2"),
+        requestId = 1,
+        requester = requester.ref,
+        timeout = 3.seconds
+      ))
+
+      device1.expectMsg(Device.ReadTemperature(requestId = 0))
+      device2.expectMsg(Device.ReadTemperature(requestId = 0))
+
+      queryActor.tell(Device.RespondTemperature(requestId = 0, None), device1.ref)
+      queryActor.tell(Device.RespondTemperature(requestId = 0, Some(2.0)), device2.ref)
+
+      requester.expectMsg(DeviceGroup.RespondAllTemperatures(
+        requestId = 1,
+        temperatures = Map(
+          "device1" -> DeviceGroup.TemperatureNotAvailable,
+          "device2" -> DeviceGroup.Temperature(2.0)
+        )
+      ))
+    }
+
+    "return DeviceNotAvailable if device stops before answering" in {
+      val requester = TestProbe()
+
+      val device1 = TestProbe()
+      val device2 = TestProbe()
+
+      val queryActor = system.actorOf(DeviceGroupQuery.props(
+        actorToDeviceId = Map(device1.ref -> "device1", device2.ref -> "device2"),
+        requestId = 1,
+        requester = requester.ref,
+        timeout = 3.seconds
+      ))
+
+      device1.expectMsg(Device.ReadTemperature(requestId = 0))
+      device2.expectMsg(Device.ReadTemperature(requestId = 0))
+
+      queryActor.tell(Device.RespondTemperature(requestId = 0, Some(1.0)), device1.ref)
+      device2.ref ! PoisonPill
+
+      requester.expectMsg(DeviceGroup.RespondAllTemperatures(
+        requestId = 1,
+        temperatures = Map(
+          "device1" -> DeviceGroup.Temperature(1.0),
+          "device2" -> DeviceGroup.DeviceNotAvailable
+        )
+      ))
+    }
+
+    "return temperature reading even if device stops after answering" in {
+      val requester = TestProbe()
+
+      val device1 = TestProbe()
+      val device2 = TestProbe()
+
+      val queryActor = system.actorOf(DeviceGroupQuery.props(
+        actorToDeviceId = Map(device1.ref -> "device1", device2.ref -> "device2"),
+        requestId = 1,
+        requester = requester.ref,
+        timeout = 3.seconds
+      ))
+
+      device1.expectMsg(Device.ReadTemperature(requestId = 0))
+      device2.expectMsg(Device.ReadTemperature(requestId = 0))
+
+      queryActor.tell(Device.RespondTemperature(requestId = 0, Some(1.0)), device1.ref)
+      queryActor.tell(Device.RespondTemperature(requestId = 0, Some(2.0)), device2.ref)
+      device2.ref ! PoisonPill
+
+      requester.expectMsg(DeviceGroup.RespondAllTemperatures(
+        requestId = 1,
+        temperatures = Map(
+          "device1" -> DeviceGroup.Temperature(1.0),
+          "device2" -> DeviceGroup.Temperature(2.0)
+        )
+      ))
+    }
+
+    "return DeviceTimedOut if device does not answer in time" in {
+      val requester = TestProbe()
+
+      val device1 = TestProbe()
+      val device2 = TestProbe()
+
+      val queryActor = system.actorOf(DeviceGroupQuery.props(
+        actorToDeviceId = Map(device1.ref -> "device1", device2.ref -> "device2"),
+        requestId = 1,
+        requester = requester.ref,
+        timeout = 1.second
+      ))
+
+      device1.expectMsg(Device.ReadTemperature(requestId = 0))
+      device2.expectMsg(Device.ReadTemperature(requestId = 0))
+
+      queryActor.tell(Device.RespondTemperature(requestId = 0, Some(1.0)), device1.ref)
+
+      requester.expectMsg(DeviceGroup.RespondAllTemperatures(
+        requestId = 1,
+        temperatures = Map(
+          "device1" -> DeviceGroup.Temperature(1.0),
+          "device2" -> DeviceGroup.DeviceTimedOut
+        )
+      ))
+    }
+
+  }
+
+}

akka-docs/src/test/scala/tutorial_6/DeviceGroupSpec.scala

@@ -0,0 +1,134 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package tutorial_6
+
+import akka.actor.PoisonPill
+import akka.testkit.{ AkkaSpec, TestProbe }
+
+import scala.concurrent.duration._
+
+class DeviceGroupSpec extends AkkaSpec {
+
+  "DeviceGroup actor" must {
+
+    "be able to register a device actor" in {
+      val probe = TestProbe()
+      val groupActor = system.actorOf(DeviceGroup.props("group"))
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device1"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val deviceActor1 = probe.lastSender
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device2"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val deviceActor2 = probe.lastSender
+      deviceActor1 should !==(deviceActor2)
+
+      // Check that the device actors are working
+      deviceActor1.tell(Device.RecordTemperature(requestId = 0, 1.0), probe.ref)
+      probe.expectMsg(Device.TemperatureRecorded(requestId = 0))
+      deviceActor2.tell(Device.RecordTemperature(requestId = 1, 2.0), probe.ref)
+      probe.expectMsg(Device.TemperatureRecorded(requestId = 1))
+    }
+
+    "ignore requests for wrong groupId" in {
+      val probe = TestProbe()
+      val groupActor = system.actorOf(DeviceGroup.props("group"))
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("wrongGroup", "device1"), probe.ref)
+      probe.expectNoMsg(500.milliseconds)
+    }
+
+    "return same actor for same deviceId" in {
+      val probe = TestProbe()
+      val groupActor = system.actorOf(DeviceGroup.props("group"))
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device1"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val deviceActor1 = probe.lastSender
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device1"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val deviceActor2 = probe.lastSender
+
+      deviceActor1 should ===(deviceActor2)
+    }
+
+    "be able to list active devices" in {
+      val probe = TestProbe()
+      val groupActor = system.actorOf(DeviceGroup.props("group"))
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device1"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device2"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+
+      groupActor.tell(DeviceGroup.RequestDeviceList(requestId = 0), probe.ref)
+      probe.expectMsg(DeviceGroup.ReplyDeviceList(requestId = 0, Set("device1", "device2")))
+    }
+
+    "be able to list active devices after one shuts down" in {
+      val probe = TestProbe()
+      val groupActor = system.actorOf(DeviceGroup.props("group"))
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device1"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val toShutDown = probe.lastSender
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device2"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+
+      groupActor.tell(DeviceGroup.RequestDeviceList(requestId = 0), probe.ref)
+      probe.expectMsg(DeviceGroup.ReplyDeviceList(requestId = 0, Set("device1", "device2")))
+
+      probe.watch(toShutDown)
+      toShutDown ! PoisonPill
+      probe.expectTerminated(toShutDown)
+
+      // using awaitAssert to retry because it might take longer for the groupActor
+      // to see the Terminated, that order is undefined
+      probe.awaitAssert {
+        groupActor.tell(DeviceGroup.RequestDeviceList(requestId = 1), probe.ref)
+        probe.expectMsg(DeviceGroup.ReplyDeviceList(requestId = 1, Set("device2")))
+      }
+    }
+
+    "be able to collect temperatures from all active devices" in {
+      val probe = TestProbe()
+      val groupActor = system.actorOf(DeviceGroup.props("group"))
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device1"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val deviceActor1 = probe.lastSender
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device2"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val deviceActor2 = probe.lastSender
+
+      groupActor.tell(DeviceManager.RequestTrackDevice("group", "device3"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      val deviceActor3 = probe.lastSender
+
+      // Check that the device actors are working
+      deviceActor1.tell(Device.RecordTemperature(requestId = 0, 1.0), probe.ref)
+      probe.expectMsg(Device.TemperatureRecorded(requestId = 0))
+      deviceActor2.tell(Device.RecordTemperature(requestId = 1, 2.0), probe.ref)
+      probe.expectMsg(Device.TemperatureRecorded(requestId = 1))
+      // No temperature for device3
+
+      groupActor.tell(DeviceGroup.RequestAllTemperatures(requestId = 0), probe.ref)
+      probe.expectMsg(
+        DeviceGroup.RespondAllTemperatures(
+          requestId = 0,
+          temperatures = Map(
+            "device1" -> DeviceGroup.Temperature(1.0),
+            "device2" -> DeviceGroup.Temperature(2.0),
+            "device3" -> DeviceGroup.TemperatureNotAvailable)))
+    }
+
+  }
+
+}

akka-docs/src/test/scala/tutorial_6/DeviceManager.scala

@@ -0,0 +1,47 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package tutorial_6
+
+import akka.actor.{ Actor, ActorLogging, ActorRef, Props, Terminated }
+import DeviceManager.RequestTrackDevice
+
+object DeviceManager {
+  def props(): Props = Props(new DeviceManager)
+
+  final case class RequestTrackDevice(groupId: String, deviceId: String)
+  case object DeviceRegistered
+}
+
+class DeviceManager extends Actor with ActorLogging {
+  var groupIdToActor = Map.empty[String, ActorRef]
+  var actorToGroupId = Map.empty[ActorRef, String]
+
+  override def preStart(): Unit = log.info("DeviceManager started")
+
+  override def postStop(): Unit = log.info("DeviceManager stopped")
+
+  override def receive = {
+    case trackMsg @ RequestTrackDevice(groupId, _) =>
+      groupIdToActor.get(groupId) match {
+        case Some(ref) =>
+          ref forward trackMsg
+        case None =>
+          log.info("Creating device group actor for {}", groupId)
+          val groupActor = context.actorOf(DeviceGroup.props(groupId), "group-" + groupId)
+          context.watch(groupActor)
+          groupActor forward trackMsg
+          groupIdToActor += groupId -> groupActor
+          actorToGroupId += groupActor -> groupId
+      }
+
+    case Terminated(groupActor) =>
+      val groupId = actorToGroupId(groupActor)
+      log.info("Device group actor for {} has been terminated", groupId)
+      actorToGroupId -= groupActor
+      groupIdToActor -= groupId
+
+  }
+
+}

akka-docs/src/test/scala/tutorial_6/DeviceSpec.scala

@@ -0,0 +1,67 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package tutorial_6
+
+import akka.testkit.{ AkkaSpec, TestProbe }
+
+import scala.concurrent.duration._
+
+class DeviceSpec extends AkkaSpec {
+
+  "Device actor" must {
+
+    "reply to registration requests" in {
+      val probe = TestProbe()
+      val deviceActor = system.actorOf(Device.props("group", "device"))
+
+      deviceActor.tell(DeviceManager.RequestTrackDevice("group", "device"), probe.ref)
+      probe.expectMsg(DeviceManager.DeviceRegistered)
+      probe.lastSender should ===(deviceActor)
+    }
+
+    "ignore wrong registration requests" in {
+      val probe = TestProbe()
+      val deviceActor = system.actorOf(Device.props("group", "device"))
+
+      deviceActor.tell(DeviceManager.RequestTrackDevice("wrongGroup", "device"), probe.ref)
+      probe.expectNoMsg(500.milliseconds)
+
+      deviceActor.tell(DeviceManager.RequestTrackDevice("group", "Wrongdevice"), probe.ref)
+      probe.expectNoMsg(500.milliseconds)
+    }
+
+    "reply with empty reading if no temperature is known" in {
+      val probe = TestProbe()
+      val deviceActor = system.actorOf(Device.props("group", "device"))
+
+      deviceActor.tell(Device.ReadTemperature(requestId = 42), probe.ref)
+      val response = probe.expectMsgType[Device.RespondTemperature]
+      response.requestId should ===(42)
+      response.value should ===(None)
+    }
+
+    "reply with latest temperature reading" in {
+      val probe = TestProbe()
+      val deviceActor = system.actorOf(Device.props("group", "device"))
+
+      deviceActor.tell(Device.RecordTemperature(requestId = 1, 24.0), probe.ref)
+      probe.expectMsg(Device.TemperatureRecorded(requestId = 1))
+
+      deviceActor.tell(Device.ReadTemperature(requestId = 2), probe.ref)
+      val response1 = probe.expectMsgType[Device.RespondTemperature]
+      response1.requestId should ===(2)
+      response1.value should ===(Some(24.0))
+
+      deviceActor.tell(Device.RecordTemperature(requestId = 3, 55.0), probe.ref)
+      probe.expectMsg(Device.TemperatureRecorded(requestId = 3))
+
+      deviceActor.tell(Device.ReadTemperature(requestId = 4), probe.ref)
+      val response2 = probe.expectMsgType[Device.RespondTemperature]
+      response2.requestId should ===(4)
+      response2.value should ===(Some(55.0))
+    }
+
+  }
+
+}

akka-docs/src/test/scala/tutorial_6/IotApp.scala

@@ -0,0 +1,29 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package tutorial_6
+
+import akka.actor.ActorSystem
+import DeviceManager.RequestTrackDevice
+
+import scala.io.StdIn
+
+object IotApp {
+
+  def main(args: Array[String]): Unit = {
+    val system = ActorSystem("iot-system")
+
+    try {
+      // Create top level supervisor
+      val supervisor = system.actorOf(DeviceManager.props(), "iot-supervisor")
+
+      supervisor ! RequestTrackDevice("mygroup", "device1")
+
+      // Exit the system after ENTER is pressed
+      StdIn.readLine()
+    } finally {
+      system.terminate()
+    }
+  }
+
+}

akka-docs/src/test/scala/tutorial_6/IotSupervisor.scala

@@ -0,0 +1,24 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package tutorial_6
+
+import akka.actor.{ Actor, ActorLogging, ActorRef, Props }
+
+object IotSupervisor {
+
+  def props(): Props = Props(new IotSupervisor)
+
+}
+
+class IotSupervisor extends Actor with ActorLogging {
+  val deviceManager: ActorRef = context.system.actorOf(DeviceManager.props(), "device-manager")
+
+  override def preStart(): Unit = log.info("IoT Application started")
+
+  override def postStop(): Unit = log.info("IoT Application stopped")
+
+  // No need to handle any messages
+  override def receive = Actor.emptyBehavior
+
+}