PSForever/PSF-BotServer
1
0
Fork 0
mirror of https://github.com/2revoemag/PSF-BotServer.git synced 2026-03-09 23:20:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Zone-local Event Systems (#295)

Browse source 
* all matters related to vehicle events, including tests, adjusted so that the service actor internalizes a specific zone; major adjustments to the order fulfillment logic of vehicle spawn pads; removed a bunch of unnecessary things such as auto-drive guidance

* all matters related to local events, including tests, adjusted so that the service actor internalizes a specific zone; special consideration for proximity units and tests; muted some excessive logging

* all matters related to avatar events, including tests, adjusted so that the service actor internalizes a specific zone; special considerations for resource silos and painbox elements

* explicit trait that acts as an owner of Amenity objects (Building and Vehicle); generalization of <obj>.Owner.Zone statement

* reduced log spam from proximity terminal activity

* tightened vehicle spawn pad control protocol; finally made the player re-appear if the vehicle doesn't spawn/mount correctly; pad operates independent of the person who submitted the current order so less chances for crash

* adjusted workflow for vehicle spawn pad task management
This commit is contained in:
Fate-JH 2019-12-10 08:37:57 -05:00 • committed by GitHub
parent 885387b734
commit 9ec97f279a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
47 changed files with 1393 additions and 2651 deletions
Download patch file Download diff file Expand all files Collapse all files

499
common/src/test/scala/objects/AutoDriveControlsTest.scala
View file

