public void Foo() { var id = Guid.NewGuid(); var foocmd = new FooCommand(id); var barcmd = new BarCommand(id); var barcmd2 = new BarCommand(id); var events = new IEvent[] { new FooEvent(Guid.NewGuid()) .Tap(x => x.Meta.AddMetaData(1, "Test", "Test", foocmd)), new FooEvent(Guid.NewGuid()) .Tap(x => x.Meta.AddMetaData(1, "Test", "Test", foocmd)), new BarEvent(Guid.NewGuid()) .Tap(x => x.Meta.AddMetaData(1, "Test", "Test", barcmd, DateTime.UtcNow.AddHours(1).Ticks)), new BarEvent(Guid.NewGuid()) .Tap(x => x.Meta.AddMetaData(1, "Test", "Test", barcmd, DateTime.UtcNow.AddHours(1).Ticks)), new BarEvent(Guid.NewGuid()) .Tap(x => x.Meta.AddMetaData(1, "Test", "Test", barcmd2, DateTime.UtcNow.AddHours(1).Ticks)), new BarEvent(Guid.NewGuid()) .Tap(x => x.Meta.AddMetaData(1, "Test", "Test", barcmd2, DateTime.UtcNow.AddHours(1).Ticks)), }; this.output.WriteLine(events.Draw()); Assert.True(false, "Command not in line"); }
static void Main() { Console.WriteLine("This is the sender."); var bus = Configure.With() .DefaultBuilder() .DisableTimeoutManager() .UnicastBus() .CreateBus() .Start(StartupAction); while (true) { var input = Console.ReadLine(); Console.WriteLine("Sending: {0}", input); var command = new FooCommand { Bar = input }; var callback = bus.Send(command); callback.Register <FooStatus>(x => Console.WriteLine("Return code: {0}", x)); } }
public void Constructing_with_a_direct_id_should_set_the_given_value() { var identifier = Guid.NewGuid(); var command = new FooCommand(identifier); command.CommandIdentifier.Should().Be(identifier); }
public async Task RunAsync() { // Commands var decoratedCommand = new FooCommand { Name = "Decorated command" }; await _executor.ExecuteAsync(decoratedCommand); await _writer.WriteLineAsync("----------------"); var regularCommand = new BarCommand { Name = "Regular command" }; var regularCommandResult = await _executor.ExecuteAsync(regularCommand); await _writer.WriteLineAsync("----------------"); var syncCommand = new BazCommand(); var syncCommandResult = await _executor.ExecuteAsync(syncCommand); await _writer.WriteLineAsync($"Sync command result is `{syncCommandResult}`"); await _writer.WriteLineAsync("----------------"); // Queries var regularQuery = new FooQuery { Number1 = 3, Number2 = 4 }; var regularQueryResult = await _executor.ExecuteAsync(regularQuery); await _writer.WriteLineAsync("----------------"); }
public void forward_command_to_handler() { var command = new FooCommand(); var venga = new Venga(); venga.RegisterHandler(new FooHandler()); venga.Handle(command); Assert.True(command.WasHandled); }
public void when_sending_then_sets_command_id_as_messageid() { var sender = new MessageSenderMock(); var sut = new CommandBus(sender, Mock.Of<IMetadataProvider>(), new JsonTextSerializer()); var command = new FooCommand { Id = Guid.NewGuid() }; sut.Send(command); Assert.Equal(command.Id.ToString(), sender.Sent.Single().MessageId); }
public void Constructing_with_custom_generator_should_it_to_generate_id() { var identifier = Guid.NewGuid(); var generator = MockRepository.GenerateMock<IUniqueIdentifierGenerator>(); generator.Expect(t => t.GenerateNewId()).Return(identifier); var command = new FooCommand(generator); generator.VerifyAllExpectations(); command.CommandIdentifier.Should().Be(identifier); }
public void Executing_one_with_a_custom_factory_should_give_context_created_with_that_factory() { var factory = MockRepository.GenerateMock <IUnitOfWorkFactory>(); var aCommand = new FooCommand(); var executor = new FooCommandExecutor(factory); executor.Execute(aCommand); factory.AssertWasCalled(f => f.CreateUnitOfWork()); }
public void Executing_should_call_ExecuteInContext_with_given_command() { var theCommand = new FooCommand(); var factory = MockRepository.GenerateMock <IUnitOfWorkFactory>(); var executor = new FooCommandExecutor(factory); executor.Execute(theCommand); executor.LastGivenCommand.Should().Be(theCommand); }
public void Constructing_with_custom_generator_should_it_to_generate_id() { var identifier = Guid.NewGuid(); var generator = MockRepository.GenerateMock <IUniqueIdentifierGenerator>(); generator.Expect(t => t.GenerateNewId()).Return(identifier); var command = new FooCommand(generator); generator.VerifyAllExpectations(); command.CommandIdentifier.Should().Be(identifier); }
public void throw_if_no_handler_registered_for_command() { var venga = new Venga(); var command = new FooCommand(); var exception = Record.Exception(() => venga.Handle(command)); Assert.NotNull(exception); Assert.IsType <UnhandledCommandException>(exception); Assert.Equal("No handler registered for FooCommand", exception.Message); }
public void when_sending_then_sets_command_id_as_messageid() { var sender = new MessageSenderMock(); var sut = new CommandBus(sender, Mock.Of <IMetadataProvider>(), new JsonTextSerializer()); var command = new FooCommand { Id = Guid.NewGuid() }; sut.Send(command); Assert.IsTrue(command.Id.ToString() == sender.Sent.Single().MessageId); }
protected override async Task When() { MethodCallCounter.Clear(); var command1 = new FooCommand(_id1); var command2 = new FooCommand(_id2); await Subject.Dispatch(await _nimbusMessageFactory.Create("nullQueue", command1)); await Subject.Dispatch(await _nimbusMessageFactory.Create("nullQueue", command2)); MethodCallCounter.Stop(); }
public override async Task SendMessages(IBus bus, Func <bool> shouldKeepSending) { while (shouldKeepSending()) { var command = new FooCommand { SomeMessage = new string(Enumerable.Range(0, 32 * 1024).Select(j => '.').ToArray()) }; await bus.Send(command); IncrementExpectedMessageCount(); } }
public void Executing_should_call_ExecuteInContext_with_context_from_factory() { var context = MockRepository.GenerateMock <IUnitOfWorkContext>(); var factory = MockRepository.GenerateMock <IUnitOfWorkFactory>(); factory.Stub(f => f.CreateUnitOfWork(Guid.NewGuid())).Return(context).IgnoreArguments(); var aCommand = new FooCommand(); var executor = new FooCommandExecutor(factory); executor.Execute(aCommand); executor.LastGivenContext.Should().Be(context); }
public void FromEnvelope_sets_CommandJson_correctly() { var fixture = new Fixture(); FooCommand command = fixture.Create <FooCommand>(); var envelope = new Envelope(command); var processManager = new FooProcessManager(); var serializer = new JsonMessageSerializer(); var actual = PendingCommand.FromEnvelope(processManager, envelope, serializer); serializer.Deserialize(actual.CommandJson) .Should().BeOfType <FooCommand>() .Subject.ShouldBeEquivalentTo(command); }
public void Dispatch_ValidState_RunsOk() { // Arrange ICommandDispatcher commandDispatcher = new CommandDispatcher(_commandHandlerFactoryMock.Object); var command = new FooCommand { Name = "Maria", }; // Act commandDispatcher.Dispatch(command); // Assert Assert.That(_nameHolder.GetName(), Is.EqualTo("Maria")); }
public override IEnumerable <Task> SendMessages(IBus bus) { for (var i = 0; i < NumMessagesToSend; i++) { var command = new FooCommand { SomeMessage = new string(Enumerable.Range(0, 32 * 1024).Select(j => '.').ToArray()), }; yield return(bus.Send(command)); Console.Write("."); } Console.WriteLine(); }
public void Constructing_without_any_parameters_should_use_IUniqueIdentifierGenerator_to_generate_id() { var generatedId = Guid.NewGuid(); var generator = MockRepository.GenerateMock<IUniqueIdentifierGenerator>(); generator.Stub(t => t.GenerateNewId()).Return(generatedId); NcqrsEnvironment.SetDefault<IUniqueIdentifierGenerator>(generator); var command = new FooCommand(); generator.VerifyAllExpectations(); command.CommandIdentifier.Should().Be(generatedId); NcqrsEnvironment.Deconfigure(); }
public void Constructing_without_any_parameters_should_use_IUniqueIdentifierGenerator_to_generate_id() { var generatedId = Guid.NewGuid(); var generator = MockRepository.GenerateMock <IUniqueIdentifierGenerator>(); generator.Stub(t => t.GenerateNewId()).Return(generatedId); NcqrsEnvironment.SetDefault <IUniqueIdentifierGenerator>(generator); var command = new FooCommand(); generator.VerifyAllExpectations(); command.CommandIdentifier.Should().Be(generatedId); NcqrsEnvironment.Deconfigure(); }
protected override void When() { var lyingClock = Substitute.For <IClock>(); var now = new DateTimeOffset(2014, 02, 09, 18, 04, 58, TimeSpan.FromHours(10)); lyingClock.UtcNow.ReturnsForAnyArgs(now); DelayedSendingExtensions.SetClockStrategy(lyingClock); _fooCommand = new FooCommand(); var delay = TimeSpan.FromDays(2); _expectedDeliveryTime = now.Add(delay); Subject.SendAfter(_fooCommand, TimeSpan.FromDays(2)); }
public void forward_same_command_to_multiple_different_handlers() { var venga = new Venga(); var command = new FooCommand(); var aFooHandler = new FooHandler(); var anotherFooHandler = new OtherFooHandler(); venga.RegisterHandler(aFooHandler); venga.RegisterHandler(anotherFooHandler); venga.Handle(command); Assert.True(command.WasHandledBy.Any(handler => handler is FooHandler)); Assert.True(command.WasHandledBy.Any(handler => handler is OtherFooHandler)); }
public void has_expected_exit_code_when_command_does_NOT_throw_exception() { var exitCode = 0; var errorCommand = new FooCommand(); var engine = CleeEngine.Create(cfg => { cfg.Factory(f => f.Use(new StubCommandFactory(errorCommand))); cfg.Registry(r => r.Register("foo", errorCommand.GetType())); }); engine.SetExitCodeAssigner(code => exitCode = code); engine.Execute("foo"); Assert.Equal(0, exitCode); }
public void Dispatch_CommandHandlerFactoryFailsToCreateCommandHandler_ThrowsCannotCreateCommandHandlerException() { // Arrange _commandHandlerFactoryMock .Setup(x => x.Create <FooCommand>()) .Returns((FooCommandHandler)null); ICommandDispatcher commandDispatcher = new CommandDispatcher(_commandHandlerFactoryMock.Object); var command = new FooCommand { Name = "Maria", }; // Act var ex = Assert.Throws <CannotCreateCommandHandlerException>(() => commandDispatcher.Dispatch(command)); Assert.That(ex.Message, Is.EqualTo("Attempt to create the command handler failed.")); var innerEx = ex.InnerException; Assert.That(innerEx, Is.Null); }
public void Dispatch_CommandHandlerFactoryThrowsExceptionOnCreation_ThrowsCannotCreateCommandHandlerException() { // Arrange _commandHandlerFactoryMock .Setup(x => x.Create <FooCommand>()) .Callback(() => throw new InvalidOperationException("internal error")); ICommandDispatcher commandDispatcher = new CommandDispatcher(_commandHandlerFactoryMock.Object); var command = new FooCommand { Name = "Maria", }; // Act var ex = Assert.Throws <CannotCreateCommandHandlerException>(() => commandDispatcher.Dispatch(command)); Assert.That(ex.Message, Is.EqualTo("Attempt to create the command handler failed.")); var innerEx = ex.InnerException; Assert.That(innerEx, Is.Not.Null); Assert.That(innerEx, Is.InstanceOf <InvalidOperationException>()); Assert.That(innerEx.Message, Is.EqualTo("internal error")); }
public void Parses_args_when_passed_by_position(CommandArgParser commandArgParser, FooCommand result) { "Given I have a commandArgParser" ._(() => commandArgParser = new CommandArgParser()); "When I parse the command 'FooCommand Hello'" ._(() => result = commandArgParser.Parse(typeof(FooCommand), new[] { "FooCommand", "Hello" }) as FooCommand); "Then the result should have Bar set to Hello" ._(() => result.Bar.Should().Be("Hello")); "And the result should not have Baz set" ._(() => result.Baz.Should().BeNull()); }
public void Parses_all_args_when_all_passed_by_switch(CommandArgParser commandArgParser, FooCommand result) { "Given I have a commandArgParser" ._(() => commandArgParser = new CommandArgParser()); "When I parse the command 'FooCommand -Bar Hello -Baz World'" ._(() => result = commandArgParser.Parse(typeof(FooCommand), "FooCommand", "-Bar", "Hello", "-Baz", "World") as FooCommand); "Then the result should have Bar set to Hello" ._(() => result.Bar.Should().Be("Hello")); "And the result should have Baz set to World" ._(() => result.Baz.Should().Be("World")); }
public override async Task Handle(FooCommand busCommand) { MethodCallCounter.ForInstance(BusId).RecordCall<MultipleCommandHandler>(h => h.Handle(busCommand)); }
public async Task Handle(FooCommand busCommand) { RecordMessageReceipt(); }
public override async Task Handle(FooCommand busCommand) { MethodCallCounter.ForInstance(BusId).RecordCall <MultipleCommandHandler>(h => h.Handle(busCommand)); }