public void OnReserveEntityIdsResponse_should_add_received_responses_to_entity()
{
var entity = SetupTestEntity();
var emptyRequest = new WorldCommands.ReserveEntityIds.Request();
var context = "Some context";
reserveEntityIdsStorage.CommandRequestsInFlight.Add(TestCommandRequestId,
new CommandRequestStore <WorldCommands.ReserveEntityIds.Request>(entity,
emptyRequest, context, TestCommandRequestId));
using (var wrappedOp = WorkerOpFactory.CreateReserveEntityIdsResponseOp(TestCommandRequestId))
{
receiveSystem.OnReserveEntityIdsResponse(wrappedOp.Op);
Assert.IsTrue(entityManager.HasComponent <WorldCommands.ReserveEntityIds.CommandResponses>(entity));
var responses = entityManager.GetComponentData <WorldCommands.ReserveEntityIds.CommandResponses>(entity);
var count = 0;
Assert.DoesNotThrow(() => { count = responses.Responses.Count; });
Assert.AreEqual(1, count);
var response = responses.Responses[0];
Assert.AreEqual(emptyRequest, response.RequestPayload);
Assert.AreEqual(context, response.Context);
Assert.AreEqual(TestCommandRequestId, response.RequestId);
Assert.AreEqual(wrappedOp.Op.StatusCode, response.StatusCode);
Assert.AreEqual(wrappedOp.Op.Message, response.Message);
Assert.AreEqual(wrappedOp.Op.FirstEntityId, response.FirstEntityId);
Assert.AreEqual(wrappedOp.Op.NumberOfEntityIds, response.NumberOfEntityIds);
}
}
public void OnAuthorityChange_should_error_if_unknown_component_id_received()
{
using (var wrappedOp = WorkerOpFactory.CreateAuthorityChangeOp(TestEntityId, InvalidComponentId))
{
Assert.Throws <UnknownComponentIdException>(() => { receiveSystem.OnAuthorityChange(wrappedOp.Op); });
}
}
public void OnEntityQueryResponse_should_error_if_request_id_not_found()
{
using (var wrappedOp = WorkerOpFactory.CreateEntityQueryResponseOp(TestCommandRequestId))
{
Assert.Throws <UnknownRequestIdException>(() => { receiveSystem.OnEntityQueryResponse(wrappedOp.Op); });
}
}
public void OnDisconnect_should_add_OnDisconnected_to_WorkerEntity_and_deallocate_world_command_senders()
{
const string DisconnectReason = "Testing disconnect.";
var createEntityRequestsHandle =
entityManager.GetComponentData <WorldCommands.CreateEntity.CommandSender>(worker.WorkerEntity).Handle;
var deleteEntityRequestsHandle =
entityManager.GetComponentData <WorldCommands.DeleteEntity.CommandSender>(worker.WorkerEntity).Handle;
var entityQueryRequestsHandle =
entityManager.GetComponentData <WorldCommands.EntityQuery.CommandSender>(worker.WorkerEntity).Handle;
var reserveEntityIdsRequestsHandle =
entityManager.GetComponentData <WorldCommands.ReserveEntityIds.CommandSender>(worker.WorkerEntity)
.Handle;
using (var wrappedOp = WorkerOpFactory.CreateDisconnectOp(DisconnectReason))
{
receiveSystem.OnDisconnect(wrappedOp.Op);
}
Assert.IsTrue(entityManager.HasComponent <OnDisconnected>(worker.WorkerEntity));
Assert.AreEqual(DisconnectReason,
entityManager.GetSharedComponentData <OnDisconnected>(worker.WorkerEntity).ReasonForDisconnect);
Assert.Throws <ArgumentException>(() =>
WorldCommands.CreateEntity.RequestsProvider.Get(createEntityRequestsHandle));
Assert.Throws <ArgumentException>(() =>
WorldCommands.DeleteEntity.RequestsProvider.Get(deleteEntityRequestsHandle));
Assert.Throws <ArgumentException>(() =>
WorldCommands.EntityQuery.RequestsProvider.Get(entityQueryRequestsHandle));
Assert.Throws <ArgumentException>(() =>
WorldCommands.ReserveEntityIds.RequestsProvider.Get(reserveEntityIdsRequestsHandle));
}
public void OnRemoveEntity_should_remove_entity_and_deallocate_world_command_providers()
{
var entity = SetupTestEntity();
var createEntityRequestsHandle =
entityManager.GetComponentData <WorldCommands.CreateEntity.CommandSender>(entity).Handle;
var deleteEntityRequestsHandle =
entityManager.GetComponentData <WorldCommands.DeleteEntity.CommandSender>(entity).Handle;
var entityQueryRequestsHandle =
entityManager.GetComponentData <WorldCommands.EntityQuery.CommandSender>(entity).Handle;
var reserveEntityIdsRequestsHandle =
entityManager.GetComponentData <WorldCommands.ReserveEntityIds.CommandSender>(entity).Handle;
using (var wrappedOp = WorkerOpFactory.CreateRemoveEntityOp(TestEntityId))
{
receiveSystem.OnRemoveEntity(wrappedOp.Op);
}
Assert.IsFalse(entityManager.Exists(entity));
Assert.IsFalse(worker.TryGetEntity(new EntityId(TestEntityId), out _));
Assert.Throws <ArgumentException>(() =>
WorldCommands.CreateEntity.RequestsProvider.Get(createEntityRequestsHandle));
Assert.Throws <ArgumentException>(() =>
WorldCommands.DeleteEntity.RequestsProvider.Get(deleteEntityRequestsHandle));
Assert.Throws <ArgumentException>(() =>
WorldCommands.EntityQuery.RequestsProvider.Get(entityQueryRequestsHandle));
Assert.Throws <ArgumentException>(() =>
WorldCommands.ReserveEntityIds.RequestsProvider.Get(reserveEntityIdsRequestsHandle));
}
public void OnAddEntity_should_add_entity_and_command_components()
{
using (var wrappedOp = WorkerOpFactory.CreateAddEntityOp(TestEntityId))
{
receiveSystem.OnAddEntity(wrappedOp.Op);
}
Assert.IsTrue(worker.TryGetEntity(new EntityId(TestEntityId), out var entity));
var id = new SpatialEntityId(); // Default value
Assert.DoesNotThrow(() => { id = entityManager.GetComponentData <SpatialEntityId>(entity); });
Assert.AreEqual(TestEntityId, id.EntityId.Id);
ComponentType[] worldCommandComponentTypes =
{
ComponentType.Create <WorldCommands.CreateEntity.CommandSender>(),
ComponentType.Create <WorldCommands.DeleteEntity.CommandSender>(),
ComponentType.Create <WorldCommands.EntityQuery.CommandSender>(),
ComponentType.Create <WorldCommands.ReserveEntityIds.CommandSender>()
};
foreach (var type in worldCommandComponentTypes)
{
Assert.IsTrue(entityManager.HasComponent(entity, type));
}
Assert.IsTrue(entityManager.HasComponent(entity,
ComponentType.Create <FirstComponentDispatcher.CommandComponent>()));
Assert.IsTrue(entityManager.HasComponent(entity,
ComponentType.Create <SecondComponentDispatcher.CommandComponent>()));
}
public void OnCommandResponse_should_error_if_unknown_component_id_received()
{
using (var wrappedOp =
WorkerOpFactory.CreateCommandResponseOp(InvalidComponentId, TestCommandIndex, TestCommandRequestId))
{
Assert.Throws <UnknownComponentIdException>(() => { receiveSystem.OnCommandResponse(wrappedOp.Op); });
}
}
public void OnAddEntity_should_throw_if_entity_already_exists()
{
SetupTestEntity();
using (var wrappedOp = WorkerOpFactory.CreateAddEntityOp(TestEntityId))
{
Assert.Throws <InvalidSpatialEntityStateException>(() => { receiveSystem.OnAddEntity(wrappedOp.Op); });
}
}
public void OnAuthorityChange_should_be_delegated_to_correct_dispatcher()
{
using (var wrappedOp = WorkerOpFactory.CreateAuthorityChangeOp(TestEntityId, FirstTestComponentId))
{
receiveSystem.OnAuthorityChange(wrappedOp.Op);
}
Assert.IsTrue(firstComponentDispatcher.HasAuthorityChangedReceived);
Assert.IsFalse(secondComponentDispatcher.HasAuthorityChangedReceived);
}
public void OnRemoveEntity_should_error_if_entity_does_not_exist()
{
using (var wrappedOp = WorkerOpFactory.CreateRemoveEntityOp(TestEntityId))
{
Assert.Throws <InvalidSpatialEntityStateException>(() =>
{
receiveSystem.OnRemoveEntity(wrappedOp.Op);
});
}
}
public void OnCommandResponse_should_be_delegated_to_correct_dispatcher()
{
using (var wrappedOp =
WorkerOpFactory.CreateCommandResponseOp(FirstTestComponentId, TestCommandIndex, TestCommandRequestId))
{
receiveSystem.OnCommandResponse(wrappedOp.Op);
}
Assert.IsTrue(firstComponentDispatcher.HasCommandResponseReceived);
Assert.IsFalse(secondComponentDispatcher.HasCommandResponseReceived);
}
public void OnReserveEntityIdsResponse_should_log_if_corresponding_entity_not_found()
{
var emptyRequest = new WorldCommands.ReserveEntityIds.Request();
reserveEntityIdsStorage.CommandRequestsInFlight.Add(TestCommandRequestId,
new CommandRequestStore <WorldCommands.ReserveEntityIds.Request>(Entity.Null,
emptyRequest, null, TestCommandRequestId));
using (var wrappedOp = WorkerOpFactory.CreateReserveEntityIdsResponseOp(TestCommandRequestId))
{
using (var expectingScope = logDispatcher.EnterExpectingScope())
{
expectingScope.Expect(LogType.Log, LoggingUtils.LoggerName, "Op");
receiveSystem.OnReserveEntityIdsResponse(wrappedOp.Op);
}
}
}
public void OnEntityQueryResponse_should_add_received_responses_to_entity()
{
var entity = SetupTestEntity();
var emptyRequest = new WorldCommands.EntityQuery.Request();
var context = "Some context";
entityQueryStorage.CommandRequestsInFlight.Add(TestCommandRequestId,
new CommandRequestStore <WorldCommands.EntityQuery.Request>(entity,
emptyRequest, context, TestCommandRequestId));
using (var wrappedOp = WorkerOpFactory.CreateEntityQueryResponseOp(TestCommandRequestId))
{
receiveSystem.OnEntityQueryResponse(wrappedOp.Op);
Assert.IsTrue(entityManager.HasComponent <WorldCommands.EntityQuery.CommandResponses>(entity));
var responses = entityManager.GetComponentData <WorldCommands.EntityQuery.CommandResponses>(entity);
var count = 0;
Assert.DoesNotThrow(() => { count = responses.Responses.Count; });
Assert.AreEqual(1, count);
var response = responses.Responses[0];
Assert.AreEqual(emptyRequest, response.RequestPayload);
Assert.AreEqual(context, response.Context);
Assert.AreEqual(TestCommandRequestId, response.RequestId);
Assert.AreEqual(wrappedOp.Op.StatusCode, response.StatusCode);
Assert.AreEqual(wrappedOp.Op.Message, response.Message);
Assert.AreEqual(wrappedOp.Op.ResultCount, response.ResultCount);
// Check that the result and the op contain snapshots of the same entities
// Or that they are both null if one of them is null
// todo UTY-1361 clean this up
if (wrappedOp.Op.Result == null)
{
Assert.IsNull(response.Result);
}
else
{
CollectionAssert.AreEquivalent(wrappedOp.Op.Result.Keys, response.Result.Keys);
}
}
}
