PSForever/PSF-BotServer
1
0
Fork 0
mirror of https://github.com/2revoemag/PSF-BotServer.git synced 2026-02-12 19:31:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Facility Turrets (#223)

Browse source 
* object class, actor class, and definitions for base turrets; untested

* wired base turrets into existence, with hoop jumping; created interface for objects with mounted weapons (vehicles and turrets); working example phalanx_sgl_hevgatcan in Anguta, Ceryshen

* re-wiring manned turrets so that the turreted weapon itself never changes externally but merely identifies different and changes internally; workflow for upgrading wall turrets in place (30s); clarifications and documentation for HackMessage and UseItemMessage; getting rid of orphaned packages from previous location of services

* added a simple task that reverts upgraded manned turrets to their None state after a certain amount of time has passed; it works but need improvement

* turret weapon upgrades now last for a duration of 30 minutes before reverting; created a service support actor base actor that underlies all current support actors; nano-dispenser now properly loads 1 unit of upgrade canister, rather than 100 units; all canister types have appropriate 2x3 inventory size

* forgot to hurry; moved over the Services tests from main/test folder into the common/test folder and needed to change the location of ActorTest to accommodate it; test and documentation for MannedTurret; codecov ignore update

* wired facility turrets in Anguta, Ceryshen; Akna tower, Ceryshen; and S.Villa tower, home3 (Anguta tower is a watchtower); attempted workaround for Travis CI issues with receiveN; re-introduced RemoveActorTest, at least the first test; expanded how ZoneActor performs tests on MannedTurret setup

* getting rid of useless commented-out code; making common operations for mounting and dismounting

* removed outdated comment; added ResourceSilo tests; added extra test for Zone
This commit is contained in:
Fate-JH 2018-07-14 21:25:44 -04:00 • committed by GitHub
parent 61a51c1dd1
commit b81ff2bbf4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
75 changed files with 2246 additions and 680 deletions
Download patch file Download diff file Expand all files Collapse all files

51
common/src/test/scala/base/ActorTest.scala Normal file
View file

@ -0,0 +1,51 @@
package base
// Copyright (c) 2017 PSForever
import akka.actor.ActorSystem
import akka.testkit.{ImplicitSender, TestKit}
import com.typesafe.config.ConfigFactory
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}
import org.specs2.specification.Scope
import scala.collection.mutable
import scala.concurrent.duration.FiniteDuration
abstract class ActorTest(sys : ActorSystem = ActorSystem("system", ConfigFactory.parseMap(ActorTest.LoggingConfig)))
extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll {
override def afterAll {
TestKit.shutdownActorSystem(system)
}
}
object ActorTest {
import scala.collection.JavaConverters._
private val LoggingConfig = Map(
"akka.loggers" -> List("akka.testkit.TestEventListener").asJava,
"akka.loglevel" -> "OFF",
"akka.stdout-loglevel" -> "OFF",
"akka.log-dead-letters" -> "OFF"
).asJava
/**
* A (potential) workaround to a Travis CI issue involving polling a series of messages over a period of time.
* Running the test in isolation works every time.
* Running the test as part of a series produces mixed results.
* Travis CI fails the test every time by not getting any messages.
* @see TestKit.receiveN
* @param n the number of messages to poll
* @param timeout how long to wait for each message
* @param sys what to poll
* @return a list of messages
*/
def receiveMultiple(n : Int, timeout : FiniteDuration, sys : TestKit) : List[Any] = {
assert(0 < n, s"number of expected messages must be positive non-zero integer - $n")
val out = {
val msgs = mutable.ListBuffer[Any]()
(0 until n).foreach(_ => {
msgs += sys.receiveOne(timeout)
})
msgs.toList
}
out
}
}

4
common/src/test/scala/game/UseItemMessageTest.scala
View file

