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