public void Should_publish_events()
{
var fakeCommand = new FakeCommand();
var fakeEvent = new FakeEvent();
var commandHandlerMock = new Mock <ICommandHandler <ICommand> >();
commandHandlerMock.Setup(x => x.Handle(fakeCommand)).Returns(new List <IDomainEvent> {
fakeEvent
});
var resolverMock = new Mock <IResolver>();
resolverMock.Setup(x => x.Resolve <ICommandHandler <ICommand> >()).Returns(commandHandlerMock.Object);
var eventPublisherMock = new Mock <IEventPublisher>();
eventPublisherMock.Setup(x => x.Publish(fakeEvent));
var eventStoreMock = new Mock <IEventStore>();
var commandSender = new CommandSender(resolverMock.Object,
eventPublisherMock.Object,
eventStoreMock.Object);
commandSender.Send <ICommand, IAggregateRoot>(fakeCommand);
commandHandlerMock.Verify(x => x.Handle(fakeCommand), Times.Once);
eventPublisherMock.Verify(x => x.Publish(It.IsAny <IDomainEvent>()), Times.Once);
}
private void WhenISendACommandIntoTheCluster(FakeCommand command)
{
var p = _peers.Peers.First();
var json = JsonConvert.SerializeObject(command, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
});
var httpContent = new StringContent(json);
httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token.AccessToken);
var response = httpClient.PostAsync($"{p.HostAndPort}/administration/raft/command", httpContent).GetAwaiter().GetResult();
response.EnsureSuccessStatusCode();
var content = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
var result = JsonConvert.DeserializeObject <OkResponse <FakeCommand> >(content);
result.Command.Value.ShouldBe(command.Value);
}
//dirty sleep to make sure command replicated...
var stopwatch = Stopwatch.StartNew();
while (stopwatch.ElapsedMilliseconds < 10000)
{
}
}
public void Dispatch_CommandThrowsCommandException_ShouldHandleExceptionAndRethrow(
[Frozen] Mock<IContainer> container,
[Frozen] Mock<ICommandHandler<ICommand>> commandHandler,
FakeCommand command,
CommandDispatcher dispatcher)
{
// Arrange
var commandException = new CommandException("Exception");
commandHandler.Setup(h => h.Handle(It.IsAny<FakeCommand>())).Throws(commandException);
var genericTypeName = typeof(ICommandHandler<FakeCommand>).FullName;
container.Setup(c => c.GetInstance(It.Is<Type>(t => t.FullName == genericTypeName)))
.Returns(commandHandler.Object);
var commandExceptionGenericTypeName = typeof(ICommandHandler<CommandException>).FullName;
container.Setup(c => c.GetInstance(It.Is<Type>(t => t.FullName == commandExceptionGenericTypeName)))
.Returns(commandHandler.Object);
// Act
Assert.Throws<CommandException>(() => dispatcher.Dispatch(command));
// Assert
commandHandler.Verify(t => t.Handle(command), Times.Once);
commandHandler.Verify(h => h.Handle(commandException), Times.Once);
}
public void CanHandleCommandIfVersionGreaterThanZero()
{
var aggregate = new FakeAggregate(version: 1);
var command = new FakeCommand();
aggregate.Handle(command);
}
public void should_send_MessageProcessingFailed_if_unable_to_deserialize_message()
{
SetupPeersHandlingMessage <MessageProcessingFailed>(_peerUp);
_bus.Start();
var command = new FakeCommand(123);
_messageSerializer.AddSerializationExceptionFor(command.TypeId(), "Serialization error");
using (SystemDateTime.PauseTime())
using (MessageId.PauseIdGeneration())
{
var transportMessage = command.ToTransportMessage();
var messageProcessingFailedBytes = new MessageProcessingFailed(null, null, null, DateTime.UtcNow, null).ToTransportMessage().Content;
_messageSerializer.AddSerializationFuncFor <MessageProcessingFailed>(x =>
{
x.FailingMessage.ShouldEqual(transportMessage);
x.ExceptionUtcTime.ShouldEqual(SystemDateTime.UtcNow);
x.ExceptionMessage.ShouldContain("Unable to deserialize message");
return(messageProcessingFailedBytes);
});
_transport.RaiseMessageReceived(transportMessage);
var processingFailedTransportMessage = new TransportMessage(MessageUtil.TypeId <MessageProcessingFailed>(), messageProcessingFailedBytes, _self);
_transport.ExpectExactly(new TransportMessageSent(processingFailedTransportMessage, _peerUp));
}
}
public void should_resolve_peer_using_basic_round_robin_for_different_commands()
{
// Arrange
var resolver = new RoundRobinPeerSelector();
var command1 = new FakeCommand(42);
var command1Peer1 = new Peer(new PeerId("command1peer1"), "endpoint1");
var command1Peer2 = new Peer(new PeerId("command1peer2"), "endpoint2");
var command1HandlingPeer = new[] { command1Peer1, command1Peer2 };
var command2 = new FakeInfrastructureCommand();
var command2Peer1 = new Peer(new PeerId("command2peer1"), "endpoint1");
var command2Peer2 = new Peer(new PeerId("command2peer2"), "endpoint2");
var command2HandlingPeer = new[] { command2Peer1, command2Peer2 };
// Act - Assert
var resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer1);
resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer2);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer1);
resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer1);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer2);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer1);
}
public void CanNotHandleCommandIfVersionEqualsZero()
{
var aggregate = new FakeAggregate(version: 0);
var command = new FakeCommand();
Assert.Throws <InvalidOperationException>(() => aggregate.Handle(command));
}
public void CanHandleCommandIfVersionGreaterThanZero()
{
var aggregate = new FakeAggregate(version: 1);
var command = new FakeCommand();
aggregate.Handle(command);
}
public void CanHandleCommandIfVersionEqualsZero()
{
var aggregate = new FakeAggregate(version: 0);
var command = new FakeCommand();
aggregate.Handle(command);
}
public async Task TrackedCommandBus_SendCommandAsyncPersistsChangesToContext()
{
var command = new FakeCommand();
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var sut = new TrackedCommandBus(
Mock.Of <IServiceProvider>(),
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IMessageSerializer>(),
Mock.Of <ILogger>(),
context);
await sut.SendCommandAsync(command);
}
using (var context = new InfrastructureContext(options))
{
var commandEntity = await context.Commands.FindAsync(command.MessageId);
Assert.NotNull(commandEntity);
Assert.Equal(command.MessageId, commandEntity.Id);
}
}
public async Task Send_FakeCommand_ShouldGoThroughHandlersCorrectly()
{
// Arrange
var serviceProvider = new ServiceCollection()
.AddLiteBus(configuration =>
{
configuration.AddCommands(builder =>
{
// Global Handlers
builder.RegisterPreHandler <FakeGlobalCommandPreHandler>();
builder.RegisterPostHandler <FakeGlobalCommandPostHandler>();
// Fake Command Handlers
builder.RegisterPreHandler <FakeCommandPreHandler>();
builder.RegisterHandler <FakeCommandHandlerWithoutResult>();
builder.RegisterPostHandler <FakeCommandPostHandler>();
});
})
.BuildServiceProvider();
var commandMediator = serviceProvider.GetRequiredService <ICommandMediator>();
var command = new FakeCommand();
// Act
var commandResult = await commandMediator.SendAsync(command);
// Assert
commandResult.CorrelationId.Should().Be(command.CorrelationId);
command.ExecutedTypes.Should().HaveCount(5);
command.ExecutedTypes[0].Should().Be <FakeGlobalCommandPreHandler>();
command.ExecutedTypes[1].Should().Be <FakeCommandPreHandler>();
command.ExecutedTypes[2].Should().Be <FakeCommandHandlerWithoutResult>();
command.ExecutedTypes[3].Should().Be <FakeCommandPostHandler>();
command.ExecutedTypes[4].Should().Be <FakeGlobalCommandPostHandler>();
}
protected override void Establish_context()
{
base.Establish_context();
this.command = new FakeCommand {
Id = Guid.NewGuid()
};
}
public async Task WhenSavingQueryThenShouldSaveToUnderlyingStorage()
{
var services = new ServiceCollection();
services.AddOpenEventSourcing()
.AddEntityFrameworkCoreInMemory()
.AddJsonSerializers()
.Services
.AddLogging(configure => configure.AddConsole());
var serviceProvider = services.BuildServiceProvider();
var dbContext = serviceProvider.GetRequiredService <IDbContextFactory>().Create();
var store = serviceProvider.GetRequiredService <ICommandStore>();
var serializer = serviceProvider.GetRequiredService <IQuerySerializer>();
var command = new FakeCommand();
await store.SaveAsync(command);
dbContext.Commands.Count(c => c.Id == command.Id).Should().Be(1);
var result = await dbContext.Commands.FirstAsync(c => c.Id == command.Id);
result.Id.Should().Be(command.Id);
result.Timestamp.Should().Be(command.Timestamp);
result.CorrelationId.Should().Be(command.CorrelationId);
result.UserId.Should().Be(command.Actor);
result.Name.Should().Be(command.GetType().Name);
result.Type.Should().Be(command.GetType().FullName);
result.Data.Should().Be(serializer.Serialize(command));
}
public void should_not_send_messages_to_persistence_twice_if_persistence_goes_up_and_down()
{
using (MessageId.PauseIdGeneration())
{
// Stopping persistence
InnerTransport.RaiseMessageReceived(new TransportMessage(MessageTypeId.PersistenceStopping, new MemoryStream(), PersistencePeer));
InnerTransport.Messages.Clear();
var ackedMessage = new FakeCommand(456).ToTransportMessage();
Transport.AckMessage(ackedMessage);
InnerTransport.AckedMessages.ShouldBeEmpty();
// starting persistence - should send enqueued messages
Transport.OnPeerUpdated(PersistencePeer.Id, PeerUpdateAction.Started);
InnerTransport.ExpectExactly(new[]
{
new TransportMessageSent(new MessageHandled(ackedMessage.Id).ToTransportMessage(Self), PersistencePeer)
});
// Stopping persistence again
InnerTransport.RaiseMessageReceived(new TransportMessage(MessageTypeId.PersistenceStopping, new MemoryStream(), PersistencePeer));
InnerTransport.Messages.Clear();
// starting persistence again - should not have anything to send
Transport.OnPeerUpdated(PersistencePeer.Id, PeerUpdateAction.Started);
InnerTransport.ExpectNothing();
}
}
public void CanHandleCommandIfVersionEqualsZero()
{
var aggregate = new FakeAggregate(version: 0);
var command = new FakeCommand();
aggregate.Handle(command);
}
public void CanNotHandleCommandIfVersionEqualsZero()
{
var aggregate = new FakeAggregate(version: 0);
var command = new FakeCommand();
Assert.Throws<InvalidOperationException>(() => aggregate.Handle(command));
}
protected override void EstablishContext()
{
base.EstablishContext();
CommandRunner = A.Fake <IRunCommand <FakeCommand> >();
CommandHandler = new CommandHandler <FakeCommand>(CommandRunner);
Command = new FakeCommand();
}
public void Query_returns_results()
{
// Arrange
var rows = PersonList;
var table = new FakeTable <Person>(rows);
var readerResult = new ReaderCommandResult
{
Result = new FakeDataReader(table)
};
var command = new FakeCommand(readerResult);
Connection.Setup(command);
// Act
var results = Connection.Query <Person>("SELECT TOP 1 * FROM [person] WHERE [Id] = {0}", 1)
.ToList();
// Assert
results.ShouldNotBeNull();
results.Count.ShouldEqual(rows.Count);
results.Skip(0).First().Id.ShouldEqual(rows.Skip(0).First().Id);
results.Skip(0).First().Name.ShouldEqual(rows.Skip(0).First().Name);
results.Skip(0).First().DateOfBirth.ShouldEqual(rows.Skip(0).First().DateOfBirth);
results.Skip(1).First().Id.ShouldEqual(rows.Skip(1).First().Id);
results.Skip(1).First().Name.ShouldEqual(rows.Skip(1).First().Name);
results.Skip(1).First().DateOfBirth.ShouldEqual(rows.Skip(1).First().DateOfBirth);
}
public void should_not_block_when_hitting_high_water_mark()
{
var senderTransport = CreateAndStartZmqTransport();
senderTransport.SocketOptions.SendHighWaterMark = 3;
senderTransport.SocketOptions.SendTimeout = 50.Milliseconds();
senderTransport.SocketOptions.SendRetriesBeforeSwitchingToClosedState = 2;
var receviedMessages = new List <TransportMessage>();
var upReceiverTransport = CreateAndStartZmqTransport(onMessageReceived: receviedMessages.Add);
var upReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Up"), upReceiverTransport.InboundEndPoint);
var downReceiverTransport = CreateAndStartZmqTransport();
var downReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Down"), downReceiverTransport.InboundEndPoint);
downReceiverTransport.Stop();
for (var i = 1; i <= 10; ++i)
{
var message = new FakeCommand(i).ToTransportMessage();
senderTransport.Send(message, new[] { upReceiver, downReceiver });
var expectedMessageCount = i;
Wait.Until(() => receviedMessages.Count == expectedMessageCount, 500.Milliseconds(), "Failed to send message after " + i + " successful sent");
}
}
public void cant_operate_if_supplied_argument_do_not_specify_a_name()
{
var sut = new FakeCommand();
Action actual = () => CommandExtensions.AddParameter(sut, null, "arne");
actual.Should().Throw <ArgumentNullException>();
}
public async Task Process_WithPrepareContextNotificationHandler_ShouldCallPrepareContextNotificationHandler()
{
// Arrange
var serviceScopeMock = new Mock <IServiceScope>();
var serviceScopeFactoryMock = NewServiceScopeFactoryMock;
serviceScopeFactoryMock.Setup(x => x.CreateScope()).Returns(() => serviceScopeMock.Object);
var commandHandlingContext = new CommandHandlingContext();
serviceScopeMock
.Setup(x => x.GetService(typeof(CommandHandlingContext)))
.Returns(commandHandlingContext);
serviceScopeMock
.Setup(x => x.GetService(typeof(IEnumerable <ICommandHandler <FakeCommand> >)))
.Returns(new[] { new Mock <ICommandHandler <FakeCommand> >().Object });
var command = new FakeCommand();
var prepareContextMock = new Mock <Action <object, CommandHandlingContext> >();
var notificationHandlers = new CommandProcessorNotificationHandlers {
PrepareContext = prepareContextMock.Object
};
var processor = new CommandProcessor(serviceScopeFactoryMock.Object, NewEventStoreMock.Object, NewEventDispatcherMock.Object, notificationHandlers);
// Act
await processor.Process(command);
// Assert
prepareContextMock.Verify(x => x(command, commandHandlingContext), Times.Once);
prepareContextMock.Verify(x => x(It.IsAny <object>(), It.IsAny <CommandHandlingContext>()), Times.Once);
}
public void FromScheduledEnvelope_generates_PendingScheduledCommand_correctly()
{
// Arrange
var random = new Random();
var processManager = new FakeProcessManager();
var messageId = Guid.NewGuid();
var correlationId = Guid.NewGuid();
var message = new FakeCommand
{
Int32Value = random.Next(),
StringValue = Guid.NewGuid().ToString(),
};
var scheduledEnvelope =
new ScheduledEnvelope(
new Envelope(messageId, message, correlationId: correlationId),
DateTime.Now.AddTicks(random.Next()));
var serializer = new JsonMessageSerializer();
// Act
var actual = PendingScheduledCommand.FromScheduledEnvelope(processManager, scheduledEnvelope, serializer);
// Assert
actual.ProcessManagerType.Should().Be(typeof(FakeProcessManager).FullName);
actual.ProcessManagerId.Should().Be(processManager.Id);
actual.MessageId.Should().Be(messageId);
actual.CorrelationId.Should().Be(correlationId);
actual.CommandJson.Should().Be(serializer.Serialize(message));
actual.ScheduledTimeUtc.Should().Be(scheduledEnvelope.ScheduledTimeUtc);
}
public void should_not_send_messages_to_persistence_twice_if_persistence_goes_up_and_down()
{
using (MessageId.PauseIdGeneration())
{
PeerDirectory.Setup(directory => directory.GetPeersHandlingMessage(new MessageBinding(new MessageTypeId(typeof(PersistMessageCommand)), BindingKey.Empty)))
.Returns(new List <Peer> {
PersistencePeer
});
// Stopping persistence
InnerTransport.RaiseMessageReceived(new TransportMessage(MessageTypeId.PersistenceStopping, new byte[0], PersistencePeer));
InnerTransport.Messages.Clear();
var ackedMessage = new FakeCommand(456).ToTransportMessage();
Transport.AckMessage(ackedMessage);
InnerTransport.AckedMessages.ShouldBeEmpty();
// starting persistence - should send enqueued messages
Transport.OnPeerUpdated(PersistencePeer.Id, PeerUpdateAction.Started);
InnerTransport.ExpectExactly(new[]
{
new TransportMessageSent(new MessageHandled(ackedMessage.Id).ToTransportMessage(Self), PersistencePeer)
});
// Stopping persistence again
InnerTransport.RaiseMessageReceived(new TransportMessage(MessageTypeId.PersistenceStopping, new byte[0], PersistencePeer));
InnerTransport.Messages.Clear();
// starting persistence again - should not have anything to send
Transport.OnPeerUpdated(PersistencePeer.Id, PeerUpdateAction.Started);
InnerTransport.ExpectNothing();
}
}
public void RedoUndo()
{
var command = new FakeCommand();
var executor = new CommandExecutor();
executor.Redo();
executor.Execute<FakeCommand>((configuration) =>
{
configuration.OnSuccess((s) => { });
configuration.OnProgress((p) => { });
configuration.OnFailure((f) => { });
configuration.ConstructUsing(() => command);
});
Assert.True(executor.CanUndo);
Assert.False(executor.CanRedo);
executor.Undo();
Assert.False(executor.CanUndo);
Assert.True(executor.CanRedo);
executor.Redo();
Assert.True(executor.CanUndo);
Assert.False(executor.CanRedo);
}
public async Task PublishAsync()
{
var command = new FakeCommand()
{
UserId = 1,
AggregateRootId = Guid.NewGuid()
};
var @event = new FakeEvent();
_resolver.Setup(x => x.Resolve <ICommandHandler <FakeCommand> >()).Returns(_handler.Object);
_handler.Setup(h => h.ExecuteAsync(command)).ReturnsAsync(new CommandResponse()
{
Events = new List <FakeEvent>()
{
@event
},
Result = new object()
});
_mapper.Setup(m => m.Map(It.IsAny <object>(), It.IsAny <Type>(), It.IsAny <Type>())).Returns(@event);
await _sender.SendAsync(command);
_publicsher.Verify(p => p.PublishAsync(@event), Times.Once);
Assert.Equal(command.Id, @event.CommandId);
Assert.Equal(command.UserId, @event.UserId);
Assert.Equal(command.AggregateRootId, @event.AggregateRootId);
}
public async Task Storage()
{
var command = new FakeCommand()
{
UserId = 1,
AggregateRootId = Guid.NewGuid()
};
var @event = new FakeEvent();
_resolver.Setup(x => x.Resolve <ICommandHandler <FakeCommand> >()).Returns(_handler.Object);
_handler.Setup(h => h.ExecuteAsync(command)).ReturnsAsync(new CommandResponse()
{
Events = new List <FakeEvent>()
{
@event
},
Result = new object()
});
_mapper.Setup(m => m.Map(It.IsAny <object>(), It.IsAny <Type>(), It.IsAny <Type>())).Returns(@event);
await _sender.SendAsync(command);
_store.Verify(p => p.SaveAsync(It.Is <StoreData>(d => d.AggregateRootId == command.AggregateRootId &&
d.Command == command)), Times.Once);
}
public void ExecuteError()
{
var configuration = new CommandConfiguration<FakeCommand>();
var success = false;
var progressCalled = false;
var coreExecuted = false;
var failExecuted = false;
var command = new FakeCommand
{
CoreExecuted = () => { throw new NotImplementedException(); }
};
configuration.ConstructUsing(() => command);
configuration.OnSuccess((s) => success = true);
configuration.OnProgress((p) => progressCalled = true);
configuration.OnFailure((f) => failExecuted = true);
configuration.Execute();
Assert.False(success);
Assert.False(progressCalled);
Assert.False(coreExecuted);
Assert.True(failExecuted);
}
public void do_not_allow_name_to_be_null()
{
var sut = new FakeCommand();
Action actual = () => CommandExtensions.AddParameter(sut, null, "arne");
actual.ShouldThrow <ArgumentNullException>();
}
public void should_send_message_to_persistence()
{
// standard case: the message is forwarded to the persistence through SendContext.PersistencePeer
// the target peer is down
var senderTransport = CreateAndStartZmqTransport();
var receiverPeerId = new PeerId("Abc.R.0");
var persistenceMessages = new ConcurrentBag <TransportMessage>();
var persistenceTransport = CreateAndStartZmqTransport(onMessageReceived: persistenceMessages.Add);
var persistencePeer = new Peer(persistenceTransport.PeerId, persistenceTransport.InboundEndPoint);
var message = new FakeCommand(999).ToTransportMessage();
senderTransport.Send(message, Enumerable.Empty <Peer>(), new SendContext {
PersistentPeerIds = { receiverPeerId }, PersistencePeer = persistencePeer
});
Wait.Until(() => persistenceMessages.Count == 1, 500.Milliseconds());
var messageFromPersistence = persistenceMessages.ExpectedSingle();
messageFromPersistence.ShouldHaveSamePropertiesAs(message, "Environment", "WasPersisted", "PersistentPeerIds", "IsPersistTransportMessage");
messageFromPersistence.Environment.ShouldEqual("Test");
messageFromPersistence.PersistentPeerIds.ShouldBeEquivalentTo(new[] { receiverPeerId });
}
public void should_not_wait_blocked_peers_on_every_send()
{
var senderTransport = CreateAndStartZmqTransport();
senderTransport.SocketOptions.SendHighWaterMark = 1;
senderTransport.SocketOptions.SendTimeout = 50.Milliseconds();
senderTransport.SocketOptions.SendRetriesBeforeSwitchingToClosedState = 0;
var receviedMessages = new List <TransportMessage>();
var upReceiverTransport = CreateAndStartZmqTransport(onMessageReceived: receviedMessages.Add);
var upReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Up"), upReceiverTransport.InboundEndPoint);
var downReceiverTransport = CreateAndStartZmqTransport();
var downReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Down"), downReceiverTransport.InboundEndPoint);
downReceiverTransport.Stop();
for (var i = 1; i <= 10; ++i)
{
var message = new FakeCommand(i).ToTransportMessage();
senderTransport.Send(message, new[] { upReceiver, downReceiver });
}
Wait.Until(() => receviedMessages.Count == 10, 200.Milliseconds(), "Throughput is too low");
}
public void should_create_message_dispatch()
{
var command = new FakeCommand(123);
var dispatch = _bus.CreateMessageDispatch(command.ToTransportMessage());
dispatch.Message.ShouldEqualDeeply(command);
}
public void should_send_messages()
{
var transport1ReceivedMessages = new ConcurrentBag <TransportMessage>();
var transport1 = CreateAndStartZmqTransport(onMessageReceived: transport1ReceivedMessages.Add);
var transport1Peer = new Peer(transport1.PeerId, transport1.InboundEndPoint);
var transport2ReceivedMessages = new ConcurrentBag <TransportMessage>();
var transport2 = CreateAndStartZmqTransport(onMessageReceived: transport2ReceivedMessages.Add);
var transport2Peer = new Peer(transport2.PeerId, transport2.InboundEndPoint);
var message1 = new FakeCommand(1).ToTransportMessage();
transport1.Send(message1, new[] { transport2Peer });
Wait.Until(() => transport2ReceivedMessages.Count == 1, 500.Milliseconds());
var transport2ReceivedMessage = transport2ReceivedMessages.ExpectedSingle();
transport2ReceivedMessage.ShouldHaveSamePropertiesAs(message1, "Environment", "WasPersisted");
transport2ReceivedMessage.Environment.ShouldEqual("Test");
transport2ReceivedMessage.WasPersisted.ShouldEqual(false);
var message2 = new FakeCommand(2).ToTransportMessage();
transport2.Send(message2, new[] { transport1Peer });
Wait.Until(() => transport1ReceivedMessages.Count == 1, 500.Milliseconds());
var transport1ReceivedMessage = transport1ReceivedMessages.ExpectedSingle();
transport1ReceivedMessage.ShouldHaveSamePropertiesAs(message2, "Environment", "WasPersisted");
transport1ReceivedMessage.Environment.ShouldEqual("Test");
transport1ReceivedMessage.WasPersisted.ShouldEqual(false);
}
public void SendCommand_WithStoredEvents_AppliesEventsBeforeHandlingCommand()
{
// Arrange
var stubEventStore = new FakeEventStore();
var mockEvent = new FakeEvent();
stubEventStore.Save(new AdditionalEvents(Guid.NewGuid(),
new ArrayList()
{
mockEvent
}));
var stubMessageDispatcher = new EventSourcedMessageDispatcher(stubEventStore);
stubMessageDispatcher
.RegisteredHandlerFor <AppliesFakeEventHandlesFakeCommand, FakeCommand>();
var mockCommand = new FakeCommand();
// Act
stubMessageDispatcher.SendCommand(mockCommand);
// Assert
Assert.Equal(mockEvent,
AppliesFakeEventHandlesFakeCommand.applied_event);
Assert.Equal(mockCommand,
AppliesFakeEventHandlesFakeCommand.handled_command);
}
public async Task Process_PassCommand_ShouldForwardCommandToHandlers()
{
// Arrange
var serviceScopeMock = new Mock <IServiceScope>();
var serviceScopeFactoryMock = NewServiceScopeFactoryMock;
serviceScopeFactoryMock.Setup(x => x.CreateScope()).Returns(() => serviceScopeMock.Object);
serviceScopeMock.Setup(x => x.GetService(typeof(CommandHandlingContext))).Returns(new CommandHandlingContext());
var handlerMocks = new[]
{
new Mock <ICommandHandler <FakeCommand> >(),
new Mock <ICommandHandler <FakeCommand> >()
};
serviceScopeMock
.Setup(x => x.GetService(typeof(IEnumerable <ICommandHandler <FakeCommand> >)))
.Returns(handlerMocks.Select(x => x.Object));
var command = new FakeCommand();
var processor = new CommandProcessor(serviceScopeFactoryMock.Object, NewEventStoreMock.Object, NewEventDispatcherMock.Object);
// Act
await processor.Process(command);
// Assert
handlerMocks[0].Verify(x => x.Handle(command, default(CancellationToken)), Times.Once);
handlerMocks[1].Verify(x => x.Handle(command, default(CancellationToken)), Times.Once);
}
public void should_not_crash_during_safety_phase()
{
Transport.Start();
var failingMessage = new FakeCommand(666).ToTransportMessage();
var otherMessage = new FakeCommand(123).ToTransportMessage();
var successfullyReceivedMessages = new List <TransportMessage>();
Transport.MessageReceived += msg =>
{
if (msg == failingMessage)
{
throw new Exception("Failure");
}
successfullyReceivedMessages.Add(msg);
};
InnerTransport.RaiseMessageReceived(new ReplayPhaseEnded(StartMessageReplayCommand.ReplayId).ToTransportMessage());
InnerTransport.RaiseMessageReceived(failingMessage);
InnerTransport.RaiseMessageReceived(otherMessage);
Wait.Until(() => successfullyReceivedMessages.Count >= 1, 150.Milliseconds());
successfullyReceivedMessages.Single().ShouldEqual(otherMessage);
}
public void do_not_allow_name_to_be_null()
{
var sut = new FakeCommand();
Action actual = () => CommandExtensions.AddParameter(sut, null, "arne");
actual.ShouldThrow<ArgumentNullException>();
}
public void CanShortCircuitAccessToUserAddressHeader()
{
var command = new FakeCommand();
var headers = new HeaderCollection(new[] { new Header(Header.UserAddress, IPAddress.Loopback.ToString(), checkReservedNames: false) });
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Equal(IPAddress.Loopback, command.GetUserAddress());
}
public void cant_operate_if_supplied_argument_do_not_specify_a_name()
{
var sut = new FakeCommand();
Action actual = () => CommandExtensions.AddParameter(sut, null, "arne");
actual.ShouldThrow<ArgumentNullException>();
}
public void CanShortCircuitAccessToOriginHeader()
{
var command = new FakeCommand();
var headers = new HeaderCollection(new[] { new Header(Header.Origin, "MyOrigin", checkReservedNames: false) });
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Equal("MyOrigin", command.GetOrigin());
}
public void convert_null_value_to_dbnull()
{
var sut = new FakeCommand();
CommandExtensions.AddParameter(sut, "name", null);
sut.Parameters[0].Value.Should().Be(DBNull.Value);
}
public void ReturnHeadersFromCommandContextIfNotNull()
{
var command = new FakeCommand();
var headers = new HeaderCollection(Enumerable.Empty<Header>());
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Same(headers, command.Headers);
}
public void convert_null_value_to_dbnull()
{
var sut = new FakeCommand();
CommandExtensions.AddParameter(sut, "name", null);
sut.Parameters[0].Value.Should().Be(DBNull.Value);
}
public void add_created_parameter_to_command()
{
var sut = new FakeCommand();
CommandExtensions.AddParameter(sut, "name", "arne");
sut.Parameters[0].Value.Should().Be("arne");
sut.Parameters[0].ParameterName.Should().Be("name");
}
public void Validation_Correct()
{
var sut = new FakeCommand(new[] {new ScalarCommandResult("SELECT 1", null){Result = "Hello"}});
sut.CommandText = "SELECT 1";
var actual = sut.ExecuteScalar();
Assert.Equal("Hello", actual);
}
public void Validation_Missing_Parameter()
{
var args = new ParameterCollection(new FakeParameter("myName", "World"));
var result = new ScalarCommandResult("SELECT 1 FROM Y WHERE Name = @myName", args) { Result = "Hello correct" };
var sut = new FakeCommand(new[] { result });
sut.CommandText = "SELECT 1 FROM Y WHERE Name = @myName";
Assert.Throws<CommandValidationException>(() => sut.ExecuteScalar());
}
public void CanShortCircuitAccessToTimestampHeader()
{
var now = DateTime.UtcNow;
var command = new FakeCommand();
var headers = new HeaderCollection(new[] { new Header(Header.Timestamp, now.ToString(DateTimeFormat.RoundTrip), checkReservedNames: false) });
using (new CommandContext(GuidStrategy.NewGuid(), headers, CommandEnvelope.Empty))
Assert.Equal(now, command.GetTimestamp());
}
/// <summary>
/// Create a new reader
/// </summary>
/// <param name="fakeCommand">Command which must return a new reader (by <see cref="IDbCommand.ExecuteReader()"/>)</param>
/// <returns>A new reader</returns>
/// <remarks>Default implementation will first try to invoke <see cref="ReaderFactory"/> and then invoke <see cref="TableFactory"/> to get a new result.
/// </remarks>
public virtual FakeDataReader CreateReader(FakeCommand fakeCommand)
{
if (ReaderFactory != null)
return ReaderFactory(fakeCommand);
if (TableFactory == null)
throw new InvalidOperationException("Either configure the command using command.Setup() or configure the Factory.TableFactory or Factory.ReaderFactory.");
return new FakeDataReader(TableFactory(fakeCommand));
}
public void RegularDispatch()
{
var innerDispatcher = Substitute.For<ICommandDispatcher>();
CommandDispatcher.Assign(innerDispatcher);
var command = new FakeCommand();
CommandDispatcher.Dispatch(command);
innerDispatcher.Received().Dispatch(Arg.Is<FakeCommand>(x => ReferenceEquals(x, command)));
}
public void ConstructUsing()
{
var configuration = new CommandConfiguration<FakeCommand>();
var command = new FakeCommand();
configuration.ConstructUsing(() => command);
Assert.AreEqual(command, configuration.Command);
}
public void Validation_Missing_Parameter2()
{
var args = new ParameterCollection(new FakeParameter("status", 1));
var result = new ScalarCommandResult("UPDATE User SET Status = @status", args) { Result = "Hello correct" };
var sut = new FakeCommand(new[] { result });
sut.CommandText = "UPDATE User SET Status = @status";
sut.AddParameter("status", 1);
sut.AddParameter("id", 22);
sut.ExecuteScalar();
}
public void Validation_Unmatched_Parameter()
{
var args = new ParameterCollection();
var result = new ScalarCommandResult("SELECT 1 FROM Y WHERE Name = @myName", args) { Result = "Hello correct" };
// you can also sue the Setup method instead of the constructor
var sut = new FakeCommand(new[] { result });
sut.CommandText = "SELECT 1 FROM Y WHERE Name = @myName";
sut.AddParameter("myName", "World");
Assert.Throws<CommandValidationException>(() => sut.ExecuteScalar());
}
public void SpecificCommand()
{
var connection = new FakeConnection();
var cmdToReturn = new FakeCommand(new ScalarCommandResult("SELECT count(*) FROM users", null){Result = 201});
connection.Setup(cmdToReturn);
var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT count(*) FROM users";
var result = cmd.ExecuteScalar();
Assert.Equal(201, result);
}
public void Validation_Correct_WithParameter()
{
var args = new ParameterCollection(new FakeParameter("myName", "World"));
var result = new ScalarCommandResult("SELECT 1 FROM Y WHERE Name = @myName", args) { Result = "Hello" };
var sut = new FakeCommand(new[] { result});
sut.CommandText = "SELECT 1 FROM Y WHERE Name = @myName";
sut.AddParameter("myName", "World");
var actual = sut.ExecuteScalar();
Assert.Equal("Hello", actual);
}
public void HeadersCanBeNull()
{
var messageFactory = new Mock<ICreateMessages>();
var messageBus = new Mock<ISendMessages<CommandEnvelope>>();
var publisher = new CommandPublisher(messageFactory.Object, messageBus.Object);
var payload = new FakeCommand();
publisher.Publish(GuidStrategy.NewGuid(), payload, null);
messageFactory.Verify(mock => mock.Create(null, It.IsAny<CommandEnvelope>()), Times.Once);
messageBus.Verify(mock => mock.Send(It.IsAny<Message<CommandEnvelope>>()), Times.Once);
}
public void OnExecute_Is_Called_When_Executing()
{
var transaction = new Mock<ITransaction>();
var session = new Mock<ISession>();
session.Setup(s => s.BeginTransaction()).Returns(() => transaction.Object);
var context = new CommandContext(session.Object, null);
var command = new FakeCommand();
command.Execute(context);
Assert.True(command.OnExecuteCalled);
}
public void ProcessCommand_HandlerRegisteredForCommand_ShouldCallHandlerWithCommand()
{
// Arrange
var fakeCommand = new FakeCommand();
var fakeCommandHandler = new FakeCommandHandler();
commandProcessor.RegisterCommandHandler(fakeCommandHandler);
// Act
commandProcessor.ProcessCommand(fakeCommand);
// Assert
Assert.That(fakeCommandHandler.HandleCommandLastCalledWith, Is.SameAs(fakeCommand));
}
public void WrapCommandInMessageEnvelope()
{
var command = new FakeCommand() as Command;
var messageFactory = new Mock<ICreateMessages>();
var messageBus = new Mock<ISendMessages<CommandEnvelope>>();
var publisher = new CommandPublisher(messageFactory.Object, messageBus.Object);
var message = new Message<CommandEnvelope>(GuidStrategy.NewGuid(), HeaderCollection.Empty, new CommandEnvelope(GuidStrategy.NewGuid(), command));
messageFactory.Setup(mock => mock.Create(HeaderCollection.Empty, It.Is<CommandEnvelope>(envelope => ReferenceEquals(command, envelope.Command)))).Returns(message);
publisher.Publish(GuidStrategy.NewGuid(), command, HeaderCollection.Empty);
messageBus.Verify(mock => mock.Send(message), Times.Once());
}
public void RetrieveCommandHandlerBasedOnCommandType()
{
var command = new FakeCommand();
var aggregate = new FakeAggregate();
var envelope = new CommandEnvelope(GuidStrategy.NewGuid(), command);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
HandlerRegistry.Setup(mock => mock.GetHandlerFor(command)).Returns(new CommandHandler(typeof(FakeAggregate), typeof(FakeCommand), AggregateStore.Object, (a, c) => { }));
AggregateStore.Setup(mock => mock.Get(typeof(FakeAggregate), envelope.AggregateId)).Returns(aggregate);
Processor.Process(message);
HandlerRegistry.Verify(mock => mock.GetHandlerFor(command), Times.Once());
}
public void OnException_Is_Called_When_Commit_Throws_Exception()
{
var transaction = new Mock<ITransaction>();
transaction.Setup(t => t.Commit()).Throws<NHibernate.Exceptions.GenericADOException>();
var session = new Mock<ISession>();
session.Setup(s => s.BeginTransaction()).Returns(() => transaction.Object);
var context = new CommandContext(session.Object, null);
var command = new FakeCommand();
command.Execute(context);
Assert.True(command.OnExecuteCalled);
Assert.True(command.OnExceptionCalled);
}
public void SetUp()
{
_handler = MockRepository.GenerateStub<ICommandExecutor<FakeCommand>>();
_container = new WindsorContainer();
_interceptor = new FakeInterceptor();
_interceptor2 = new FakeInterceptor2();
_container.Register(
Component.For<IWindsorContainer>().Instance(_container),
Component.For<ICommandExecutor<FakeCommand>>().Instance(_handler),
Component.For<ICommandServiceInterceptor>().Instance(_interceptor),
Component.For<ICommandServiceInterceptor>().Instance(_interceptor2),
Component.For<ICommandService>().ImplementedBy<WindsorCommandService>());
var svc = _container.Resolve<ICommandService>();
_testCommand = new FakeCommand();
svc.Execute(_testCommand);
}