@ -1,499 +0,0 @@
// Copyright (c) 2017 PSForever
package objects
import akka.actor.Props
import akka.testkit.TestProbe
import base.ActorTest
import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Vehicle}
import net.psforever.objects.serverobject.pad.process.{AutoDriveControls, VehicleSpawnControlGuided}
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import org.specs2.mutable.Specification
import scala.concurrent.duration._
class AutoDriveControlsTest extends Specification {
"CancelEntry" should {
val vehicle = Vehicle(GlobalDefinitions.fury)
def exampleTest(vehicle : Vehicle) : Boolean = { vehicle.Position == Vector3(1,1,1) }
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.CancelEarly(exampleTest)
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Cancel
setting.Data mustEqual None
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.CancelEarly(exampleTest)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Position mustEqual Vector3.Zero
setting.Validate(vehicle) mustEqual false
vehicle.Position = Vector3(1,1,1)
setting.Validate(vehicle) mustEqual true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.CancelEarly(exampleTest)
val setting : AutoDriveControls.Setting = config.Create
setting.CompletionTest(vehicle) mustEqual true //always true
}
}
"Climb" should {
val vehicle = Vehicle(GlobalDefinitions.mosquito)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Climb(10.5f)
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Climb
setting.Data mustEqual Some(10.5f)
setting.Delay mustEqual 200L
}
"validate" in {
val vehicle_fury = Vehicle(GlobalDefinitions.fury)
val config : AutoDriveControls.Configuration = AutoDriveControls.Climb(10.5f)
val setting : AutoDriveControls.Setting = config.Create
setting.Validate(vehicle) mustEqual true //mosquito is a flying vehicle
setting.Validate(vehicle_fury) mustEqual false
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Climb(10.5f)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Position mustEqual Vector3.Zero
setting.CompletionTest(vehicle) mustEqual false
vehicle.Position = Vector3(0,0,10.5f)
setting.CompletionTest(vehicle) mustEqual true
}
}
"Distance" should {
val vehicle = Vehicle(GlobalDefinitions.fury)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Distance(Vector3.Zero, 10.5f)
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Wait
setting.Data mustEqual None
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Distance(Vector3.Zero, 10.5f)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Velocity mustEqual None
setting.Validate(vehicle) mustEqual false
vehicle.Velocity = Vector3.Zero
setting.Validate(vehicle) mustEqual false
vehicle.Velocity = Vector3(1,0,0)
setting.Validate(vehicle) mustEqual true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Distance(Vector3.Zero, 10.5f)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Position = Vector3(0,0,0)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Position = Vector3(10.5f,0,0)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Position = Vector3(11,0,0)
setting.CompletionTest(vehicle) mustEqual true
vehicle.Position = Vector3(0,11,0)
setting.CompletionTest(vehicle) mustEqual true
vehicle.Position = Vector3(0,0,11)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Position = Vector3(7.5f,7.5f,0)
setting.CompletionTest(vehicle) mustEqual true
}
}
"DistanceFromHere" should {
val vehicle = Vehicle(GlobalDefinitions.fury)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.DistanceFromHere(10.5f)
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Wait
setting.Data mustEqual None
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.DistanceFromHere(10.5f)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Velocity mustEqual None
setting.Validate(vehicle) mustEqual false
vehicle.Velocity = Vector3.Zero
setting.Validate(vehicle) mustEqual false
vehicle.Velocity = Vector3(1,0,0)
setting.Validate(vehicle) mustEqual true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.DistanceFromHere(10.5f)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Position = Vector3(0,0,0)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Position = Vector3(10.5f,0,0)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Position = Vector3(11,0,0)
setting.CompletionTest(vehicle) mustEqual true
vehicle.Position = Vector3(0,11,0)
setting.CompletionTest(vehicle) mustEqual true
vehicle.Position = Vector3(0,0,11)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Position = Vector3(7.5f,7.5f,0)
setting.CompletionTest(vehicle) mustEqual true
}
}
"Drive" should {
val vehicle = Vehicle(GlobalDefinitions.fury)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Drive(3)
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Drive
setting.Data mustEqual Some(3)
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Drive(3)
val setting : AutoDriveControls.Setting = config.Create
setting.Validate(vehicle) mustEqual true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Drive(3)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Velocity mustEqual None
setting.CompletionTest(vehicle) mustEqual false
vehicle.Velocity = Vector3.Zero
vehicle.Velocity mustEqual Some(Vector3.Zero)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Velocity = Vector3(1,0,0)
vehicle.Velocity mustEqual Some(Vector3(1,0,0))
setting.CompletionTest(vehicle) mustEqual true
}
}
"FirstGear" should {
val veh_def = GlobalDefinitions.mediumtransport
val vehicle = Vehicle(veh_def)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.FirstGear()
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Drive
setting.Data mustEqual Some(0)
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.FirstGear()
val setting : AutoDriveControls.Setting = config.Create
setting.Validate(vehicle) mustEqual true //always true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.FirstGear()
val setting : AutoDriveControls.Setting = config.Create
vehicle.Velocity mustEqual None
setting.CompletionTest(vehicle) mustEqual false
vehicle.Velocity = Vector3.Zero
setting.CompletionTest(vehicle) mustEqual false
vehicle.Velocity = Vector3(1,0,0)
setting.CompletionTest(vehicle) mustEqual true
}
"data" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.FirstGear()
val setting : AutoDriveControls.Setting = config.Create
setting.Data mustEqual Some(0)
setting.Validate(vehicle)
setting.Data mustEqual Some(veh_def.AutoPilotSpeed1)
}
}
"ForTime" should {
val veh_def = GlobalDefinitions.mediumtransport
val vehicle = Vehicle(veh_def)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.ForTime(1200L)
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Wait
setting.Data mustEqual None
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.ForTime(1200L)
val setting : AutoDriveControls.Setting = config.Create
setting.Validate(vehicle) mustEqual true //always true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.ForTime(1200L)
val setting : AutoDriveControls.Setting = config.Create
setting.CompletionTest(vehicle) mustEqual false
Thread.sleep(1100)
setting.CompletionTest(vehicle) mustEqual false
Thread.sleep(200)
setting.CompletionTest(vehicle) mustEqual true
}
}
"SecondGear" should {
val veh_def = GlobalDefinitions.mediumtransport
val vehicle = Vehicle(veh_def)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.SecondGear()
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Drive
setting.Data mustEqual Some(0)
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.SecondGear()
val setting : AutoDriveControls.Setting = config.Create
setting.Validate(vehicle) mustEqual true //always true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.SecondGear()
val setting : AutoDriveControls.Setting = config.Create
vehicle.Velocity mustEqual None
setting.CompletionTest(vehicle) mustEqual false
vehicle.Velocity = Vector3.Zero
setting.CompletionTest(vehicle) mustEqual false
vehicle.Velocity = Vector3(1,0,0)
setting.CompletionTest(vehicle) mustEqual true
}
"data" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.SecondGear()
val setting : AutoDriveControls.Setting = config.Create
setting.Data mustEqual Some(0)
setting.Validate(vehicle)
setting.Data mustEqual Some(veh_def.AutoPilotSpeed2)
}
}
"Stop" should {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Stop()
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Stop
setting.Data mustEqual None
setting.Delay mustEqual 200L
}
"validate" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Stop()
val setting : AutoDriveControls.Setting = config.Create
setting.Validate(vehicle) mustEqual true //always true
}
"completion" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.Stop()
val setting : AutoDriveControls.Setting = config.Create
setting.CompletionTest(vehicle) mustEqual true //always true
}
}
"TurnBy" should {
"create" in {
val config : AutoDriveControls.Configuration = AutoDriveControls.TurnBy(35.5f, 23)
val setting : AutoDriveControls.Setting = config.Create
setting.Type mustEqual AutoDriveControls.State.Turn
setting.Data mustEqual Some(23)
setting.Delay mustEqual 100L
}
"validate (velocity)" in {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
val config : AutoDriveControls.Configuration = AutoDriveControls.TurnBy(35.5f, 23)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Velocity mustEqual None
setting.Validate(vehicle) mustEqual false
vehicle.Velocity = Vector3(1,1,1)
setting.Validate(vehicle) mustEqual true
}
"validate (wheel direction = 15)" in {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
val config : AutoDriveControls.Configuration = AutoDriveControls.TurnBy(35.5f, 15)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Velocity = Vector3(1,1,1)
setting.Validate(vehicle) mustEqual false
}
"completion (passing 35.5-up)" in {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
val config : AutoDriveControls.Configuration = AutoDriveControls.TurnBy(35.5f, 25)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Orientation mustEqual Vector3.Zero
setting.CompletionTest(vehicle) mustEqual false
vehicle.Orientation = Vector3(0,0,34.5f)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Orientation = Vector3(0,0,35f)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Orientation = Vector3(0,0,36.0f)
setting.CompletionTest(vehicle) mustEqual true
}
"completion (passing 35.5 down)" in {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
val config : AutoDriveControls.Configuration = AutoDriveControls.TurnBy(-35.5f, 25)
val setting : AutoDriveControls.Setting = config.Create
vehicle.Orientation = Vector3(0,0,40f)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Orientation = Vector3(0,0,5f)
setting.CompletionTest(vehicle) mustEqual false
vehicle.Orientation = Vector3(0,0,4f)
setting.CompletionTest(vehicle) mustEqual true
}
}
}
class GuidedControlTest1 extends ActorTest {
"VehicleSpawnControlGuided" should {
"unguided" in {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
vehicle.GUID = PlanetSideGUID(1)
val driver = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
driver.VehicleSeated = vehicle.GUID
val sendTo = TestProbe()
val order = VehicleSpawnControl.Order(driver, vehicle, sendTo.ref)
val pad = VehicleSpawnPad(GlobalDefinitions.mb_pad_creation)
pad.GUID = PlanetSideGUID(1)
pad.Railed = false //suppress certain events
val guided = system.actorOf(Props(classOf[VehicleSpawnControlGuided], pad), "pad")
guided ! VehicleSpawnControl.Process.StartGuided(order)
val msg = sendTo.receiveOne(100 milliseconds)
assert(msg.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
}
}
}
class GuidedControlTest2 extends ActorTest {
"VehicleSpawnControlGuided" should {
"guided (one)" in {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
vehicle.GUID = PlanetSideGUID(1)
vehicle.Velocity = Vector3(1,1,1)
val driver = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
driver.VehicleSeated = vehicle.GUID
val sendTo = TestProbe()
val order = VehicleSpawnControl.Order(driver, vehicle, sendTo.ref)
val pad = VehicleSpawnPad(GlobalDefinitions.mb_pad_creation)
pad.Railed = false //suppress certain events
val guided = system.actorOf(Props(classOf[VehicleSpawnControlGuided], pad), "pad")
pad.Guide = List(AutoDriveControls.FirstGear())
guided ! VehicleSpawnControl.Process.StartGuided(order)
val msg1 = sendTo.receiveOne(100 milliseconds)
assert(msg1.isInstanceOf[VehicleSpawnControlGuided.GuidedControl])
assert(msg1.asInstanceOf[VehicleSpawnControlGuided.GuidedControl].command == AutoDriveControls.State.Drive)
val msg2 = sendTo.receiveOne(200 milliseconds)
assert(msg2.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
}
}
}
class GuidedControlTest3 extends ActorTest {
"VehicleSpawnControlGuided" should {
"guided (three)" in {
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
vehicle.GUID = PlanetSideGUID(1)
vehicle.Velocity = Vector3(1,1,1)
val driver = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
driver.VehicleSeated = vehicle.GUID
val sendTo = TestProbe()
val order = VehicleSpawnControl.Order(driver, vehicle, sendTo.ref)
val pad = VehicleSpawnPad(GlobalDefinitions.mb_pad_creation)
pad.Railed = false //suppress certain events
val guided = system.actorOf(Props(classOf[VehicleSpawnControlGuided], pad), "pad")
pad.Guide = List(
AutoDriveControls.FirstGear(),
AutoDriveControls.ForTime(1000L),
AutoDriveControls.SecondGear()
)
guided ! VehicleSpawnControl.Process.StartGuided(order)
val msg1 = sendTo.receiveOne(100 milliseconds)
assert(msg1.isInstanceOf[VehicleSpawnControlGuided.GuidedControl])
assert(msg1.asInstanceOf[VehicleSpawnControlGuided.GuidedControl].command == AutoDriveControls.State.Drive)
val msg2 = sendTo.receiveOne(100 milliseconds)
assert(msg2.isInstanceOf[VehicleSpawnControlGuided.GuidedControl])
assert(msg2.asInstanceOf[VehicleSpawnControlGuided.GuidedControl].command == AutoDriveControls.State.Wait)
sendTo.expectNoMsg(1000 milliseconds)
val msg3 = sendTo.receiveOne(300 milliseconds)
assert(msg3.isInstanceOf[VehicleSpawnControlGuided.GuidedControl])
assert(msg3.asInstanceOf[VehicleSpawnControlGuided.GuidedControl].command == AutoDriveControls.State.Drive)
val msg4 = sendTo.receiveOne(200 milliseconds)
assert(msg4.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
}
}
}
class GuidedControlTest4 extends ActorTest {
"VehicleSpawnControlGuided" should {
"fail validation test" in {
def validationFailure(vehicle : Vehicle) : Boolean = false
val vehicle = Vehicle(GlobalDefinitions.mediumtransport)
vehicle.GUID = PlanetSideGUID(1)
vehicle.Velocity = Vector3(1,1,1)
val driver = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
driver.VehicleSeated = vehicle.GUID
val sendTo = TestProbe()
val order = VehicleSpawnControl.Order(driver, vehicle, sendTo.ref)
val pad = VehicleSpawnPad(GlobalDefinitions.mb_pad_creation)
pad.Railed = false //suppress certain events
val guided = system.actorOf(Props(classOf[VehicleSpawnControlGuided], pad), "pad")
pad.Guide = List(
AutoDriveControls.FirstGear(),
AutoDriveControls.CancelEarly(validationFailure),
AutoDriveControls.SecondGear()
)
guided ! VehicleSpawnControl.Process.StartGuided(order)
val msg1 = sendTo.receiveOne(100 milliseconds)
assert(msg1.isInstanceOf[VehicleSpawnControlGuided.GuidedControl])
assert(msg1.asInstanceOf[VehicleSpawnControlGuided.GuidedControl].command == AutoDriveControls.State.Drive)
val msg2 = sendTo.receiveOne(200 milliseconds)
assert(msg2.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
}
}
}

91
common/src/test/scala/objects/ResourceSiloTest.scala
View file

@ -9,11 +9,11 @@ import net.psforever.objects.guid.TaskResolver
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.resourcesilo.{ResourceSilo, ResourceSiloControl, ResourceSiloDefinition}
import net.psforever.objects.serverobject.structures.{Building, StructureType}
import net.psforever.objects.zones.Zone
import net.psforever.objects.zones.{Zone, ZoneMap}
import net.psforever.packet.game.{PlanetSideGUID, UseItemMessage}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import org.specs2.mutable.Specification
import services.ServiceManager
import services.{Service, ServiceManager}
import services.avatar.{AvatarAction, AvatarServiceMessage}
import scala.concurrent.duration._
@ -103,24 +103,23 @@ class ResourceSiloControlUseTest extends ActorTest {
}
class ResourceSiloControlNtuWarningTest extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
val bldg = new Building(building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
obj.Owner = new Building(building_guid = 6, map_id = 0, Zone.Nowhere, StructureType.Building, GlobalDefinitions.building)
obj.Owner = bldg
val zoneEvents = TestProbe("zone-events")
"Resource silo" should {
"announce high ntu" in {
expectNoMsg(1 seconds)
assert(obj.LowNtuWarningOn == true)
zone.AvatarEvents = zoneEvents.ref
assert(obj.LowNtuWarningOn)
obj.Actor ! ResourceSilo.LowNtuWarning(false)
val reply = probe.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == false)
val reply = zoneEvents.receiveOne(500 milliseconds)
assert(!obj.LowNtuWarningOn)
assert(reply.isInstanceOf[AvatarServiceMessage])
assert(reply.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply.asInstanceOf[AvatarServiceMessage]
@ -136,29 +135,27 @@ class ResourceSiloControlNtuWarningTest extends ActorTest {
}
class ResourceSiloControlUpdate1Test extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe1 = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
val bldg = new Building(building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(building_guid = 6, map_id = 0, Zone.Nowhere, StructureType.Building, GlobalDefinitions.building)
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
val zoneEvents = TestProbe("zone-events")
val buildingEvents = TestProbe("building-events")
"Resource silo" should {
"update the charge level and capacitor display (report high ntu, power restored)" in {
expectNoMsg(1 seconds)
zone.AvatarEvents = zoneEvents.ref
bldg.Actor = buildingEvents.ref
assert(obj.ChargeLevel == 0)
assert(obj.CapacitorDisplay == 0)
obj.Actor ! ResourceSilo.UpdateChargeLevel(305)
val reply1 = probe1.receiveOne(500 milliseconds)
val reply2 = probe2.receiveOne(500 milliseconds)
val reply1 = zoneEvents.receiveOne(500 milliseconds)
val reply2 = buildingEvents.receiveOne(500 milliseconds)
assert(obj.ChargeLevel == 305)
assert(obj.CapacitorDisplay == 4)
assert(reply1.isInstanceOf[AvatarServiceMessage])
@ -174,7 +171,7 @@ class ResourceSiloControlUpdate1Test extends ActorTest {
assert(reply2.isInstanceOf[Building.SendMapUpdate])
val reply3 = probe1.receiveOne(500 milliseconds)
val reply3 = zoneEvents.receiveOne(500 milliseconds)
assert(reply3.isInstanceOf[AvatarServiceMessage])
assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply3.asInstanceOf[AvatarServiceMessage]
@ -186,7 +183,7 @@ class ResourceSiloControlUpdate1Test extends ActorTest {
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 0)
val reply4 = probe1.receiveOne(500 milliseconds)
val reply4 = zoneEvents.receiveOne(500 milliseconds)
assert(!obj.LowNtuWarningOn)
assert(reply4.isInstanceOf[AvatarServiceMessage])
assert(reply4.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
@ -203,33 +200,31 @@ class ResourceSiloControlUpdate1Test extends ActorTest {
}
class ResourceSiloControlUpdate2Test extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe1 = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
val bldg = new Building(building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(building_guid = 6, map_id = 0, Zone.Nowhere, StructureType.Building, GlobalDefinitions.building)
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
val zoneEvents = TestProbe("zone-events")
val buildingEvents = TestProbe("building-events")
"Resource silo" should {
"update the charge level and capacitor display (report good ntu)" in {
expectNoMsg(1 seconds)
zone.AvatarEvents = zoneEvents.ref
bldg.Actor = buildingEvents.ref
obj.ChargeLevel = 100
obj.CapacitorDisplay = 1
obj.LowNtuWarningOn = true
assert(obj.ChargeLevel == 100)
assert(obj.CapacitorDisplay == 1)
assert(obj.LowNtuWarningOn == true)
assert(obj.LowNtuWarningOn)
obj.Actor ! ResourceSilo.UpdateChargeLevel(105)
val reply1 = probe1.receiveOne(500 milliseconds)
val reply2 = probe2.receiveOne(500 milliseconds)
val reply1 = zoneEvents.receiveOne(500 milliseconds)
val reply2 = buildingEvents.receiveOne(500 milliseconds)
assert(obj.ChargeLevel == 205)
assert(obj.CapacitorDisplay == 3)
assert(reply1.isInstanceOf[AvatarServiceMessage])
@ -245,8 +240,8 @@ class ResourceSiloControlUpdate2Test extends ActorTest {
assert(reply2.isInstanceOf[Building.SendMapUpdate])
val reply3 = probe1.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == false)
val reply3 = zoneEvents.receiveOne(500 milliseconds)
assert(!obj.LowNtuWarningOn)
assert(reply3.isInstanceOf[AvatarServiceMessage])
assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply3.asInstanceOf[AvatarServiceMessage]
@ -262,43 +257,41 @@ class ResourceSiloControlUpdate2Test extends ActorTest {
}
class ResourceSiloControlNoUpdateTest extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe1 = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
val zone = new Zone("nowhere", new ZoneMap("nowhere-map"), 0)
val bldg = new Building(building_guid = 6, map_id = 0, zone, StructureType.Building, GlobalDefinitions.building)
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(building_guid = 6, map_id = 6, Zone.Nowhere, StructureType.Building, GlobalDefinitions.building)
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
val zoneEvents = TestProbe("zone-events")
val buildingEvents = TestProbe("building-events")
"Resource silo" should {
"update, but not sufficiently to change the capacitor display" in {
expectNoMsg(1 seconds)
zone.AvatarEvents = zoneEvents.ref
bldg.Actor = buildingEvents.ref
obj.ChargeLevel = 250
obj.CapacitorDisplay = 3
obj.LowNtuWarningOn = false
assert(obj.ChargeLevel == 250)
assert(obj.CapacitorDisplay == 3)
assert(obj.LowNtuWarningOn == false)
assert(!obj.LowNtuWarningOn)
obj.Actor ! ResourceSilo.UpdateChargeLevel(50)
expectNoMsg(500 milliseconds)
probe1.expectNoMsg(500 milliseconds)
probe2.expectNoMsg(500 milliseconds)
zoneEvents.expectNoMsg(500 milliseconds)
buildingEvents.expectNoMsg(500 milliseconds)
assert(obj.ChargeLevel == 299 || obj.ChargeLevel == 300) // Just in case the capacitor level drops while waiting for the message check 299 & 300
assert(obj.CapacitorDisplay == 3)
assert(obj.LowNtuWarningOn == false)
assert(!obj.LowNtuWarningOn)
}
}
}
object ResourceSiloTest {
val player = Player(Avatar("TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
val player = Player(new Avatar(0L, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
class ProbedAvatarService(probe : TestProbe) extends Actor {
override def receive : Receive = {

406
common/src/test/scala/objects/VehicleSpawnPadTest.scala
View file

@ -4,14 +4,14 @@ package objects
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.testkit.TestProbe
import base.ActorTest
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
import net.psforever.objects.serverobject.structures.StructureType
import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Vehicle}
import net.psforever.objects.zones.Zone
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterVoice, PlanetSideEmpire, Vector3}
import net.psforever.types._
import org.specs2.mutable.Specification
import services.vehicle.{VehicleAction, VehicleServiceMessage}
import scala.concurrent.duration._
@ -27,14 +27,6 @@ class VehicleSpawnPadTest extends Specification {
val obj = VehicleSpawnPad(GlobalDefinitions.mb_pad_creation)
obj.Actor mustEqual ActorRef.noSender
obj.Definition mustEqual GlobalDefinitions.mb_pad_creation
obj.Railed mustEqual true
}
"un-railed" in {
val obj = VehicleSpawnPad(GlobalDefinitions.mb_pad_creation)
obj.Railed mustEqual true
obj.Railed = false
obj.Railed mustEqual false
}
}
}
@ -49,264 +41,174 @@ class VehicleSpawnControl1Test extends ActorTest {
}
}
class VehicleSpawnControl2aTest extends ActorTest {
// This runs for a long time.
class VehicleSpawnControl2Test extends ActorTest {
"VehicleSpawnControl" should {
"complete on a vehicle order (block a second one until the first is done and the spawn pad is cleared)" in {
"complete a vehicle order" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
//we can recycle the vehicle and the player for each order
val probe1 = new TestProbe(system, "first-order")
val probe2 = new TestProbe(system, "second-order")
val probe3 = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe3.ref
val probe = new TestProbe(system, "zone-events")
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe1.ref) //first order
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe2.ref) //second order
zone.VehicleEvents = probe.ref //zone events
pad.Actor ! VehicleSpawnPad.VehicleOrder(player, vehicle) //order
val probe2Msg1 = probe2.receiveOne(100 milliseconds)
assert(probe2Msg1.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe2Msg1.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Queue)
assert(probe2Msg1.asInstanceOf[VehicleSpawnPad.PeriodicReminder].data.contains("2"))
val probe3Msg1 = probe3.receiveOne(3 seconds)
assert(probe3Msg1.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
val probe3Msg2 = probe3.receiveOne(3 seconds)
assert(probe3Msg2.isInstanceOf[VehicleSpawnPad.LoadVehicle])
val probe3Msg3 = probe3.receiveOne(200 milliseconds)
assert(probe3Msg3.isInstanceOf[VehicleSpawnPad.AttachToRails])
val probe1Msg1 = probe1.receiveOne(200 milliseconds)
assert(probe1Msg1.isInstanceOf[VehicleSpawnPad.StartPlayerSeatedInVehicle])
val probe1Msg2 = probe1.receiveOne(200 milliseconds)
assert(probe1Msg2.isInstanceOf[Mountable.MountMessages])
val probe1Msg2Contents = probe1Msg2.asInstanceOf[Mountable.MountMessages]
assert(probe1Msg2Contents.response.isInstanceOf[Mountable.CanMount])
val probe1Msg3 = probe1.receiveOne(3 seconds)
assert(probe1Msg3.isInstanceOf[VehicleSpawnPad.PlayerSeatedInVehicle])
val probe3Msg4 = probe3.receiveOne(1 seconds)
assert(probe3Msg4.isInstanceOf[VehicleSpawnPad.DetachFromRails])
val probe1Msg4 = probe1.receiveOne(1 seconds)
assert(probe1Msg4.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideStart])
val probe1Msg5 = probe1.receiveOne(4 seconds)
assert(probe1Msg5.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
val probe1Msg6 = probe1.receiveOne(11 seconds)
assert(probe1Msg6.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe1Msg6.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Blocked)
val probe2Msg2 = probe2.receiveOne(100 milliseconds)
assert(probe2Msg2.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe2Msg2.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Blocked)
//if we move the vehicle more than 25m away from the pad, we should receive a ResetSpawnPad, and a second ConcealPlayer message
//that means that the first order has cleared and the spawn pad is now working on the second order successfully
player.VehicleSeated = None //since shared between orders, is necessary
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ConcealPlayer])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.LoadVehicle])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.AttachToRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.StartPlayerSeatedInVehicle])
vehicle.Seats(0).Occupant = player
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.PlayerSeatedInVehicle])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.DetachFromRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ServerVehicleOverrideStart])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
//if we move the vehicle away from the pad, we should receive a ResetSpawnPad message
//that means that the first order has cleared and the spawn pad is now waiting for additional orders
vehicle.Position = Vector3(12,0,0)
val probe3Msg5 = probe3.receiveOne(4 seconds)
assert(probe3Msg5.isInstanceOf[VehicleSpawnPad.ResetSpawnPad])
val probe3Msg6 = probe3.receiveOne(4 seconds)
assert(probe3Msg6.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
}
}
}
class VehicleSpawnControl2bTest extends ActorTest {
// This runs for a long time.
"VehicleSpawnControl" should {
"complete on a vehicle order (railless)" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
//we can recycle the vehicle and the player for each order
val probe1 = new TestProbe(system, "first-order")
val probe2 = new TestProbe(system, "second-order")
val probe3 = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe3.ref
pad.Railed = false
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe1.ref) //first order
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe2.ref) //second order
val probe2Msg1 = probe2.receiveOne(100 milliseconds)
assert(probe2Msg1.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe2Msg1.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Queue)
assert(probe2Msg1.asInstanceOf[VehicleSpawnPad.PeriodicReminder].data.contains("2"))
val probe3Msg1 = probe3.receiveOne(3 seconds)
assert(probe3Msg1.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
val probe3Msg2 = probe3.receiveOne(3 seconds)
assert(probe3Msg2.isInstanceOf[VehicleSpawnPad.LoadVehicle])
val probe1Msg1 = probe1.receiveOne(200 milliseconds)
assert(probe1Msg1.isInstanceOf[VehicleSpawnPad.StartPlayerSeatedInVehicle])
val probe1Msg2 = probe1.receiveOne(200 milliseconds)
assert(probe1Msg2.isInstanceOf[Mountable.MountMessages])
val probe1Msg2Contents = probe1Msg2.asInstanceOf[Mountable.MountMessages]
assert(probe1Msg2Contents.response.isInstanceOf[Mountable.CanMount])
val probe1Msg3 = probe1.receiveOne(4 seconds)
assert(probe1Msg3.isInstanceOf[VehicleSpawnPad.PlayerSeatedInVehicle])
val probe1Msg4 = probe1.receiveOne(1 seconds)
assert(probe1Msg4.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideStart])
val probe1Msg5 = probe1.receiveOne(4 seconds)
assert(probe1Msg5.isInstanceOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
val probe1Msg6 = probe1.receiveOne(11 seconds)
assert(probe1Msg6.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe1Msg6.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Blocked)
val probe2Msg2 = probe2.receiveOne(100 milliseconds)
assert(probe2Msg2.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe2Msg2.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Blocked)
//if we move the vehicle more than 10m away from the pad, we should receive a second ConcealPlayer message
//that means that the first order has cleared and the spawn pad is now working on the second order successfully
player.VehicleSeated = None //since shared between orders, is necessary
vehicle.Position = Vector3(12,0,0)
val probe3Msg6 = probe3.receiveOne(10 seconds)
assert(probe3Msg6.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ResetSpawnPad])
}
}
}
class VehicleSpawnControl3Test extends ActorTest {
"VehicleSpawnControl" should {
"player is on wrong continent before vehicle can partially load; vehicle is cleaned up" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
val probe1 = new TestProbe(system, "first-order")
val probe3 = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe3.ref
player.Continent = "problem" //problem
assert(vehicle.HasGUID)
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe1.ref)
val probe3Msg1 = probe3.receiveOne(3 seconds)
assert(probe3Msg1.isInstanceOf[VehicleSpawnPad.RevealPlayer])
probe3.expectNoMsg(5 seconds)
assert(!vehicle.HasGUID) //vehicle has been unregistered
}
}
}
class VehicleSpawnControl4Test extends ActorTest() {
"VehicleSpawnControl" should {
"the player is on wrong continent when the vehicle tries to load; vehicle is cleaned up" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
val probe1 = new TestProbe(system, "first-order")
val probe3 = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe3.ref
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe1.ref)
val probe3Msg1 = probe3.receiveOne(3 seconds)
assert(probe3Msg1.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
player.Continent = "problem" //problem
assert(vehicle.HasGUID)
val probe3Msg2 = probe3.receiveOne(3 seconds)
assert(probe3Msg2.isInstanceOf[VehicleSpawnPad.RevealPlayer])
probe3.expectNoMsg(5 seconds)
assert(!vehicle.HasGUID) //vehicle has been unregistered
}
}
}
//class VehicleSpawnControl5aTest extends ActorTest() {
// "VehicleSpawnControl" should {
// "the vehicle is destroyed before being fully loaded; the vehicle is cleaned up" in {
// val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
// //we can recycle the vehicle and the player for each order
// val probe1 = new TestProbe(system, "first-order")
// val probe3 = new TestProbe(system, "zone-events")
// zone.VehicleEvents = probe3.ref
//
// pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe1.ref)
//
// val probe3Msg1 = probe3.receiveOne(3 seconds)
// assert(probe3Msg1.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
//
// val probe3Msg2 = probe3.receiveOne(3 seconds)
// assert(probe3Msg2.isInstanceOf[VehicleSpawnPad.LoadVehicle])
// vehicle.Health = 0 //problem
//
// val probe3Msg3 = probe3.receiveOne(3 seconds)
// assert(probe3Msg3.isInstanceOf[VehicleSpawnPad.DisposeVehicle])
// val probe3Msg4 = probe3.receiveOne(100 milliseconds)
// assert(probe3Msg4.isInstanceOf[VehicleSpawnPad.RevealPlayer])
// //note: the vehicle will not be unregistered by this logic alone
// //since LoadVehicle should introduce it into the game world properly, it has to be handled properly
// }
// }
//}
class VehicleSpawnControl5Test extends ActorTest {
"VehicleSpawnControl" should {
"player dies right after vehicle partially loads; the vehicle spawns and blocks the pad" in {
"block the second vehicle order until the first is completed" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
//we can recycle the vehicle and the player for each order
val probe1 = new TestProbe(system, "first-order")
val probe3 = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe3.ref
val probe = new TestProbe(system, "zone-events")
val player2 = Player(Avatar("test2", player.Faction, CharacterGender.Male, 0, CharacterVoice.Mute))
player2.GUID = PlanetSideGUID(11)
player2.Continent = zone.Id
player2.Spawn
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe1.ref)
zone.VehicleEvents = probe.ref //zone events
pad.Actor ! VehicleSpawnPad.VehicleOrder(player, vehicle) //first order
pad.Actor ! VehicleSpawnPad.VehicleOrder(player2, vehicle) //second order (vehicle shared)
val probe3Msg1 = probe3.receiveOne(3 seconds)
assert(probe3Msg1.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
assert(probe.receiveOne(1 seconds) match {
case VehicleSpawnPad.PeriodicReminder(_, VehicleSpawnPad.Reminders.Queue, _) => true
case _ => false
})
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ConcealPlayer])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.LoadVehicle])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.AttachToRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.StartPlayerSeatedInVehicle])
vehicle.Seats(0).Occupant = player
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.PlayerSeatedInVehicle])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.DetachFromRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ServerVehicleOverrideStart])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ServerVehicleOverrideEnd])
assert(probe.receiveOne(1 minute) match {
case VehicleSpawnPad.PeriodicReminder(_, VehicleSpawnPad.Reminders.Blocked, _) => true
case _ => false
})
assert(probe.receiveOne(1 minute) match {
case VehicleSpawnPad.PeriodicReminder(_, VehicleSpawnPad.Reminders.Blocked, _) => true
case _ => false
})
val probe3Msg2 = probe3.receiveOne(3 seconds)
assert(probe3Msg2.isInstanceOf[VehicleSpawnPad.LoadVehicle])
player.Die //problem
val probe3Msg3 = probe3.receiveOne(3 seconds)
assert(probe3Msg3.isInstanceOf[VehicleSpawnPad.AttachToRails])
val probe3Msg4 = probe3.receiveOne(3 seconds)
assert(probe3Msg4.isInstanceOf[VehicleSpawnPad.DetachFromRails])
val probe3Msg5 = probe3.receiveOne(1 seconds)
assert(probe3Msg5.isInstanceOf[VehicleSpawnPad.RevealPlayer])
val probe1Msg = probe1.receiveOne(12 seconds)
assert(probe1Msg.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe1Msg.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Blocked)
//if we move the vehicle away from the pad, we should receive a second ConcealPlayer message
//that means that the first order has cleared and the spawn pad is now working on the second order successfully
player.VehicleSeated = None //since shared between orders, as necessary
vehicle.Seats(0).Occupant = None
vehicle.Position = Vector3(12,0,0)
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ResetSpawnPad])
probe.expectMsgClass(3 seconds, classOf[VehicleSpawnPad.ConcealPlayer])
}
}
}
class VehicleSpawnControl6Test extends ActorTest {
class VehicleSpawnControl4Test extends ActorTest {
"VehicleSpawnControl" should {
"the player can not sit in vehicle; vehicle spawns and blocks the pad" in {
"clean up the vehicle if the driver-to-be is on the wrong continent" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
//we can recycle the vehicle and the player for each order
val probe1 = new TestProbe(system, "first-order")
val probe3 = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe3.ref
pad.Actor.tell(VehicleSpawnPad.VehicleOrder(player, vehicle), probe1.ref)
val probe3Msg1 = probe3.receiveOne(3 seconds)
assert(probe3Msg1.isInstanceOf[VehicleSpawnPad.ConcealPlayer])
val probe3Msg2 = probe3.receiveOne(3 seconds)
assert(probe3Msg2.isInstanceOf[VehicleSpawnPad.LoadVehicle])
val probe3Msg3 = probe3.receiveOne(3 seconds)
assert(probe3Msg3.isInstanceOf[VehicleSpawnPad.AttachToRails])
val probe1Msg1 = probe1.receiveOne(200 milliseconds)
assert(probe1Msg1.isInstanceOf[VehicleSpawnPad.StartPlayerSeatedInVehicle])
val probe = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe.ref
player.Continent = "problem" //problem
probe1.receiveOne(200 milliseconds) //Mountable.MountMessage
val probe3Msg4 = probe3.receiveOne(3 seconds)
assert(probe3Msg4.isInstanceOf[VehicleSpawnPad.DetachFromRails])
val probe3Msg5 = probe3.receiveOne(3 seconds)
assert(probe3Msg5.isInstanceOf[VehicleSpawnPad.RevealPlayer])
pad.Actor ! VehicleSpawnPad.VehicleOrder(player, vehicle) //order
val probe1Msg3 = probe1.receiveOne(12 seconds)
assert(probe1Msg3.isInstanceOf[VehicleSpawnPad.PeriodicReminder])
assert(probe1Msg3.asInstanceOf[VehicleSpawnPad.PeriodicReminder].reason == VehicleSpawnPad.Reminders.Blocked)
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.DisposeVehicle])
probe.expectNoMsg(5 seconds)
}
}
}
class VehicleSpawnControl5Test extends ActorTest() {
"VehicleSpawnControl" should {
"abandon a destroyed vehicle on the spawn pad (blocking)" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
val probe = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe.ref
pad.Actor ! VehicleSpawnPad.VehicleOrder(player, vehicle) //order
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ConcealPlayer])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.LoadVehicle])
vehicle.Health = 0 //problem
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.AttachToRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.DetachFromRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.RevealPlayer])
assert(probe.receiveOne(1 minute) match {
case VehicleServiceMessage(_, VehicleAction.LoadVehicle(_,_,_,_,_)) => true
case _ => false
})
assert(probe.receiveOne(1 minute) match {
case VehicleSpawnPad.PeriodicReminder(_, VehicleSpawnPad.Reminders.Blocked, _) => true
case _ => false
})
}
}
}
class VehicleSpawnControl6Test extends ActorTest() {
"VehicleSpawnControl" should {
"abandon a vehicle on the spawn pad if driver is unfit to drive (blocking)" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
val probe = new TestProbe(system, "zone-events")
zone.VehicleEvents = probe.ref
pad.Actor ! VehicleSpawnPad.VehicleOrder(player, vehicle) //order
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ConcealPlayer])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.LoadVehicle])
player.Die
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.AttachToRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.DetachFromRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.RevealPlayer])
assert(probe.receiveOne(1 minute) match {
case VehicleServiceMessage(_, VehicleAction.LoadVehicle(_,_,_,_,_)) => true
case _ => false
})
assert(probe.receiveOne(1 minute) match {
case VehicleSpawnPad.PeriodicReminder(_, VehicleSpawnPad.Reminders.Blocked, _) => true
case _ => false
})
}
}
}
class VehicleSpawnControl7Test extends ActorTest {
"VehicleSpawnControl" should {
"abandon a vehicle on the spawn pad if driver is unfit to drive (blocking)" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
val probe = new TestProbe(system, "zone-events")
player.ExoSuit = ExoSuitType.MAX
zone.VehicleEvents = probe.ref //zone events
pad.Actor ! VehicleSpawnPad.VehicleOrder(player, vehicle) //order
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.ConcealPlayer])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.LoadVehicle])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.AttachToRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.StartPlayerSeatedInVehicle])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.DetachFromRails])
probe.expectMsgClass(1 minute, classOf[VehicleSpawnPad.RevealPlayer])
assert(probe.receiveOne(1 minute) match {
case VehicleServiceMessage(_, VehicleAction.LoadVehicle(_,_,_,_,_)) => true
case _ => false
})
assert(probe.receiveOne(1 minute) match {
case VehicleSpawnPad.PeriodicReminder(_, VehicleSpawnPad.Reminders.Blocked, _) => true
case _ => false
})
}
}
}
@ -324,15 +226,19 @@ object VehicleSpawnPadControlTest {
import net.psforever.objects.Tool
import net.psforever.types.CharacterGender
val zone = new Zone("test-zone", map, 0) { override def SetupNumberPools() = { } }
val vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy)
val weapon = vehicle.WeaponControlledFromSeat(1).get.asInstanceOf[Tool]
val guid : NumberPoolHub = new NumberPoolHub(LimitedNumberSource(5))
guid.AddPool("test-pool", (0 to 2).toList)
guid.register(vehicle, "test-pool")
guid.register(weapon, "test-pool")
guid.register(weapon.AmmoSlot.Box, "test-pool")
zone.GUID(guid)
val zone = new Zone("test-zone", map, 0) {
override def SetupNumberPools() = {
val guid : NumberPoolHub = new NumberPoolHub(LimitedNumberSource(5))
guid.AddPool("test-pool", (0 to 2).toList)
//do not do this under normal conditions
guid.register(vehicle, "test-pool")
guid.register(weapon, "test-pool")
guid.register(weapon.AmmoSlot.Box, "test-pool")
GUID(guid)
}
}
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), s"test-zone-${System.nanoTime()}")
zone.Actor ! Zone.Init()
vehicle.Actor = system.actorOf(Props(classOf[VehicleControl], vehicle), s"vehicle-control-${System.nanoTime()}")

