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