public void StoreEmptyId()
{
var theEvent = new FakeEvent();
var storage = new MemoryStorage();
Assert.Throws<ArgumentException>(() => storage.Hold(Guid.Empty, theEvent));
}
public void SagaContextRequired()
{
var saga = new FakeSaga();
var e = new FakeEvent();
Assert.Throws<InvalidOperationException>(() => saga.Handle(e));
}
public void CanShortCircuitAccessToOriginHeader()
{
var e = new FakeEvent();
var headers = new HeaderCollection(new[] { new Header(Header.Origin, "MyOrigin", checkReservedNames: false) });
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Equal("MyOrigin", e.GetOrigin());
}
public void ReturnHeadersFromEventContextIfNotNull()
{
var e = new FakeEvent();
var headers = new HeaderCollection(Enumerable.Empty<Header>());
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Same(headers, e.Headers);
}
public void ReturnIdFromEventContextIfNotNull()
{
var e = new FakeEvent();
var aggregateId = GuidStrategy.NewGuid();
using (new EventContext(aggregateId, HeaderCollection.Empty, e))
Assert.Equal(aggregateId, e.FakeId);
}
public void EventWrapper_GetEventData_Should_Throw_ArgumentException_If_EventType_IsNot_The_Same()
{
var ev = new FakeEvent("value");
var wrapper = EventWrapper.Wrap(ev);
var ex = Assert.Throws<ArgumentException>(() => wrapper.GetEventData(typeof(AnotherEvent)));
Assert.Equal("The type does not correspond to the saved type", ex.Message);
}
public void DeleteCorrectId()
{
var guid = Guid.NewGuid();
var theEvent = new FakeEvent();
var storage = new MemoryStorage();
storage.Hold(guid, theEvent);
storage.Delete(guid);
}
public void CanShortCircuitAccessToTimestampHeader()
{
var now = DateTime.UtcNow;
var e = new FakeEvent();
var headers = new HeaderCollection(new[] { new Header(Header.Timestamp, now.ToString(DateTimeFormat.RoundTrip), checkReservedNames: false) });
using (new EventContext(GuidStrategy.NewGuid(), headers, e))
Assert.Equal(now, e.GetTimestamp());
}
public override void Context()
{
base.Context();
SubscriptionManager.subscribe<FakeEvent>(x =>
{
_wasCalled = true;
_localFakeEvent = x;
}, null, null);
}
public void EventWrapper_Should_Deserialize_FakeEvent()
{
var ev = new FakeEvent("value");
var wrapper = EventWrapper.Wrap(ev);
var deserialized = wrapper.GetEventData(Type.GetType(wrapper.EventType));
Assert.Equal(typeof(FakeEvent), deserialized.GetType());
Assert.Equal(ev.ToString(), deserialized.ToString());
}
public void LoadCorrectId()
{
var guid = Guid.NewGuid();
var theEvent = new FakeEvent();
var storage = new MemoryStorage();
storage.Hold(guid, theEvent);
var result = storage.Release(guid);
Assert.Same(theEvent, result.FirstOrDefault());
}
public void DoNotDispatchUndispatchedCommitsIfNotMarkingDispatched()
{
var e = new FakeEvent();
var commit = new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, new EventCollection(new Event[] { e }));
eventStore.Setup(mock => mock.GetUndispatched()).Returns(new[] { commit });
Assert.NotNull(new EventDispatcher(eventStore.Object, eventPublisher.Object, new EventStoreSettings { MarkDispatched = false }));
eventPublisher.Verify(mock => mock.Publish(HeaderCollection.Empty, It.IsAny<EventEnvelope>()), Times.Never());
}
public void CanTolerateTransientExceptions()
{
var execution = 0;
var e = new FakeEvent();
var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { if (++execution == 1) { throw new ConcurrencyException(); } }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler });
Processor.Process(message);
}
public void DispatchUndispatchedCommitsIfMarkingDispatched()
{
var e = new FakeEvent();
var commit = new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, new EventCollection(new Event[] { e }));
var dispatcher = new EventDispatcher(eventStore.Object, eventPublisher.Object, new EventStoreSettings { MarkDispatched = true });
eventStore.Setup(mock => mock.GetUndispatched()).Returns(new[] { commit });
dispatcher.EnsurePersistedCommitsDispatched();
eventPublisher.Verify(mock => mock.Publish(HeaderCollection.Empty, It.IsAny<EventEnvelope>()), Times.Once());
}
public void InvokeUnderlyingExecutorWithEventAndHandlerInstance()
{
var handled = false;
var e = new FakeEvent();
var handler = new Object();
var eventHandler = new EventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { handled = a == handler && b == e; }, () => handler);
using (var context = new EventContext(GuidStrategy.NewGuid(), HeaderCollection.Empty, e))
eventHandler.Handle(context);
Assert.True(handled);
}
public void CurrentContextSetToNewSagaContextInstance()
{
var e = new FakeEvent();
var sagaId = GuidStrategy.NewGuid();
using (var context = new SagaContext(typeof(Saga), sagaId, e))
{
Assert.Same(context, SagaContext.Current);
Assert.Equal(sagaId, SagaContext.Current.SagaId);
Assert.Equal(typeof(Saga), SagaContext.Current.SagaType);
Assert.Equal(e, SagaContext.Current.Event);
}
}
public void AggregateMustHaveAtLeastOneKnownApplyMethod()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny<Func<Type, Boolean>>())).Returns(new Type[0]);
var updater = new AggregateUpdater(typeLocator.Object);
var aggregate = new ImplicitStrategyAggregate();
var e = new FakeEvent();
var ex = Assert.Throws<MappingException>(() => updater.Apply(e, aggregate));
Assert.Equal(Exceptions.AggregateTypeUndiscovered.FormatWith(typeof(ImplicitStrategyAggregate)), ex.Message);
}
public void CanScheduleTimeoutIfNotScheduled()
{
var saga = new FakeSaga();
var e = new FakeEvent();
using (var context = new SagaContext(typeof(Saga), GuidStrategy.NewGuid(), e))
{
saga.Handle(e);
Assert.NotNull(saga.Timeout);
Assert.True(context.TimeoutChanged);
}
}
public void CurrentContextSetToNewEventContextInstance()
{
var @event = new FakeEvent();
var aggregateId = Guid.NewGuid();
using (var context = new EventContext(aggregateId, HeaderCollection.Empty, @event))
{
Assert.Same(context, EventContext.Current);
Assert.Same(@event, EventContext.Current.Event);
Assert.Equal(aggregateId, EventContext.Current.AggregateId);
Assert.Equal(HeaderCollection.Empty, EventContext.Current.Headers);
}
}
public void AppendToStream_HasNoSendableEvents_NotSendedToQueue()
{
// arrange
var(eventStore, fakeSender, fakeEfs) = CreateEventStore(false);
var fakeEvent = new FakeEvent {
Initiator = "some content",
};
// act
eventStore.AppendToStream <FakeIntegrationEvent>(true, "", fakeEvent);
// assert
fakeSender.Verify(x => x.SendMessage(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public void AppendToStream_WithoutCommit_UowNotCreated()
{
// arrange
var(eventStore, fakeSender, fakeEfs) = CreateEventStore(true);
var fakeEvent = new FakeEvent {
Initiator = "some initiator",
};
// act
eventStore.AppendToStream <FakeIntegrationEvent>(false, fakeEvent);
// assert
fakeEfs.Verify(x => x.Create(It.IsAny <IsolationLevel>(), It.IsAny <bool>(), It.IsAny <bool>()), Times.Never);
}
public void AppendToStreamWithoutQueueId_HasSendableEvents_SendedToQueueNotCalled()
{
// arrange
var(eventStore, fakeSender, fakeEfs) = CreateEventStore(true);
var fakeEvent = new FakeEvent {
Initiator = "some initiator",
};
// act
eventStore.AppendToStream <FakeIntegrationEvent>(true, fakeEvent);
// assert
fakeSender.Verify(x => x.SendMessage(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public void CheckCondEvent()
{
var obj1 = new Object1(); // { Position = new Position(new Point(0, 0), new Size(1, 1)) };
var obj2 = new Object2(); // { Position = new Position(new Point(1, 1), new Size(1, 1)) };
var condEvent = new FakeEvent();
var world = new World(
new FourWays(),
new GameObject[] { obj1, obj2 });
world.AddIConditionalEvent(condEvent);
world.Tick();
Assert.AreEqual(condEvent.ShouldCount, 1);
Assert.AreEqual(condEvent.HappenCount, 0);
}
public void persistent_messages_sent_to_multiple_peers_should_only_be_persisted_for_persistent_ones()
{
using (MessageId.PauseIdGeneration())
{
var message = new FakeEvent(123).ToTransportMessage(Self);
Transport.Send(message, new[] { AnotherPersistentPeer, AnotherNonPersistentPeer });
InnerTransport.ExpectExactly(new []
{
new TransportMessageSent(message).To(AnotherPersistentPeer, true).To(AnotherNonPersistentPeer, false).ToPersistence(PersistencePeer),
});
}
}
public void Dispatch()
{
var root = Substitute.For<IRootContainer>();
var child = Substitute.For<IScopedContainer>();
var handler = Substitute.For<ISubscribeOn<FakeEvent>>();
root.CreateScope().Returns(child);
child.ResolveAll<ISubscribeOn<FakeEvent>>().Returns(new[] {handler});
var theEvent = new FakeEvent();
var dispatcher = new IocDispatcher(root);
dispatcher.Dispatch(theEvent);
handler.Received().Handle(theEvent);
}
public void should_only_forward_replayed_messages_during_replay_phase()
{
Transport.Start();
var transportMessageToForward = new FakeCommand(123).ToTransportMessage();
var normalTransportMessage = new FakeEvent(123).ToTransportMessage();
var replayedTransportMessage = transportMessageToForward.ToReplayedTransportMessage(ReplayId);
InnerTransport.RaiseMessageReceived(replayedTransportMessage);
InnerTransport.RaiseMessageReceived(normalTransportMessage);
MessagesForwardedToBus.Count.ShouldEqual(1);
MessagesForwardedToBus.Single().Id.ShouldEqual(transportMessageToForward.Id);
}
public void should_dispatch_to_event_handler()
{
LoadAndStartDispatcher();
IMessage receivedMessage = null;
_messageDispatcher.AddInvoker(new DynamicMessageHandlerInvoker(x => receivedMessage = x, typeof(FakeEvent), new[] { BindingKey.Empty }));
var evt = new FakeEvent(123);
DispatchAndWaitForCompletion(evt);
receivedMessage.ShouldEqual(evt);
}
public void DispatchUndispatchedCommitsIfMarkingDispatched()
{
var e = new FakeEvent();
var commit = new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, new EventCollection(new Event[] { e }));
var dispatcher = new EventDispatcher(eventStore.Object, eventPublisher.Object, new EventStoreSettings {
MarkDispatched = true
});
eventStore.Setup(mock => mock.GetUndispatched()).Returns(new[] { commit });
dispatcher.EnsurePersistedCommitsDispatched();
eventPublisher.Verify(mock => mock.Publish(HeaderCollection.Empty, It.IsAny <EventEnvelope>()), Times.Once());
}
public void should_publish_event_with_message_context()
{
MessageContext.Current.ShouldBeNull();
var message = new FakeEvent(1);
MessageContext context = null;
_busMock.Setup(x => x.Publish(message)).Callback(() => context = MessageContext.Current);
_bus.Publish(message);
MessageContext.Current.ShouldBeNull();
context.ShouldEqual(_context);
}
public void should_serialize_persist_message_command()
{
var transportMessage = new FakeEvent(42).ToTransportMessage(_self);
var persistMessageCommand = new PersistMessageCommand(transportMessage, new PeerId("Abc.Testing.A"), new PeerId("Abc.Testing.B"));
var serializedTransportMessage = _messageSerializer.ToTransportMessage(persistMessageCommand, _self.Id, _self.EndPoint);
serializedTransportMessage.Id.ShouldEqual(transportMessage.Id);
serializedTransportMessage.MessageTypeId.ShouldEqual(transportMessage.MessageTypeId);
serializedTransportMessage.Content.ShouldEqual(transportMessage.Content);
serializedTransportMessage.Originator.ShouldEqual(transportMessage.Originator);
serializedTransportMessage.Environment.ShouldEqual(transportMessage.Environment);
serializedTransportMessage.WasPersisted.ShouldEqual(transportMessage.WasPersisted);
serializedTransportMessage.PersistentPeerIds.ShouldBeEquivalentTo(persistMessageCommand.Targets);
}
public void CanClearTimeoutIfScheduled()
{
var saga = new FakeSaga {
Timeout = SystemTime.Now
};
var e = new FakeEvent();
using (var context = new SagaContext(typeof(Saga), GuidStrategy.NewGuid(), e))
{
saga.Handle(e);
Assert.Null(saga.Timeout);
Assert.True(context.TimeoutChanged);
}
}
public void CannotScheduleTimeoutIfAlreadyScheduled()
{
var saga = new FakeSaga {
CorrelationId = GuidStrategy.NewGuid(), Timeout = SystemTime.Now
};
var e = new FakeEvent();
using (var context = new SagaContext(typeof(Saga), GuidStrategy.NewGuid(), e))
{
var ex = Assert.Throws <InvalidOperationException>(() => saga.Handle(e));
Assert.Equal(Exceptions.SagaTimeoutAlreadyScheduled.FormatWith(saga.GetType(), saga.CorrelationId), ex.Message);
Assert.False(context.TimeoutChanged);
}
}
public void Read_RecoversConcreteTypeProperties()
{
//Arrange
string json = serializer.Serialize(@event);
//Act
Event deserializedEvent = serializer.Deserialize(json);
FakeEvent deserializedFakeEvent = (FakeEvent)deserializedEvent;
//Assert
deserializedFakeEvent.AggregateId.Should().Be(@event.AggregateId);
deserializedFakeEvent.Id.Should().Be(@event.Id);
deserializedFakeEvent.Date.Should().Be(@event.Date);
deserializedFakeEvent.Message.Should().Be(@event.Message);
}
public void EventStoreGetsNewEvents()
{
var history = new Event[]
{
new FakeEvent(Guid.NewGuid(), "First"),
new FakeEvent(Guid.NewGuid(), "Second"),
};
var newEvent = new FakeEvent(Guid.NewGuid(), "Any");
Given(history);
Published(newEvent);
Assert.Equal(history.Concat(new [] { newEvent }).ToArray(), EventStore.History);
}
public void RetrieveEventHandlersBasedOnEventType()
{
var e = new FakeEvent();
var eventHandler1 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object());
var eventHandler2 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler1, eventHandler2 });
Processor.Process(message);
Assert.True(eventHandler1.Handled);
Assert.True(eventHandler2.Handled);
}
public void should_dispatch_to_event_handler()
{
IMessage receivedMessage = null;
var predicateBuilder = new Mock <IBindingKeyPredicateBuilder>();
predicateBuilder.Setup(x => x.GetPredicate(It.IsAny <Type>(), It.IsAny <BindingKey>())).Returns(_ => true);
_messageDispatcher.AddInvoker(new DynamicMessageHandlerInvoker(x => receivedMessage = x, typeof(FakeEvent), new [] { BindingKey.Empty }, predicateBuilder.Object));
var evt = new FakeEvent(123);
DispatchAndWaitForCompletion(evt);
receivedMessage.ShouldEqual(evt);
}
public override void Context()
{
base.Context();
SubscriptionManager.subscribe <FakeEvent>(
m =>
{
//stuff is happening
Thread.Sleep(2000);
_wasCalled = true;
_localFakeEvent = m;
Console.WriteLine("event complete");
},
null,
null);
}
public void RetrieveEventHandlersBasedOnEventType()
{
var e = new FakeEvent();
var eventHandler1 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object());
var eventHandler2 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler1, eventHandler2 });
Processor.Process(message);
Assert.True(eventHandler1.Handled);
Assert.True(eventHandler2.Handled);
}
public void persistent_messages_sent_to_multiple_peers_should_only_be_persisted_for_persistent_ones()
{
using (MessageId.PauseIdGeneration())
{
var message = new FakeEvent(123).ToTransportMessage(Self);
var persistCommand = new PersistMessageCommand(message, new[] { AnotherPersistentPeer.Id }).ToTransportMessage(Self);
Transport.Send(message, new[] { AnotherPersistentPeer, AnotherNonPersistentPeer });
InnerTransport.ExpectExactly(
new TransportMessageSent(message, new[] { AnotherPersistentPeer, AnotherNonPersistentPeer }),
new TransportMessageSent(persistCommand, new[] { PersistencePeer })
);
}
}
public void Dispatch()
{
var root = Substitute.For <IRootContainer>();
var child = Substitute.For <IScopedContainer>();
var handler = Substitute.For <ISubscribeOn <FakeEvent> >();
root.CreateScope().Returns(child);
child.ResolveAll <ISubscribeOn <FakeEvent> >().Returns(new[] { handler });
var theEvent = new FakeEvent();
var dispatcher = new IocDispatcher(root);
dispatcher.Dispatch(theEvent);
handler.Received().Handle(theEvent);
}
public virtual async Task CheckAggregateExists()
{
_logger.LogInformation("Running CheckAggregateExists");
var @event = FakeEvent.Create();
var store = CreateInstance();
var exists = await store.CheckAggregateExists <FakeAggregate>(@event.AggregateId).ConfigureAwait(false);
exists.Should().BeFalse();
await store.SaveEventsAsync <FakeAggregate>(@event.AggregateId, new IDomainEvent[] { @event }, 0).ConfigureAwait(false);
exists = await store.CheckAggregateExists <FakeAggregate>(@event.AggregateId).ConfigureAwait(false);
exists.Should().BeTrue();
}
public void should_not_fail_when_publishing_a_message_to_an_unknown_peer()
{
using (MessageId.PauseIdGeneration())
{
// Arrange
var message = new FakeEvent(42);
_bus.Start();
// Act
Assert.DoesNotThrow(() => _bus.Publish(message, new PeerId("Abc.Unknown.0")));
// Assert
_transport.Messages.ShouldBeEmpty();
}
}
public void should_publish_a_message()
{
using (MessageId.PauseIdGeneration())
{
var message = new FakeEvent(456);
SetupPeersHandlingMessage <FakeEvent>(_peerUp);
var expectedTransportMessage = message.ToTransportMessage(_self);
_bus.Publish(message);
var sentMessage = _transport.Messages.Single();
expectedTransportMessage.ShouldHaveSamePropertiesAs(sentMessage.TransportMessage);
var destination = sentMessage.Targets.Single();
destination.ShouldHaveSamePropertiesAs(_peerUp);
}
}
public void SetUp()
{
_testEvent = new FakeEvent();
_handler1 = MockRepository.GenerateMock<IEventHandler<FakeEvent>>();
_handler2 = MockRepository.GenerateMock<IEventHandler<SourcedEvent>>();
_handler3 = MockRepository.GenerateMock<IEventHandler<IEvent>>();
_container = new WindsorContainer();
_container.Register(
Component.For<IWindsorContainer>().Instance(_container),
Component.For<IEventHandler<FakeEvent>>().Instance(_handler1),
Component.For<IEventHandler<SourcedEvent>>().Instance(_handler2),
Component.For<IEventHandler<IEvent>>().Instance(_handler3),
Component.For<IEventBus>().ImplementedBy<WindsorInProcessEventBus>());
var svc = _container.Resolve<IEventBus>();
svc.Publish(_testEvent);
}
public void CannotScheduleTimeoutIfTimeoutNotHandled()
{
var saga = new FakeSagaWithoutTimeout()
{
CorrelationId = GuidStrategy.NewGuid()
};
var e = new FakeEvent();
using (var context = new SagaContext(saga.GetType(), GuidStrategy.NewGuid(), e))
{
var ex = Assert.Throws <InvalidOperationException>(() => saga.Handle(e));
Assert.Equal(Exceptions.SagaTimeoutNotHandled.FormatWith(saga.GetType()), ex.Message);
Assert.False(context.TimeoutChanged);
}
}
public void CanRescheduleIfTimeoutAlreadyScheduled()
{
var e = new FakeEvent();
var timeout = SystemTime.Now;
var saga = new FakeSaga {
Timeout = timeout
};
using (var context = new SagaContext(typeof(Saga), GuidStrategy.NewGuid(), e))
{
saga.Handle(e);
Assert.NotEqual(timeout, saga.Timeout);
Assert.True(context.TimeoutChanged);
}
}
public void should_handle_event_locally()
{
var message = new FakeEvent(1);
var handled = false;
SetupDispatch(message, x => handled = true);
SetupPeersHandlingMessage <FakeEvent>(_self, _peerUp);
_bus.Publish(message);
handled.ShouldBeTrue();
var sentMessage = _transport.Messages.Single();
sentMessage.Targets.Single().ShouldEqual(_peerUp);
}
public void CanTolerateTransientExceptions()
{
var execution = 0;
var e = new FakeEvent();
var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { if (++execution == 1)
{
throw new ConcurrencyException();
}
}, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler });
Processor.Process(message);
}
public void WhenCreateMessageCalledWithEventThenShouldPopulateBodyFromEvent()
{
using (var scope = ServiceProvider.CreateScope())
{
var factory = scope.ServiceProvider.GetRequiredService <IMessageFactory>();
var serializer = scope.ServiceProvider.GetRequiredService <IEventSerializer>();
var @event = new FakeEvent();
var notification = new EventNotification <FakeEvent>(streamId: @event.Subject, @event: @event, correlationId: null, causationId: null, timestamp: @event.Timestamp, userId: null);
var body = Encoding.UTF8.GetBytes(serializer.Serialize(@event));
var result = factory.CreateMessage(notification);
result.Body.Should().Equal(body);
result.Size.Should().Be(body.Length);
}
}
public void ESTestProjections()
{
FakeEventDto evDto = new FakeEventDto();
evDto.TestString = "Testing";
FakeEvent fc = evDto.ProjectAsEvent <FakeEventDto, FakeEvent>();
Assert.AreEqual <string>(fc.TestString, evDto.TestString, "Same Projection Id To DTO");
fc.TestString = "String changed";
evDto = fc.ProjectAsDto <FakeEvent, FakeEventDto>();
Assert.AreEqual <string>(fc.TestString, evDto.TestString, "Same Projection Id From DTO");
fc.TestString = "Testing collection";
List <FakeEvent> events = new List <FakeEvent>();
events.Add(fc);
var dtos = new List <FakeEventDto>(events.ProjectAsDto <FakeEvent, FakeEventDto>());
Assert.AreEqual <string>(events[0].TestString, dtos[0].TestString, "Same Projection Id To Collection DTO");
evDto.TestString = "String collection changed";
List <FakeEventDto> fakeDTOs = new List <FakeEventDto>();
fakeDTOs.Add(evDto);
List <FakeEvent> fakeCommands = new List <FakeEvent>(fakeDTOs.ProjectAsEvent <FakeEventDto, FakeEvent>());
Assert.AreEqual <string>(events[0].TestString, dtos[0].TestString, "Same Projection Id From Collection DTO");
var fcdto = fc.ProjectAsDto <FakeEvent, FakeEventDto>(CustomConvertToDTO);
Assert.AreEqual <string>(fcdto.TestString, "As Dto", "Same custom Projection string From DTO");
fc = fcdto.ProjectAsEvent <FakeEventDto, FakeEvent>(CustomConvertToCommand);
Assert.AreEqual <string>(fc.TestString, "As Event", "Same custom Projection string From command");
dtos = new List <FakeEventDto>(events.ProjectAsDto <FakeEvent, FakeEventDto>(CustomConvertToDTO));
Assert.AreEqual <string>(dtos[0].TestString, "As Dto", "Same custom Projection string From DTO");
fakeCommands = new List <FakeEvent>(fakeDTOs.ProjectAsEvent <FakeEventDto, FakeEvent>(CustomConvertToCommand));
Assert.AreEqual <string>(fakeCommands[0].TestString, "As Event", "Same custom Projection Id From Collection DTO");
}
public void SetUp()
{
_testEvent = new FakeEvent();
_handler1 = MockRepository.GenerateMock <IEventHandler <FakeEvent> >();
_handler2 = MockRepository.GenerateMock <IEventHandler <SourcedEvent> >();
_handler3 = MockRepository.GenerateMock <IEventHandler <IEvent> >();
_container = new WindsorContainer();
_container.Register(
Component.For <IWindsorContainer>().Instance(_container),
Component.For <IEventHandler <FakeEvent> >().Instance(_handler1),
Component.For <IEventHandler <SourcedEvent> >().Instance(_handler2),
Component.For <IEventHandler <IEvent> >().Instance(_handler3),
Component.For <IEventBus>().ImplementedBy <WindsorInProcessEventBus>());
var svc = _container.Resolve <IEventBus>();
svc.Publish(_testEvent);
}
public void RaiseMaintainsEventOrder()
{
FakeEvent e1 = new FakeEvent(), e2 = new FakeEvent(), e3 = new FakeEvent();
using (var context = new CommandContext(Guid.NewGuid(), HeaderCollection.Empty, CommandEnvelope.Empty))
{
context.Raise(e1);
context.Raise(e2);
context.Raise(e3);
var raisedEvents = context.GetRaisedEvents();
Assert.Equal(3, raisedEvents.Count);
Assert.Same(e1, raisedEvents[0]);
Assert.Same(e2, raisedEvents[1]);
Assert.Same(e3, raisedEvents[2]);
}
}
public virtual async Task SaveThrowsErrorIfVersionsNotMatch()
{
_logger.LogInformation("Running SaveThrowsErrorIfVersionsNotMatch");
var store = CreateInstance();
await Task.Delay(0).ConfigureAwait(false);
var event1 = FakeEvent.Create();
await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { event1 }, 0).ConfigureAwait(false);
var event2 = FakeEvent.Create();
Func <Task> f = async() => { await store.SaveEventsAsync <FakeAggregate>(event1.AggregateId, new IDomainEvent[] { event2 }, 42).ConfigureAwait(false); };
f.Should().Throw <ConcurrencyException>(); //.WithInnerException<ConcurrencyException>();
}
protected Boolean OnFakeEvent(FakeEvent e)
{
return false;
}
protected void OnFakeEvent(FakeEvent e)
{
}
public void WillTimeoutEventuallyIfCannotExecuteHandler()
{
var e = new FakeEvent();
var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { throw new ConcurrencyException(); }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
SystemTime.ClearOverride();
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler });
Assert.Throws<TimeoutException>(() => Processor.Process(message));
}
protected void Apply(FakeEvent e)
{
}
private void OnFakeEvent(FakeEvent e)
{
}
protected void OnFakeEvent(FakeEvent e1, FakeEvent e2)
{
}
public void Handle(FakeEvent e)
{
}