142
common/src/test/scala/objects/terminal/ProximityTest.scala
View file

@ -4,7 +4,6 @@ package objects.terminal
import akka.actor.Props
import akka.testkit.TestProbe
import base.ActorTest
import net.psforever.objects.guid.TaskResolver
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.serverobject.structures.{Building, StructureType}
import net.psforever.objects.serverobject.terminals.{ProximityTerminal, ProximityTerminalControl, ProximityUnit, Terminal}
@ -13,8 +12,8 @@ import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import org.specs2.mutable.Specification
import services.{Service, ServiceManager}
import services.local.{LocalResponse, LocalService, LocalServiceResponse}
import services.Service
import services.local.LocalService
import scala.concurrent.duration._
@ -96,19 +95,14 @@ class ProximityTest extends Specification {
class ProximityTerminalControlStartTest extends ActorTest {
"ProximityTerminalControl" should {
//setup
val probe = new TestProbe(system)
val service = ServiceManager.boot(system)
service ! ServiceManager.Register(Props(classOf[ProximityTest.ProbedLocalService], probe), "local")
service ! ServiceManager.Register(Props[TaskResolver], "taskResolver")
service ! ServiceManager.Register(Props[TaskResolver], "cluster")
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
val zone : Zone = new Zone("test", new ZoneMap("test-map"), 0) {
Actor = system.actorOf(Props(classOf[ZoneActor], this), "test-zone")
override def SetupNumberPools() = {
AddPool("dynamic", 1 to 10)
}
}
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
new Building(building_guid = 0, map_id = 0, zone, StructureType.Facility, GlobalDefinitions.building) {
Amenities = terminal
Faction = PlanetSideEmpire.VS
@ -122,17 +116,18 @@ class ProximityTerminalControlStartTest extends ActorTest {
terminal.GUID = PlanetSideGUID(2)
terminal.Actor ! Service.Startup()
expectNoMsg(500 milliseconds) //spacer
val probe1 = new TestProbe(system, "local-events")
val probe2 = new TestProbe(system, "target-callback")
zone.LocalEvents = probe1.ref
"send out a start message" in {
assert(terminal.NumberUsers == 0)
assert(terminal.Owner.Continent.equals("test"))
terminal.Actor ! CommonMessages.Use(avatar, Some(avatar))
val msg = probe.receiveOne(500 milliseconds)
terminal.Actor.tell(CommonMessages.Use(avatar, Some(avatar)), probe2.ref)
probe1.expectMsgClass(1 second, classOf[Terminal.StartProximityEffect])
probe2.expectMsgClass(1 second, classOf[ProximityUnit.Action])
assert(terminal.NumberUsers == 1)
assert(msg.isInstanceOf[LocalServiceResponse])
val resp = msg.asInstanceOf[LocalServiceResponse]
assert(resp.replyMessage == LocalResponse.ProximityTerminalEffect(PlanetSideGUID(2), true))
}
}
}
@ -140,50 +135,50 @@ class ProximityTerminalControlStartTest extends ActorTest {
class ProximityTerminalControlTwoUsersTest extends ActorTest {
"ProximityTerminalControl" should {
//setup
val probe = new TestProbe(system)
val service = ServiceManager.boot(system)
service ! ServiceManager.Register(Props(classOf[ProximityTest.ProbedLocalService], probe), "local")
service ! ServiceManager.Register(Props[TaskResolver], "taskResolver")
service ! ServiceManager.Register(Props[TaskResolver], "cluster")
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
val zone : Zone = new Zone("test", new ZoneMap("test-map"), 0) {
Actor = system.actorOf(Props(classOf[ZoneActor], this), "test-zone")
override def SetupNumberPools() = {
AddPool("dynamic", 1 to 10)
}
}
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
new Building(building_guid = 0, map_id = 0, zone, StructureType.Facility, GlobalDefinitions.building) {
Amenities = terminal
Faction = PlanetSideEmpire.VS
}
val avatar = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
avatar.Continent = "test"
avatar.Spawn
avatar.Health = 50
val avatar2 = Player(Avatar("TestCharacter2", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
avatar2.Continent = "test"
avatar2.Spawn
avatar2.Health = 50
avatar.GUID = PlanetSideGUID(1)
terminal.GUID = PlanetSideGUID(2)
avatar.GUID = PlanetSideGUID(2)
terminal.GUID = PlanetSideGUID(3)
terminal.Actor ! Service.Startup()
expectNoMsg(500 milliseconds) //spacer
val probe1 = new TestProbe(system, "local-events")
val probe2 = new TestProbe(system, "target-callback-1")
val probe3 = new TestProbe(system, "target-callback-2")
zone.LocalEvents = probe1.ref
"will not send out a start message if not the first user" in {
"not send out a start message if not the first user" in {
assert(terminal.NumberUsers == 0)
assert(terminal.Owner.Continent.equals("test"))
terminal.Actor ! CommonMessages.Use(avatar, Some(avatar))
val msg = probe.receiveOne(500 milliseconds)
assert(terminal.NumberUsers == 1)
assert(msg.isInstanceOf[LocalServiceResponse])
val resp = msg.asInstanceOf[LocalServiceResponse]
assert(resp.replyMessage == LocalResponse.ProximityTerminalEffect(PlanetSideGUID(2), true))
terminal.Actor.tell(CommonMessages.Use(avatar, Some(avatar)), probe2.ref)
probe1.expectMsgClass(1 second, classOf[Terminal.StartProximityEffect])
probe2.expectMsgClass(1 second, classOf[ProximityUnit.Action])
val avatar2 = Player(Avatar("TestCharacter2", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
avatar2.Continent = "test"
avatar2.Spawn
avatar2.Health = 50
terminal.Actor ! CommonMessages.Use(avatar2, Some(avatar2))
probe.expectNoMsg(500 milliseconds)
terminal.Actor.tell(CommonMessages.Use(avatar2, Some(avatar2)), probe3.ref)
probe1.expectNoMsg(1 second)
probe2.expectMsgClass(1 second, classOf[ProximityUnit.Action])
probe3.expectMsgClass(1 second, classOf[ProximityUnit.Action])
assert(terminal.NumberUsers == 2)
}
}
@ -192,19 +187,14 @@ class ProximityTerminalControlTwoUsersTest extends ActorTest {
class ProximityTerminalControlStopTest extends ActorTest {
"ProximityTerminalControl" should {
//setup
val probe = new TestProbe(system)
val service = ServiceManager.boot(system)
service ! ServiceManager.Register(Props(classOf[ProximityTest.ProbedLocalService], probe), "local")
service ! ServiceManager.Register(Props[TaskResolver], "taskResolver")
service ! ServiceManager.Register(Props[TaskResolver], "cluster")
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
val zone : Zone = new Zone("test", new ZoneMap("test-map"), 0) {
Actor = system.actorOf(Props(classOf[ZoneActor], this), "test-zone")
override def SetupNumberPools() = {
AddPool("dynamic", 1 to 10)
}
}
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
new Building(building_guid = 0, map_id = 0, zone, StructureType.Facility, GlobalDefinitions.building) {
Amenities = terminal
Faction = PlanetSideEmpire.VS
@ -218,24 +208,21 @@ class ProximityTerminalControlStopTest extends ActorTest {
terminal.GUID = PlanetSideGUID(2)
terminal.Actor ! Service.Startup()
expectNoMsg(500 milliseconds) //spacer
val probe1 = new TestProbe(system, "local-events")
val probe2 = new TestProbe(system, "target-callback-1")
zone.LocalEvents = probe1.ref
"send out a stop message" in {
assert(terminal.NumberUsers == 0)
assert(terminal.Owner.Continent.equals("test"))
terminal.Actor ! CommonMessages.Use(avatar, Some(avatar))
val msg1 = probe.receiveOne(500 milliseconds)
assert(terminal.NumberUsers == 1)
assert(msg1.isInstanceOf[LocalServiceResponse])
val resp1 = msg1.asInstanceOf[LocalServiceResponse]
assert(resp1.replyMessage == LocalResponse.ProximityTerminalEffect(PlanetSideGUID(2), true))
terminal.Actor.tell(CommonMessages.Use(avatar, Some(avatar)), probe2.ref)
probe1.expectMsgClass(1 second, classOf[Terminal.StartProximityEffect])
probe2.expectMsgClass(1 second, classOf[ProximityUnit.Action])
terminal.Actor ! CommonMessages.Unuse(avatar, Some(avatar))
val msg2 = probe.receiveWhile(500 milliseconds) {
case LocalServiceResponse(_, _, replyMessage) => replyMessage
}
probe1.expectMsgClass(1 second, classOf[Terminal.StopProximityEffect])
assert(terminal.NumberUsers == 0)
assert(msg2.last == LocalResponse.ProximityTerminalEffect(PlanetSideGUID(2), false))
}
}
}
@ -243,58 +230,59 @@ class ProximityTerminalControlStopTest extends ActorTest {
class ProximityTerminalControlNotStopTest extends ActorTest {
"ProximityTerminalControl" should {
//setup
val probe = new TestProbe(system)
val service = ServiceManager.boot(system)
service ! ServiceManager.Register(Props(classOf[ProximityTest.ProbedLocalService], probe), "local")
service ! ServiceManager.Register(Props[TaskResolver], "taskResolver")
service ! ServiceManager.Register(Props[TaskResolver], "cluster")
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
val zone : Zone = new Zone("test", new ZoneMap("test-map"), 0) {
Actor = system.actorOf(Props(classOf[ZoneActor], this), "test-zone")
override def SetupNumberPools() = {
AddPool("dynamic", 1 to 10)
}
}
val probe = new TestProbe(system)
zone.LocalEvents = probe.ref
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.Actor = system.actorOf(Props(classOf[ProximityTerminalControl], terminal), "test-prox")
new Building(building_guid = 0, map_id = 0, zone, StructureType.Facility, GlobalDefinitions.building) {
Amenities = terminal
Faction = PlanetSideEmpire.VS
}
val avatar = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
avatar.Continent = "test"
avatar.Spawn
avatar.Health = 50
val avatar2 = Player(Avatar("TestCharacter2", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
avatar2.Continent = "test"
avatar2.Spawn
avatar2.Health = 50
avatar.GUID = PlanetSideGUID(1)
terminal.GUID = PlanetSideGUID(2)
avatar.GUID = PlanetSideGUID(2)
terminal.GUID = PlanetSideGUID(3)
terminal.Actor ! Service.Startup()
expectNoMsg(500 milliseconds) //spacer
val probe1 = new TestProbe(system, "local-events")
val probe2 = new TestProbe(system, "target-callback-1")
val probe3 = new TestProbe(system, "target-callback-2")
zone.LocalEvents = probe1.ref
"will not send out one stop message until last user" in {
assert(terminal.NumberUsers == 0)
assert(terminal.Owner.Continent.equals("test"))
terminal.Actor ! CommonMessages.Use(avatar, Some(avatar))
val msg = probe.receiveOne(500 milliseconds)
terminal.Actor.tell(CommonMessages.Use(avatar, Some(avatar)), probe2.ref)
probe1.expectMsgClass(100 millisecond, classOf[Terminal.StartProximityEffect])
assert(terminal.NumberUsers == 1)
assert(msg.isInstanceOf[LocalServiceResponse])
val resp = msg.asInstanceOf[LocalServiceResponse]
assert(resp.replyMessage == LocalResponse.ProximityTerminalEffect(PlanetSideGUID(2), true))
val avatar2 = Player(Avatar("TestCharacter2", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
avatar2.Continent = "test"
avatar2.Spawn
avatar2.Health = 50
terminal.Actor ! CommonMessages.Use(avatar2, Some(avatar2))
probe.expectNoMsg(500 milliseconds)
terminal.Actor.tell(CommonMessages.Use(avatar2, Some(avatar2)), probe3.ref)
probe1.expectNoMsg(100 millisecond)
assert(terminal.NumberUsers == 2)
terminal.Actor ! CommonMessages.Unuse(avatar, Some(avatar))
val msg2 = probe.receiveWhile(500 milliseconds) {
case LocalServiceResponse(_, _, replyMessage) => replyMessage
}
probe1.expectNoMsg(100 millisecond)
assert(terminal.NumberUsers == 1)
assert(!msg2.contains(LocalResponse.ProximityTerminalEffect(PlanetSideGUID(2), false)))
terminal.Actor ! CommonMessages.Unuse(avatar2, Some(avatar2))
probe1.expectMsgClass(100 millisecond, classOf[Terminal.StopProximityEffect])
assert(terminal.NumberUsers == 0)
}
}
}
@ -302,7 +290,7 @@ class ProximityTerminalControlNotStopTest extends ActorTest {
object ProximityTest {
class SampleTerminal extends Terminal(GlobalDefinitions.dropship_vehicle_terminal) with ProximityUnit
class ProbedLocalService(probe : TestProbe) extends LocalService {
class ProbedLocalService(probe : TestProbe, zone : Zone) extends LocalService(zone) {
self.tell(Service.Join("test"), probe.ref)
}
}

74
common/src/test/scala/service/AvatarServiceTest.scala
View file

@ -19,7 +19,7 @@ class AvatarService1Test extends ActorTest {
"AvatarService" should {
"construct" in {
ServiceManager.boot(system)
system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
assert(true)
}
}
@ -29,7 +29,7 @@ class AvatarService2Test extends ActorTest {
"AvatarService" should {
"subscribe" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
assert(true)
}
@ -40,7 +40,7 @@ class AvatarService3Test extends ActorTest {
"AvatarService" should {
ServiceManager.boot(system)
"subscribe to a specific channel" in {
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
@ -52,7 +52,7 @@ class AvatarService4Test extends ActorTest {
"AvatarService" should {
"subscribe" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
@ -64,7 +64,7 @@ class AvatarService5Test extends ActorTest {
"AvatarService" should {
"pass an unhandled message" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
@ -76,7 +76,7 @@ class ArmorChangedTest extends ActorTest {
"AvatarService" should {
"pass ArmorChanged" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ArmorChanged(PlanetSideGUID(10), ExoSuitType.Reinforced, 0))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ArmorChanged(ExoSuitType.Reinforced, 0)))
@ -88,7 +88,7 @@ class ConcealPlayerTest extends ActorTest {
"AvatarService" should {
"pass ConcealPlayer" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ConcealPlayer(PlanetSideGUID(10)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ConcealPlayer()))
@ -97,11 +97,8 @@ class ConcealPlayerTest extends ActorTest {
}
class EquipmentInHandTest extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0)
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
ServiceManager.boot(system)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), "release-test-service")
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.GUID = PlanetSideGUID(40)
@ -123,8 +120,8 @@ class EquipmentInHandTest extends ActorTest {
}
class DeployItemTest extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "deploy-item-test-service")
ServiceManager.boot(system)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), "deploy-item-test-service")
val objDef = GlobalDefinitions.motionalarmsensor
val obj = new SensorDeployable(objDef)
obj.Position = Vector3(1,2,3)
@ -146,13 +143,8 @@ class DeployItemTest extends ActorTest {
}
class DroptItemTest extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0)
val taskResolver = system.actorOf(Props[TaskResolver], "drop-item-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "drop-item-test-zone")
zone.Actor ! Zone.Init()
ServiceManager.boot(system)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), "release-test-service")
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.Position = Vector3(1,2,3)
@ -171,7 +163,7 @@ class DroptItemTest extends ActorTest {
"AvatarService" should {
"pass DropItem" in {
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.DropItem(PlanetSideGUID(10), tool, zone))
service ! AvatarServiceMessage("test", AvatarAction.DropItem(PlanetSideGUID(10), tool, Zone.Nowhere))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.DropItem(pkt)))
}
}
@ -191,7 +183,7 @@ class LoadPlayerTest extends ActorTest {
"AvatarService" should {
"pass LoadPlayer" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
//no parent data
service ! AvatarServiceMessage("test", AvatarAction.LoadPlayer(
@ -211,7 +203,7 @@ class ObjectDeleteTest extends ActorTest {
"AvatarService" should {
"pass ObjectDelete" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ObjectDelete(PlanetSideGUID(10), PlanetSideGUID(11)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectDelete(PlanetSideGUID(11), 0)))
@ -226,7 +218,7 @@ class ObjectHeldTest extends ActorTest {
"AvatarService" should {
"pass ObjectHeld" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ObjectHeld(PlanetSideGUID(10), 1))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectHeld(1)))
@ -238,7 +230,7 @@ class PutDownFDUTest extends ActorTest {
"AvatarService" should {
"pass PutDownFDU" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PutDownFDU(PlanetSideGUID(10)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.PutDownFDU(PlanetSideGUID(10))))
@ -250,7 +242,7 @@ class PlanetsideAttributeTest extends ActorTest {
"AvatarService" should {
"pass PlanetsideAttribute" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PlanetsideAttribute(PlanetSideGUID(10), 5, 1200L))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.PlanetsideAttribute(5, 1200L)))
@ -264,7 +256,7 @@ class PlayerStateTest extends ActorTest {
"AvatarService" should {
"pass PlayerState" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PlayerState(PlanetSideGUID(10), Vector3(3694.1094f, 2735.4531f, 90.84375f), Some(Vector3(4.375f, 2.59375f, 0.0f)), 61.875f, 351.5625f, 0.0f, 136, false, false, false, false, false, false))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.PlayerState(Vector3(3694.1094f, 2735.4531f, 90.84375f), Some(Vector3(4.375f, 2.59375f, 0.0f)), 61.875f, 351.5625f, 0.0f, 136, false, false, false, false, false, false)))
@ -290,7 +282,7 @@ class PickupItemATest extends ActorTest {
"pass PickUpItem as EquipmentInHand (visible pistol slot)" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PickupItem(PlanetSideGUID(10), Zone.Nowhere, obj, 0, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.EquipmentInHand(pkt)))
@ -304,7 +296,7 @@ class PickupItemBTest extends ActorTest {
"pass PickUpItem as ObjectDelete (not visible inventory space)" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PickupItem(PlanetSideGUID(10), Zone.Nowhere, obj, 6, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectDelete(tool.GUID, 0)))
@ -315,7 +307,7 @@ class ReloadTest extends ActorTest {
"AvatarService" should {
"pass Reload" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.Reload(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.Reload(PlanetSideGUID(40))))
@ -330,7 +322,7 @@ class ChangeAmmoTest extends ActorTest {
"AvatarService" should {
"pass ChangeAmmo" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeAmmo(PlanetSideGUID(10), PlanetSideGUID(40), 0, PlanetSideGUID(40), ammoDef.ObjectId, PlanetSideGUID(41), ammoDef.Packet.ConstructorData(ammoBox).get))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeAmmo(PlanetSideGUID(40), 0, PlanetSideGUID(40), ammoDef.ObjectId, PlanetSideGUID(41), ammoDef.Packet.ConstructorData(ammoBox).get)))
@ -345,7 +337,7 @@ class ChangeFireModeTest extends ActorTest {
"AvatarService" should {
"pass ChangeFireMode" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeFireMode(PlanetSideGUID(10), PlanetSideGUID(40), 0))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeFireMode(PlanetSideGUID(40), 0)))
@ -357,7 +349,7 @@ class ChangeFireStateStartTest extends ActorTest {
"AvatarService" should {
"pass ChangeFireState_Start" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeFireState_Start(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeFireState_Start(PlanetSideGUID(40))))
@ -369,7 +361,7 @@ class ChangeFireStateStopTest extends ActorTest {
"AvatarService" should {
"pass ChangeFireState_Stop" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeFireState_Stop(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeFireState_Stop(PlanetSideGUID(40))))
@ -387,7 +379,7 @@ class DamageTest extends ActorTest {
"AvatarService" should {
"pass Damage" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.Damage(PlanetSideGUID(10), player, test_func_ref))
val msg = receiveOne(1 seconds)
@ -408,7 +400,7 @@ class WeaponDryFireTest extends ActorTest {
"AvatarService" should {
"pass WeaponDryFire" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.WeaponDryFire(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.WeaponDryFire(PlanetSideGUID(40))))
@ -422,7 +414,7 @@ class AvatarStowEquipmentTest extends ActorTest {
"AvatarService" should {
"pass StowEquipment" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
val service = system.actorOf(Props(classOf[AvatarService], Zone.Nowhere), AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.StowEquipment(PlanetSideGUID(10), PlanetSideGUID(11), 2, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.StowEquipment(PlanetSideGUID(11), 2, tool)))
@ -448,8 +440,8 @@ Even with all this work, the tests have a high chance of failure just due to bei
*/
class AvatarReleaseTest extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0) { override def SetupNumberPools() = { AddPool("dynamic", 1 to 10) } }
val service = system.actorOf(Props(classOf[AvatarService], zone), "release-test-service")
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
@ -497,8 +489,8 @@ class AvatarReleaseTest extends ActorTest {
class AvatarReleaseEarly1Test extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0) { override def SetupNumberPools() = { AddPool("dynamic", 1 to 10) } }
val service = system.actorOf(Props(classOf[AvatarService], zone), "release-test-service")
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
@ -547,8 +539,8 @@ class AvatarReleaseEarly1Test extends ActorTest {
class AvatarReleaseEarly2Test extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0) { override def SetupNumberPools() = { AddPool("dynamic", 1 to 10) } }
val service = system.actorOf(Props(classOf[AvatarService], zone), "release-test-service")
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()

37
common/src/test/scala/service/LocalServiceTest.scala
View file

@ -6,6 +6,7 @@ import base.ActorTest
import net.psforever.objects.{GlobalDefinitions, SensorDeployable, Vehicle}
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.serverobject.terminals.{ProximityTerminal, Terminal}
import net.psforever.objects.zones.Zone
import net.psforever.packet.game._
import net.psforever.types.{PlanetSideEmpire, Vector3}
import services.{Service, ServiceManager}
@ -16,7 +17,7 @@ class LocalService1Test extends ActorTest {
"LocalService" should {
"construct" in {
system.actorOf(Props[LocalService], "l_service")
system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
assert(true)
}
}
@ -27,7 +28,7 @@ class LocalService2Test extends ActorTest {
"LocalService" should {
"subscribe" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
assert(true)
}
@ -39,7 +40,7 @@ class LocalService3Test extends ActorTest {
"LocalService" should {
"subscribe to a specific channel" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
@ -52,7 +53,7 @@ class LocalService4Test extends ActorTest {
"LocalService" should {
"subscribe" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
@ -65,7 +66,7 @@ class LocalService5Test extends ActorTest {
"LocalService" should {
"pass an unhandled message" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
@ -79,7 +80,7 @@ class AlertDestroyDeployableTest extends ActorTest {
"LocalService" should {
"pass AlertDestroyDeployable" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.AlertDestroyDeployable(PlanetSideGUID(10), obj))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(0), LocalResponse.AlertDestroyDeployable(obj)))
@ -92,7 +93,7 @@ class DeployableMapIconTest extends ActorTest {
"LocalService" should {
"pass DeployableMapIcon" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test",
LocalAction.DeployableMapIcon(
@ -116,7 +117,7 @@ class DoorClosesTest extends ActorTest {
"LocalService" should {
"pass DoorCloses" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.DoorCloses(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.DoorCloses(PlanetSideGUID(40))))
@ -134,7 +135,7 @@ class HackClearTest extends ActorTest {
"LocalService" should {
"pass HackClear" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.HackClear(PlanetSideGUID(10), obj, 0L, 1000L))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.HackClear(PlanetSideGUID(40), 0L, 1000L)))
@ -144,7 +145,7 @@ class HackClearTest extends ActorTest {
class ProximityTerminalEffectOnTest extends ActorTest {
ServiceManager.boot(system)
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.GUID = PlanetSideGUID(1)
@ -159,7 +160,7 @@ class ProximityTerminalEffectOnTest extends ActorTest {
class ProximityTerminalEffectOffTest extends ActorTest {
ServiceManager.boot(system)
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
val terminal = new ProximityTerminal(GlobalDefinitions.medical_terminal)
terminal.GUID = PlanetSideGUID(1)
@ -177,7 +178,7 @@ class RouterTelepadTransportTest extends ActorTest {
"LocalService" should {
"pass RouterTelepadTransport" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.RouterTelepadTransport(PlanetSideGUID(10), PlanetSideGUID(11), PlanetSideGUID(12), PlanetSideGUID(13)))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.RouterTelepadTransport(PlanetSideGUID(11), PlanetSideGUID(12), PlanetSideGUID(13))))
@ -191,7 +192,7 @@ class SetEmpireTest extends ActorTest {
"LocalService" should {
"pass SetEmpire" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.SetEmpire(PlanetSideGUID(10), PlanetSideEmpire.TR))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(0), LocalResponse.SetEmpire(PlanetSideGUID(10), PlanetSideEmpire.TR)))
@ -205,7 +206,7 @@ class ToggleTeleportSystemTest extends ActorTest {
"LocalService" should {
"pass ToggleTeleportSystem" in {
val router = Vehicle(GlobalDefinitions.router)
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.ToggleTeleportSystem(PlanetSideGUID(10), router, None))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.ToggleTeleportSystem(router, None)))
@ -218,7 +219,7 @@ class TriggerEffectTest extends ActorTest {
"LocalService" should {
"pass TriggerEffect (1)" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.TriggerEffect(PlanetSideGUID(10), "on", PlanetSideGUID(40)))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.TriggerEffect(PlanetSideGUID(40), "on", None, None)))
@ -231,7 +232,7 @@ class TriggerEffectInfoTest extends ActorTest {
"LocalService" should {
"pass TriggerEffect (2)" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.TriggerEffectInfo(PlanetSideGUID(10), "on", PlanetSideGUID(40), true, 1000))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.TriggerEffect(PlanetSideGUID(40), "on", Some(TriggeredEffect(true, 1000)), None)))
@ -244,7 +245,7 @@ class TriggerEffectLocationTest extends ActorTest {
"LocalService" should {
"pass TriggerEffect (3)" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.TriggerEffectLocation(PlanetSideGUID(10), "spawn_object_failed_effect", Vector3(1.1f, 2.2f, 3.3f), Vector3(4.4f, 5.5f, 6.6f)))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.TriggerEffect(PlanetSideGUID(0), "spawn_object_failed_effect", None, Some(TriggeredEffectLocation(Vector3(1.1f, 2.2f, 3.3f), Vector3(4.4f, 5.5f, 6.6f))))))
@ -258,7 +259,7 @@ class TriggerSoundTest extends ActorTest {
"LocalService" should {
"pass TriggerSound" in {
val service = system.actorOf(Props[LocalService], "l_service")
val service = system.actorOf(Props(classOf[LocalService], Zone.Nowhere), "l_service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.TriggerSound(PlanetSideGUID(10), TriggeredSound.LockedOut, Vector3(1.1f, 2.2f, 3.3f), 0, 0.75f))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.TriggerSound(TriggeredSound.LockedOut, Vector3(1.1f, 2.2f, 3.3f), 0, 0.75f)))

63
common/src/test/scala/service/VehicleServiceTest.scala
View file

@ -4,6 +4,7 @@ package service
import akka.actor.Props
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.zones.Zone
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types._
import services.{Service, ServiceManager}
@ -14,7 +15,7 @@ class VehicleService1Test extends ActorTest {
"VehicleService" should {
"construct" in {
system.actorOf(Props[VehicleService], "v-service")
system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
assert(true)
}
}
@ -25,7 +26,7 @@ class VehicleService2Test extends ActorTest {
"VehicleService" should {
"subscribe" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
assert(true)
}
@ -37,7 +38,7 @@ class VehicleService3Test extends ActorTest {
"VehicleService" should {
"subscribe to a specific channel" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
@ -50,7 +51,7 @@ class VehicleService4Test extends ActorTest {
"VehicleService" should {
"subscribe" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
@ -63,7 +64,7 @@ class VehicleService5Test extends ActorTest {
"VehicleService" should {
"pass an unhandled message" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
@ -76,7 +77,7 @@ class OwnershipTest extends ActorTest {
"VehicleService" should {
"pass Awareness" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.Ownership(PlanetSideGUID(10), PlanetSideGUID(11)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.Ownership(PlanetSideGUID(11))))
@ -89,7 +90,7 @@ class ChildObjectStateTest extends ActorTest {
"VehicleService" should {
"pass ChildObjectState" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.ChildObjectState(PlanetSideGUID(10), PlanetSideGUID(11), 1.2f, 3.4f))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.ChildObjectState(PlanetSideGUID(11), 1.2f, 3.4f)))
@ -102,7 +103,7 @@ class DeployRequestTest extends ActorTest {
"VehicleService" should {
"pass DeployRequest" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.DeployRequest(PlanetSideGUID(10), PlanetSideGUID(11), DriveState.Mobile, 0, false, Vector3(1.2f, 3.4f, 5.6f)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.DeployRequest(PlanetSideGUID(11), DriveState.Mobile, 0, false, Vector3(1.2f, 3.4f, 5.6f))))
@ -115,7 +116,7 @@ class DismountVehicleTest extends ActorTest {
"VehicleService" should {
"pass DismountVehicle" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.DismountVehicle(PlanetSideGUID(10), BailType.Normal, false))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.DismountVehicle(BailType.Normal, false)))
@ -131,7 +132,7 @@ class InventoryStateTest extends ActorTest {
"VehicleService" should {
"pass InventoryState" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.InventoryState(PlanetSideGUID(10), tool, PlanetSideGUID(11), 0, cdata))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.InventoryState(tool, PlanetSideGUID(11), 0, cdata)))
@ -147,7 +148,7 @@ class InventoryState2Test extends ActorTest {
"VehicleService" should {
"pass InventoryState2" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.InventoryState2(PlanetSideGUID(10), PlanetSideGUID(11), PlanetSideGUID(12), 13))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.InventoryState2(PlanetSideGUID(11), PlanetSideGUID(12), 13)))
@ -160,7 +161,7 @@ class KickPassengerTest extends ActorTest {
"VehicleService" should {
"pass KickPassenger" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.KickPassenger(PlanetSideGUID(10), 0, false, PlanetSideGUID(11)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.KickPassenger(0, false, PlanetSideGUID(11))))
@ -175,7 +176,7 @@ class LoadVehicleTest extends ActorTest {
"VehicleService" should {
"pass LoadVehicle" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.LoadVehicle(PlanetSideGUID(10), vehicle, 12, PlanetSideGUID(11), cdata))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.LoadVehicle(vehicle, 12, PlanetSideGUID(11), cdata)))
@ -188,7 +189,7 @@ class MountVehicleTest extends ActorTest {
"VehicleService" should {
"pass MountVehicle" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.MountVehicle(PlanetSideGUID(10), PlanetSideGUID(11), 0))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.MountVehicle(PlanetSideGUID(11), 0)))
@ -201,7 +202,7 @@ class SeatPermissionsTest extends ActorTest {
"VehicleService" should {
"pass SeatPermissions" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.SeatPermissions(PlanetSideGUID(10), PlanetSideGUID(11), 0, 12L))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.SeatPermissions(PlanetSideGUID(11), 0, 12L)))
@ -219,7 +220,7 @@ class StowEquipmentTest extends ActorTest {
"StowEquipment" should {
"pass StowEquipment" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.StowEquipment(PlanetSideGUID(10), PlanetSideGUID(11), 0, tool))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.StowEquipment(PlanetSideGUID(11), 0, toolDef.ObjectId, tool.GUID, cdata)))
@ -232,7 +233,7 @@ class UnstowEquipmentTest extends ActorTest {
"VehicleService" should {
"pass UnstowEquipment" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.UnstowEquipment(PlanetSideGUID(10), PlanetSideGUID(11)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.UnstowEquipment(PlanetSideGUID(11))))
@ -245,7 +246,7 @@ class VehicleStateTest extends ActorTest {
"VehicleService" should {
"pass VehicleState" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.VehicleState(PlanetSideGUID(10), PlanetSideGUID(11), 0, Vector3(1.2f, 3.4f, 5.6f), Vector3(7.8f, 9.1f, 2.3f), Some(Vector3(4.5f, 6.7f, 8.9f)), Option(1), 2, 3, 4, false, true))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.VehicleState(PlanetSideGUID(11), 0, Vector3(1.2f, 3.4f, 5.6f), Vector3(7.8f, 9.1f, 2.3f), Some(Vector3(4.5f, 6.7f, 8.9f)), Option(1), 2, 3, 4, false, true)))
@ -258,7 +259,7 @@ class TransferPassengerChannelTest extends ActorTest {
"VehicleService" should {
"pass TransferPassengerChannel" in {
val service = system.actorOf(Props[VehicleService], "v-service")
val service = system.actorOf(Props(classOf[VehicleService], Zone.Nowhere), "v-service")
val fury = Vehicle(GlobalDefinitions.fury)
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.TransferPassengerChannel(PlanetSideGUID(10), "old_channel", "new_channel", fury))
@ -267,18 +268,18 @@ class TransferPassengerChannelTest extends ActorTest {
}
}
class TransferPassengerTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass TransferPassenger" in {
val fury = Vehicle(GlobalDefinitions.fury)
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.TransferPassenger(PlanetSideGUID(10), "temp_channel", fury, PlanetSideGUID(11)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.TransferPassenger("temp_channel", fury, PlanetSideGUID(11))))
}
}
}
//class TransferPassengerTest extends ActorTest {
// ServiceManager.boot(system)
// "VehicleService" should {
// "pass TransferPassenger" in {
// val fury = Vehicle(GlobalDefinitions.fury)
// val service = system.actorOf(Props[VehicleService], "v-service")
// service ! Service.Join("test")
// service ! VehicleServiceMessage("test", VehicleAction.TransferPassenger(PlanetSideGUID(10), "temp_channel", fury, PlanetSideGUID(11)))
// expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.TransferPassenger("temp_channel", fury, PlanetSideGUID(11))))
// }
// }
//}
object VehicleServiceTest {
//decoy