private static EntityEventBus BusFactory()
{
var entManMock = new Mock <IEntityManager>();
var bus = new EntityEventBus(entManMock.Object);
return(bus);
}
private static EntityEventBus BusFactory()
{
var entityMan = new Mock<IEntityManager>();
var compMan = new Mock<IComponentManager>();
entityMan.Setup(m => m.ComponentManager).Returns(compMan.Object);
var bus = new EntityEventBus(entityMan.Object);
return bus;
}
public void SubscribeCompEvent()
{
// Arrange
var entUid = new EntityUid(7);
var compInstance = new MetaDataComponent();
var compRegistration = new Mock <IComponentRegistration>();
var entManMock = new Mock <IEntityManager>();
var compManMock = new Mock <IComponentManager>();
var compFacMock = new Mock <IComponentFactory>();
compRegistration.Setup(m => m.References).Returns(new List <Type> {
typeof(MetaDataComponent)
});
compFacMock.Setup(m => m.GetRegistration(typeof(MetaDataComponent))).Returns(compRegistration.Object);
compManMock.Setup(m => m.ComponentFactory).Returns(compFacMock.Object);
IComponent?outIComponent = compInstance;
compManMock.Setup(m => m.TryGetComponent(entUid, typeof(MetaDataComponent), out outIComponent))
.Returns(true);
compManMock.Setup(m => m.GetComponent(entUid, typeof(MetaDataComponent)))
.Returns(compInstance);
entManMock.Setup(m => m.ComponentManager).Returns(compManMock.Object);
var bus = new EntityEventBus(entManMock.Object);
// Subscribe
int calledCount = 0;
bus.SubscribeLocalEvent <MetaDataComponent, TestEvent>(HandleTestEvent);
// add a component to the system
entManMock.Raise(m => m.EntityAdded += null, entManMock.Object, entUid);
compManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(compInstance, entUid));
// Raise
var evntArgs = new TestEvent(5);
bus.RaiseLocalEvent(entUid, evntArgs);
// Assert
Assert.That(calledCount, Is.EqualTo(1));
void HandleTestEvent(EntityUid uid, MetaDataComponent component, TestEvent args)
{
calledCount++;
Assert.That(uid, Is.EqualTo(entUid));
Assert.That(component, Is.EqualTo(compInstance));
Assert.That(args.TestNumber, Is.EqualTo(5));
}
}
public void SubscribeEvent_NullSubscriber_NullArgumentException()
{
// Arrange
var bus = new EntityEventBus();
// Act
void Code() => bus.SubscribeEvent <TestEventArgs>(EventSource.Local, null !, ev => {});
//Assert: this should do nothing
Assert.Throws <ArgumentNullException>(Code);
}
public void UnsubscribeEvent_NullSubscriber_NullArgumentException()
{
// Arrange
var bus = new EntityEventBus();
// Act
void Code() => bus.UnsubscribeEvent <TestEventArgs>(EventSource.Local, null !);
// Assert
Assert.Throws <ArgumentNullException>(Code);
}
public void UnsubscribeEvent_NoSubscription_Nop()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
// Act
bus.UnsubscribeEvent <TestEventArgs>(EventSource.Local, subscriber);
// Assert: Does not throw
}
public void UnsubscribeEvents_NoSubscriptions_Nop()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
// Act
bus.UnsubscribeEvents(subscriber);
// Assert: no exception
}
public void QueueEvent_NullEvent_ArgumentNullException()
{
// Arrange
var bus = new EntityEventBus();
// Act
void Code() => bus.QueueEvent(EventSource.Local, null !);
// Assert
Assert.Throws <ArgumentNullException>(Code);
}
public void RaiseEvent_NullEvent_ArgumentNullException()
{
// Arrange
var bus = new EntityEventBus();
// Act
void Code() => bus.RaiseEvent(null, null);
// Assert
Assert.Throws <ArgumentNullException>(Code);
}
public void AwaitEvent_SourceNone_ArgOutOfRange()
{
// Arrange
var bus = new EntityEventBus();
// Act
void Code() => bus.AwaitEvent <TestEventArgs>(EventSource.None);
// Assert
Assert.Throws <ArgumentOutOfRangeException>(Code);
}
public void UnsubscribeEvents_NullSubscriber_NullArgumentException()
{
// Arrange
var bus = new EntityEventBus();
// Act
void Code() => bus.UnsubscribeEvents(null !);
// Assert
Assert.Throws <ArgumentNullException>(Code);
}
public void UnsubscribeEvent_SourceNone_ArgOutOfRange()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
// Act
void Code() => bus.UnsubscribeEvent <TestEventArgs>(EventSource.None, subscriber);
// Assert
Assert.Throws <ArgumentOutOfRangeException>(Code);
}
public void SubscribeEvent_NullHandler_NullArgumentException()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
// Act
void Code() => bus.SubscribeEvent(EventSource.Local, subscriber, (EntityEventHandler <TestEventArgs>)null !);
//Assert
Assert.Throws <ArgumentNullException>(Code);
}
public void AwaitEvent_DoubleTask_InvalidException()
{
// Arrange
var bus = new EntityEventBus();
bus.AwaitEvent <TestEventArgs>(EventSource.Local);
// Act
void Code() => bus.AwaitEvent <TestEventArgs>(EventSource.Local);
// Assert
Assert.Throws <InvalidOperationException>(Code);
}
public async Task AwaitEvent()
{
// Arrange
var bus = new EntityEventBus();
var args = new TestEventArgs();
// Act
var task = bus.AwaitEvent <TestEventArgs>(EventSource.Local);
bus.RaiseEvent(EventSource.Local, args);
var result = await task;
// Assert
Assert.That(result, Is.EqualTo(args));
}
public void RaiseEvent_NoSubscriptions_Nop()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delCalledCount = 0;
bus.SubscribeEvent <TestEventTwoArgs>(EventSource.Local, subscriber, ev => delCalledCount++);
// Act
bus.RaiseEvent(EventSource.Local, new TestEventArgs());
// Assert
Assert.That(delCalledCount, Is.EqualTo(0));
}
public void SubscribeCompLifeEvent()
{
// Arrange
var entUid = new EntityUid(7);
var compInstance = new MetaDataComponent();
var mockEnt = new Mock <IEntity>();
mockEnt.SetupGet(m => m.Uid).Returns(entUid);
compInstance.Owner = mockEnt.Object;
var entManMock = new Mock <IEntityManager>();
var compManMock = new Mock <IComponentManager>();
IComponent?outIComponent = compInstance;
compManMock.Setup(m => m.TryGetComponent(entUid, typeof(MetaDataComponent), out outIComponent))
.Returns(true);
compManMock.Setup(m => m.GetComponent(entUid, typeof(MetaDataComponent)))
.Returns(compInstance);
entManMock.Setup(m => m.ComponentManager).Returns(compManMock.Object);
var bus = new EntityEventBus(entManMock.Object);
// Subscribe
int calledCount = 0;
bus.SubscribeLocalEvent <MetaDataComponent, ComponentInit>(HandleTestEvent);
// add a component to the system
entManMock.Raise(m => m.EntityAdded += null, entManMock.Object, entUid);
compManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(compInstance, entUid));
// Raise
bus.RaiseComponentEvent(compInstance, new ComponentInit());
// Assert
Assert.That(calledCount, Is.EqualTo(1));
void HandleTestEvent(EntityUid uid, MetaDataComponent component, ComponentInit args)
{
calledCount++;
Assert.That(uid, Is.EqualTo(entUid));
Assert.That(component, Is.EqualTo(compInstance));
}
}
public void UnsubscribeEvent_DoubleUnsubscribe_Nop()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
void Handler(object sender, TestEventArgs ev)
{
}
bus.SubscribeEvent <TestEventArgs>(Handler, subscriber);
bus.UnsubscribeEvent <TestEventArgs>(subscriber);
// Act
bus.UnsubscribeEvent <TestEventArgs>(subscriber);
// Assert: Does not throw
}
public void QueueEvent_EventQueued_DoesNotImmediatelyRaise()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delCallCount = 0;
void Handler(TestEventArgs ev) => delCallCount++;
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, Handler);
// Act
bus.QueueEvent(EventSource.Local, new TestEventArgs());
// Assert
Assert.That(delCallCount, Is.EqualTo(0));
}
public void UnsubscribeEvent_DoubleUnsubscribe_Nop()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
void Handler(TestEventArgs ev)
{
}
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, Handler);
bus.UnsubscribeEvent <TestEventArgs>(EventSource.Local, subscriber);
// Act
bus.UnsubscribeEvent <TestEventArgs>(EventSource.Local, subscriber);
// Assert: Does not throw
}
public void UnsubscribeCompEvent()
{
// Arrange
var entUid = new EntityUid(7);
var compInstance = new MetaDataComponent();
var entManMock = new Mock <IEntityManager>();
var compManMock = new Mock <IComponentManager>();
IComponent?outIComponent = compInstance;
compManMock.Setup(m => m.TryGetComponent(entUid, typeof(MetaDataComponent), out outIComponent))
.Returns(true);
compManMock.Setup(m => m.GetComponent(entUid, typeof(MetaDataComponent)))
.Returns(compInstance);
entManMock.Setup(m => m.ComponentManager).Returns(compManMock.Object);
var bus = new EntityEventBus(entManMock.Object);
// Subscribe
int calledCount = 0;
bus.SubscribeLocalEvent <MetaDataComponent, TestEvent>(HandleTestEvent);
bus.UnsubscribeLocalEvent <MetaDataComponent, TestEvent>();
// add a component to the system
entManMock.Raise(m => m.EntityAdded += null, entManMock.Object, entUid);
compManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(compInstance, entUid));
// Raise
var evntArgs = new TestEvent(5);
bus.RaiseLocalEvent(entUid, evntArgs);
// Assert
Assert.That(calledCount, Is.EqualTo(0));
void HandleTestEvent(EntityUid uid, MetaDataComponent component, TestEvent args)
{
calledCount++;
}
}
public void SubscribeEvent_MultipleDelegates_BothRaised()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delFooCount = 0;
int delBarCount = 0;
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, ev => delFooCount++);
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, ev => delBarCount++);
// Act
bus.RaiseEvent(EventSource.Local, new TestEventArgs());
// Assert
Assert.That(delFooCount, Is.EqualTo(1));
Assert.That(delBarCount, Is.EqualTo(1));
}
public void RaiseEvent_Unsubscribed_Nop()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delCallCount = 0;
void Handler(object sender, TestEventArgs ev) => delCallCount++;
bus.SubscribeEvent <TestEventArgs>(Handler, subscriber);
bus.UnsubscribeEvent <TestEventArgs>(subscriber);
// Act
bus.RaiseEvent(null, new TestEventArgs());
// Assert
Assert.That(delCallCount, Is.EqualTo(0));
}
public void ProcessQueue_EventQueued_HandlerRaised()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delCallCount = 0;
void Handler(TestEventArgs ev) => delCallCount++;
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, Handler);
bus.QueueEvent(EventSource.Local, new TestEventArgs());
// Act
bus.ProcessEventQueue();
// Assert
Assert.That(delCallCount, Is.EqualTo(1));
}
public void UnsubscribeEvents_UnsubscribedHandler_Nop()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delCallCount = 0;
void Handler(TestEventArgs ev) => delCallCount++;
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, Handler);
bus.UnsubscribeEvents(subscriber);
// Act
bus.RaiseEvent(EventSource.Local, new TestEventArgs());
// Assert
Assert.That(delCallCount, Is.EqualTo(0));
}
public void SubscribeEvent_DuplicateSubscription_RaisedOnce()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delegateCallCount = 0;
void Handler(TestEventArgs ev) => delegateCallCount++;
// 2 subscriptions 1 handler
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, Handler);
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, Handler);
// Act
bus.RaiseEvent(EventSource.Local, new TestEventArgs());
//Assert
Assert.That(delegateCallCount, Is.EqualTo(1));
}
public void SubscribeEvent_MultipleSubscriptions_IndividuallyCalled()
{
// Arrange
var bus = new EntityEventBus();
var subscriber = new TestEventSubscriber();
int delFooCount = 0;
int delBarCount = 0;
bus.SubscribeEvent <TestEventArgs>(EventSource.Local, subscriber, ev => delFooCount++);
bus.SubscribeEvent <TestEventTwoArgs>(EventSource.Local, subscriber, ev => delBarCount++);
// Act & Assert
bus.RaiseEvent(EventSource.Local, new TestEventArgs());
Assert.That(delFooCount, Is.EqualTo(1));
Assert.That(delBarCount, Is.EqualTo(0));
delFooCount = delBarCount = 0;
bus.RaiseEvent(EventSource.Local, new TestEventTwoArgs());
Assert.That(delFooCount, Is.EqualTo(0));
Assert.That(delBarCount, Is.EqualTo(1));
}
public void CompEventOrdered()
{
// Arrange
var entUid = new EntityUid(7);
var entManMock = new Mock <IEntityManager>();
var compFacMock = new Mock <IComponentFactory>();
void Setup <T>(out T instance) where T : IComponent, new()
{
IComponent?inst = instance = new T();
var reg = new Mock <IComponentRegistration>();
reg.Setup(m => m.References).Returns(new Type[] { typeof(T) });
compFacMock.Setup(m => m.GetRegistration(typeof(T))).Returns(reg.Object);
entManMock.Setup(m => m.TryGetComponent(entUid, typeof(T), out inst)).Returns(true);
entManMock.Setup(m => m.GetComponent(entUid, typeof(T))).Returns(inst);
}
Setup <OrderComponentA>(out var instA);
Setup <OrderComponentB>(out var instB);
Setup <OrderComponentC>(out var instC);
entManMock.Setup(m => m.ComponentFactory).Returns(compFacMock.Object);
var bus = new EntityEventBus(entManMock.Object);
// Subscribe
var a = false;
var b = false;
var c = false;
void HandlerA(EntityUid uid, Component comp, TestEvent ev)
{
Assert.That(b, Is.False, "A should run before B");
Assert.That(c, Is.False, "A should run before C");
a = true;
}
void HandlerB(EntityUid uid, Component comp, TestEvent ev)
{
Assert.That(c, Is.True, "B should run after C");
b = true;
}
void HandlerC(EntityUid uid, Component comp, TestEvent ev) => c = true;
bus.SubscribeLocalEvent <OrderComponentA, TestEvent>(HandlerA, typeof(OrderComponentA), before: new [] { typeof(OrderComponentB), typeof(OrderComponentC) });
bus.SubscribeLocalEvent <OrderComponentB, TestEvent>(HandlerB, typeof(OrderComponentB), after: new [] { typeof(OrderComponentC) });
bus.SubscribeLocalEvent <OrderComponentC, TestEvent>(HandlerC, typeof(OrderComponentC));
// add a component to the system
entManMock.Raise(m => m.EntityAdded += null, entManMock.Object, entUid);
entManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(instA, entUid));
entManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(instB, entUid));
entManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(instC, entUid));
// Raise
var evntArgs = new TestEvent(5);
bus.RaiseLocalEvent(entUid, evntArgs);
// Assert
Assert.That(a, Is.True, "A did not fire");
Assert.That(b, Is.True, "B did not fire");
Assert.That(c, Is.True, "C did not fire");
}
