PSForever/PSF-BotServer
1
0
Fork 0
mirror of https://github.com/2revoemag/PSF-BotServer.git synced 2026-03-17 19:10:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Unique Number System Operations (#906)

Browse source 
* propagation of the ask pattern into the unique number actor

* TaskWorkflow as a replacement for TaskResolver; includes working tests

* AvailabilityPolicy has been changed slightly; number source restriction mechanic has been completely removed

* TaskResolver is gone and done and TaskWorkflow replaces it

* number pool variety

* every zone gets a custom tailored 'environment' number pool, as well as all other number pools; uns involves many more static functions and hard-defined variables

* repairs to uns and guidtask tests; worked uns into unops, an actorless version, but did not integrate into server

* shuffled around files in the guid package, causing import threshing; wrote extensive comments; repaired tests; classes related to the old unique number system have been removed

* created straightforward tasks; simplified number pool actor calls; repaired tests due to modifications to generic pool

* bad merge recovery
This commit is contained in:
Fate-JH 2021-08-15 21:27:45 -04:00 • committed by GitHub
parent ce2a3f5422
commit 9841b7e97d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
114 changed files with 2323 additions and 3374 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/test/scala/objects/DamageableTest.scala
View file

@ -1614,7 +1614,6 @@ class DamageableVehicleDestroyMountedTest extends FreedContextActorTest {
override def Activity = activityProbe.ref
override def AvatarEvents = avatarProbe.ref
override def VehicleEvents = vehicleProbe.ref
override def tasks = catchall.ref
import akka.actor.typed.scaladsl.adapter._
this.actor = catchall.ref.toTyped[ZoneActor.Command]
}

26
src/test/scala/objects/DeployableBehaviorTest.scala
View file

@ -9,7 +9,7 @@ import net.psforever.actors.zone.ZoneActor
import net.psforever.objects.avatar.{Avatar, Certification, PlayerControl}
import net.psforever.objects.{ConstructionItem, Deployables, GlobalDefinitions, Player}
import net.psforever.objects.ce.{Deployable, DeployedItem}
import net.psforever.objects.guid.{NumberPoolHub, TaskResolver}
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.zones.{Zone, ZoneDeployableActor, ZoneMap}
import net.psforever.packet.game._
@ -141,7 +141,6 @@ class DeployableBehaviorSetupOwnedP2Test extends FreedContextActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar)
override def LivePlayers = List(player)
override def tasks: ActorRef = eventsProbe.ref
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
}
@ -165,7 +164,7 @@ class DeployableBehaviorSetupOwnedP2Test extends FreedContextActorTest {
assert(!avatar.deployables.Contains(jmine), "owned setup test, 2 - avatar already owns deployable")
zone.Deployables ! Zone.Deployable.BuildByOwner(jmine, player, citem)
//assert(false, "test needs to be fixed")
val eventsMsgs = eventsProbe.receiveN(8, 10.seconds)
val eventsMsgs = eventsProbe.receiveN(7, 10.seconds)
eventsMsgs.head match {
case AvatarServiceMessage(
"TestCharacter1",
@ -220,11 +219,6 @@ class DeployableBehaviorSetupOwnedP2Test extends FreedContextActorTest {
case _ =>
assert(false, "owned setup test, 2 - construction tool not deleted")
}
eventsMsgs(7) match {
case TaskResolver.GiveTask(_, _) => ;
case _ =>
assert(false, "owned setup test, 2 - construction tool not unregistered")
}
assert(player.Slot(slot = 0).Equipment.isEmpty, "owned setup test, 2 - player hand should be empty")
assert(deployableList.contains(jmine), "owned setup test, 2 - deployable not appended to list")
assert(avatar.deployables.Contains(jmine), "owned setup test, 2 - avatar does not own deployable")
@ -244,7 +238,6 @@ class DeployableBehaviorDeconstructTest extends ActorTest {
GUID(guid)
override def AvatarEvents: ActorRef = eventsProbe.ref
override def LocalEvents: ActorRef = eventsProbe.ref
override def tasks: ActorRef = eventsProbe.ref
override def Deployables: ActorRef = deployables
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
@ -261,7 +254,7 @@ class DeployableBehaviorDeconstructTest extends ActorTest {
assert(deployableList.contains(jmine), "deconstruct test - deployable not appended to list")
jmine.Actor ! Deployable.Deconstruct()
val eventsMsgs = eventsProbe.receiveN(3, 10.seconds)
val eventsMsgs = eventsProbe.receiveN(2, 10.seconds)
eventsMsgs.head match {
case LocalServiceMessage("test", LocalAction.EliminateDeployable(`jmine`, PlanetSideGUID(1), Vector3(1,2,3), 2)) => ;
case _ => assert(false, "deconstruct test - not eliminating deployable")
@ -277,10 +270,6 @@ class DeployableBehaviorDeconstructTest extends ActorTest {
) => ;
case _ => assert(false, "owned deconstruct test - not removing icon")
}
eventsMsgs(2) match {
case TaskResolver.GiveTask(_, _) => ;
case _ => assert(false, "deconstruct test - not unregistering deployable")
}
assert(!deployableList.contains(jmine), "deconstruct test - deployable not removed from list")
}
}
@ -304,7 +293,6 @@ class DeployableBehaviorDeconstructOwnedTest extends FreedContextActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar)
override def LivePlayers = List(player)
override def tasks: ActorRef = eventsProbe.ref
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
}
@ -324,12 +312,12 @@ class DeployableBehaviorDeconstructOwnedTest extends FreedContextActorTest {
"DeployableBehavior" should {
"deconstruct and alert owner" in {
zone.Deployables ! Zone.Deployable.BuildByOwner(jmine, player, citem)
eventsProbe.receiveN(8, 10.seconds)
eventsProbe.receiveN(7, 10.seconds)
assert(deployableList.contains(jmine), "owned deconstruct test - deployable not appended to list")
assert(avatar.deployables.Contains(jmine), "owned deconstruct test - avatar does not own deployable")
jmine.Actor ! Deployable.Deconstruct()
val eventsMsgs = eventsProbe.receiveN(4, 10.seconds)
val eventsMsgs = eventsProbe.receiveN(3, 10.seconds)
eventsMsgs.head match {
case LocalServiceMessage("test", LocalAction.EliminateDeployable(`jmine`, PlanetSideGUID(1), Vector3(1,2,3), 2)) => ;
case _ => assert(false, "owned deconstruct test - not eliminating deployable")
@ -349,10 +337,6 @@ class DeployableBehaviorDeconstructOwnedTest extends FreedContextActorTest {
) => ;
case _ => assert(false, "owned deconstruct test - not removing icon")
}
eventsMsgs(3) match {
case TaskResolver.GiveTask(_, _) => ;
case _ => assert(false, "owned deconstruct test - not unregistering deployable")
}
assert(deployableList.isEmpty, "owned deconstruct test - deployable still in list")
assert(!avatar.deployables.Contains(jmine), "owned deconstruct test - avatar still owns deployable")

3
src/test/scala/objects/DeployableTest.scala
View file

@ -330,7 +330,6 @@ class ExplosiveDeployableJammerTest extends ActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar1, avatar2)
override def LivePlayers = List(player1, player2)
override def tasks: ActorRef = eventsProbe.ref
}
player1.Spawn()
player2.Spawn()
@ -408,7 +407,6 @@ class ExplosiveDeployableJammerExplodeTest extends ActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar1, avatar2)
override def LivePlayers = List(player1, player2)
override def tasks: ActorRef = eventsProbe.ref
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
}
@ -518,7 +516,6 @@ class ExplosiveDeployableDestructionTest extends ActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar1, avatar2)
override def LivePlayers = List(player1, player2)
override def tasks: ActorRef = eventsProbe.ref
}
player1.Spawn()
player1.Actor = player1Probe.ref