@ -14,7 +14,7 @@ class UseItemMessageTest extends Specification {
PacketCoding.DecodePacket(string).require match {
case UseItemMessage(avatar_guid, unk1, object_guid, unk2, unk3, unk4, unk5, unk6, unk7, unk8, itemType) =>
avatar_guid mustEqual PlanetSideGUID(75)
unk1 mustEqual 0
unk1 mustEqual PlanetSideGUID(0)
object_guid mustEqual PlanetSideGUID(372)
unk2 mustEqual 0xFFFFFFFFL
unk3 mustEqual false
@ -30,7 +30,7 @@ class UseItemMessageTest extends Specification {
}
"encode" in {
val msg = UseItemMessage(PlanetSideGUID(75), 0, PlanetSideGUID(372), 0xFFFFFFFFL, false, Vector3(5.0f, 0.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), 11, 25, 0, 364)
val msg = UseItemMessage(PlanetSideGUID(75), PlanetSideGUID(0), PlanetSideGUID(372), 0xFFFFFFFFL, false, Vector3(5.0f, 0.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), 11, 25, 0, 364)
val pkt = PacketCoding.EncodePacket(msg).require.toByteVector
pkt mustEqual string

25
common/src/test/scala/objects/ActorTest.scala
View file

@ -1,25 +0,0 @@
// Copyright (c) 2017 PSForever
package objects
import akka.actor.ActorSystem
import akka.testkit.{ImplicitSender, TestKit}
import com.typesafe.config.{ConfigFactory, ConfigValueFactory}
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}
import org.specs2.specification.Scope
abstract class ActorTest(sys : ActorSystem = ActorSystem("system", ConfigFactory.parseMap(ActorTest.LoggingConfig)))
extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll {
override def afterAll {
TestKit.shutdownActorSystem(system)
}
}
object ActorTest {
import scala.collection.JavaConverters._
private val LoggingConfig = Map(
"akka.loggers" -> List("akka.testkit.TestEventListener").asJava,
"akka.loglevel" -> "OFF",
"akka.stdout-loglevel" -> "OFF",
"akka.log-dead-letters" -> "OFF"
).asJava
}

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

@ -3,6 +3,7 @@ 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}

14
common/src/test/scala/objects/BuildingTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.GlobalDefinitions
import net.psforever.objects.definition.ObjectDefinition
import net.psforever.objects.serverobject.affinity.FactionAffinity
@ -128,12 +129,11 @@ class BuildingControl2Test extends ActorTest {
val bldg = Building(10, Zone.Nowhere, StructureType.Building)
bldg.Faction = PlanetSideEmpire.TR
bldg.Actor = system.actorOf(Props(classOf[BuildingControl], bldg), "test")
bldg.Actor ! "startup"
"Building Control" should {
"convert and assert faction affinity on convert request" in {
expectNoMsg(250 milliseconds)
bldg.Actor ! "startup"
expectNoMsg(250 milliseconds)
expectNoMsg(500 milliseconds)
assert(bldg.Faction == PlanetSideEmpire.TR)
bldg.Actor ! FactionAffinity.ConvertFactionAffinity(PlanetSideEmpire.VS)
@ -159,12 +159,11 @@ class BuildingControl3Test extends ActorTest {
door2.Actor = system.actorOf(Props(classOf[DoorControl], door2), "door2-test")
bldg.Amenities = door2
bldg.Amenities = door1
bldg.Actor ! "startup"
"Building Control" should {
"convert and assert faction affinity on convert request, and for each of its amenities" in {
expectNoMsg(250 milliseconds)
bldg.Actor ! "startup"
expectNoMsg(250 milliseconds)
expectNoMsg(500 milliseconds)
assert(bldg.Faction == PlanetSideEmpire.TR)
assert(bldg.Amenities.length == 2)
@ -172,7 +171,8 @@ class BuildingControl3Test extends ActorTest {
assert(bldg.Amenities(1) == door1)
bldg.Actor ! FactionAffinity.ConvertFactionAffinity(PlanetSideEmpire.VS)
val reply = receiveN(3, Duration.create(500, "ms"))
val reply = ActorTest.receiveMultiple(3, 500 milliseconds, this)
//val reply = receiveN(3, Duration.create(5000, "ms"))
assert(reply.length == 3)
var building_count = 0
var door_count = 0

1
common/src/test/scala/objects/DeploymentTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.serverobject.deploy.{Deployment, DeploymentBehavior}

11
common/src/test/scala/objects/DoorTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.doors.{Door, DoorControl}
import net.psforever.objects.serverobject.structures.{Building, StructureType}
@ -42,7 +43,7 @@ class DoorTest extends Specification {
}
"be opened and closed (2; toggle)" in {
val msg = UseItemMessage(PlanetSideGUID(6585), 0, PlanetSideGUID(372), 4294967295L, false, Vector3(5.0f,0.0f,0.0f), Vector3(0.0f,0.0f,0.0f), 11, 25, 0, 364)
val msg = UseItemMessage(PlanetSideGUID(6585), PlanetSideGUID(0), PlanetSideGUID(372), 4294967295L, false, Vector3(5.0f,0.0f,0.0f), Vector3(0.0f,0.0f,0.0f), 11, 25, 0, 364)
val door = Door(GlobalDefinitions.door)
door.Open mustEqual None
door.Use(player, msg)
@ -74,7 +75,7 @@ class DoorTest extends Specification {
}
}
class DoorControl1Test extends ActorTest() {
class DoorControl1Test extends ActorTest {
"DoorControl" should {
"construct" in {
val door = Door(GlobalDefinitions.door)
@ -84,11 +85,11 @@ class DoorControl1Test extends ActorTest() {
}
}
class DoorControl2Test extends ActorTest() {
class DoorControl2Test extends ActorTest {
"DoorControl" should {
"open on use" in {
val (player, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
val msg = UseItemMessage(PlanetSideGUID(1), 0, PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
assert(door.Open.isEmpty)
door.Actor ! Door.Use(player, msg)
@ -103,7 +104,7 @@ class DoorControl2Test extends ActorTest() {
}
}
class DoorControl3Test extends ActorTest() {
class DoorControl3Test extends ActorTest {
"DoorControl" should {
"do nothing if given garbage" in {
val (_, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)

7
common/src/test/scala/objects/FactionAffinityTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.serverobject.affinity.FactionAffinity
import net.psforever.objects.serverobject.doors.Door
@ -55,7 +56,7 @@ class FactionAffinityTest extends Specification {
}
}
class FactionAffinity1Test extends ActorTest() {
class FactionAffinity1Test extends ActorTest {
"FactionAffinity" should {
"assert affinity on confirm request" in {
val obj = FactionAffinityTest.SetUpAgent
@ -71,7 +72,7 @@ class FactionAffinity1Test extends ActorTest() {
}
}
class FactionAffinity2Test extends ActorTest() {
class FactionAffinity2Test extends ActorTest {
"FactionAffinity" should {
"assert affinity on assert request" in {
val obj = FactionAffinityTest.SetUpAgent
@ -87,7 +88,7 @@ class FactionAffinity2Test extends ActorTest() {
}
}
class FactionAffinity3Test extends ActorTest() {
class FactionAffinity3Test extends ActorTest {
"FactionAffinity" should {
"convert and assert affinity on convert request" in {
val obj = FactionAffinityTest.SetUpAgent

7
common/src/test/scala/objects/IFFLockTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.locks.{IFFLock, IFFLockControl}
@ -22,7 +23,7 @@ class IFFLockTest extends Specification {
}
}
class IFFLockControl1Test extends ActorTest() {
class IFFLockControl1Test extends ActorTest {
"IFFLockControl" should {
"construct" in {
val lock = IFFLock(GlobalDefinitions.lock_external)
@ -32,7 +33,7 @@ class IFFLockControl1Test extends ActorTest() {
}
}
class IFFLockControl2Test extends ActorTest() {
class IFFLockControl2Test extends ActorTest {
"IFFLockControl" should {
"can hack" in {
val (player, lock) = IFFLockControlTest.SetUpAgents(PlanetSideEmpire.TR)
@ -46,7 +47,7 @@ class IFFLockControl2Test extends ActorTest() {
}
}
class IFFLockControl3Test extends ActorTest() {
class IFFLockControl3Test extends ActorTest {
"IFFLockControl" should {
"can hack" in {
val (player, lock) = IFFLockControlTest.SetUpAgents(PlanetSideEmpire.TR)

1
common/src/test/scala/objects/LockerTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.GlobalDefinitions
import net.psforever.objects.serverobject.affinity.FactionAffinity
import net.psforever.objects.serverobject.mblocker.{Locker, LockerControl}

179
common/src/test/scala/objects/MannedTurretTest.scala Normal file
View file

@ -0,0 +1,179 @@
// Copyright (c) 2017 PSForever
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Tool}
import net.psforever.objects.definition.ToolDefinition
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.structures.{Building, StructureType}
import net.psforever.objects.serverobject.turret.{MannedTurret, MannedTurretControl, MannedTurretDefinition, TurretUpgrade}
import net.psforever.objects.zones.Zone
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import org.specs2.mutable.Specification
import scala.collection.mutable
import scala.concurrent.duration._
class MannedTurretTest extends Specification {
"MannedTurretTest" should {
"define" in {
val obj = new MannedTurretDefinition(480)
obj.Weapons mustEqual mutable.HashMap.empty[TurretUpgrade.Value, ToolDefinition]
obj.ReserveAmmunition mustEqual false
obj.FactionLocked mustEqual true
obj.MaxHealth mustEqual 100
obj.MountPoints mustEqual mutable.HashMap.empty[Int,Int]
}
"construct" in {
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.Weapons.size mustEqual 1
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
case _ =>
ko
}
obj.Seats.size mustEqual 1
obj.Seats(0).ControlledWeapon mustEqual Some(1)
obj.MountPoints.size mustEqual 1
obj.MountPoints(1) mustEqual 0
obj.Health mustEqual 3600
obj.Upgrade mustEqual TurretUpgrade.None
obj.Jammered mustEqual false
obj.Health = 360
obj.Health mustEqual 360
obj.Jammered = true
obj.Jammered mustEqual true
}
"upgrade to a different weapon" in {
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.Upgrade = TurretUpgrade.None
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
tool.FireModeIndex mustEqual 0
tool.NextFireMode
tool.FireModeIndex mustEqual 0 //one fire mode
case _ =>
ko
}
//upgrade
obj.Upgrade = TurretUpgrade.AVCombo
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_avcombo
tool.FireModeIndex mustEqual 0
tool.ProjectileType mustEqual GlobalDefinitions.phalanx_projectile.ProjectileType
tool.NextFireMode
tool.FireModeIndex mustEqual 1
tool.ProjectileType mustEqual GlobalDefinitions.phalanx_av_projectile.ProjectileType
case _ =>
ko
}
//revert
obj.Upgrade = TurretUpgrade.None
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
case _ =>
ko
}
}
}
}
class MannedTurretControl1Test extends ActorTest {
"MannedTurretControl" should {
"construct" in {
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
assert(obj.Actor != ActorRef.noSender)
}
}
}
class MannedTurretControl2Test extends ActorTest {
val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
val bldg = Building(0, Zone.Nowhere, StructureType.Building)
bldg.Amenities = obj
bldg.Faction = PlanetSideEmpire.TR
"MannedTurretControl" should {
"seat on faction affiliation when FactionLock is true" in {
assert(player.Faction == PlanetSideEmpire.TR)
assert(obj.Faction == PlanetSideEmpire.TR)
assert(obj.Definition.FactionLocked)
obj.Actor ! Mountable.TryMount(player, 0)
val reply = receiveOne(300 milliseconds)
reply match {
case msg : Mountable.MountMessages =>
assert(msg.response.isInstanceOf[Mountable.CanMount])
case _ =>
assert(false)
}
}
}
}
class MannedTurretControl3Test extends ActorTest {
val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
val bldg = Building(0, Zone.Nowhere, StructureType.Building)
bldg.Amenities = obj
"MannedTurretControl" should {
"block seating on mismatched faction affiliation when FactionLock is true" in {
assert(player.Faction == PlanetSideEmpire.TR)
assert(obj.Faction == PlanetSideEmpire.NEUTRAL)
assert(obj.Definition.FactionLocked)
obj.Actor ! Mountable.TryMount(player, 0)
val reply = receiveOne(300 milliseconds)
reply match {
case msg : Mountable.MountMessages =>
assert(msg.response.isInstanceOf[Mountable.CanNotMount])
case _ =>
assert(false)
}
}
}
}
class MannedTurretControl4Test extends ActorTest {
val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
val objDef = new MannedTurretDefinition(480)
objDef.FactionLocked = false
val obj = MannedTurret(objDef)
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
val bldg = Building(0, Zone.Nowhere, StructureType.Building)
bldg.Amenities = obj
"MannedTurretControl" should {
"seating even with mismatched faction affiliation when FactionLock is false" in {
assert(player.Faction == PlanetSideEmpire.TR)
assert(obj.Faction == PlanetSideEmpire.NEUTRAL)
assert(!obj.Definition.FactionLocked)
obj.Actor ! Mountable.TryMount(player, 0)
val reply = receiveOne(300 milliseconds)
reply match {
case msg : Mountable.MountMessages =>
assert(msg.response.isInstanceOf[Mountable.CanMount])
case _ =>
assert(false)
}
}
}
}

7
common/src/test/scala/objects/MountableTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorRef, Props}
import base.ActorTest
import net.psforever.objects.{Avatar, Player}
import net.psforever.objects.definition.{ObjectDefinition, SeatDefinition}
import net.psforever.objects.serverobject.mount.{Mountable, MountableBehavior}
@ -12,7 +13,7 @@ import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration.Duration
class MountableControl1Test extends ActorTest() {
class MountableControl1Test extends ActorTest {
"MountableControl" should {
"construct" in {
val obj = new MountableTest.MountableTestObject
@ -22,7 +23,7 @@ class MountableControl1Test extends ActorTest() {
}
}
class MountableControl2Test extends ActorTest() {
class MountableControl2Test extends ActorTest {
"MountableControl" should {
"let a player mount" in {
val player = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
@ -43,7 +44,7 @@ class MountableControl2Test extends ActorTest() {
}
}
class MountableControl3Test extends ActorTest() {
class MountableControl3Test extends ActorTest {
"MountableControl" should {
"block a player from mounting" in {
val player1 = Player(Avatar("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

332
common/src/test/scala/objects/ResourceSiloTest.scala Normal file
View file

@ -0,0 +1,332 @@
// Copyright (c) 2017 PSForever
package objects
import akka.actor.{Actor, Props}
import akka.routing.RandomPool
import akka.testkit.TestProbe
import base.ActorTest
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.packet.game.{PlanetSideGUID, UseItemMessage}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import org.specs2.mutable.Specification
import services.ServiceManager
import services.avatar.{AvatarAction, AvatarService, AvatarServiceMessage}
import scala.concurrent.duration._
class ResourceSiloTest extends Specification {
"Resource Silo" should {
"define" in {
val obj = new ResourceSiloDefinition
obj.ObjectId mustEqual 731
}
"construct" in {
val obj = ResourceSilo()
obj.Definition mustEqual GlobalDefinitions.resource_silo
obj.MaximumCharge mustEqual 1000
obj.ChargeLevel mustEqual 0
obj.LowNtuWarningOn mustEqual 0
obj.CapacitorDisplay mustEqual 0
//
obj.ChargeLevel = 50
obj.LowNtuWarningOn = 25
obj.CapacitorDisplay = 75
obj.ChargeLevel mustEqual 50
obj.LowNtuWarningOn mustEqual 25
obj.CapacitorDisplay mustEqual 75
}
"charge level can not exceed limits(0 to maximum)" in {
val obj = ResourceSilo()
obj.ChargeLevel mustEqual 0
obj.ChargeLevel = -5
obj.ChargeLevel mustEqual 0
obj.ChargeLevel = 1250
obj.ChargeLevel mustEqual 1000
obj.ChargeLevel mustEqual obj.MaximumCharge
}
"using the silo generates a charge event" in {
val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
ResourceSilo().Use(ResourceSiloTest.player, msg) mustEqual ResourceSilo.ChargeEvent()
}
}
}
class ResourceSiloControlStartupTest extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
val probe = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
"Resource silo" should {
"startup properly" in {
expectNoMsg(500 milliseconds)
system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
expectNoMsg(1 seconds)
assert(true)
}
}
}
class ResourceSiloControlUseTest 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 msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
"Resource silo" should {
"respond when being used" in {
expectNoMsg(1 seconds)
obj.Actor ! ResourceSilo.Use(ResourceSiloTest.player, msg)
val reply = receiveOne(500 milliseconds)
assert(reply.isInstanceOf[ResourceSilo.ResourceSiloMessage])
assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].player == ResourceSiloTest.player)
assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].msg == msg)
assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].response == ResourceSilo.ChargeEvent())
}
}
}
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 obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
obj.Owner = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
"Resource silo" should {
"announce low ntu" in {
expectNoMsg(1 seconds)
assert(obj.LowNtuWarningOn == 0)
obj.Actor ! ResourceSilo.LowNtuWarning(10)
val reply = probe.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == 10)
assert(reply.isInstanceOf[AvatarServiceMessage])
assert(reply.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 10)
}
}
}
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 obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
"Resource silo" should {
"update the charge level and capacitor display (report low ntu, power restored)" in {
expectNoMsg(1 seconds)
assert(obj.ChargeLevel == 0)
assert(obj.CapacitorDisplay == 0)
obj.Actor ! ResourceSilo.UpdateChargeLevel(105)
val reply1 = probe1.receiveOne(500 milliseconds)
val reply2 = probe2.receiveOne(500 milliseconds)
assert(obj.ChargeLevel == 105)
assert(obj.CapacitorDisplay == 1)
assert(reply1.isInstanceOf[AvatarServiceMessage])
assert(reply1.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(1))
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 45)
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 1)
assert(reply2.isInstanceOf[Building.SendMapUpdateToAllClients])
val reply3 = probe1.receiveOne(500 milliseconds)
assert(reply3.isInstanceOf[AvatarServiceMessage])
assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 48)
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 0)
val reply4 = probe1.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == 1)
assert(reply4.isInstanceOf[AvatarServiceMessage])
assert(reply4.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 1)
}
}
}
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 obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
"Resource silo" should {
"update the charge level and capacitor display (report good ntu)" in {
expectNoMsg(1 seconds)
obj.ChargeLevel = 100
obj.CapacitorDisplay = 1
obj.LowNtuWarningOn = 1
assert(obj.ChargeLevel == 100)
assert(obj.CapacitorDisplay == 1)
assert(obj.LowNtuWarningOn == 1)
obj.Actor ! ResourceSilo.UpdateChargeLevel(105)
val reply1 = probe1.receiveOne(500 milliseconds)
val reply2 = probe2.receiveOne(500 milliseconds)
assert(obj.ChargeLevel == 205)
assert(obj.CapacitorDisplay == 2)
assert(reply1.isInstanceOf[AvatarServiceMessage])
assert(reply1.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(1))
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 45)
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 2)
assert(reply2.isInstanceOf[Building.SendMapUpdateToAllClients])
val reply3 = probe1.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == 0)
assert(reply3.isInstanceOf[AvatarServiceMessage])
assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 0)
}
}
}
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 obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
"Resource silo" should {
"update, but not sufficiently to change the capacitor display" in {
expectNoMsg(1 seconds)
obj.ChargeLevel = 250
obj.CapacitorDisplay = 3
obj.LowNtuWarningOn = 0
assert(obj.ChargeLevel == 250)
assert(obj.CapacitorDisplay == 3)
assert(obj.LowNtuWarningOn == 0)
obj.Actor ! ResourceSilo.UpdateChargeLevel(50)
expectNoMsg(500 milliseconds)
probe1.expectNoMsg(500 milliseconds)
probe2.expectNoMsg(500 milliseconds)
assert(obj.ChargeLevel == 300)
assert(obj.CapacitorDisplay == 3)
assert(obj.LowNtuWarningOn == 0)
}
}
}
object ResourceSiloTest {
val player = Player(Avatar("TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
class ProbedAvatarService(probe : TestProbe) extends Actor {
override def receive : Receive = {
case msg =>
probe.ref ! msg
}
}
class ProbedBuildingControl(probe : TestProbe) extends Actor {
override def receive : Receive = {
case msg =>
probe.ref ! msg
}
}
class ProbedResourceSiloControl(silo : ResourceSilo, probe : TestProbe) extends ResourceSiloControl(silo) {
override def receive : Receive = {
case msg =>
super.receive.apply(msg)
probe.ref ! msg
}
}
}

47
common/src/test/scala/objects/ServerObjectBuilderTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorContext, Props}
import base.ActorTest
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.objects.serverobject.ServerObjectBuilder
@ -137,7 +138,8 @@ class ProximityTerminalObjectBuilderTest extends ActorTest {
"Terminal object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1, ProximityTerminal.Constructor(medical_terminal)), hub), "term")
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
ProximityTerminal.Constructor(medical_terminal)), hub), "term")
actor ! "!"
val reply = receiveOne(Duration.create(1000, "ms"))
@ -172,7 +174,7 @@ class VehicleSpawnPadObjectBuilderTest extends ActorTest {
class LocalProjectileBuilderTest extends ActorTest {
import net.psforever.objects.LocalProjectile
"Local ProjectileBuilder" should {
"Local projectile object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@ -190,7 +192,7 @@ class LocalProjectileBuilderTest extends ActorTest {
class LockerObjectBuilderTest extends ActorTest {
import net.psforever.objects.serverobject.mblocker.Locker
"LockerObjectBuilder" should {
"Locker object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@ -206,9 +208,27 @@ class LockerObjectBuilderTest extends ActorTest {
}
}
class ResourceSiloObjectBuilderTest extends ActorTest {
import net.psforever.objects.serverobject.resourcesilo.ResourceSilo
"Resource silo object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
ResourceSilo.Constructor), hub), "spawn-tube")
actor ! "startup"
val reply = receiveOne(Duration.create(1000, "ms"))
assert(reply.isInstanceOf[ResourceSilo])
assert(reply.asInstanceOf[ResourceSilo].HasGUID)
assert(reply.asInstanceOf[ResourceSilo].GUID == PlanetSideGUID(1))
assert(reply == hub(1).get)
}
}
}
class SpawnTubeObjectBuilderTest extends ActorTest {
import net.psforever.objects.serverobject.tube.SpawnTube
"LockerObjectBuilder" should {
"Spawn tube object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@ -226,6 +246,25 @@ class SpawnTubeObjectBuilderTest extends ActorTest {
}
}
class MannedTurretObjectBuilderTest extends ActorTest {
import net.psforever.objects.GlobalDefinitions.manned_turret
import net.psforever.objects.serverobject.turret.MannedTurret
"MannedTurretObjectBuilder" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
MannedTurret.Constructor(manned_turret)), hub), "spawn-tube")
actor ! "!"
val reply = receiveOne(Duration.create(1000, "ms"))
assert(reply.isInstanceOf[MannedTurret])
assert(reply.asInstanceOf[MannedTurret].HasGUID)
assert(reply.asInstanceOf[MannedTurret].GUID == PlanetSideGUID(1))
assert(reply == hub(1).get)
}
}
}
object ServerObjectBuilderTest {
import net.psforever.objects.guid.source.LimitedNumberSource
def NumberPoolHub : NumberPoolHub = {

3
common/src/test/scala/objects/SpawnTubeTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.GlobalDefinitions
import net.psforever.objects.serverobject.tube.{SpawnTube, SpawnTubeControl, SpawnTubeDefinition}
import org.specs2.mutable.Specification
@ -48,7 +49,7 @@ class SpawnTubeTest extends Specification {
}
}
class SpawnTubeControlTest extends ActorTest() {
class SpawnTubeControlTest extends ActorTest {
"SpawnTubeControl" should {
"construct" in {
val obj = SpawnTube(GlobalDefinitions.ams_respawn_tube)

9
common/src/test/scala/objects/UtilityTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorRef, Props}
import base.ActorTest
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.serverobject.terminals.Terminal
import net.psforever.objects.vehicles._
@ -73,7 +74,7 @@ class UtilityTest extends Specification {
}
}
class Utility1Test extends ActorTest() {
class Utility1Test extends ActorTest {
"Utility" should {
"wire an order_terminala Actor" in {
val obj = Utility(UtilityType.order_terminala, UtilityTest.vehicle)
@ -87,7 +88,7 @@ class Utility1Test extends ActorTest() {
}
}
class Utility2Test extends ActorTest() {
class Utility2Test extends ActorTest {
"Utility" should {
"wire an order_terminalb Actor" in {
val obj = Utility(UtilityType.order_terminalb, UtilityTest.vehicle)
@ -101,7 +102,7 @@ class Utility2Test extends ActorTest() {
}
}
class Utility3Test extends ActorTest() {
class Utility3Test extends ActorTest {
"Utility" should {
"wire a matrix_terminalc Actor" in {
val obj = Utility(UtilityType.matrix_terminalc, UtilityTest.vehicle)
@ -115,7 +116,7 @@ class Utility3Test extends ActorTest() {
}
}
class Utility4Test extends ActorTest() {
class Utility4Test extends ActorTest {
"Utility" should {
"wire an ams_respawn_tube Actor" in {
val obj = Utility(UtilityType.ams_respawn_tube, UtilityTest.vehicle)

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

@ -3,7 +3,7 @@ package objects
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.testkit.TestProbe
import net.psforever.objects.ballistics.Projectile
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
@ -39,7 +39,7 @@ class VehicleSpawnPadTest extends Specification {
}
}
class VehicleSpawnControl1Test extends ActorTest() {
class VehicleSpawnControl1Test extends ActorTest {
"VehicleSpawnControl" should {
"construct" in {
val obj = VehicleSpawnPad(GlobalDefinitions.spawn_pad)
@ -49,7 +49,7 @@ class VehicleSpawnControl1Test extends ActorTest() {
}
}
class VehicleSpawnControl2aTest extends ActorTest() {
class VehicleSpawnControl2aTest extends ActorTest {
// This runs for a long time.
"VehicleSpawnControl" should {
"complete on a vehicle order (block a second one until the first is done and the spawn pad is cleared)" in {
@ -113,7 +113,7 @@ class VehicleSpawnControl2aTest extends ActorTest() {
}
}
class VehicleSpawnControl2bTest extends ActorTest() {
class VehicleSpawnControl2bTest extends ActorTest {
// This runs for a long time.
"VehicleSpawnControl" should {
"complete on a vehicle order (railless)" in {
@ -170,7 +170,7 @@ class VehicleSpawnControl2bTest extends ActorTest() {
}
}
class VehicleSpawnControl3Test extends ActorTest() {
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)
@ -241,7 +241,7 @@ class VehicleSpawnControl4Test extends ActorTest() {
// }
//}
class VehicleSpawnControl5Test extends ActorTest() {
class VehicleSpawnControl5Test extends ActorTest {
"VehicleSpawnControl" should {
"player dies right after vehicle partially loads; the vehicle spawns and blocks the pad" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
@ -274,7 +274,7 @@ class VehicleSpawnControl5Test extends ActorTest() {
}
}
class VehicleSpawnControl6Test extends ActorTest() {
class VehicleSpawnControl6Test extends ActorTest {
"VehicleSpawnControl" should {
"the player can not sit in vehicle; vehicle spawns and blocks the pad" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)

1
common/src/test/scala/objects/VehicleTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.Props
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.definition.{SeatDefinition, VehicleDefinition}
import net.psforever.objects.serverobject.mount.Mountable

10
common/src/test/scala/objects/ZoneTest.scala
View file

@ -4,6 +4,7 @@ package objects
import java.util.concurrent.atomic.AtomicInteger
import akka.actor.{ActorContext, ActorRef, Props}
import base.ActorTest
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.guid.NumberPoolHub
@ -74,6 +75,15 @@ class ZoneTest extends Specification {
map.TerminalToInterface(3, 4)
map.TerminalToInterface mustEqual Map(1 -> 2, 3 -> 4)
}
"associate turrets to weapons" in {
val map = new ZoneMap("map13")
map.TurretToWeapon mustEqual Map.empty
map.TurretToWeapon(1, 2)
map.TurretToWeapon mustEqual Map(1 -> 2)
map.TurretToWeapon(3, 4)
map.TurretToWeapon mustEqual Map(1 -> 2, 3 -> 4)
}
}
val map13 = new ZoneMap("map13")

2
common/src/test/scala/objects/guidtask/GUIDTaskRegister1Test.scala
View file

@ -1,8 +1,8 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister1Test extends ActorTest {
"RegisterObjectTask" in {

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister2Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister2Test extends ActorTest() {
class GUIDTaskRegister2Test extends ActorTest {
"RegisterEquipment -> RegisterObjectTask" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister3Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister3Test extends ActorTest() {
class GUIDTaskRegister3Test extends ActorTest {
"RegisterEquipment -> RegisterTool" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister4Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister4Test extends ActorTest() {
class GUIDTaskRegister4Test extends ActorTest {
"RegisterVehicle" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister5Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskRegister5Test extends ActorTest() {
class GUIDTaskRegister5Test extends ActorTest {
"RegisterAvatar" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister6Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskRegister6Test extends ActorTest() {
class GUIDTaskRegister6Test extends ActorTest {
"RegisterPlayer" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister1Test.scala
View file

@ -1,10 +1,10 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister1Test extends ActorTest() {
class GUIDTaskUnregister1Test extends ActorTest {
"UnregisterObjectTask" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister2Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister2Test extends ActorTest() {
class GUIDTaskUnregister2Test extends ActorTest {
"UnregisterEquipment -> UnregisterObjectTask" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister3Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister3Test extends ActorTest() {
class GUIDTaskUnregister3Test extends ActorTest {
"UnregisterEquipment -> UnregisterTool" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister4Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister4Test extends ActorTest() {
class GUIDTaskUnregister4Test extends ActorTest {
"RegisterVehicle" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister5Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskUnregister5Test extends ActorTest() {
class GUIDTaskUnregister5Test extends ActorTest {
"UnregisterAvatar" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister6Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskUnregister6Test extends ActorTest() {
class GUIDTaskUnregister6Test extends ActorTest {
"UnregisterPlayer" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

8
common/src/test/scala/objects/number/NumberPoolActorTest.scala
View file

@ -2,14 +2,14 @@
package objects.number
import akka.actor.{ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.guid.actor.NumberPoolActor
import net.psforever.objects.guid.pool.ExclusivePool
import net.psforever.objects.guid.selector.RandomSelector
import objects.ActorTest
import scala.concurrent.duration.Duration
class NumberPoolActorTest extends ActorTest() {
class NumberPoolActorTest extends ActorTest {
"NumberPoolActor" should {
"GetAnyNumber" in {
val pool = new ExclusivePool((25 to 50).toList)
@ -22,7 +22,7 @@ class NumberPoolActorTest extends ActorTest() {
}
}
class NumberPoolActorTest1 extends ActorTest() {
class NumberPoolActorTest1 extends ActorTest {
"NumberPoolActor" should {
"GetSpecificNumber" in {
val pool = new ExclusivePool((25 to 50).toList)
@ -34,7 +34,7 @@ class NumberPoolActorTest1 extends ActorTest() {
}
}
class NumberPoolActorTest2 extends ActorTest() {
class NumberPoolActorTest2 extends ActorTest {
"NumberPoolActor" should {
"NoNumber" in {
val pool = new ExclusivePool((25 to 25).toList) //pool only has one number - 25

4
common/src/test/scala/objects/number/UniqueNumberSystemTest.scala
View file

@ -2,17 +2,17 @@
package objects.number
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.objects.guid.actor.{NumberPoolActor, Register, UniqueNumberSystem, Unregister}
import net.psforever.objects.guid.selector.RandomSelector
import net.psforever.objects.guid.source.LimitedNumberSource
import objects.ActorTest
import scala.concurrent.duration.Duration
import scala.util.{Failure, Success}
class AllocateNumberPoolActors extends ActorTest() {
class AllocateNumberPoolActors extends ActorTest {
"AllocateNumberPoolActors" in {
val src : LimitedNumberSource = LimitedNumberSource(6000)
val guid : NumberPoolHub = new NumberPoolHub(src)

12
common/src/test/scala/objects/terminal/ImplantTerminalMechTest.scala
View file

@ -2,6 +2,7 @@
package objects.terminal
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.definition.SeatDefinition
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.implantmech.{ImplantTerminalMech, ImplantTerminalMechControl}
@ -9,7 +10,6 @@ import net.psforever.objects.serverobject.structures.StructureType
import net.psforever.objects.vehicles.Seat
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import objects.ActorTest
import org.specs2.mutable.Specification
import scala.concurrent.duration.Duration
@ -56,7 +56,7 @@ class ImplantTerminalMechTest extends Specification {
}
}
class ImplantTerminalMechControl1Test extends ActorTest() {
class ImplantTerminalMechControl1Test extends ActorTest {
"ImplantTerminalMechControl" should {
"construct" in {
val obj = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)
@ -66,7 +66,7 @@ class ImplantTerminalMechControl1Test extends ActorTest() {
}
}
class ImplantTerminalMechControl2Test extends ActorTest() {
class ImplantTerminalMechControl2Test extends ActorTest {
"ImplantTerminalMechControl" should {
"let a player mount" in {
val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)
@ -85,7 +85,7 @@ class ImplantTerminalMechControl2Test extends ActorTest() {
}
}
class ImplantTerminalMechControl3Test extends ActorTest() {
class ImplantTerminalMechControl3Test extends ActorTest {
import net.psforever.types.CharacterGender
"ImplantTerminalMechControl" should {
"block a player from mounting" in {
@ -108,7 +108,7 @@ class ImplantTerminalMechControl3Test extends ActorTest() {
}
}
class ImplantTerminalMechControl4Test extends ActorTest() {
class ImplantTerminalMechControl4Test extends ActorTest {
"ImplantTerminalMechControl" should {
"dismount player after mounting" in {
val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)
@ -130,7 +130,7 @@ class ImplantTerminalMechControl4Test extends ActorTest() {
}
}
class ImplantTerminalMechControl5Test extends ActorTest() {
class ImplantTerminalMechControl5Test extends ActorTest {
"ImplantTerminalMechControl" should {
"block a player from dismounting" in {
val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)

12
common/src/test/scala/objects/terminal/ProximityTerminalControlTest.scala
View file

@ -2,16 +2,16 @@
package objects.terminal
import akka.actor.{ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.terminals._
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
import scala.concurrent.duration.Duration
class ProximityTerminalControl1Test extends ActorTest() {
class ProximityTerminalControl1Test extends ActorTest {
"ProximityTerminalControl" should {
"construct (medical terminal)" in {
val terminal = ProximityTerminal(GlobalDefinitions.medical_terminal)
@ -20,7 +20,7 @@ class ProximityTerminalControl1Test extends ActorTest() {
}
}
class ProximityTerminalControl2Test extends ActorTest() {
class ProximityTerminalControl2Test extends ActorTest {
"ProximityTerminalControl can not process wrong messages" in {
val (_, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
@ -30,7 +30,7 @@ class ProximityTerminalControl2Test extends ActorTest() {
}
//terminal control is mostly a pass-through actor for Terminal.Exchange messages, wrapped in Terminal.TerminalMessage protocol
class MedicalTerminalControl1Test extends ActorTest() {
class MedicalTerminalControl1Test extends ActorTest {
"ProximityTerminalControl sends a message to the first new user only" in {
val (player, terminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
player.GUID = PlanetSideGUID(10)
@ -53,7 +53,7 @@ class MedicalTerminalControl1Test extends ActorTest() {
}
}
class MedicalTerminalControl2Test extends ActorTest() {
class MedicalTerminalControl2Test extends ActorTest {
"ProximityTerminalControl sends a message to the last user only" in {
val (player, terminal) : (Player, ProximityTerminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
player.GUID = PlanetSideGUID(10)
@ -82,7 +82,7 @@ class MedicalTerminalControl2Test extends ActorTest() {
}
}
class MedicalTerminalControl3Test extends ActorTest() {
class MedicalTerminalControl3Test extends ActorTest {
"ProximityTerminalControl sends a message to the last user only (confirmation of test #2)" in {
val (player, terminal) : (Player, ProximityTerminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
player.GUID = PlanetSideGUID(10)

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

@ -2,13 +2,13 @@
package objects.terminal
import akka.actor.Props
import base.ActorTest
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.serverobject.terminals.Terminal.TerminalMessage
import net.psforever.objects.serverobject.terminals.{ProximityTerminal, ProximityTerminalControl, ProximityUnit, Terminal}
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
import org.specs2.mutable.Specification
import scala.concurrent.duration._

16
common/src/test/scala/objects/terminal/TerminalControlTest.scala
View file

@ -2,17 +2,17 @@
package objects.terminal
import akka.actor.{ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.structures.{Building, StructureType}
import net.psforever.objects.serverobject.terminals.{Terminal, TerminalControl, TerminalDefinition}
import net.psforever.objects.zones.Zone
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID}
import net.psforever.types._
import objects.ActorTest
import scala.concurrent.duration.Duration
class TerminalControl1Test extends ActorTest() {
class TerminalControl1Test extends ActorTest {
"TerminalControl" should {
"construct (cert terminal)" in {
val terminal = Terminal(GlobalDefinitions.cert_terminal)
@ -21,7 +21,7 @@ class TerminalControl1Test extends ActorTest() {
}
}
class TerminalControl2Test extends ActorTest() {
class TerminalControl2Test extends ActorTest {
"TerminalControl can not process wrong messages" in {
val (_, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
@ -32,7 +32,7 @@ class TerminalControl2Test extends ActorTest() {
//terminal control is mostly a pass-through actor for Terminal.Exchange messages, wrapped in Terminal.TerminalMessage protocol
//test for Cert_Terminal messages (see CertTerminalTest)
class CertTerminalControl1Test extends ActorTest() {
class CertTerminalControl1Test extends ActorTest {
"TerminalControl can be used to learn a certification ('medium_assault')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "medium_assault", 0, PlanetSideGUID(0))
@ -47,7 +47,7 @@ class CertTerminalControl1Test extends ActorTest() {
}
}
class CertTerminalControl2Test extends ActorTest() {
class CertTerminalControl2Test extends ActorTest {
"TerminalControl can be used to warn about not learning a fake certification ('juggling')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "juggling", 0, PlanetSideGUID(0))
@ -62,7 +62,7 @@ class CertTerminalControl2Test extends ActorTest() {
}
}
class CertTerminalControl3Test extends ActorTest() {
class CertTerminalControl3Test extends ActorTest {
"TerminalControl can be used to forget a certification ('medium_assault')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "medium_assault", 0, PlanetSideGUID(0))
@ -77,7 +77,7 @@ class CertTerminalControl3Test extends ActorTest() {
}
}
class VehicleTerminalControl1Test extends ActorTest() {
class VehicleTerminalControl1Test extends ActorTest {
"TerminalControl can be used to buy a vehicle ('two_man_assault_buggy')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.ground_vehicle_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "two_man_assault_buggy", 0, PlanetSideGUID(0))
@ -102,7 +102,7 @@ class VehicleTerminalControl1Test extends ActorTest() {
}
}
class VehicleTerminalControl2Test extends ActorTest() {
class VehicleTerminalControl2Test extends ActorTest {
"TerminalControl can be used to warn about not buy a vehicle ('harasser')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.ground_vehicle_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "harasser", 0, PlanetSideGUID(0))

544
common/src/test/scala/service/AvatarServiceTest.scala Normal file
View file

@ -0,0 +1,544 @@
// Copyright (c) 2017 PSForever
package service
import akka.actor.Props
import akka.routing.RandomPool
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.zones.{Zone, ZoneActor, ZoneMap}
import net.psforever.packet.game.objectcreate.{DroppedItemData, ObjectClass, ObjectCreateMessageParent, PlacementData}
import net.psforever.packet.game.{ObjectCreateMessage, PlanetSideGUID, PlayerStateMessageUpstream}
import net.psforever.types._
import services.{RemoverActor, Service, ServiceManager}
import services.avatar._
import scala.concurrent.duration._
class AvatarService1Test extends ActorTest {
"AvatarService" should {
"construct" in {
ServiceManager.boot(system)
system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
assert(true)
}
}
}
class AvatarService2Test extends ActorTest {
"AvatarService" should {
"subscribe" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
assert(true)
}
}
}
class AvatarService3Test extends ActorTest {
"AvatarService" should {
ServiceManager.boot(system)
"subscribe to a specific channel" in {
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
}
}
}
class AvatarService4Test extends ActorTest {
"AvatarService" should {
"subscribe" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
}
}
}
class AvatarService5Test extends ActorTest {
"AvatarService" should {
"pass an unhandled message" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
}
}
}
class ArmorChangedTest extends ActorTest {
"AvatarService" should {
"pass ArmorChanged" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
}
}
}
class ConcealPlayerTest extends ActorTest {
"AvatarService" should {
"pass ConcealPlayer" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ConcealPlayer(PlanetSideGUID(10)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ConcealPlayer()))
}
}
}
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")
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.GUID = PlanetSideGUID(40)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(41)
val pkt = ObjectCreateMessage(
toolDef.ObjectId,
tool.GUID,
ObjectCreateMessageParent(PlanetSideGUID(11), 2),
toolDef.Packet.ConstructorData(tool).get
)
"AvatarService" should {
"pass EquipmentInHand" in {
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.EquipmentInHand(PlanetSideGUID(10), PlanetSideGUID(11), 2, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.EquipmentInHand(pkt)))
}
}
}
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()
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.Position = Vector3(1,2,3)
tool.Orientation = Vector3(4,5,6)
tool.GUID = PlanetSideGUID(40)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(41)
val pkt = ObjectCreateMessage(
toolDef.ObjectId,
tool.GUID,
DroppedItemData(
PlacementData(tool.Position, tool.Orientation),
toolDef.Packet.ConstructorData(tool).get
)
)
"AvatarService" should {
"pass DropItem" in {
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.DropItem(PlanetSideGUID(10), tool, zone))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.DropItem(pkt)))
}
}
}
class LoadPlayerTest extends ActorTest {
val obj = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.GUID = PlanetSideGUID(10)
obj.Slot(5).Equipment.get.GUID = PlanetSideGUID(11)
val c1data = obj.Definition.Packet.DetailedConstructorData(obj).get
val pkt1 = ObjectCreateMessage(ObjectClass.avatar, PlanetSideGUID(10), c1data)
val parent = ObjectCreateMessageParent(PlanetSideGUID(12), 0)
obj.VehicleSeated = PlanetSideGUID(12)
val c2data = obj.Definition.Packet.DetailedConstructorData(obj).get
val pkt2 = ObjectCreateMessage(ObjectClass.avatar, PlanetSideGUID(10), parent, c2data)
"AvatarService" should {
"pass LoadPlayer" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
//no parent data
service ! AvatarServiceMessage("test", AvatarAction.LoadPlayer(
PlanetSideGUID(20), ObjectClass.avatar, PlanetSideGUID(10), c1data, None)
)
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(20), AvatarResponse.LoadPlayer(pkt1)))
//parent data
service ! AvatarServiceMessage("test", AvatarAction.LoadPlayer(
PlanetSideGUID(20), ObjectClass.avatar, PlanetSideGUID(10), c2data, Some(parent))
)
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(20), AvatarResponse.LoadPlayer(pkt2)))
}
}
}
class ObjectDeleteTest extends ActorTest {
"AvatarService" should {
"pass ObjectDelete" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
service ! AvatarServiceMessage("test", AvatarAction.ObjectDelete(PlanetSideGUID(10), PlanetSideGUID(11), 55))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectDelete(PlanetSideGUID(11), 55)))
}
}
}
class ObjectHeldTest extends ActorTest {
"AvatarService" should {
"pass ObjectHeld" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ObjectHeld(PlanetSideGUID(10), 1))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectHeld(1)))
}
}
}
class PlanetsideAttributeTest extends ActorTest {
"AvatarService" should {
"pass PlanetsideAttribute" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
}
}
}
class PlayerStateTest extends ActorTest {
val msg = PlayerStateMessageUpstream(PlanetSideGUID(75), Vector3(3694.1094f, 2735.4531f, 90.84375f), Some(Vector3(4.375f, 2.59375f, 0.0f)), 61.875f, 351.5625f, 0.0f, 136, 0, false, false, false, false, 112, 0)
"AvatarService" should {
"pass PlayerState" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PlayerState(PlanetSideGUID(10), msg, false, false))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.PlayerState(msg, false, false)))
}
}
}
class PickupItemATest extends ActorTest {
val obj = Player(Avatar("TestCharacter", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.GUID = PlanetSideGUID(10)
obj.Slot(5).Equipment.get.GUID = PlanetSideGUID(11)
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.GUID = PlanetSideGUID(40)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(41)
val pkt = ObjectCreateMessage(
toolDef.ObjectId,
tool.GUID,
ObjectCreateMessageParent(PlanetSideGUID(10), 0),
toolDef.Packet.ConstructorData(tool).get
)
"pass PickUpItem as EquipmentInHand (visible pistol slot)" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
}
}
class PickupItemBTest extends ActorTest {
val obj = Player(Avatar("TestCharacter", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
val tool = Tool(GlobalDefinitions.beamer)
tool.GUID = PlanetSideGUID(40)
"pass PickUpItem as ObjectDelete (not visible inventory space)" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
}
}
class ReloadTest extends ActorTest {
"AvatarService" should {
"pass Reload" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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))))
}
}
}
class ChangeAmmoTest extends ActorTest {
val ammoDef = GlobalDefinitions.energy_cell
val ammoBox = AmmoBox(ammoDef)
"AvatarService" should {
"pass ChangeAmmo" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
}
}
}
class ChangeFireModeTest extends ActorTest {
val ammoDef = GlobalDefinitions.energy_cell
val ammoBox = AmmoBox(ammoDef)
"AvatarService" should {
"pass ChangeFireMode" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
}
}
}
class ChangeFireStateStartTest extends ActorTest {
"AvatarService" should {
"pass ChangeFireState_Start" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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))))
}
}
}
class ChangeFireStateStopTest extends ActorTest {
"AvatarService" should {
"pass ChangeFireState_Stop" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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))))
}
}
}
class WeaponDryFireTest extends ActorTest {
"AvatarService" should {
"pass WeaponDryFire" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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))))
}
}
}
class AvatarStowEquipmentTest extends ActorTest {
val tool = Tool(GlobalDefinitions.beamer)
"AvatarService" should {
"pass StowEquipment" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], 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)))
}
}
}
/*
Preparation for these three Release tests is involved.
The ServiceManager must not only be set up correctly, but must be given a TaskResolver.
The AvatarService is started and that starts CorpseRemovalActor, an essential part of this test.
The CorpseRemovalActor needs that TaskResolver created by the ServiceManager;
but, another independent TaskResolver will be needed for manual parts of the test.
(The ServiceManager's TaskResolver can be "borrowed" but that requires writing code to intercept it.)
The Zone needs to be set up and initialized properly with a ZoneActor.
The ZoneActor builds the GUID Actor and the ZonePopulationActor.
ALL of these Actors will talk to each other.
The lines of communication can short circuit if the next Actor does not have the correct information.
Putting Actor startup in the main class, outside of the body of the test, helps.
Frequent pauses to allow everything to sort their messages also helps.
Even with all this work, the tests have a high chance of failure just due to being asynchronous.
*/
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 taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
val obj = Player(Avatar("TestCharacter", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.Continent = "test"
obj.Release
"AvatarService" should {
"pass Release" in {
expectNoMsg(100 milliseconds) //spacer
service ! Service.Join("test")
taskResolver ! GUIDTask.RegisterObjectTask(obj)(zone.GUID)
assert(zone.Corpses.isEmpty)
zone.Population ! Zone.Corpse.Add(obj)
expectNoMsg(200 milliseconds) //spacer
assert(zone.Corpses.size == 1)
assert(obj.HasGUID)
val guid = obj.GUID
service ! AvatarServiceMessage("test", AvatarAction.Release(obj, zone, Some(1 second))) //alive for one second
val reply1 = receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[AvatarServiceResponse])
val reply1msg = reply1.asInstanceOf[AvatarServiceResponse]
assert(reply1msg.toChannel == "/test/Avatar")
assert(reply1msg.avatar_guid == guid)
assert(reply1msg.replyMessage.isInstanceOf[AvatarResponse.Release])
assert(reply1msg.replyMessage.asInstanceOf[AvatarResponse.Release].player == obj)
val reply2 = receiveOne(2 seconds)
assert(reply2.isInstanceOf[AvatarServiceResponse])
val reply2msg = reply2.asInstanceOf[AvatarServiceResponse]
assert(reply2msg.toChannel.equals("/test/Avatar"))
assert(reply2msg.avatar_guid == Service.defaultPlayerGUID)
assert(reply2msg.replyMessage.isInstanceOf[AvatarResponse.ObjectDelete])
assert(reply2msg.replyMessage.asInstanceOf[AvatarResponse.ObjectDelete].item_guid == guid)
expectNoMsg(1 seconds)
assert(zone.Corpses.isEmpty)
assert(!obj.HasGUID)
}
}
}
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 taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
val obj = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.Continent = "test"
obj.Release
"AvatarService" should {
"pass Release" in {
expectNoMsg(100 milliseconds) //spacer
service ! Service.Join("test")
taskResolver ! GUIDTask.RegisterObjectTask(obj)(zone.GUID)
assert(zone.Corpses.isEmpty)
zone.Population ! Zone.Corpse.Add(obj)
expectNoMsg(200 milliseconds) //spacer
assert(zone.Corpses.size == 1)
assert(obj.HasGUID)
val guid = obj.GUID
service ! AvatarServiceMessage("test", AvatarAction.Release(obj, zone)) //3+ minutes!
val reply1 = receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[AvatarServiceResponse])
val reply1msg = reply1.asInstanceOf[AvatarServiceResponse]
assert(reply1msg.toChannel == "/test/Avatar")
assert(reply1msg.avatar_guid == guid)
assert(reply1msg.replyMessage.isInstanceOf[AvatarResponse.Release])
assert(reply1msg.replyMessage.asInstanceOf[AvatarResponse.Release].player == obj)
service ! AvatarServiceMessage.Corpse(RemoverActor.HurrySpecific(List(obj), zone)) //IMPORTANT: ONE ENTRY
val reply2 = receiveOne(200 milliseconds)
assert(reply2.isInstanceOf[AvatarServiceResponse])
val reply2msg = reply2.asInstanceOf[AvatarServiceResponse]
assert(reply2msg.toChannel.equals("/test/Avatar"))
assert(reply2msg.avatar_guid == Service.defaultPlayerGUID)
assert(reply2msg.replyMessage.isInstanceOf[AvatarResponse.ObjectDelete])
assert(reply2msg.replyMessage.asInstanceOf[AvatarResponse.ObjectDelete].item_guid == guid)
expectNoMsg(1 seconds)
assert(zone.Corpses.isEmpty)
assert(!obj.HasGUID)
}
}
}
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 taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
val objAlt = Player(Avatar("TestCharacter2", PlanetSideEmpire.NC, CharacterGender.Male, 1, CharacterVoice.Voice1)) //necessary clutter
val obj = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.Continent = "test"
obj.Release
"AvatarService" should {
"pass Release" in {
expectNoMsg(100 milliseconds) //spacer
service ! Service.Join("test")
taskResolver ! GUIDTask.RegisterObjectTask(obj)(zone.GUID)
assert(zone.Corpses.isEmpty)
zone.Population ! Zone.Corpse.Add(obj)
expectNoMsg(200 milliseconds) //spacer
assert(zone.Corpses.size == 1)
assert(obj.HasGUID)
val guid = obj.GUID
service ! AvatarServiceMessage("test", AvatarAction.Release(obj, zone)) //3+ minutes!
val reply1 = receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[AvatarServiceResponse])
val reply1msg = reply1.asInstanceOf[AvatarServiceResponse]
assert(reply1msg.toChannel == "/test/Avatar")
assert(reply1msg.avatar_guid == guid)
assert(reply1msg.replyMessage.isInstanceOf[AvatarResponse.Release])
assert(reply1msg.replyMessage.asInstanceOf[AvatarResponse.Release].player == obj)
service ! AvatarServiceMessage.Corpse(RemoverActor.HurrySpecific(List(objAlt, obj), zone)) //IMPORTANT: TWO ENTRIES
val reply2 = receiveOne(100 milliseconds)
assert(reply2.isInstanceOf[AvatarServiceResponse])
val reply2msg = reply2.asInstanceOf[AvatarServiceResponse]
assert(reply2msg.toChannel.equals("/test/Avatar"))
assert(reply2msg.avatar_guid == Service.defaultPlayerGUID)
assert(reply2msg.replyMessage.isInstanceOf[AvatarResponse.ObjectDelete])
assert(reply2msg.replyMessage.asInstanceOf[AvatarResponse.ObjectDelete].item_guid == guid)
expectNoMsg(1 seconds)
assert(zone.Corpses.isEmpty)
assert(!obj.HasGUID)
}
}
}
object AvatarServiceTest {
import java.util.concurrent.atomic.AtomicInteger
private val number = new AtomicInteger(1)
def TestName : String = {
s"service${number.getAndIncrement()}"
}
}

118
common/src/test/scala/service/LocalServiceTest.scala Normal file
View file

@ -0,0 +1,118 @@
package service
// Copyright (c) 2017 PSForever
import akka.actor.Props
import base.ActorTest
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{PlanetSideEmpire, Vector3}
import services.Service
import services.local._
class LocalService1Test extends ActorTest {
"LocalService" should {
"construct" in {
system.actorOf(Props[LocalService], "service")
assert(true)
}
}
}
class LocalService2Test extends ActorTest {
"LocalService" should {
"subscribe" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
assert(true)
}
}
}
class LocalService3Test extends ActorTest {
"LocalService" should {
"subscribe to a specific channel" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
}
}
}
class LocalService4Test extends ActorTest {
"LocalService" should {
"subscribe" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
}
}
}
class LocalService5Test extends ActorTest {
"LocalService" should {
"pass an unhandled message" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
}
}
}
class DoorClosesTest extends ActorTest {
"LocalService" should {
"pass DoorCloses" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.DoorCloses(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.DoorCloses(PlanetSideGUID(40))))
}
}
}
class HackClearTest extends ActorTest {
val obj = new PlanetSideServerObject() {
def Faction = PlanetSideEmpire.NEUTRAL
def Definition = null
GUID = PlanetSideGUID(40)
}
"LocalService" should {
"pass HackClear" in {
val service = system.actorOf(Props[LocalService], "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)))
}
}
}
class ProximityTerminalEffectTest extends ActorTest {
"LocalService" should {
"pass ProximityTerminalEffect" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.ProximityTerminalEffect(PlanetSideGUID(10), PlanetSideGUID(40), true))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.ProximityTerminalEffect(PlanetSideGUID(40), true)))
}
}
}
class TriggerSoundTest extends ActorTest {
import net.psforever.packet.game.TriggeredSound
"LocalService" should {
"pass TriggerSound" in {
val service = system.actorOf(Props[LocalService], "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)))
}
}
}
object LocalServiceTest {
//decoy
}

540
common/src/test/scala/service/RemoverActorTest.scala Normal file
View file

@ -0,0 +1,540 @@
// Copyright (c) 2017 PSForever
package service
import akka.actor.{ActorRef, Props}
import akka.routing.RandomPool
import akka.testkit.TestProbe
import base.ActorTest
import net.psforever.objects.PlanetSideGameObject
import net.psforever.objects.definition.{EquipmentDefinition, ObjectDefinition}
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.guid.TaskResolver
import net.psforever.objects.zones.{Zone, ZoneMap}
import net.psforever.packet.game.PlanetSideGUID
import services.{RemoverActor, ServiceManager}
import scala.concurrent.duration._
class StandardRemoverActorTest extends ActorTest {
ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
"RemoverActor" should {
"handle a simple task" in {
expectNoMsg(500 milliseconds)
val probe = TestProbe()
val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere)
val reply1 = probe.receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
val reply2 = probe.receiveOne(200 milliseconds)
assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
probe.expectNoMsg(1 seconds) //delay
val reply3 = probe.receiveOne(300 milliseconds)
assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
val reply4 = probe.receiveOne(300 milliseconds)
assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
val reply5 = probe.receiveOne(300 milliseconds)
assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
val reply6 = probe.receiveOne(500 milliseconds)
assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
val reply7 = probe.receiveOne(500 milliseconds)
assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
}
}
}
//class DelayedRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
//
// "RemoverActor" should {
// "handle a simple task (timed)" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(100 milliseconds))
//
// val reply1 = probe.receiveOne(200 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// val reply2 = probe.receiveOne(200 milliseconds)
// assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
// //no delay
// val reply3 = probe.receiveOne(300 milliseconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = probe.receiveOne(300 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = probe.receiveOne(300 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = probe.receiveOne(300 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = probe.receiveOne(300 milliseconds)
// assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class ExcludedRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// val AlternateTestObject = new PlanetSideGameObject() { def Definition = new ObjectDefinition(0) { } }
//
// "RemoverActor" should {
// "allow only specific objects" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(AlternateTestObject, Zone.Nowhere)
//
// val reply1 = probe.receiveOne(200 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// expectNoMsg(2 seconds)
// //RemoverActor is stalled because it received an object that it was not allowed to act upon
// }
// }
//}
//
//class MultipleRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "work on parallel tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere)
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere)
//
// val replies = probe.receiveN(14, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2 && fja == 2 && cta == 2 && sja == 2 && dta == 2 && dtr == 2)
// }
// }
//}
//
//class HurrySpecificRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
//
// "RemoverActor" should {
// "be able to hurry certain tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(10 minutes)) //TEN MINUTE WAIT
//
// val reply1 = probe.receiveOne(200 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// val reply2 = probe.receiveOne(200 milliseconds)
// assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 10 minutes
// remover ! RemoverActor.HurrySpecific(List(RemoverActorTest.TestObject), Zone.Nowhere) //hurried
// val reply3 = probe.receiveOne(300 milliseconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = probe.receiveOne(300 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = probe.receiveOne(300 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = probe.receiveOne(500 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = probe.receiveOne(500 milliseconds)
// assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurrySelectionRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to hurry certain tasks, but let others finish normally" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(10 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.HurrySpecific(List(RemoverActorTest.TestObject), Zone.Nowhere) //hurried
// //first
// val reply3a = probe.receiveOne(300 milliseconds)
// assert(reply3a.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4a = probe.receiveOne(300 milliseconds)
// assert(reply4a.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5a = probe.receiveOne(300 milliseconds)
// assert(reply5a.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6a = probe.receiveOne(500 milliseconds)
// assert(reply6a.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7a = probe.receiveOne(500 milliseconds)
// assert(reply7a.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// //second
// remover ! RemoverActor.HurrySpecific(List(TestObject2), Zone.Nowhere) //hurried
// val reply3b = probe.receiveOne(300 milliseconds)
// assert(reply3b.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4b = probe.receiveOne(300 milliseconds)
// assert(reply4b.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5b = probe.receiveOne(300 milliseconds)
// assert(reply5b.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6b = probe.receiveOne(500 milliseconds)
// assert(reply6b.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7b = probe.receiveOne(500 milliseconds)
// assert(reply7b.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurryMultipleRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
// final val TestObject3 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(3) } }
//
// "RemoverActor" should {
// "be able to hurry certain tasks, but only valid ones" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.HurrySpecific(List(RemoverActorTest.TestObject, TestObject3), Zone.Nowhere) //multiple hurried, only one valid
// //first
// val reply3a = probe.receiveOne(300 milliseconds)
// assert(reply3a.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4a = probe.receiveOne(300 milliseconds)
// assert(reply4a.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5a = probe.receiveOne(300 milliseconds)
// assert(reply5a.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6a = probe.receiveOne(500 milliseconds)
// assert(reply6a.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7a = probe.receiveOne(500 milliseconds)
// assert(reply7a.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// //second
// remover ! RemoverActor.HurrySpecific(List(TestObject2), Zone.Nowhere) //hurried
// val reply3b = probe.receiveOne(300 milliseconds)
// assert(reply3b.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4b = probe.receiveOne(300 milliseconds)
// assert(reply4b.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5b = probe.receiveOne(300 milliseconds)
// assert(reply5b.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6b = probe.receiveOne(500 milliseconds)
// assert(reply6b.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7b = probe.receiveOne(500 milliseconds)
// assert(reply7b.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurryByZoneRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
// final val TestObject3 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(3) } }
// final val zone = new Zone("test", new ZoneMap("test-map"), 11)
//
// "RemoverActor" should {
// "be able to hurry certain tasks by their zone" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, zone, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject3, Zone.Nowhere, Some(5 seconds))
//
// val replies1 = probe.receiveN(6, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies1.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 3 && ija == 3)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.HurrySpecific(List(), Zone.Nowhere) //multiple hurried, only the two entries with Zone.Nowhere
// //
// val replies2 = probe.receiveN(10, 5 seconds)
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies2.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(fja == 2 && cta == 2 && sja == 2 && dta == 2 && dtr == 2)
// //final
// remover ! RemoverActor.HurrySpecific(List(), zone) //hurried
// val reply3b = probe.receiveOne(300 milliseconds)
// assert(reply3b.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4b = probe.receiveOne(300 milliseconds)
// assert(reply4b.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5b = probe.receiveOne(300 milliseconds)
// assert(reply5b.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6b = probe.receiveOne(500 milliseconds)
// assert(reply6b.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7b = probe.receiveOne(500 milliseconds)
// assert(reply7b.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurryAllRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
// final val TestObject3 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(3) } }
//
// "RemoverActor" should {
// "be able to hurry all tasks to completion" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(20 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(15 seconds))
// remover ! RemoverActor.AddTask(TestObject3, Zone.Nowhere, Some(10 seconds))
//
// val replies1 = probe.receiveN(6, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies1.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 3 && ija == 3)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet longer than any of the tasks
// remover ! RemoverActor.HurryAll() //all hurried
// //
// val replies2 = probe.receiveN(15, 5 seconds)
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies2.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(fja == 3 && cta == 3 && sja == 3 && dta == 3 && dtr == 3)
// }
// }
//}
//
//class ClearSelectionRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to clear certain tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(4 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.ClearSpecific(List(RemoverActorTest.TestObject), Zone.Nowhere) //cleared
// //
// val reply3 = probe.receiveOne(2 seconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = probe.receiveOne(300 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = probe.receiveOne(300 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = probe.receiveOne(500 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = probe.receiveOne(500 milliseconds)
// assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// //wait
// probe.expectNoMsg(2 seconds) //nothing more to do
// }
// }
//}
//
//class ClearAllRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to clear all tasks, with no more work on them" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(4 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.ClearAll() //cleared
// //wait
// probe.expectNoMsg(3 seconds) //nothing more to do
// }
// }
//}
//
//class EarlyDeathRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to hurry certain tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(2 seconds)
// remover ! akka.actor.PoisonPill
// //
// val replies2 = probe.receiveN(8, 5 seconds)
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies2.collect {
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(fja == 2 && cta == 0 && sja == 2 && dta == 2 && dtr == 2) //no clearance tests
// }
// }
//}
object RemoverActorTest {
final val TestObject = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(1) } }
final case class InclusionTestAlert()
final case class InitialJobAlert()
final case class FirstJobAlert()
final case class SecondJobAlert()
final case class ClearanceTestAlert()
final case class DeletionTaskAlert()
final case class DeletionTaskRunAlert()
class TestRemover(probe : TestProbe) extends RemoverActor {
import net.psforever.objects.guid.{Task, TaskResolver}
val FirstStandardDuration = 1 seconds
val SecondStandardDuration = 100 milliseconds
def InclusionTest(entry : RemoverActor.Entry) : Boolean = {
probe.ref ! InclusionTestAlert()
entry.obj.isInstanceOf[Equipment]
}
def InitialJob(entry : RemoverActor.Entry) : Unit = {
probe.ref ! InitialJobAlert()
}
def FirstJob(entry : RemoverActor.Entry) : Unit = {
probe.ref ! FirstJobAlert()
}
override def SecondJob(entry : RemoverActor.Entry) : Unit = {
probe.ref ! SecondJobAlert()
super.SecondJob(entry)
}
def ClearanceTest(entry : RemoverActor.Entry) : Boolean = {
probe.ref ! ClearanceTestAlert()
true
}
def DeletionTask(entry : RemoverActor.Entry) : TaskResolver.GiveTask = {
probe.ref ! DeletionTaskAlert()
TaskResolver.GiveTask(new Task() {
private val localProbe = probe
override def isComplete = Task.Resolution.Success
def Execute(resolver : ActorRef) : Unit = {
localProbe.ref ! DeletionTaskRunAlert()
resolver ! scala.util.Success(this)
}
})
}
}
}

258
common/src/test/scala/service/VehicleServiceTest.scala Normal file
View file

@ -0,0 +1,258 @@
// Copyright (c) 2017 PSForever
package service
import akka.actor.Props
import base.ActorTest
import net.psforever.objects._
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types._
import services.{Service, ServiceManager}
import services.vehicle._
class VehicleService1Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"construct" in {
system.actorOf(Props[VehicleService], "v-service")
assert(true)
}
}
}
class VehicleService2Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"subscribe" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
assert(true)
}
}
}
class VehicleService3Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"subscribe to a specific channel" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
}
}
}
class VehicleService4Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"subscribe" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
}
}
}
class VehicleService5Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass an unhandled message" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
}
}
}
class OwnershipTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass Awareness" in {
val service = system.actorOf(Props[VehicleService], "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))))
}
}
}
class ChildObjectStateTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass ChildObjectState" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class DeployRequestTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass DeployRequest" in {
val service = system.actorOf(Props[VehicleService], "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))))
}
}
}
class DismountVehicleTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass DismountVehicle" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class InventoryStateTest extends ActorTest {
ServiceManager.boot(system)
val tool = Tool(GlobalDefinitions.beamer)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(13)
val cdata = tool.Definition.Packet.ConstructorData(tool).get
"VehicleService" should {
"pass InventoryState" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class InventoryState2Test extends ActorTest {
ServiceManager.boot(system)
val tool = Tool(GlobalDefinitions.beamer)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(13)
val cdata = tool.Definition.Packet.ConstructorData(tool).get
"VehicleService" should {
"pass InventoryState2" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class KickPassengerTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass KickPassenger" in {
val service = system.actorOf(Props[VehicleService], "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))))
}
}
}
class LoadVehicleTest extends ActorTest {
ServiceManager.boot(system)
val vehicle = Vehicle(GlobalDefinitions.quadstealth)
val cdata = vehicle.Definition.Packet.ConstructorData(vehicle).get
"VehicleService" should {
"pass LoadVehicle" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class MountVehicleTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass MountVehicle" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class SeatPermissionsTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass SeatPermissions" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class StowEquipmentTest extends ActorTest {
ServiceManager.boot(system)
val tool = Tool(GlobalDefinitions.beamer)
tool.GUID = PlanetSideGUID(12)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(13)
val toolDef = tool.Definition
val cdata = tool.Definition.Packet.DetailedConstructorData(tool).get
"StowEquipment" should {
"pass StowEquipment" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
class UnstowEquipmentTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass UnstowEquipment" in {
val service = system.actorOf(Props[VehicleService], "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))))
}
}
}
class VehicleStateTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass VehicleState" in {
val service = system.actorOf(Props[VehicleService], "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)))
}
}
}
object VehicleServiceTest {
//decoy
}