fixing tests

src/test/scala/objects/DoorTest.scala

@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package objects
 
-import akka.actor.{ActorSystem, Props}
+import akka.actor.{ActorRef, ActorSystem, Props}
 import akka.testkit.TestProbe
 import base.ActorTest
 import net.psforever.objects.avatar.Avatar
@@ -12,15 +12,14 @@ import net.psforever.objects.{Default, GlobalDefinitions, Player}
 import net.psforever.objects.serverobject.doors.{Door, DoorControl}
 import net.psforever.objects.serverobject.structures.{Building, StructureType}
 import net.psforever.objects.zones.{Zone, ZoneMap}
-import net.psforever.packet.game.UseItemMessage
+import net.psforever.services.local.{LocalAction, LocalResponse, LocalServiceMessage, LocalServiceResponse}
-import net.psforever.services.local.{LocalAction, LocalServiceMessage}
 import net.psforever.types._
 import org.specs2.mutable.Specification
 
 import scala.concurrent.duration._
 
 class DoorTest extends Specification {
-  val player = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
+  private val player: Player = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
 
   "Door" should {
     "construct" in {
@@ -49,19 +48,6 @@ class DoorTest extends Specification {
     }
 
     "be opened and closed (2; toggle)" in {
-      val msg = UseItemMessage(
-        PlanetSideGUID(6585),
-        PlanetSideGUID(0),
-        PlanetSideGUID(372),
-        4294967295L,
-        false,
-        Vector3(5.0f, 0.0f, 0.0f),
-        Vector3(0.0f, 0.0f, 0.0f),
-        11,
-        25,
-        0,
-        364
-      )
       val door = Door(GlobalDefinitions.door)
       door.Open.isEmpty mustEqual true
       door.Open = player
@@ -74,7 +60,7 @@ class DoorTest extends Specification {
   }
 }
 
-class DoorControl1Test extends ActorTest {
+class DoorControlConstructTest extends ActorTest {
   "DoorControl" should {
     "construct" in {
       val door = Door(GlobalDefinitions.door)
@@ -84,28 +70,11 @@ class DoorControl1Test extends ActorTest {
   }
 }
 
-class DoorControl2Test extends ActorTest {
+class DoorControlOpenTest extends ActorTest {
   "DoorControl" should {
     "open on use" in {
-      val (player, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
+      val (player, door, probe) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
-      val probe = new TestProbe(system)
+      door.Actor ! CommonMessages.Use(player)
-      door.Zone.LocalEvents = probe.ref
-      val msg = UseItemMessage(
-        PlanetSideGUID(1),
-        PlanetSideGUID(0),
-        PlanetSideGUID(2),
-        0L,
-        false,
-        Vector3(0f, 0f, 0f),
-        Vector3(0f, 0f, 0f),
-        0,
-        0,
-        0,
-        0L
-      ) //faked
-      assert(door.Open.isEmpty)
-
-      door.Actor ! CommonMessages.Use(player, Some(msg))
       val reply = probe.receiveOne(1000 milliseconds)
       assert(reply match {
         case LocalServiceMessage("test", LocalAction.DoorOpens(PlanetSideGUID(0), _, d)) => d eq door
@@ -116,26 +85,55 @@ class DoorControl2Test extends ActorTest {
   }
 }
 
-class DoorControl3Test extends ActorTest {
+class DoorControlTooFarTest extends ActorTest {
   "DoorControl" should {
-    "do nothing if given garbage" in {
+    "do not open if the player is too far away" in {
-      val (_, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
+      val (player, door, probe) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
+      player.Position = Vector3(10,0,0)
+      door.Actor ! CommonMessages.Use(player)
+      probe.expectNoMessage(Duration.create(500, "ms"))
+      assert(door.Open.isEmpty)
+    }
+  }
+}
+
+class DoorControlAlreadyOpenTest extends ActorTest {
+  "DoorControl" should {
+    "is already open" in {
+      val (player, door, probe) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
+      door.Open = player //door thinks it is open
+      door.Actor.tell(CommonMessages.Use(player), probe.ref)
+      val reply = probe.receiveOne(1000 milliseconds)
+      assert(reply match {
+        case LocalServiceResponse("test", _, LocalResponse.DoorOpens(guid)) => guid == door.GUID
+        case _ => false
+      })
+    }
+  }
+}
+
+class DoorControlGarbageDataTest extends ActorTest {
+  "DoorControl" should {
+    "do nothing if given garbage data" in {
+      val (_, door, probe) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
       assert(door.Open.isEmpty)
 
       door.Actor ! "trash"
-      expectNoMessage(Duration.create(500, "ms"))
+      probe.expectNoMessage(Duration.create(500, "ms"))
       assert(door.Open.isEmpty)
     }
   }
 }
 
 object DoorControlTest {
-  def SetUpAgents(faction: PlanetSideEmpire.Value)(implicit system: ActorSystem): (Player, Door) = {
+  def SetUpAgents(faction: PlanetSideEmpire.Value)(implicit system: ActorSystem): (Player, Door, TestProbe) = {
+    val eventsProbe = new TestProbe(system)
     val door = Door(GlobalDefinitions.door)
     val guid = new NumberPoolHub(new MaxNumberSource(5))
-    val zone = new Zone("test", new ZoneMap("test"), 0) {
+    val zone = new Zone(id = "test", new ZoneMap(name = "test"), zoneNumber = 0) {
-      override def SetupNumberPools() = {}
+      override def SetupNumberPools(): Unit = {}
       GUID(guid)
+      override def LocalEvents: ActorRef = eventsProbe.ref
     }
     guid.register(door, 1)
     door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door")
@@ -149,7 +147,8 @@ object DoorControlTest {
     )
     door.Owner.Faction = faction
     val player = Player(Avatar(0, "test", faction, CharacterSex.Male, 0, CharacterVoice.Mute))
+    player.Zone = zone
     guid.register(player, 2)
-    (player, door)
+    (player, door, eventsProbe)
   }
 }