22
src/test/scala/objects/OrbitalShuttlePadTest.scala
View file

@ -2,13 +2,11 @@
package objects
import akka.actor.{ActorRef, Props}
import akka.routing.RandomPool
import akka.testkit.TestProbe
import base.FreedContextActorTest
import net.psforever.actors.zone.{BuildingActor, ZoneActor}
import net.psforever.objects.guid.actor.UniqueNumberSystem
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.guid.{NumberPoolHub, TaskResolver}
import net.psforever.objects.guid.{NumberPoolHub, UniqueNumberOps, UniqueNumberSetup}
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.serverobject.doors.Door
import net.psforever.objects.serverobject.shuttle.{OrbitalShuttle, OrbitalShuttlePad, OrbitalShuttlePadControl, ShuttleAmenity}
@ -23,7 +21,7 @@ import scala.collection.concurrent.TrieMap
import scala.collection.mutable.ListBuffer
import scala.concurrent.duration._
class OrbitalShuttlePadControltest extends FreedContextActorTest {
class OrbitalShuttlePadControlTest extends FreedContextActorTest {
import akka.actor.typed.scaladsl.adapter._
system.spawn(InterstellarClusterService(Nil), InterstellarClusterService.InterstellarClusterServiceKey.id)
val services = ServiceManager.boot(system)
@ -32,22 +30,17 @@ class OrbitalShuttlePadControltest extends FreedContextActorTest {
expectNoMessage(1000 milliseconds)
var buildingMap = new TrieMap[Int, Building]()
val vehicles = ListBuffer[Vehicle]()
val guid = new NumberPoolHub(new MaxNumberSource(max = 15))
guid.AddPool("dynamic", (11 to 15).toList)
val guid = new NumberPoolHub(new MaxNumberSource(max = 20))
guid.AddPool("vehicles", (11 to 15).toList)
guid.AddPool("tools", (16 to 19).toList)
val catchall = new TestProbe(system).ref
val resolver = context.actorOf(RandomPool(1).props(Props[TaskResolver]()), s"test-taskResolver")
val uns = context.actorOf(
RandomPool(1).props(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystem.AllocateNumberPoolActors(this.guid))
),
s"test-uns"
)
val unops = new UniqueNumberOps(guid, UniqueNumberSetup.AllocateNumberPoolActors(context, guid))
val zone = new Zone("test", new ZoneMap("test-map"), 0) {
val transport: ActorRef = context.actorOf(Props(classOf[ZoneVehicleActor], this, vehicles), s"zone-test-vehicles")
override def SetupNumberPools() = {}
GUID(guid)
override def GUID = { uns }
override def GUID = { unops }
override def AvatarEvents = catchall
override def LocalEvents = catchall
override def VehicleEvents = catchall
@ -55,7 +48,6 @@ class OrbitalShuttlePadControltest extends FreedContextActorTest {
override def Transport = { transport }
override def Vehicles = { vehicles.toList }
override def Buildings = { buildingMap.toMap }
override def tasks = { resolver }
import akka.actor.typed.scaladsl.adapter._
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]

116
src/test/scala/objects/TaskWorkflowTest.scala Normal file
View file

@ -0,0 +1,116 @@
// Copyright (c) 2021 PSForever
package objects
import net.psforever.objects.guid.{Task, TaskBundle, TaskWorkflow}
import org.scalatest.flatspec.AsyncFlatSpec
import scala.concurrent.Future
import scala.util.Failure
class AsyncTaskWorkflowTest extends AsyncFlatSpec {
case class StringAppendTask(product: StringBuilder, str: String) extends Task {
def action() = { Future({ product.append(str) }) }
def undo() = {
val index = product.indexOf(str)
product.replace(index, index + str.length, "[successful task undo]")
}
def isSuccessful() = { product.indexOf(str) > -1 }
}
case class FailedStringAppendTask(product: StringBuilder, str: String) extends Task {
def action() = { Future(Failure(new Exception("intentional failure"))) }
def undo() = {
val index = product.indexOf(str)
product.replace(index, index + str.length, "[failed task undo]")
}
def isSuccessful() = { product.indexOf(str) > -1 }
}
behavior of "TaskWorkFlow"
it should "append a string as a task" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(StringAppendTask(test, "hello")))
result map { _ =>
assert(test.mkString.equals("hello"), "async result does not equal 'hello'")
}
}
it should "append the strings in order of subtask then main task" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(StringAppendTask(test, " world"), StringAppendTask(test, "hello")))
result map { _ =>
assert(test.mkString.equals("hello world"), "async result does not equal 'hello world'")
}
}
it should "append the strings in order of subtasks then main task, with the subtasks being in either order" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(
StringAppendTask(test, " world"),
Seq(
TaskBundle(StringAppendTask(test, " hello")),
TaskBundle(StringAppendTask(test, " or goodbye"))
)
))
result map { _ =>
val output = test.mkString
assert(
output.equals(" or goodbye hello world") || output.equals(" hello or goodbye world"),
s"async result '$output' does not equal either pattern"
)
}
}
it should "if a task fails, do not undo it" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(FailedStringAppendTask(test, " world")))
result map { _ =>
val output = test.mkString
assert(output.equals(""),"async result was written when should have not been written")
//see implementation of FailedStringAppendTask.undo
}
}
it should "if a middling subtask fails, its parent task will not be executed or undone, but its own subtask will be undone (1)" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(
StringAppendTask(test, " world"),
TaskBundle(FailedStringAppendTask(test, "hello"), StringAppendTask(test, " or goodbye")))
)
result map { _ =>
val output = test.mkString
assert(output.equals("[successful task undo]"),s"async result, formerly successful, was written as if it had failed - $output")
//see implementation of StringAppendTask.undo
}
}
it should "if a middling subtask fails, its parent task will not be executed or undone, but its own subtasks will be undone (2)" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(
StringAppendTask(test, " world"),
TaskBundle(FailedStringAppendTask(test, "hello"), List(
TaskBundle(StringAppendTask(test, " or goodbye")),
TaskBundle(StringAppendTask(test, " or something"))
))
))
result map { _ =>
val output = test.mkString
assert(
output.equals("[successful task undo][successful task undo]"),
s"async result, formerly successful, was written as if it had failed - $output"
)
//see implementation of StringAppendTask.undo
}
}
}
object TaskWorkflowTest {
/** placeholder */
}

1
src/test/scala/objects/VehicleControlTest.scala
View file

@ -212,7 +212,6 @@ class VehicleControlPrepareForDeletionMountedCargoTest extends FreedContextActor
override def SetupNumberPools(): Unit = {}
override def VehicleEvents = vehicleProbe.ref
override def tasks = catchall.ref
}
zone.actor = system.spawn(ZoneActor(zone), "test-zone-actor")
// crappy workaround but without it the zone doesn't get initialized in time

2
src/test/scala/objects/ZoneTest.scala
View file

