public void ObserverShouldOnlyReceiveSubscribedNotifications()
{
// Arrange
var eventAggregator = new EventAggregator();
var observer1 = new Mock<IObserve<TestEvent>>();
var observer2 = new Mock<IObserve<OtherEvent>>();
eventAggregator.Subscribe(observer1.Object);
eventAggregator.Subscribe(observer2.Object);
var testEvent = new TestEvent();
var otherEvent = new OtherEvent();
// Act
eventAggregator.Publish(testEvent);
eventAggregator.Publish(otherEvent);
// Assert
observer1.Verify(x => x.OnNext(It.IsAny<IEvent>()), Times.Once);
observer1.Verify(x => x.OnNext(testEvent), Times.Once);
observer2.Verify(x => x.OnNext(otherEvent), Times.Once);
}
public void IgnoresAllIAggregateRootEventProperties()
{
var eventWithAllValuesSet = new TestEvent("Test1", "Test2")
{
AggregateRootId = Guid.NewGuid(),
AggregateRootVersion = 2,
EventId = Guid.NewGuid(),
InsertAfter = 10,
InsertBefore = 20,
Replaces = 30,
InsertionOrder = 40,
UtcTimeStamp = DateTime.Now + 1.Minutes()};
var eventWithOnlySubclassValues = new TestEvent("Test1", "Test2")
{
EventId = Guid.Empty,
UtcTimeStamp = DateTime.MinValue
};
var eventWithAllValuesJson = JsonConvert.SerializeObject(eventWithAllValuesSet, JsonSettings.SqlEventStoreSerializerSettings);
var eventWithOnlySubclassValuesJson = JsonConvert.SerializeObject(eventWithOnlySubclassValues, JsonSettings.SqlEventStoreSerializerSettings);
var roundTripped = JsonConvert.DeserializeObject<TestEvent>(eventWithAllValuesJson, JsonSettings.SqlEventStoreSerializerSettings);
Console.WriteLine(eventWithAllValuesJson);
eventWithAllValuesJson.Should().Be("{\"Test1\":\"Test1\",\"Test2\":\"Test2\"}");
eventWithAllValuesJson.Should().Be(eventWithOnlySubclassValuesJson);
roundTripped.ShouldBeEquivalentTo(eventWithOnlySubclassValues,
config => config.Excluding(@event => @event.UtcTimeStamp)//Timestamp is defaulted in the constructor used by serialization.
.Excluding(@event => @event.EventId)
);
}
public void PublishDomainEvents()
{
var e = new TestEvent();
var mockRepository = new MockRepository();
IEnumerable<object> handlers;
using (mockRepository.Record())
{
var handler1 = mockRepository.StrictMock<IEventHandler<TestEvent>>();
handler1.Expect(h => h.Handle(e)).Repeat.Once();
var handler2 = mockRepository.StrictMock<IEventHandler<TestEvent>>();
handler2.Expect(h => h.Handle(e)).Repeat.Once();
handlers = new[] { handler1, handler2 };
}
MultiInstanceFactory multiInstanceFactory = t => handlers;
var publisher = new DomainEventsPublisher(multiInstanceFactory);
DomainEvents.Raise(e);
using (mockRepository.Playback())
publisher.Publish();
mockRepository.VerifyAll();
}
public void test_add_handler_during_event()
{
var instance = new DeferredEventListener();
var count = 0;
var target = new TestEvent();
instance.AddSupportedType<TestEvent>();
instance.AddEventHandler<TestEvent>((ep) =>
{
count = 10;
instance.AddEventHandler<TestEvent>((ep2) => { count = 100; }, 1f);
}, 1f);
Assert(instance.Count == 1);
instance.Step(1f);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(instance.Count == 1);
instance.Step(1f);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(instance.Count == 0);
Assert(count == 100);
}
public void Update_WithThreeEvent_IsDispatchedInFIFOOrder()
{
int counter = 0;
int event1Number = 0;
int event2Number = 0;
int event3Number = 0;
var eventMock1 = new TestEvent();
var eventMock2 = new TestEvent();
var eventMock3 = new TestEvent();
eventMock1.Callback = () => { event1Number = counter; counter++; };
eventMock2.Callback = () => { event2Number = counter; counter++; };
eventMock3.Callback = () => { event3Number = counter; counter++; };
eventComponent.AddEvent(eventMock1);
eventComponent.AddEvent(eventMock2);
eventComponent.AddEvent(eventMock3);
while (UndispatchedEventsLeft(eventMock1, eventMock2, eventMock3))
eventComponent.Update(new GameTime());
Assert.AreEqual(0, event1Number);
Assert.AreEqual(1, event2Number);
Assert.AreEqual(2, event3Number);
}
public void test_deferred_task()
{
var instance = new DeferredEventListener();
var count = 0;
var target = new TestEvent();
instance.AddSupportedType<TestEvent>();
instance.AddEventHandler<TestEvent>((ep) =>
{ if (ep == target) { count += 1; } }, 2f);
instance.AddEventHandler<TestEvent>((ep) =>
{ if (ep == target) { count += 1; } }, 4f);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(count == 0);
Assert(instance.Count == 2);
instance.Step(2f);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(count == 1);
Assert(instance.Count == 1);
instance.Step(2f);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(count == 2);
Assert(instance.Count == 0);
}
public void TestChangesToAFileResultInChangeEventBeingRaised()
{
mTestEvent = new TestEvent("testing");
TestEventHandler += (o, a) => mTestEvent.TestPhrase = "gnitset";
TestEventHandler.RaiseEvent(null, mTestEvent);
Assert.That(mTestEvent.TestPhrase, Is.EqualTo("gnitset"));
}
private void btnNext_Click(object sender, EventArgs e)
{
Session.Instance.AddEvent(new TestEvent(Constants.Event.ControlActivated, Constants.Phase.Proficiency,
Constants.SubPhase.None, @"Next button pressed"));
this.btnHidden.Focus();
if (tbEntry.Text.Equals(lblProficiencyString.Text))
{
TestEvent evt = new TestEvent(Constants.Event.CorrectValueEntered, Constants.Phase.Proficiency,
Constants.SubPhase.None, @"Correct value entered");
evt.TargetString = lblProficiencyString.Text;
Session.Instance.AddEvent(evt);
}
else
{
TestEvent evt = new TestEvent(Constants.Event.IncorrectValueEntered, Constants.Phase.Proficiency,
Constants.SubPhase.None, @"Incorrect value entered");
evt.TargetString = lblProficiencyString.Text;
Session.Instance.AddEvent(evt);
}
if (Session.Instance.CurrentProficiencyString+1 >= Session.Instance.ProficiencyStrings.Length)
{
executeCommand(@"Go To Instructions");
}
else
{
executeCommand(@"Next Proficiency Item");
}
}
public void ShouldHandleAndIgnoreException()
{
var ex = new Exception();
var @event = new TestEvent();
var exceptionHandler = new IgnoreExceptionHandler();
exceptionHandler.HandleEventException(ex, 0L, @event);
}
public void AggregateBus_CallingPublishWithoutConfigurationShouldRaiseException()
{
var @event = new TestEvent();
AggregateBus.Instance.Reset();
AggregateBus.Instance.Awaiting(m => m.PublishAsync<TestAggregate, TestEvent>(Guid.NewGuid(), @event))
.ShouldThrow<ApplicationException>();
}
public void GetEventsReturnsCorrectNumberOfEvents()
{
var aggregateId = Guid.NewGuid();
var @event = new TestEvent("Bob");
var es = _kernel.Get<IEventStore>();
es.SaveEvents(aggregateId, new Event[] { @event }, -1);
var events = es.GetEventsForAggregate(aggregateId);
events.Count().Should().Be.EqualTo(1);
}
public void EventTypeIsPreserved()
{
var aggregateId = Guid.NewGuid();
var @event = new TestEvent("Bob");
var es = _kernel.Get<IEventStore>();
es.SaveEvents(aggregateId, new Event[] { @event }, -1);
var events = es.GetEventsForAggregate(aggregateId);
events.Single().Should().Be.InstanceOf<TestEvent>();
}
public void CanRegisterEvents()
{
var sw = new StringWriter();
var testCase =new TestCase(sw);
var eventData = new TestEvent {Name = "Hello"};
EventManager.Register<TestEvent>(testCase.ProcessEvent);
EventManager.Raise(eventData);
Assert.AreEqual(sw.ToString(), eventData.Name);
}
public void OverlapsEndOf()
{
var events = AddSlot.CreateEvents();
var removingX = new TestEvent("X") { Start = new DateTime(2015, 1, 1, 0, 30, 0), Duration = TimeSpan.FromHours(1) };
var commands = events.RemoveEvent(removingX).ToArray();
Assert.AreEqual(1, commands.Length);
Assert.AreEqual(events[0], commands[0].Event);
Assert.AreEqual(DataCommandVerb.Update, commands[0].Verb);
Assert.AreEqual(removingX.Start, events[0].End);
}
public void EventDataIsPreserved()
{
var aggregateId = Guid.NewGuid();
var @event = new TestEvent("Bob");
var es = _kernel.Get<IEventStore>();
es.SaveEvents(aggregateId, new Event[] { @event }, -1);
var events = es.GetEventsForAggregate(aggregateId);
var testEvent = events.Single() as TestEvent;
testEvent.Name.Should().Be.EqualTo("Bob");
}
private void btnNext_Click(object sender, EventArgs e)
{
Session.Instance.AddEvent(new TestEvent(Constants.Event.ControlActivated, Constants.Phase.Entry, Constants.SubPhase.None,
"Next button pressed"));
this.btnHidden.Focus();
if (tbEntry.Text.Equals(Options.Instance.QuitString)) // check for quit phrase
{
TestEvent te = new TestEvent(Constants.Event.ControlActivated, Constants.Phase.Entry, Constants.SubPhase.None,
@"Quit phrase entered");
te.TargetString = currentString;
Session.Instance.AddEvent(te);
executeCommand("Go To Recall");
return;
}
else if (tbEntry.Text.Equals(Options.Instance.SkipString)) // check for skip phrase
{
TestEvent te = new TestEvent(Constants.Event.ControlActivated, Constants.Phase.Entry, Constants.SubPhase.None,
@"Skip phrase entered");
te.TargetString = currentString;
Session.Instance.AddEvent(te);
executeCommand(@"Next Entity");
return;
}
else if (tbEntry.Text.Equals(currentString)) // check for correct entry
{
TestEvent te = new TestEvent(Constants.Event.CorrectValueEntered, Constants.Phase.Entry, Constants.SubPhase.None,
@"Correct value entered");
te.TargetString = currentString;
Session.Instance.AddEvent(te);
}
else // incorrect and non special string entered
{
TestEvent te = new TestEvent(Constants.Event.IncorrectValueEntered, Constants.Phase.Entry, Constants.SubPhase.None,
@"Incorrect value entered");
te.TargetString = currentString;
Session.Instance.AddEvent(te);
}
// increment the entry # and determine if another is needed or where to go
Session.Instance.CurrentEntryForEntity++;
tbEntry.Text = string.Empty;
if (Session.Instance.CurrentEntryForEntity > Options.Instance.RepetitionPerEntity)
{
if (Session.Instance.CurrentEntity + 1 >= Session.Instance.EntityStrings.Length)
{
executeCommand(@"Go To Recall");
}
else
{
executeCommand(@"Next Entity");
}
}
UpdateUi();
}
public void MultipleSubscribersAreCalled()
{
var sw = new StringWriter();
var testCase = new TestCase(sw);
var testCase2 = new TestCase(sw);
var eventData = new TestEvent { Name = "Hello" };
EventManager.Register<TestEvent>(testCase.ProcessEvent);
EventManager.Register<TestEvent>(testCase2.ProcessEvent);
EventManager.Raise(eventData);
Assert.AreEqual(sw.ToString(), eventData.Name + eventData.Name);
}
public void RaiseEventShouldCallHandlersFromContainer()
{
var container = MockRepository.GenerateStub<IHandlerLocator>();
DomainEvent.HandlerLocator = container;
var handler = MockRepository.GenerateStub<IHandle<TestEvent>>();
container.Stub(x => x.GetHandlersFor<TestEvent>())
.Return(new[] {handler});
var @event = new TestEvent();
DomainEvent.Raise(@event);
handler.AssertWasCalled(x => x.Handle(@event));
}
public void Should_add_to_projection()
{
// Arrange
var @event = new TestEvent {EventProperty = 5};
var projection = new TestProjection {ProjectionProperty = 5};
var builder = new AddNewProjectionStrategyArguments<TestEvent, TestProjection>();
builder.Add(p => p.ProjectionProperty, e => e.EventProperty);
// Act
builder.Mappers.Map(@event, projection);
// Assert
Assert.AreEqual(10, projection.ProjectionProperty);
}
public void Should_add_using_only_projection_property_name()
{
// Arrange
var @event = new TestEvent {MappedByName = 10};
var projection = new TestProjection {MappedByName = 10};
var builder = new AddNewProjectionStrategyArguments<TestEvent, TestProjection>();
builder.Add(p => p.MappedByName);
// Act
builder.Mappers.Map(@event, projection);
// Assert
Assert.AreEqual(20, projection.MappedByName);
}
public void Should_decrement_projection()
{
// Arrange
var @event = new TestEvent();
var projection = new TestProjection {ProjectionProperty = 5};
var builder = new AddNewProjectionStrategyArguments<TestEvent, TestProjection>();
builder.Decrement(p => p.ProjectionProperty);
// Act
builder.Mappers.Map(@event, projection);
// Assert
Assert.AreEqual(4, projection.ProjectionProperty);
}
public void Should_do_lambda_expression()
{
// Arrange
var @event = new TestEvent {EventProperty = 5};
var projection = new TestProjection {ProjectionProperty = 5};
var builder = new AddNewProjectionStrategyArguments<TestEvent, TestProjection>();
builder.Do((e, p) => p.ProjectionProperty = p.ProjectionProperty*e.EventProperty);
// Act
builder.Mappers.Map(@event, projection);
// Assert
Assert.AreEqual(25, projection.ProjectionProperty);
}
public void DoubleRaiseTest()
{
var botBits = new BotBitsClient();
var e = new TestEvent();
e.RaiseIn(botBits);
try
{
e.RaiseIn(botBits);
Assert.Fail();
}
catch (InvalidOperationException) { } // Expected
}
public void SerializeEmptyEnumerable()
{
var initialData = new int[] {};
var values = initialData.Select(i => new DateTimeContainer { Now = DateTime.Now.AddDays(i) });
var data = new TestEvent
{
Values = values.ToList()
};
JsonSerializer serializer = new JsonSerializer();
var content = serializer.Serialize(data);
var result = (TestEvent)serializer.Deserialize(content, typeof(TestEvent));
Assert.IsNotNull(result);
Assert.IsNotNull(result.Values);
Assert.AreEqual(initialData.Length, result.Values.Count());
}
public void TestMapOneArgumentCallback ()
{
confirmationValue = INIT_VALUE;
IEventBinding binding = new EventBinding ();
binding.Bind (SomeEnum.ONE).To (oneArgumentCallback);
EventCallbackType type = binding.TypeForCallback (oneArgumentCallback);
object[] value = binding.value as object[];
Delegate extracted = value[0] as Delegate;
Assert.AreEqual (EventCallbackType.ONE_ARGUMENT, type);
object[] parameters = new object[1];
parameters [0] = new TestEvent("TEST", null, INIT_VALUE);
extracted.DynamicInvoke(parameters);
//Calling the method should change the confirmationValue
Assert.AreEqual (confirmationValue, INIT_VALUE * INIT_VALUE);
}
public void when_append_and_read_event()
{
var eventStore = new EventStore(_messageStore);
var testEvent1 = new TestEvent("Event1");
var testEvent2 = new TestEvent("Event2");
eventStore.AppendEventsToStream(null, -1, new[] { testEvent1 });
eventStore.AppendEventsToStream(null, -1, new[] { testEvent2 });
eventStore.AppendEventsToStream(null, -1, new[] { testEvent1, testEvent2 });
var stream = eventStore.LoadEventStream(null);
Assert.AreEqual(3, stream.StreamVersion);
Assert.AreEqual(4, stream.Events.Count);
Assert.AreEqual("Event1", (stream.Events[0] as TestEvent).Name);
Assert.AreEqual("Event2", (stream.Events[1] as TestEvent).Name);
Assert.AreEqual("Event1", (stream.Events[2] as TestEvent).Name);
Assert.AreEqual("Event2", (stream.Events[3] as TestEvent).Name);
}
public void CallTheInnerHandler()
{
var mockRepository = new MockRepository();
var @event = new TestEvent();
var eventHandler = mockRepository.StrictMock<IEventHandler<TestEvent>>();
var publisher = mockRepository.DynamicMock<IDomainEventsPublisher>();
var decorator = new DomainEventsPublisherEventHandler<TestEvent>(eventHandler, publisher);
using (mockRepository.Record())
eventHandler
.Expect(h => h.Handle(@event))
.Repeat.Once();
using (mockRepository.Playback())
decorator.Handle(@event);
mockRepository.VerifyAll();
}
public void AggregateBus_PublishWillPassToTheEventBus()
{
var guid = Guid.NewGuid();
var @event = new TestEvent();
var eventBus = new Moq.Mock<IEventBus>();
eventBus.Setup(m => m.PublishAsync<TestAggregate, TestEvent>(guid, @event))
.Returns(Task.FromResult<object>(null)).Verifiable();
var aggregateCache = new Moq.Mock<IAggregateCache>();
aggregateCache.Setup(x => x.HandleAsync<TestAggregate, TestEvent>(guid, @event))
.Returns(Task.FromResult<object>(null)).Verifiable();
AggregateBus.Instance.Configure(eventBus.Object, aggregateCache.Object);
AggregateBus.Instance.Awaiting(m => m.PublishAsync<TestAggregate, TestEvent>(guid, @event))
.ShouldNotThrow();
eventBus.Verify(m => m.PublishAsync<TestAggregate, TestEvent>(guid, @event), Moq.Times.Once);
aggregateCache.Verify(m => m.HandleAsync<TestAggregate, TestEvent>(guid, @event), Moq.Times.Once);
}
public void test_manually_invoke_targets()
{
var instance = new SimpleEventListener();
var count = 0;
var target = new TestEvent();
instance.AddSupportedType<TestEvent>();
instance.AddEventHandler<TestEvent>((ep) =>
{ if (ep == target) { count += 1; } });
instance.AddEventHandler<TestEvent>((ep) =>
{ if (ep == target) { count += 1; } });
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(count == 2);
Assert(instance.Count == 2);
}
public void AddNew()
{
var events = CreateEvents();
var bStart = events[1].Start;
var addingX = new TestEvent("X") { Start = new DateTime(2015, 1, 1, 4, 15, 0), Duration = TimeSpan.FromMinutes(1) };
var pos = events.ResolvePosition(addingX);
Assert.IsNull(pos.OverlapsEndOf);
Assert.IsNull(pos.StartsAdjacentTo);
Assert.IsNull(pos.EndsAdjacentTo);
Assert.IsNull(pos.OverlapsStartOf);
Assert.IsFalse(pos.OverlapsCompletely.Any());
var commands = events.AddEvent(addingX).ToArray();
Assert.AreEqual(1, commands.Length);
Assert.AreEqual(addingX, commands[0].Event);
Assert.AreEqual(DataCommandVerb.Insert, commands[0].Verb);
}
public void IdIsGenerated()
{
var integrationEvent = new TestEvent();
Assert.NotEqual(Guid.Empty, integrationEvent.Id);
}
public when_a_null_event_is_published()
{
Publisher.Use(new TestPipelineAdapter(test_publisher), new PublishingContext("TEST_SYSTEM", "TEST"));
expected_event = null;
}
internal void InvokeTestEvent()
{
TestEvent?.Invoke(this, new CustomEventArgs {
Data = "test"
});
}
public void return_empty_slice_when_called_on_non_existing_range()
{
const string stream = "read_event_stream_forward_should_return_empty_slice_when_called_on_non_existing_range";
using (var store = BuildConnection())
{
store.ConnectAsync().Wait();
var write10 = store.AppendToStreamAsync(stream,
ExpectedVersion.EmptyStream,
Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent((x + 1).ToString(CultureInfo.InvariantCulture))));
Assert.DoesNotThrow(write10.Wait);
var read = store.ReadStreamEventsForwardAsync(stream, 11, 5, resolveLinkTos: false);
Assert.DoesNotThrow(read.Wait);
Assert.That(read.Result.Events.Length, Is.EqualTo(0));
}
}
public GLTFLoadingTestTrackingData()
{
events[0] = new TestEvent();
}
protected virtual void OnTestEvent()
{
TestEvent?.Invoke(this, EventArgs.Empty);
}
public void OnTest(TestEvent evt) => evt.Value = 100;
private void OnPrivateTest(TestEvent evt) => evt.Value = 100;
public async Task OnTestAsync(TestEvent evt)
{
await Task.Delay(100);
evt.Value = 100;
}
public void OnTest_TooManyParams(TestEvent evt, int x)
{
}
public int OnTest_NotVoid(TestEvent evt) => 0;
public void HandleEvent(TestEvent evt)
{
EventCounter++;
}
protected override void OnEvent(TestEvent @event)
{
ReceivedEvents.Add(@event);
}
public void CreatedDateIsGenerated()
{
var integrationEvent = new TestEvent();
Assert.Equal(DateTime.UtcNow, integrationEvent.CreationDate, TimeSpan.FromSeconds(1));
}
public void InvokeEvent()
{
TestEvent.Raise(this, new TestEventArgs());
}
private void RecordEvent(TestEvent e)
{
this._eventStore.RecordMessage("testStream", new ImmutableEnvelope(Guid.NewGuid().ToString(), DateTime.UtcNow, e, new MessageAttribute[0]));
}
void OnTestEvent(TestEvent e)
{
Debug.Log(e.text);
}
public void InvokeWithoutSender()
{
TestEvent.Raise(null, new TestEventArgs());
}
public void InvokeEvent()
{
TestEvent.Execute(this, EventArgs.Empty);
}
public void Fire()
{
TestEvent?.Invoke(null, new TestClass2());
}
public async Task append_to_stream_should_fail_with_not_supported_exception()
{
const string stream = "append_to_stream_should_fail_with_not_supported_exception";
await AssertEx.ThrowsAsync <OperationNotSupportedException>(
() => _conn.AppendToStreamAsync(stream, ExpectedVersion.Any, TestEvent.NewTestEvent()));
}
private void OnTestEvent(TestEvent @event)
{
}
public void SuccessorEvent(TestEvent evt)
{
}
public override void RegisterEvent(TestEvent registerEvent)
{
registerEvent("SetActivityPermission", RequestActivityPermission);
registerEvent("RequestActivity", RequestActivity);
registerEvent("RemoveRunning", RemoveRunning);
}
public void FireTestEvent(int item)
{
TestEvent?.Invoke(item);
}
public void Verify(TestEvent e)
{
Assert.That(_expectations, Does.ContainKey(e.TestName), $"The test {e.TestName} is not in the dictionary.");
_expectations[e.TestName].Verify(e);
}
public void OnTestEvent() => TestEvent?.Invoke(this, EventArgs.Empty);
