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 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 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) { }