@ -130,7 +130,7 @@ class ZoneActorTest extends ActorTest {
zone.actor = system.spawn(ZoneActor(zone), "test-add-pool-actor-init")
expectNoMessage(Duration.create(500, "ms"))
assert(!zone.AddPool("test1", 1 to 2))
assert(zone.AddPool("test1", 1 to 2).isEmpty)
}
"refuse to remove number pools after the Actor is started" in {

16
src/test/scala/objects/guidtask/GUIDTaskRegisterAmmoTest.scala
View file

@ -3,19 +3,21 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterAmmoTest extends ActorTest {
"RegisterEquipment -> RegisterObjectTask" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
assert(!obj.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterEquipment(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerEquipment(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
}
}

18
src/test/scala/objects/guidtask/GUIDTaskRegisterAvatarTest.scala
View file

@ -4,15 +4,17 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import net.psforever.objects.locker.LockerEquipment
import net.psforever.types.{CharacterSex, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration._
class GUIDTaskRegisterAvatarTest extends ActorTest {
"RegisterAvatar" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
obj.Slot(0).Equipment = obj_wep
val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_wep.AmmoSlots.head.Box = obj_wep_ammo
@ -28,11 +30,11 @@ class GUIDTaskRegisterAvatarTest extends ActorTest {
assert(!obj_inv_ammo.HasGUID)
assert(!obj_locker.HasGUID)
assert(obj_locker_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterAvatar(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerAvatar(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_wep_ammo.HasGUID)

16
src/test/scala/objects/guidtask/GUIDTaskRegisterObjectTest.scala
View file

@ -2,19 +2,21 @@
package objects.guidtask
import base.ActorTest
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterObjectTest extends ActorTest {
"RegisterObjectTask" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject
assert(!obj.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterObjectTask(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerObject(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
}
}

18
src/test/scala/objects/guidtask/GUIDTaskRegisterPlayerTest.scala
View file

@ -4,15 +4,17 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import net.psforever.objects.locker.LockerEquipment
import net.psforever.types.{CharacterSex, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration._
class GUIDTaskRegisterPlayerTest extends ActorTest {
"RegisterPlayer" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
obj.Slot(0).Equipment = obj_wep
val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_wep.AmmoSlots.head.Box = obj_wep_ammo
@ -28,11 +30,11 @@ class GUIDTaskRegisterPlayerTest extends ActorTest {
assert(!obj_inv_ammo.HasGUID)
assert(!obj_locker.HasGUID)
assert(obj_locker_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterPlayer(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerPlayer(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_wep_ammo.HasGUID)

16
src/test/scala/objects/guidtask/GUIDTaskRegisterToolTest.scala
View file

@ -3,21 +3,23 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterToolTest extends ActorTest {
"RegisterEquipment -> RegisterTool" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)
obj.AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.energy_cell)
assert(!obj.HasGUID)
assert(!obj.AmmoSlots.head.Box.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterEquipment(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerEquipment(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj.AmmoSlots.head.Box.HasGUID)
}

22
src/test/scala/objects/guidtask/GUIDTaskRegisterTurretTest.scala
View file

@ -3,25 +3,27 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterTurretTest extends ActorTest {
"RegisterDeployableTurret" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new TurretDeployable(GlobalDefinitions.portable_manned_turret_vs)
val obj_wep = obj.Weapons(1).Equipment.get
val obj_ammo = obj_wep.asInstanceOf[Tool].AmmoSlot.Box
val obj_res = obj.Inventory.Items.map(_.obj)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = new TurretDeployable(GlobalDefinitions.portable_manned_turret_vs)
val obj_wep = obj.Weapons(1).Equipment.get
val obj_ammo = obj_wep.asInstanceOf[Tool].AmmoSlot.Box
val obj_res = obj.Inventory.Items.map(_.obj)
assert(!obj.HasGUID)
assert(!obj_wep.HasGUID)
assert(!obj_ammo.HasGUID)
obj_res.foreach(box => !box.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterDeployableTurret(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerDeployableTurret(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_ammo.HasGUID)

18
src/test/scala/objects/guidtask/GUIDTaskRegisterVehicleTest.scala
View file

@ -3,13 +3,15 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterVehicleTest extends ActorTest {
"RegisterVehicle" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)
val obj_wep = obj.WeaponControlledFromSeat(0).get
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)
val obj_wep = obj.WeaponControlledFromSeat(0).get
val obj_wep_ammo = (obj.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box =
AmmoBox(GlobalDefinitions.hellfire_ammo)).get
obj.Trunk += 30 -> AmmoBox(GlobalDefinitions.hellfire_ammo)
@ -19,11 +21,11 @@ class GUIDTaskRegisterVehicleTest extends ActorTest {
assert(!obj_wep.HasGUID)
assert(!obj_wep_ammo.HasGUID)
assert(!obj_trunk_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterVehicle(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerVehicle(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_wep_ammo.HasGUID)

46
src/test/scala/objects/guidtask/GUIDTaskTest.scala
View file

@ -2,50 +2,54 @@
package objects.guidtask
import java.util.logging.LogManager
import scala.util.Success
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.testkit.TestProbe
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.actor.{NumberPoolActor, UniqueNumberSystem}
import net.psforever.objects.guid.selector.RandomSelector
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.guid.{NumberPoolHub, Task, TaskResolver}
import net.psforever.objects.guid.uns.NumberPoolActor
import net.psforever.objects.guid.{NumberPoolHub, StraightforwardTask, UniqueNumberOps}
import scala.concurrent.Future
object GUIDTaskTest {
class TestObject extends IdentifiableEntity
class RegisterTestTask(probe: ActorRef) extends Task {
def Execute(resolver: ActorRef): Unit = {
probe ! Success
resolver ! Success(this)
class RegisterTestTask(probe: ActorRef) extends StraightforwardTask {
def action(): Future[Any] = {
probe ! Success(true)
Future(this)(scala.concurrent.ExecutionContext.Implicits.global)
}
}
def CommonTestSetup(implicit system: ActorSystem): (NumberPoolHub, ActorRef, ActorRef, TestProbe) = {
import akka.actor.Props
import akka.routing.RandomPool
def CommonTestSetup(implicit system: ActorSystem): (NumberPoolHub, UniqueNumberOps, TestProbe) = {
import akka.testkit.TestProbe
val guid: NumberPoolHub = new NumberPoolHub(new MaxNumberSource(110))
guid.AddPool("dynamic", (1 to 100).toList).Selector = new RandomSelector //TODO name is hardcoded for now
val uns = system.actorOf(
RandomPool(25).props(Props(classOf[UniqueNumberSystem], guid, GUIDTaskTest.AllocateNumberPoolActors(guid))),
"uns"
)
val taskResolver = system.actorOf(RandomPool(15).props(Props[TaskResolver]()), "resolver")
val guid: NumberPoolHub = new NumberPoolHub(new MaxNumberSource(90))
guid.AddPool("players", (1 to 10).toList).Selector = new RandomSelector
guid.AddPool("lockers", (11 to 20).toList).Selector = new RandomSelector
guid.AddPool("ammo", (21 to 30).toList).Selector = new RandomSelector
guid.AddPool("tools", (31 to 40).toList).Selector = new RandomSelector
guid.AddPool("vehicles", (41 to 50).toList).Selector = new RandomSelector
guid.AddPool("terminals", (51 to 60).toList).Selector = new RandomSelector
guid.AddPool("items", (61 to 70).toList).Selector = new RandomSelector
guid.AddPool("deployables", (71 to 80).toList).Selector = new RandomSelector
val uns = new UniqueNumberOps(guid, AllocateNumberPoolActors(guid)(system))
LogManager.getLogManager.reset() //suppresses any internal loggers created by the above elements
(guid, uns, taskResolver, TestProbe())
(guid, uns, TestProbe())
}
/**
* @see `UniqueNumberSystem.AllocateNumberPoolActors(NumberPoolHub)(implicit ActorContext)`
* @see `UniqueNumberSetup.AllocateNumberPoolActors(NumberPoolHub)(implicit ActorContext)`
*/
def AllocateNumberPoolActors(poolSource: NumberPoolHub)(implicit system: ActorSystem): Map[String, ActorRef] = {
poolSource.Pools
.map({
case ((pname, pool)) =>
.map {
case (pname, pool) =>
pname -> system.actorOf(Props(classOf[NumberPoolActor], pool), pname)
})
}
.toMap
}
}

18
src/test/scala/objects/guidtask/GUIDTaskUnregisterAmmoTest.scala
View file

@ -3,20 +3,22 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskUnregisterAmmoTest extends ActorTest {
"UnregisterEquipment -> UnregisterObjectTask" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
guid.register(obj, "dynamic")
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
guid.register(obj, name = "ammo")
assert(obj.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterEquipment(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterEquipment(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
}
}

30
src/test/scala/objects/guidtask/GUIDTaskUnregisterAvatarTest.scala
View file

@ -4,15 +4,17 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import net.psforever.objects.locker.LockerEquipment
import net.psforever.types.{CharacterSex, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration._
class GUIDTaskUnregisterAvatarTest extends ActorTest {
"UnregisterAvatar" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
obj.Slot(0).Equipment = obj_wep
val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_wep.AmmoSlots.head.Box = obj_wep_ammo
@ -21,12 +23,12 @@ class GUIDTaskUnregisterAvatarTest extends ActorTest {
val obj_locker = obj.Slot(5).Equipment.get
val obj_locker_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_locker.asInstanceOf[LockerEquipment].Inventory += 0 -> obj_locker_ammo
guid.register(obj, "dynamic")
guid.register(obj_wep, "dynamic")
guid.register(obj_wep_ammo, "dynamic")
guid.register(obj_inv_ammo, "dynamic")
guid.register(obj_locker, "dynamic")
guid.register(obj_locker_ammo, "dynamic")
guid.register(obj, name = "players")
guid.register(obj_wep, name = "tools")
guid.register(obj_wep_ammo, name = "ammo")
guid.register(obj_inv_ammo, name = "ammo")
guid.register(obj_locker, name = "lockers")
guid.register(obj_locker_ammo, name = "amoo")
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
@ -34,11 +36,11 @@ class GUIDTaskUnregisterAvatarTest extends ActorTest {
assert(obj_inv_ammo.HasGUID)
assert(obj_locker.HasGUID)
assert(obj_locker_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterAvatar(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterAvatar(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
assert(!obj_wep.HasGUID)
assert(!obj_wep_ammo.HasGUID)

18
src/test/scala/objects/guidtask/GUIDTaskUnregisterObjectTest.scala
View file

@ -2,20 +2,22 @@
package objects.guidtask
import base.ActorTest
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskUnregisterObjectTest extends ActorTest {
"UnregisterObjectTask" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject
guid.register(obj, "dynamic")
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject
guid.register(obj)
assert(obj.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterObjectTask(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterObject(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
}
}

30
src/test/scala/objects/guidtask/GUIDTaskUnregisterPlayerTest.scala
View file

@ -4,15 +4,17 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import net.psforever.objects.locker.LockerEquipment
import net.psforever.types.{CharacterSex, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration._
class GUIDTaskUnregisterPlayerTest extends ActorTest {
"UnregisterPlayer" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
obj.Slot(0).Equipment = obj_wep
val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_wep.AmmoSlots.head.Box = obj_wep_ammo
@ -21,12 +23,12 @@ class GUIDTaskUnregisterPlayerTest extends ActorTest {
val obj_locker = obj.Slot(5).Equipment.get
val obj_locker_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_locker.asInstanceOf[LockerEquipment].Inventory += 0 -> obj_locker_ammo
guid.register(obj, "dynamic")
guid.register(obj_wep, "dynamic")
guid.register(obj_wep_ammo, "dynamic")
guid.register(obj_inv_ammo, "dynamic")
guid.register(obj_locker, "dynamic")
guid.register(obj_locker_ammo, "dynamic")
guid.register(obj, name = "players")
guid.register(obj_wep, name = "tools")
guid.register(obj_wep_ammo, name = "ammo")
guid.register(obj_inv_ammo, name = "ammo")
guid.register(obj_locker, name = "lockers")
guid.register(obj_locker_ammo, name = "ammo")
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
@ -34,11 +36,11 @@ class GUIDTaskUnregisterPlayerTest extends ActorTest {
assert(obj_inv_ammo.HasGUID)
assert(obj_locker.HasGUID)
assert(obj_locker_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterPlayer(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterPlayer(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
assert(!obj_wep.HasGUID)
assert(!obj_wep_ammo.HasGUID)

20
src/test/scala/objects/guidtask/GUIDTaskUnregisterToolTest.scala
View file

@ -3,23 +3,25 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskUnregisterToolTest extends ActorTest {
"UnregisterEquipment -> UnregisterTool" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)
obj.AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.energy_cell)
guid.register(obj, "dynamic")
guid.register(obj.AmmoSlots.head.Box, "dynamic")
guid.register(obj, name = "tools")
guid.register(obj.AmmoSlots.head.Box, name ="ammo")
assert(obj.HasGUID)
assert(obj.AmmoSlots.head.Box.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterEquipment(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterEquipment(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
assert(!obj.AmmoSlots.head.Box.HasGUID)
}

30
src/test/scala/objects/guidtask/GUIDTaskUnregisterTurretTest.scala
View file

@ -3,29 +3,31 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskUnregisterTurretTest extends ActorTest {
"UnregisterDeployableTurret" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new TurretDeployable(GlobalDefinitions.portable_manned_turret_vs)
val obj_wep = obj.Weapons(1).Equipment.get
val obj_ammo = obj_wep.asInstanceOf[Tool].AmmoSlot.Box
val obj_res = obj.Inventory.Items.map(_.obj)
guid.register(obj, "dynamic")
guid.register(obj_wep, "dynamic")
guid.register(obj_ammo, "dynamic")
obj_res.foreach(box => guid.register(box, "dynamic"))
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = new TurretDeployable(GlobalDefinitions.portable_manned_turret_vs)
val obj_wep = obj.Weapons(1).Equipment.get
val obj_ammo = obj_wep.asInstanceOf[Tool].AmmoSlot.Box
val obj_res = obj.Inventory.Items.map(_.obj)
guid.register(obj, name = "deployables")
guid.register(obj_wep, name = "tools")
guid.register(obj_ammo, name = "ammo")
obj_res.foreach(box => guid.register(box, name = "ammo"))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_ammo.HasGUID)
obj_res.foreach(box => box.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterDeployableTurret(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterDeployableTurret(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
assert(!obj_wep.HasGUID)
assert(!obj_ammo.HasGUID)

26
src/test/scala/objects/guidtask/GUIDTaskUnregisterVehicleTest.scala
View file

@ -3,31 +3,33 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskUnregisterVehicleTest extends ActorTest {
"RegisterVehicle" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)
val obj_wep = obj.WeaponControlledFromSeat(0).get
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)
val obj_wep = obj.WeaponControlledFromSeat(0).get
val obj_wep_ammo = (obj.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box =
AmmoBox(GlobalDefinitions.hellfire_ammo)).get
obj.Trunk += 30 -> AmmoBox(GlobalDefinitions.hellfire_ammo)
val obj_trunk_ammo = obj.Trunk.Items(0).obj
guid.register(obj, "dynamic")
guid.register(obj_wep, "dynamic")
guid.register(obj_wep_ammo, "dynamic")
guid.register(obj_trunk_ammo, "dynamic")
guid.register(obj, name = "vehicles")
guid.register(obj_wep, name = "tools")
guid.register(obj_wep_ammo, name = "ammo")
guid.register(obj_trunk_ammo, name = "ammo")
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_wep_ammo.HasGUID)
assert(obj_trunk_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterVehicle(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterVehicle(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
assert(!obj_wep.HasGUID)
assert(!obj_wep_ammo.HasGUID)

6
src/test/scala/objects/number/NumberPoolActorTest.scala
View file

@ -3,9 +3,9 @@ package objects.number
import akka.actor.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 net.psforever.objects.guid.uns.NumberPoolActor
import scala.concurrent.duration.Duration
@ -29,7 +29,7 @@ class NumberPoolActorTest1 extends ActorTest {
pool.Selector = new RandomSelector
val poolActor = system.actorOf(Props(classOf[NumberPoolActor], pool), name = "poolActor2")
poolActor ! NumberPoolActor.GetSpecificNumber(37)
expectMsg(NumberPoolActor.GiveNumber(37, None))
expectMsg(NumberPoolActor.GiveNumber(37))
}
}
}
@ -41,7 +41,7 @@ class NumberPoolActorTest2 extends ActorTest {
pool.Selector = new RandomSelector
val poolActor = system.actorOf(Props(classOf[NumberPoolActor], pool), name = "poolActor3")
poolActor ! NumberPoolActor.GetAnyNumber()
expectMsg(NumberPoolActor.GiveNumber(25, None))
expectMsg(NumberPoolActor.GiveNumber(25))
poolActor ! NumberPoolActor.GetAnyNumber()
val msg = receiveOne(Duration.create(500, "ms"))

59
src/test/scala/objects/number/NumberPoolHubTest.scala
View file

@ -262,46 +262,6 @@ class NumberPoolHubTest extends Specification {
}
}
"not affect the hidden restricted pool by adding a new pool" in {
val src = new MaxNumberSource(51)
src.restrictNumber(4)
src.restrictNumber(8) //in fibonacci
src.restrictNumber(10)
src.restrictNumber(12)
val hub = new NumberPoolHub(src)
hub.AddPool("fibonacci", numberList) must throwA[IllegalArgumentException]
}
"not register an object to a number belonging to the restricted pool" in {
val src = new MaxNumberSource(51)
src.restrictNumber(4)
val hub = new NumberPoolHub(src)
val obj = new EntityTestClass()
hub.register(obj, 4).isFailure mustEqual true
}
"not register an object to the restricted pool directly" in {
val src = new MaxNumberSource(51)
// src.restrictNumber(4)
val hub = new NumberPoolHub(src)
val obj = new EntityTestClass()
hub.register(obj, "").isFailure mustEqual true //the empty string represents the restricted pool
}
"not register a number belonging to the restricted pool" in {
val src = new MaxNumberSource(51)
src.restrictNumber(4)
val hub = new NumberPoolHub(src)
hub.register(4).isFailure mustEqual true
}
"not unregister a number belonging to the restricted pool" in {
val src = new MaxNumberSource(51)
src.restrictNumber(4)
val hub = new NumberPoolHub(src)
hub.unregister(4).isFailure mustEqual true
}
"identity an object that is registered to it" in {
val hub1 = new NumberPoolHub(new MaxNumberSource(10))
val hub2 = new NumberPoolHub(new MaxNumberSource(10))
@ -316,28 +276,21 @@ class NumberPoolHubTest extends Specification {
hub2.isRegistered(obj1) mustEqual false
}
"identity a number that is registered to it" in {
"identity an entity that is registered to it" in {
val src1 = new MaxNumberSource(5)
val hub1 = new NumberPoolHub(src1)
val src2 = new MaxNumberSource(10)
src2.restrictNumber(0)
src2.restrictNumber(1)
src2.restrictNumber(2)
src2.restrictNumber(3)
src2.restrictNumber(4)
src2.restrictNumber(5)
val hub2 = new NumberPoolHub(src2)
val obj1 = new EntityTestClass()
val obj2 = new EntityTestClass()
hub1.register(obj1)
hub2.register(obj2)
val num1 = obj1.GUID.guid
val num2 = obj2.GUID.guid
hub1.isRegistered(num1) mustEqual true
hub2.isRegistered(num2) mustEqual true
hub1.isRegistered(num2) mustEqual false
hub2.isRegistered(num1) mustEqual false
obj1.GUID mustEqual obj2.GUID
hub1.isRegistered(obj1) mustEqual true
hub2.isRegistered(obj2) mustEqual true
hub1.isRegistered(obj2) mustEqual false
hub2.isRegistered(obj1) mustEqual false
}
}
}

20
src/test/scala/objects/number/NumberPoolTest.scala
View file

@ -135,13 +135,13 @@ class NumberPoolTest extends Specification {
"GenericPool" should {
"construct" in {
new GenericPool(mutable.LongMap[String](), 11)
GenericPool(mutable.LongMap[String](), max = 11, poolName = "generic")
ok
}
"get a provided number" in {
val map = mutable.LongMap[String]()
val obj = new GenericPool(map, 11)
val obj = GenericPool(map, max = 11, poolName = "generic")
obj.Numbers.isEmpty mustEqual true
obj.Selector.asInstanceOf[SpecificSelector].SelectionIndex = 5
obj.Get() match {
@ -157,7 +157,7 @@ class NumberPoolTest extends Specification {
"return a number" in {
val map = mutable.LongMap[String]()
val obj = new GenericPool(map, 11)
val obj = GenericPool(map, max = 11, poolName = "generic")
obj.Selector.asInstanceOf[SpecificSelector].SelectionIndex = 5
obj.Get()
map.get(5).contains("generic") mustEqual true
@ -170,7 +170,7 @@ class NumberPoolTest extends Specification {
"block on numbers that are already defined" in {
val map = mutable.LongMap[String]()
map += 5L -> "test" //5 is defined
val obj = new GenericPool(map, 11)
val obj = GenericPool(map, max = 11, poolName = "generic")
obj.Numbers.isEmpty mustEqual true
obj.Selector.asInstanceOf[SpecificSelector].SelectionIndex = 5 //5 is requested
obj.Get() match {
@ -183,10 +183,10 @@ class NumberPoolTest extends Specification {
"get a free number on own if none provided" in {
val map = mutable.LongMap[String]()
val obj = new GenericPool(map, 11)
val obj = GenericPool(map, max = 11, poolName = "generic")
obj.Get() match {
case Success(number) =>
number mustEqual 5
number mustEqual 1
case _ =>
ko
}
@ -195,10 +195,10 @@ class NumberPoolTest extends Specification {
"get a free number that is not already defined" in {
val map = mutable.LongMap[String]()
map += 5L -> "test" //5 is defined; think, -1 :: 5 :: 11
val obj = new GenericPool(map, 11)
val obj = GenericPool(map, max = 11, poolName = "generic")
obj.Get() match {
case Success(number) =>
number mustEqual 2 // think, -1 :: 2 :: 5 :: 11
number mustEqual 1 // think, -1 :: 2 :: 5 :: 11
case _ => ko
}
@ -208,10 +208,10 @@ class NumberPoolTest extends Specification {
val map = mutable.LongMap[String]()
map += 5L -> "test" //5 is defined; think, -1 :: 5 :: 11
map += 4L -> "test" //4 is defined; think, -1 :: 4 :: 5 :: 11
val obj = new GenericPool(map, 11)
val obj = GenericPool(map, max = 11, poolName = "generic")
obj.Get() match {
case Success(number) =>
number mustEqual 8 // think, -1 :: 4 :: 5 :: 8 :: 11
number mustEqual 1 // think, -1 :: 4 :: 5 :: 8 :: 11
case _ =>
ko
}

117
src/test/scala/objects/number/NumberSourceTest.scala
View file

@ -1,8 +1,7 @@
// Copyright (c) 2017 PSForever
package objects.number
import net.psforever.objects.guid.AvailabilityPolicy
import net.psforever.objects.guid.key.{LoanedKey, SecureKey}
import net.psforever.objects.guid.key.{AvailabilityPolicy, LoanedKey, SecureKey}
import net.psforever.types.PlanetSideGUID
import org.specs2.mutable.Specification
@ -72,46 +71,6 @@ class NumberSourceTest extends Specification {
obj.countUsed mustEqual 0
}
"restrict a number (unassigned)" in {
val obj = MaxNumberSource(25)
val result: Option[LoanedKey] = obj.restrictNumber(5)
result.isDefined mustEqual true
result.get.GUID mustEqual 5
result.get.Policy mustEqual AvailabilityPolicy.Restricted
result.get.Object.isEmpty mustEqual true
}
"restrict a number (assigned + multiple assignments)" in {
val obj = MaxNumberSource(25)
val test1 = new TestClass()
val test2 = new TestClass()
val result: Option[LoanedKey] = obj.restrictNumber(5)
result.get.GUID mustEqual 5
result.get.Policy mustEqual AvailabilityPolicy.Restricted
result.get.Object.isEmpty mustEqual true
result.get.Object = None //assignment 1
result.get.Object.isEmpty mustEqual true //still unassigned
result.get.Object = test1 //assignment 2
result.get.Object.contains(test1) mustEqual true
result.get.Object = test2 //assignment 3
result.get.Object.contains(test1) mustEqual true //same as above
}
"return a restricted number (correctly fail)" in {
val obj = MaxNumberSource(25)
val test = new TestClass()
val result: Option[LoanedKey] = obj.restrictNumber(5)
result.get.GUID mustEqual 5
result.get.Policy mustEqual AvailabilityPolicy.Restricted
result.get.Object = test
obj.returnNumber(5)
val result2: Option[SecureKey] = obj.get(5)
result2.get.GUID mustEqual 5
result2.get.Policy mustEqual AvailabilityPolicy.Restricted
result2.get.Object.contains(test) mustEqual true
}
"return a secure key" in {
val obj = MaxNumberSource(25)
val test = new TestClass()
@ -124,19 +83,6 @@ class NumberSourceTest extends Specification {
obj.returnNumber(result2.get).contains(test) mustEqual true
}
"restrict a previously-assigned number" in {
val obj = MaxNumberSource(25)
val test = new TestClass()
val result1: Option[LoanedKey] = obj.getAvailable(5)
result1.isDefined mustEqual true
result1.get.Policy mustEqual AvailabilityPolicy.Leased
result1.get.Object = test
val result2: Option[LoanedKey] = obj.restrictNumber(5)
result2.isDefined mustEqual true
result2.get.Policy mustEqual AvailabilityPolicy.Restricted
result2.get.Object.contains(test) mustEqual true
}
"check a number (not previously gotten)" in {
val obj = MaxNumberSource(25)
val result2: Option[SecureKey] = obj.get(5)
@ -194,9 +140,9 @@ class NumberSourceTest extends Specification {
obj.getAvailable(5) //no assignment
obj.getAvailable(10).get.Object = test1
obj.getAvailable(15).get.Object = test2
obj.restrictNumber(15)
obj.restrictNumber(20).get.Object = test3
obj.getAvailable(20).get.Object = test3
obj.countUsed mustEqual 4
obj.countDangling mustEqual 1
val list: List[IdentifiableEntity] = obj.clear()
obj.countUsed mustEqual 0
@ -273,46 +219,6 @@ class NumberSourceTest extends Specification {
obj.countUsed mustEqual 0
}
"restrict a number (unassigned)" in {
val obj = SpecificNumberSource(List(25))
val result: Option[LoanedKey] = obj.restrictNumber(number = 25)
result.isDefined mustEqual true
result.get.GUID mustEqual 25
result.get.Policy mustEqual AvailabilityPolicy.Restricted
result.get.Object.isEmpty mustEqual true
}
"restrict a number (assigned + multiple assignments)" in {
val obj = SpecificNumberSource(List(25, 26))
val test1 = new TestClass()
val test2 = new TestClass()
val result: Option[LoanedKey] = obj.restrictNumber(number = 25)
result.get.GUID mustEqual 25
result.get.Policy mustEqual AvailabilityPolicy.Restricted
result.get.Object.isEmpty mustEqual true
result.get.Object = None //assignment 1
result.get.Object.isEmpty mustEqual true //still unassigned
result.get.Object = test1 //assignment 2
result.get.Object.contains(test1) mustEqual true
result.get.Object = test2 //assignment 3
result.get.Object.contains(test1) mustEqual true //same as above
}
"return a restricted number (correctly fail)" in {
val obj = SpecificNumberSource(List(25))
val test = new TestClass()
val result: Option[LoanedKey] = obj.restrictNumber(number = 25)
result.get.GUID mustEqual 25
result.get.Policy mustEqual AvailabilityPolicy.Restricted
result.get.Object = test
obj.returnNumber(number = 25)
val result2: Option[SecureKey] = obj.get(25)
result2.get.GUID mustEqual 25
result2.get.Policy mustEqual AvailabilityPolicy.Restricted
result2.get.Object.contains(test) mustEqual true
}
"return a secure key" in {
val obj = SpecificNumberSource(List(25))
val test = new TestClass()
@ -325,19 +231,6 @@ class NumberSourceTest extends Specification {
obj.returnNumber(result2.get).contains(test) mustEqual true
}
"restrict a previously-assigned number" in {
val obj = SpecificNumberSource(List(25))
val test = new TestClass()
val result1: Option[LoanedKey] = obj.getAvailable(number = 25)
result1.isDefined mustEqual true
result1.get.Policy mustEqual AvailabilityPolicy.Leased
result1.get.Object = test
val result2: Option[LoanedKey] = obj.restrictNumber(number = 25)
result2.isDefined mustEqual true
result2.get.Policy mustEqual AvailabilityPolicy.Restricted
result2.get.Object.contains(test) mustEqual true
}
"check a number (not previously gotten)" in {
val obj = SpecificNumberSource(List(25))
val result2: Option[SecureKey] = obj.get(25)
@ -395,9 +288,9 @@ class NumberSourceTest extends Specification {
obj.getAvailable(25) //no assignment
obj.getAvailable(26).get.Object = test1
obj.getAvailable(28).get.Object = test2
obj.restrictNumber(28)
obj.restrictNumber(30).get.Object = test3
obj.getAvailable(30).get.Object = test3
obj.countUsed mustEqual 4
obj.countDangling mustEqual 1
val list: List[IdentifiableEntity] = obj.clear()
obj.countUsed mustEqual 0

60
src/test/scala/objects/number/RegisterTest.scala
View file

@ -1,60 +0,0 @@
// Copyright (c) 2017 PSForever
package objects.number
import akka.actor.ActorRef
import net.psforever.objects.guid.actor.Register
import org.specs2.mutable.Specification
class RegisterTest extends Specification {
val obj = new net.psforever.objects.entity.IdentifiableEntity() {}
"Register" should {
"construct (object)" in {
val reg = Register(obj)
reg.obj mustEqual obj
reg.number.isEmpty mustEqual true
reg.name.isEmpty mustEqual true
reg.callback.isEmpty mustEqual true
}
"construct (object, callback)" in {
val reg = Register(obj, ActorRef.noSender)
reg.obj mustEqual obj
reg.number.isEmpty mustEqual true
reg.name.isEmpty mustEqual true
reg.callback.contains(ActorRef.noSender) mustEqual true
}
"construct (object, suggested number)" in {
val reg = Register(obj, 5)
reg.obj mustEqual obj
reg.number.contains(5) mustEqual true
reg.name.isEmpty mustEqual true
reg.callback.isEmpty mustEqual true
}
"construct (object, suggested number, callback)" in {
val reg = Register(obj, 5, ActorRef.noSender)
reg.obj mustEqual obj
reg.number.contains(5) mustEqual true
reg.name.isEmpty mustEqual true
reg.callback.contains(ActorRef.noSender) mustEqual true
}
"construct (object, pool name)" in {
val reg = Register(obj, "pool")
reg.obj mustEqual obj
reg.number.isEmpty mustEqual true
reg.name.contains("pool") mustEqual true
reg.callback.isEmpty mustEqual true
}
"construct (object, pool name, callback)" in {
val reg = Register(obj, "pool", ActorRef.noSender)
reg.obj mustEqual obj
reg.number.isEmpty mustEqual true
reg.name.contains("pool") mustEqual true
reg.callback.contains(ActorRef.noSender) mustEqual true
}
}
}

53
src/test/scala/objects/number/UniqueNumberOpsTest.scala Normal file
View file

@ -0,0 +1,53 @@
// Copyright (c) 2017 PSForever
package objects.number
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.{NumberPoolHub, UniqueNumberOps, UniqueNumberSetup}
import net.psforever.objects.guid.source.MaxNumberSource
import org.scalatest.flatspec.AsyncFlatSpec
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.Promise
import scala.concurrent.duration._
import scala.util.Success
class UniqueNumberOpsTest extends AsyncFlatSpec {
behavior of "UniqueNumberOps"
it should "UniqueNumberOpsTest" in {
val promise: Promise[Any] = Promise()
val sys = ActorSystem()
val source = new MaxNumberSource(max = 21)
val hub = new NumberPoolHub(source)
hub.AddPool(name = "default", List(0,1,2,3,5,8,13,21))
val entity = new UniqueNumberOpsTest.EntityTestClass()
assert(!entity.HasGUID)
assert(source.countUsed == 0)
ask(sys.actorOf(Props[UniqueNumberOpsTest.NumberPoolBuilder](), "test"), hub)(Timeout(2.seconds)).onComplete {
case Success(pools: Map[_,_]) =>
val unops = new UniqueNumberOps(hub, pools.asInstanceOf[Map[String, ActorRef]])
promise.completeWith { unops.Register(entity, poolName = "default") }
case _ =>
promise.failure(new Exception(""))
}
promise.future map { _ =>
assert(entity.HasGUID)
assert(source.countUsed == 1)
}
}
}
object UniqueNumberOpsTest {
class EntityTestClass extends IdentifiableEntity
class NumberPoolBuilder extends Actor {
def receive: Receive = {
case hub: NumberPoolHub =>
sender() ! UniqueNumberSetup.AllocateNumberPoolActors(context, hub)
case _ => ;
}
}
}

386
src/test/scala/objects/number/UniqueNumberSystemTest.scala
View file

@ -1,386 +0,0 @@
// Copyright (c) 2017 PSForever
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.MaxNumberSource
import net.psforever.types.PlanetSideGUID
import scala.concurrent.duration._
import scala.util.{Failure, Success}
class AllocateNumberPoolActors extends ActorTest {
"AllocateNumberPoolActors" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList)
guid.AddPool("pool2", (3001 to 4000).toList)
guid.AddPool("pool3", (5001 to 6000).toList)
val actorMap = UniqueNumberSystemTest.AllocateNumberPoolActors(guid)
assert(actorMap.size == 4)
assert(actorMap.get("generic").isDefined) //automatically generated
assert(actorMap.get("pool1").isDefined)
assert(actorMap.get("pool2").isDefined)
assert(actorMap.get("pool3").isDefined)
}
}
class UniqueNumberSystemTest extends ActorTest() {
"UniqueNumberSystem" should {
"constructor" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList)
guid.AddPool("pool2", (3001 to 4000).toList)
guid.AddPool("pool3", (5001 to 6000).toList)
system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
//as long as it constructs ...
}
}
}
class UniqueNumberSystemTest1 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Register (success)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
val pool1 = (1001 to 2000).toList
val pool2 = (3001 to 4000).toList
val pool3 = (5001 to 6000).toList
guid.AddPool("pool1", pool1).Selector = new RandomSelector
guid.AddPool("pool2", pool2).Selector = new RandomSelector
guid.AddPool("pool3", pool3).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
assert(src.countUsed == 0)
//pool1
for (_ <- 1 to 100) {
val testObj = new EntityTestClass()
uns ! Register(testObj, "pool1")
val msg = receiveOne(Duration.create(500, "ms"))
assert(msg.isInstanceOf[Success[_]])
assert(pool1.contains(testObj.GUID.guid))
}
//pool2
for (_ <- 1 to 100) {
val testObj = new EntityTestClass()
uns ! Register(testObj, "pool2")
val msg = receiveOne(Duration.create(500, "ms"))
assert(msg.isInstanceOf[Success[_]])
assert(pool2.contains(testObj.GUID.guid))
}
//pool3
for (_ <- 1 to 100) {
val testObj = new EntityTestClass()
uns ! Register(testObj, "pool3")
val msg = receiveOne(Duration.create(500, "ms"))
assert(msg.isInstanceOf[Success[_]])
assert(pool3.contains(testObj.GUID.guid))
}
assert(src.countUsed == 300)
}
}
}
class UniqueNumberSystemTest2 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Register (success; already registered)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", (3001 to 4000).toList).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val testObj = new EntityTestClass()
assert(!testObj.HasGUID)
assert(src.countUsed == 0)
uns ! Register(testObj, "pool1")
val msg1 = receiveOne(Duration.create(500, "ms"))
assert(msg1.isInstanceOf[Success[_]])
assert(testObj.HasGUID)
assert(src.countUsed == 1)
val id = testObj.GUID.guid
uns ! Register(testObj, "pool2") //different pool; makes no difference
val msg2 = receiveOne(Duration.create(500, "ms"))
assert(msg2.isInstanceOf[Success[_]])
assert(testObj.HasGUID)
assert(src.countUsed == 1)
assert(testObj.GUID.guid == id) //unchanged
}
}
//a log.warn should have been generated during this test
}
class UniqueNumberSystemTest3 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Register (failure; no pool)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", (3001 to 4000).toList).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val testObj = new EntityTestClass()
assert(!testObj.HasGUID)
assert(src.countUsed == 0)
uns ! Register(testObj, "pool4")
val msg1 = receiveOne(Duration.create(500, "ms"))
assert(msg1.isInstanceOf[Failure[_]])
assert(!testObj.HasGUID)
assert(src.countUsed == 0)
}
}
}
class UniqueNumberSystemTest4 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Register (failure; empty pool)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", (3001 to 4000).toList).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
guid.AddPool("pool4", 50 :: Nil).Selector = new RandomSelector //list of one element; can not add an empty list
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val testObj1 = new EntityTestClass()
uns ! Register(testObj1, "pool4")
val msg1 = receiveOne(Duration.create(500, "ms"))
assert(msg1.isInstanceOf[Success[_]]) //pool4 is now empty
val testObj2 = new EntityTestClass()
uns ! Register(testObj2, "pool4")
val msg2 = receiveOne(Duration.create(500, "ms"))
assert(msg2.isInstanceOf[Failure[_]])
}
}
}
class UniqueNumberSystemTest5 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Unregister (success)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
val pool2 = (3001 to 4000).toList
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", pool2).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val testObj = new EntityTestClass()
assert(!testObj.HasGUID)
assert(src.countUsed == 0)
uns ! Register(testObj, "pool2")
val msg1 = receiveOne(Duration.create(2000, "ms"))
assert(msg1.isInstanceOf[Success[_]])
assert(testObj.HasGUID)
assert(pool2.contains(testObj.GUID.guid))
assert(src.countUsed == 1)
uns ! Unregister(testObj)
val msg2 = receiveOne(Duration.create(2000, "ms"))
assert(msg2.isInstanceOf[Success[_]])
assert(!testObj.HasGUID)
assert(src.countUsed == 0)
}
}
}
class UniqueNumberSystemTest6 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Unregister (success; object not registered at all)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", (3001 to 4000).toList).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val testObj = new EntityTestClass()
assert(!testObj.HasGUID)
assert(src.countUsed == 0)
uns ! Unregister(testObj)
val msg1 = receiveOne(Duration.create(500, "ms"))
assert(msg1.isInstanceOf[Success[_]])
assert(!testObj.HasGUID)
assert(src.countUsed == 0)
}
}
}
class UniqueNumberSystemTest7 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Unregister (failure; number not in system)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", (3001 to 4000).toList).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val testObj = new EntityTestClass()
testObj.GUID = PlanetSideGUID(6001) //fake registering; number too high
assert(testObj.HasGUID)
assert(src.countUsed == 0)
uns ! Unregister(testObj)
val msg1 = receiveOne(Duration.create(500, "ms"))
assert(msg1.isInstanceOf[Failure[_]])
assert(testObj.HasGUID)
assert(src.countUsed == 0)
}
}
}
class UniqueNumberSystemTest8 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Unregister (failure; object is not registered to that number)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", (3001 to 4000).toList).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val testObj = new EntityTestClass()
testObj.GUID = PlanetSideGUID(3500) //fake registering
assert(testObj.HasGUID)
assert(src.countUsed == 0)
uns ! Unregister(testObj)
val msg1 = receiveOne(Duration.create(500, "ms"))
assert(msg1.isInstanceOf[Failure[_]])
assert(testObj.HasGUID)
assert(src.countUsed == 0)
}
}
}
class UniqueNumberSystemTest9 extends ActorTest() {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"Failures (manually walking the failure cases)" in {
val src: MaxNumberSource = MaxNumberSource(6000)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (1001 to 2000).toList).Selector = new RandomSelector
guid.AddPool("pool2", (3001 to 4000).toList).Selector = new RandomSelector
guid.AddPool("pool3", (5001 to 6000).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
val excp = new Exception("EXCEPTION MESSAGE")
expectNoMessage(Duration.create(200, "ms"))
//GiveNumber
uns ! NumberPoolActor.GiveNumber(1001, Some("test")) //no task associated with id="test"
uns ! NumberPoolActor.GiveNumber(1000, Some("test")) //no task associated with id="test" and number is not pooled
uns ! NumberPoolActor.GiveNumber(1000, Some(1)) //the task could theoretically exist, but does not
//NoNumber
uns ! NumberPoolActor.NoNumber(excp, Some(1))
uns ! NumberPoolActor.NoNumber(excp, None)
uns ! NumberPoolActor.NoNumber(excp, Some("test"))
//ReturnNumberResult A
uns ! NumberPoolActor.ReturnNumberResult(1001, None, Some("test"))
uns ! NumberPoolActor.ReturnNumberResult(1000, None, Some("test"))
uns ! NumberPoolActor.ReturnNumberResult(1001, None, Some(1))
uns ! NumberPoolActor.ReturnNumberResult(1000, None, Some(1))
//ReturnNumberResult B
uns ! NumberPoolActor.ReturnNumberResult(1001, Some(excp), Some("test"))
uns ! NumberPoolActor.ReturnNumberResult(1001, Some(excp), Some(1))
}
}
}
class UniqueNumberSystemTestA extends ActorTest {
class EntityTestClass extends IdentifiableEntity
"UniqueNumberSystem" should {
"remain consistent between registrations" in {
val src: MaxNumberSource = MaxNumberSource(10)
val guid: NumberPoolHub = new NumberPoolHub(src)
guid.AddPool("pool1", (0 until 10).toList).Selector = new RandomSelector
val uns = system.actorOf(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)),
"uns"
)
expectNoMessage(Duration.create(200, "ms"))
assert(src.countUsed == 0)
(0 to 4).foreach(i => { assert(guid.register(new EntityTestClass(), i).isSuccess) })
assert(src.countUsed == 5)
(0 to 5).foreach(_ => { uns ! Register(new EntityTestClass(), "pool1") })
assert(receiveOne(200 milliseconds).isInstanceOf[Success[_]]) //6th
assert(receiveOne(200 milliseconds).isInstanceOf[Success[_]]) //7th
assert(receiveOne(200 milliseconds).isInstanceOf[Success[_]]) //8th
assert(receiveOne(200 milliseconds).isInstanceOf[Success[_]]) //9th
assert(receiveOne(200 milliseconds).isInstanceOf[Success[_]]) //10th
assert(receiveOne(200 milliseconds).isInstanceOf[Failure[_]]) //no more
assert(src.countUsed == 10)
}
}
}
object UniqueNumberSystemTest {
/**
* @see `UniqueNumberSystem.AllocateNumberPoolActors(NumberPoolHub)(implicit ActorContext)`
*/
def AllocateNumberPoolActors(poolSource: NumberPoolHub)(implicit system: ActorSystem): Map[String, ActorRef] = {
poolSource.Pools
.map({
case (pname, pool) =>
pname -> system.actorOf(Props(classOf[NumberPoolActor], pool), pname)
})
.toMap
}
}

555
src/test/scala/service/RemoverActorTest.scala
View file

@ -1,555 +0,0 @@
// Copyright (c) 2017 PSForever
package service
/* Temporary imports */
import akka.actor.ActorRef
import net.psforever.objects.definition.EquipmentDefinition
import net.psforever.objects.equipment.Equipment
import net.psforever.types.PlanetSideGUID
import net.psforever.services.RemoverActor
//import akka.actor.{ActorRef, Props}
//import akka.routing.RandomPool
//import akka.testkit.TestProbe
//import base.ActorTest
//import net.psforever.objects.{GlobalDefinitions, PlanetSideGameObject, Tool}
//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.types.PlanetSideGUID
//import net.psforever.services.{RemoverActor, ServiceManager}
import scala.concurrent.duration._
import scala.util.Success
//class StandardRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
//
// "RemoverActor" should {
// "handle a simple task" in {
// expectNoMessage(500 milliseconds)
// val remover = system.actorOf(
// Props(classOf[ActorTest.SupportActorInterface], Props[RemoverActorTest.TestRemover], self),
// "test-remover"
// )
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere)
//
// val reply1 = receiveOne(500 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// val reply2 = receiveOne(500 milliseconds)
// assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
// expectNoMessage(1 seconds) //delay
// val reply3 = receiveOne(500 milliseconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = receiveOne(500 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = receiveOne(500 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = receiveOne(500 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = 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 {
// expectNoMessage(500 milliseconds)
// val remover = system.actorOf(
// Props(classOf[ActorTest.SupportActorInterface], Props[RemoverActorTest.TestRemover], self),
// "test-remover"
// )
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(100 milliseconds))
//
// val reply1 = receiveOne(500 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// val reply2 = receiveOne(500 milliseconds)
// assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
// //no delay
// val reply3 = receiveOne(500 milliseconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = receiveOne(500 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = receiveOne(500 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = receiveOne(500 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = receiveOne(500 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 {
// expectNoMessage(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(
// Props(classOf[ActorTest.SupportActorInterface], Props[RemoverActorTest.TestRemover], self),
// "test-remover"
// )
// remover ! RemoverActor.AddTask(AlternateTestObject, Zone.Nowhere)
//
// val reply1 = probe.receiveOne(200 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// expectNoMessage(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 {
// expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(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.expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(4 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.ClearAll() //cleared
// //wait
// probe.expectNoMessage(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 {
// expectNoMessage(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.expectNoMessage(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(taskResolver: ActorRef) extends RemoverActor(taskResolver) {
import net.psforever.objects.guid.{Task, TaskResolver}
val FirstStandardDuration = 1 seconds
val SecondStandardDuration = 100 milliseconds
def InclusionTest(entry: RemoverActor.Entry): Boolean = {
context.parent ! InclusionTestAlert()
true
}
def InitialJob(entry: RemoverActor.Entry): Unit = {
context.parent ! InitialJobAlert()
}
def FirstJob(entry: RemoverActor.Entry): Unit = {
context.parent ! FirstJobAlert()
}
override def SecondJob(entry: RemoverActor.Entry): Unit = {
context.parent ! SecondJobAlert()
super.SecondJob(entry)
}
def ClearanceTest(entry: RemoverActor.Entry): Boolean = {
context.parent ! ClearanceTestAlert()
true
}
def DeletionTask(entry: RemoverActor.Entry): TaskResolver.GiveTask = {
context.parent ! DeletionTaskAlert()
TaskResolver.GiveTask(new Task() {
private val localProbe = context.parent
override def isComplete = Task.Resolution.Success
def Execute(resolver: ActorRef): Unit = {
context.parent ! DeletionTaskRunAlert()
resolver ! Success(this)
}
})
}
}
}