public async Task When_outstanding_in_outbox_sweep_clears_them_async()
{
//Arrange
const int milliSecondsSinceSent = 500;
var outbox = new InMemoryOutbox();
var commandProcessor = new FakeCommandProcessor();
var sweeper = new OutboxSweeper(milliSecondsSinceSent, commandProcessor);
var messages = new Message[] { new MessageTestDataBuilder(), new MessageTestDataBuilder(), new MessageTestDataBuilder() };
foreach (var message in messages)
{
outbox.Add(message);
commandProcessor.Post(message.ToStubRequest());
}
//Act
await Task.Delay(milliSecondsSinceSent * 2); // -- let the messages expire
sweeper.SweepAsyncOutbox();
await Task.Delay(200);
//Assert
outbox.EntryCount.Should().Be(3);
commandProcessor.Dispatched.Count.Should().Be(3);
commandProcessor.Deposited.Count.Should().Be(3);
}
public async Task Test_Adding_A_Task()
{
/*
* Given that I have a command to add a ToDo
* When I handle that command
* Then I should add to the list of Tasks
*
*/
const string TODO_TITLE = "test_title";
const int ORDER_NUM = 10;
var fakeCommandProcessor = new FakeCommandProcessor();
var options = new DbContextOptionsBuilder <ToDoContext>()
.UseInMemoryDatabase("Add_writes_to_database")
.Options;
var command = new AddToDoCommand(TODO_TITLE, true, ORDER_NUM);
var handler = new AddToDoCommandHandlerAsync(options, fakeCommandProcessor);
await handler.HandleAsync(command);
using (var context = new ToDoContext(options))
{
Assert.AreEqual(1, context.ToDoItems.Count());
Assert.AreEqual(TODO_TITLE, context.ToDoItems.Single().Title);
Assert.AreEqual(true, context.ToDoItems.Single().Completed);
Assert.AreEqual(ORDER_NUM, context.ToDoItems.Single().Order.Value);
}
Assert.IsTrue(fakeCommandProcessor.SentCreatedEvent);
}
public async Task when_handling_the_command()
{
CommandName = "FakeCommand";
Json = JObject.Parse("{}");
async Task should_invoke_the_command_processor()
{
FakeCommandProcessor.Setup(x => x.ProcessWithOrWithoutResultAsync(CommandName, Json)).Returns(Task.FromResult(CommandResult.None));
var result = await Subject.Handle(CommandName, Json) as OkResult;
result.StatusCode.Should().Be(200);
}
async Task should_handle_CommandValidationException()
{
FakeCommandProcessor.Setup(x => x.ProcessWithOrWithoutResultAsync(CommandName, Json)).Throws(new CommandValidationException("invalid"));
var result = await Subject.Handle(CommandName, Json) as BadRequestObjectResult;
result.ShouldBeError("invalid");
}
async Task should_handle_Exception()
{
FakeCommandProcessor.Setup(x => x.ProcessWithOrWithoutResultAsync(CommandName, Json)).Throws(new Exception("fail"));
var result = await Subject.Handle(CommandName, Json) as ObjectResult;
result.StatusCode.Should().Be(500);
result.ShouldBeError("fail");
}
}
public async Task When_updating_a_shipping_line_name()
{
using (var contextFactory = new FakeShipRegistryContextFactory(_options))
{
//arrange
var uow = contextFactory.Create();
var repository = new ShippingLineRepositoryAsync(uow);
var existingLine = new ShippingLine(new Id(), new LineName("Maersk"));
await repository.AddAsync(existingLine);
var commandProcessor = new FakeCommandProcessor();
var command = new UpdateLineNameCommand(existingLine.Id, new LineName("Onassis"));
var handler = new UpdateLineNameHandler(contextFactory, commandProcessor);
//act
await handler.HandleAsync(command);
//assert
var line = uow.Lines.SingleOrDefault(l => l.Id == existingLine.Id);
Assert.That(line.LineName, Is.EqualTo(new LineName("Onassis")));
Assert.That(line.Version, Is.EqualTo(1));
var domainEvent = commandProcessor.Messages.SingleOrDefault(m => m.Action == Action.Post);
Assert.That(domainEvent, Is.Not.Null);
var addedMessage = (LineNameUpdatedEvent)domainEvent.Message;
Assert.That(addedMessage.LineName, Is.EqualTo(new LineName("Onassis")));
Assert.That(addedMessage.Version, Is.EqualTo(1));
}
}
public async Task When_registering_a_new_shipping_line()
{
using (var contextFactory = new FakeShipRegistryContextFactory(_options))
{
//arrange
var commandProcessor = new FakeCommandProcessor();
var newShippingLineCommand = new AddShippingLineCommand(new LineName("Maersk"));
var handler = new NewShippingLineHandlerAsync(contextFactory, commandProcessor);
//act
await handler.HandleAsync(newShippingLineCommand);
//assert
var uow = contextFactory.Create();
var line = uow.Lines.SingleOrDefault(l => l.Id == new Id(newShippingLineCommand.Id));
Assert.That(line, Is.Not.Null);
Assert.That(line.Id, Is.EqualTo(new Id(newShippingLineCommand.Id)));
Assert.That(line.LineName, Is.EqualTo(newShippingLineCommand.LineName));
var domainEvent = commandProcessor.Messages.SingleOrDefault(m => m.Action == Action.Post);
Assert.That(domainEvent, Is.Not.Null);
var addedMessage = (NewLineAddedEvent)domainEvent.Message;
Assert.That(addedMessage, Is.Not.Null);
Assert.That(addedMessage.LineId, Is.EqualTo(new Id(newShippingLineCommand.Id)));
Assert.That(addedMessage.LineName, Is.EqualTo(newShippingLineCommand.LineName));
}
}
public async Task When_removing_a_ship_registration()
{
//arrange
using (var contextFactory = new FakeShipRegistryContextFactory(_options))
{
var uow = contextFactory.Create();
var repository = new ShipRepositoryAsync(uow);
var ship = new Ship(new Id(), new ShipName("Majestic"), ShipType.Container, new Capacity(50000), new Id());
await repository.AddAsync(ship);
var commandProcessor = new FakeCommandProcessor();
var command = new RemoveShipCommand(ship.Id);
var handler = new RemoveShipHandlerAsync(contextFactory, commandProcessor);
//act
await handler.HandleAsync(command);
//assert
var removedShip = await uow.Ships.SingleOrDefaultAsync(s => s.Id == ship.Id);
Assert.That(removedShip, Is.Null);
var domainEvent = commandProcessor.Messages.SingleOrDefault(m => m.Action == Action.Post);
Assert.That(domainEvent, Is.Not.Null);
var shipRemovedEvent = (ShipRemovedEvent)domainEvent.Message;
Assert.That(shipRemovedEvent.ShipRemoved, Is.EqualTo(ship.Id));
}
}
public void When_too_new_to_sweep_leaves_them()
{
//Arrange
const int milliSecondsSinceSent = 500;
var commandProcessor = new FakeCommandProcessor();
var sweeper = new OutboxSweeper(milliSecondsSinceSent, commandProcessor);
Message oldMessage = new MessageTestDataBuilder();
commandProcessor.DepositPost(oldMessage.ToStubRequest());
var messages = new Message[] { new MessageTestDataBuilder(), new MessageTestDataBuilder(), new MessageTestDataBuilder() };
Thread.Sleep(milliSecondsSinceSent * 2);
foreach (var message in messages)
{
commandProcessor.DepositPost(message.ToStubRequest());
}
//Act
sweeper.Sweep();
Thread.Sleep(200);
//Assert
commandProcessor.Dispatched.Count.Should().Be(1);
commandProcessor.Deposited.Count.Should().Be(4);
}
public async Task when_handling_the_command()
{
CommandName = "FakeCommand";
FakeCommandProcessor.Setup(x => x.GetCommandType(CommandName)).Returns(typeof(FakeCommand));
async Task should_invoke_the_command_processor()
{
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Returns(Task.CompletedTask);
var result = await Subject.Handle(CommandName, Json);
(await result.ExecuteAsync(CancellationToken.None)).StatusCode.Should().Be(200);
}
async Task should_handle_CommandProcessorException()
{
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Throws(new CommandProcessorException("fail"));
var result = await Subject.Handle(CommandName, Json);
await result.ShouldBeErrorAsync("fail", 400);
}
async Task should_handle_CommandException()
{
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Throws(new CommandException("invalid"));
var result = await Subject.Handle(CommandName, Json);
await result.ShouldBeErrorAsync("invalid", 400);
}
async Task should_handle_Exception()
{
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Throws(new Exception("fail"));
var result = await Subject.Handle(CommandName, Json);
await result.ShouldBeErrorAsync("fail", 500);
}
async Task should_log_errors()
{
var fakeTraceWriter = new Mock <ITraceWriter>();
var subject = new FakeCommandController(FakeCommandProcessor.Object, fakeTraceWriter.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Throws(new Exception("fail"));
await subject.Handle(CommandName, Json);
fakeTraceWriter.Verify(x => x.Trace(It.IsAny <HttpRequestMessage>(), "UnhandledCommandException", TraceLevel.Error, It.IsAny <Action <TraceRecord> >()));
}
}
public async Task when_handling_the_command_with_result()
{
CommandName = "FakeResultCommand";
Json = JObject.Parse("{}");
async Task should_invoke_the_command_processor()
{
FakeCommandProcessor.Setup(x => x.ProcessWithOrWithoutResultAsync(CommandName, Json)).Returns(Task.FromResult(new CommandResult(new FakeResult())));
var result = await Subject.Handle(CommandName, Json);
(await result.ExecuteAsync(CancellationToken.None)).Content.Should().NotBeNull();
}
}
public async Task when_handling_the_command_with_result()
{
CommandName = "FakeResultCommand";
Json = JObject.Parse("{}");
async Task should_invoke_the_command_processor()
{
FakeCommandProcessor.Setup(x => x.ProcessWithOrWithoutResultAsync(CommandName, Json)).Returns(Task.FromResult(new CommandResult(new FakeResult())));
var result = await Subject.Handle(CommandName, Json) as OkObjectResult;
result.StatusCode.Should().Be(200);
result.Value.Should().NotBeNull();
}
}
public async Task When_registering_a_new_ship()
{
//arrange
using (var contextFactory = new FakeShipRegistryContextFactory(_options))
{
var uow = contextFactory.Create();
var lineRepo = new ShippingLineRepositoryAsync(uow);
var shippingLine = lineRepo.AddAsync(new ShippingLine(new Id(), new LineName("Maersk"))).Result;
var commandProcessor = new FakeCommandProcessor();
var handler = new NewShipRegistrationHandlerAsync(contextFactory, commandProcessor);
var newShipCommand = new AddShipCommand(
type: ShipType.Tanker,
name: new ShipName("MV Toronto Star"),
capacity: new Capacity(30000),
shippingLine: shippingLine.Id);
//act
await handler.HandleAsync(newShipCommand);
//assert
var ship = uow.Ships.SingleOrDefault(s => s.Id == new Id(newShipCommand.Id));
Assert.That(ship, Is.Not.Null);
Assert.That(ship.ShipType, Is.EqualTo(newShipCommand.Type));
Assert.That(ship.ShipName, Is.EqualTo(newShipCommand.Name));
Assert.That(ship.Capacity, Is.EqualTo(newShipCommand.Capacity));
Assert.That(ship.Id, Is.EqualTo(new Id(newShipCommand.Id)));
Assert.That(ship.ShippingLineId, Is.EqualTo(newShipCommand.ShippingLine));
Assert.That(ship.Version, Is.EqualTo(0));
var domainEvent = commandProcessor.Messages.SingleOrDefault(m => m.Action == Action.Post);
Assert.That(domainEvent, Is.Not.Null);
var addedMessage = (NewShipAddedEvent)domainEvent.Message;
Assert.That(addedMessage.Id, Is.EqualTo(newShipCommand.Id));
Assert.That(addedMessage.Capacity, Is.EqualTo(newShipCommand.Capacity));
Assert.That(addedMessage.Name, Is.EqualTo(newShipCommand.Name));
Assert.That(addedMessage.Type, Is.EqualTo(newShipCommand.Type));
Assert.That(addedMessage.ShipId, Is.EqualTo(new Id(newShipCommand.Id)));
Assert.That(addedMessage.ShippingLine, Is.EqualTo(newShipCommand.ShippingLine));
}
}
public async Task when_handling_the_command_with_result()
{
CommandName = "FakeResultCommand";
FakeCommandProcessor.Setup(x => x.GetCommandType(CommandName)).Returns(typeof(FakeResultCommand));
async Task should_return_the_result_from_the_command_processor()
{
var expected = new FakeResult();
FakeCommandProcessor.Setup(x => x.ProcessWithResultAsync(It.IsAny <FakeResultCommand>())).Returns(Task.FromResult(expected));
var result = await Subject.Handle(CommandName, Json) as OkNegotiatedContentResult <object>;
(await result.ExecuteAsync(CancellationToken.None)).StatusCode.Should().Be(200);
result.Content.Should().Be(expected);
}
}
public async Task Test_Updating_The_ToDo_Title_Completed_Order()
{
/*
* Given that I have a command to update a ToDo's title, complete, & order
* When I handle that command
* Then I should update the ToDo
*
*/
const string NEW_TITLE = "New Title";
const bool NEW_COMPLETED = false;
const int NEW_ORDER = 523;
var options = new DbContextOptionsBuilder <ToDoContext>()
.UseInMemoryDatabase("order_title_completed_writes_to_database")
.Options;
var fakeCommandProcessor = new FakeCommandProcessor();
var toDoItem = new ToDoItem {
Title = "Title", Completed = true, Order = 10
};
using (var context = new ToDoContext(options))
{
context.ToDoItems.Add(toDoItem);
context.SaveChanges();
}
var command = new UpdateToDoCommand(toDoItem.Id, NEW_TITLE, NEW_COMPLETED, NEW_ORDER);
var handler = new UpdateToDoCommandHandlerAsync(options, fakeCommandProcessor);
await handler.HandleAsync(command);
using (var context = new ToDoContext(options))
{
Assert.AreEqual(1, context.ToDoItems.Count());
Assert.AreEqual(NEW_TITLE, context.ToDoItems.Single().Title);
Assert.AreEqual(NEW_COMPLETED, context.ToDoItems.Single().Completed);
Assert.AreEqual(NEW_ORDER, context.ToDoItems.Single().Order);
}
// Should not send task complete event
Assert.IsFalse(fakeCommandProcessor.SentCompletedEvent);
}
public async Task When_adding_an_account()
{
//arrange
var commandProcessor = new FakeCommandProcessor();
var handler = new AddNewAccountHandlerAsync(_options, commandProcessor);
var command = new AddNewAccountCommand()
{
Id = Guid.NewGuid(),
Name = new Name {
FirstName = "Jack", LastName = "Torrance"
},
Addresses = new List <Address>
{
new Address("Overlook Hotel", AddressType.Billing, "CO", "80517")
},
ContactDetails = new ContactDetails {
Email = "*****@*****.**", TelephoneNumber = "666-6666"
},
CardDetails = new CardDetails {
CardNumber = "4104231121998973", CardSecurityCode = "517"
}
};
//act
await handler.HandleAsync(command);
var savedAccount = await new EFUnitOfWork(new AccountContext(_options)).GetAsync(command.Id);
//assert
Assert.That(savedAccount.AccountId, Is.EqualTo(command.Id));
Assert.That(savedAccount.Name.FirstName, Is.EqualTo(command.Name.FirstName));
Assert.That(savedAccount.Name.LastName, Is.EqualTo(command.Name.LastName));
var expectedAddress = command.Addresses.First();
var savedAddress = savedAccount.Addresses.FirstOrDefault();
Assert.That(savedAddress, Is.Not.Null);
Assert.That(savedAddress.AddressType, Is.EqualTo(expectedAddress.AddressType));
Assert.That(savedAddress.FistLineOfAddress, Is.EqualTo(expectedAddress.FistLineOfAddress));
Assert.That(savedAddress.State, Is.EqualTo(expectedAddress.State));
Assert.That(savedAddress.ZipCode, Is.EqualTo(expectedAddress.ZipCode));
Assert.IsTrue(commandProcessor.RaiseAccountEvent);
Assert.IsTrue(commandProcessor.AllSent);
}
public async Task Test_Updating_a_ToDo_Title_and_Completed()
{
/*
* Given that I have a command to pdate add a ToDo's Title and Completed
* When I handle that command
* Then I should update the ToDo
*
*/
const string TODO_TITLE = "test_title";
var options = new DbContextOptionsBuilder <ToDoContext>()
.UseInMemoryDatabase("titlecompleted_writes_to_database")
.Options;
var fakeCommandProcessor = new FakeCommandProcessor();
var toDoItem = new ToDoItem {
Title = "This title will be changed"
};
using (var context = new ToDoContext(options))
{
context.ToDoItems.Add(toDoItem);
context.SaveChanges();
}
var command = new UpdateToDoCommand(toDoItem.Id, TODO_TITLE, true);
var handler = new UpdateToDoCommandHandlerAsync(options, fakeCommandProcessor);
await handler.HandleAsync(command);
using (var context = new ToDoContext(options))
{
Assert.AreEqual(1, context.ToDoItems.Count());
Assert.AreEqual(TODO_TITLE, context.ToDoItems.Single().Title);
Assert.AreEqual(true, context.ToDoItems.Single().Completed);
}
// Has sent task complete event
Assert.IsTrue(fakeCommandProcessor.SentCompletedEvent);
}
public async Task when_handling_the_command()
{
async Task should_return_the_result_from_the_command_processor()
{
var expected = new FakeResult();
FakeCommandProcessor.Setup(x => x.ProcessWithResultAsync(It.IsAny <FakeResultCommand>())).Returns(Task.FromResult(expected));
var result = await Subject.Handle(new FakeResultCommand()) as OkObjectResult;
result.StatusCode.Should().Be(200);
result.Value.Should().Be(expected);
}
async Task should_handle_CommandProcessorException()
{
FakeCommandProcessor.Setup(x => x.ProcessWithResultAsync(It.IsAny <FakeResultCommand>())).Throws(new CommandProcessorException("fail"));
var result = await Subject.Handle(new FakeResultCommand());
result.ShouldBeError("fail", 400);
}
async Task should_handle_CommandException()
{
FakeCommandProcessor.Setup(x => x.ProcessWithResultAsync(It.IsAny <FakeResultCommand>())).Throws(new CommandException("invalid"));
var result = await Subject.Handle(new FakeResultCommand());
result.ShouldBeError("invalid", 400);
}
async Task should_handle_Exception()
{
FakeCommandProcessor.Setup(x => x.ProcessWithResultAsync(It.IsAny <FakeResultCommand>())).Throws(new Exception("fail"));
var result = await Subject.Handle(new FakeResultCommand());
result.ShouldBeError("fail", 500);
}
}
public async Task Test_Updating_The_ToDo_Order()
{
/*
Given that I have a command to update a ToDo's complete
When I handle that command
Then I should update the ToDo
*/
const int NEW_ORDER = 523;
var options = new DbContextOptionsBuilder<ToDoContext>()
.UseInMemoryDatabase(databaseName: "order_writes_to_database")
.Options;
var fakeCommandProcessor = new FakeCommandProcessor();
var toDoItem = new ToDoItem() { Title = "This title won't be changed", Completed = true, Order = 10};
using (var context = new ToDoContext(options))
{
context.ToDoItems.Add(toDoItem);
context.SaveChanges();
}
var command = new UpdateToDoCommand(toDoItem.Id, order: NEW_ORDER);
var handler = new UpdateToDoCommandHandlerAsync(options, fakeCommandProcessor);
await handler.HandleAsync(command);
using (var context = new ToDoContext(options))
{
Assert.AreEqual(1, context.ToDoItems.Count());
Assert.AreEqual(toDoItem.Title, context.ToDoItems.Single().Title);
Assert.AreEqual(true, context.ToDoItems.Single().Completed);
Assert.AreEqual(NEW_ORDER, context.ToDoItems.Single().Order);
}
// Should not send task complete event
Assert.IsFalse(fakeCommandProcessor.SentCompletedEvent);
}
public async Task When_adding_a_room_booking_on_account()
{
using (var uow = new BookingContext(_options))
{
//arrange
var booking = new BookGuestRoomOnAccount()
{
BookingId = Guid.NewGuid(),
AccountId = Guid.NewGuid().ToString(),
DateOfFirstNight = DateTime.UtcNow,
NumberOfNights = 1,
NumberOfGuests = 1,
Type = RoomType.King,
Price = 120
};
var commandProcessor = new FakeCommandProcessor();
var handler = new BookGuestRoomOnAccountHandlerAsync(_options, commandProcessor);
//act
await handler.HandleAsync(booking);
//assert
var roomBookingRepositoryAsync = new RoomBookingRepositoryAsync(new EFUnitOfWork(uow));
var savedBooking = await roomBookingRepositoryAsync.GetAsync(booking.BookingId);
Assert.That(savedBooking.RoomBookingId, Is.EqualTo(booking.BookingId));
Assert.That(savedBooking.DateOfFirstNight, Is.EqualTo(booking.DateOfFirstNight));
Assert.That(savedBooking.NumberOfNights, Is.EqualTo(booking.NumberOfNights));
Assert.That(savedBooking.NumberOfGuests, Is.EqualTo(booking.NumberOfGuests));
Assert.That(savedBooking.RoomType, Is.EqualTo(booking.Type));
Assert.That(savedBooking.Price, Is.EqualTo(booking.Price));
Assert.That(savedBooking.AccountId, Is.EqualTo(booking.AccountId));
Assert.That(commandProcessor.AllSent);
Assert.That(commandProcessor.RaiseRoomBookingEvent);
}
}
public async Task when_handling_the_command()
{
CommandName = "FakeCommand";
Json = JObject.Parse("{}");
async Task should_invoke_the_command_processor()
{
FakeCommandProcessor.Setup(x => x.ProcessWithOrWithoutResultAsync(CommandName, Json)).Returns(Task.FromResult(CommandResult.None));
var result = await Subject.Handle(CommandName, Json);
(await result.ExecuteAsync(CancellationToken.None)).Content.Should().BeNull();
}
async Task should_handle_Exception()
{
FakeCommandProcessor.Setup(x => x.ProcessWithOrWithoutResultAsync(CommandName, Json)).Throws(new Exception("fail"));
var result = await Subject.Handle(CommandName, Json) as ExceptionResult;
await result.ShouldBeErrorAsync("fail");
}
}
public async Task When_updating_an_existing_ship_name()
{
//arrange
using (var contextFactory = new FakeShipRegistryContextFactory(_options))
{
var uow = contextFactory.Create();
var repository = new ShipRepositoryAsync(uow);
var ship = new Ship(new Id(), new ShipName("Majestic"), ShipType.Container, new Capacity(50000), new Id());
await repository.AddAsync(ship);
var commandProcessor = new FakeCommandProcessor();
var command = new UpdateShipNameCommand(ship.Id, name: new ShipName("Toronto Star"));
var handler = new UpdateShipNameHandlerAsync(contextFactory, commandProcessor);
//act
await handler.HandleAsync(command);
//assert
var updatedShip = await uow.Ships.SingleOrDefaultAsync(s => s.Id == ship.Id);
Assert.That(updatedShip, Is.Not.Null);
Assert.That(updatedShip.ShipName, Is.EqualTo(command.Name));
Assert.That(updatedShip.Version, Is.EqualTo(1));
Assert.That(ship.Version, Is.EqualTo(1));
var domainEvent = commandProcessor.Messages.SingleOrDefault(m => m.Action == Action.Post);
Assert.That(domainEvent, Is.Not.Null);
var updatedNameMessage = (ShipNameUpdatedEvent)domainEvent.Message;
Assert.That(updatedNameMessage.ShipId, Is.EqualTo(updatedShip.Id));
Assert.That(updatedNameMessage.ShipName, Is.EqualTo(updatedShip.ShipName));
Assert.That(updatedNameMessage.Version, Is.EqualTo(1));
}
}
public void When_too_new_to_sweep_leaves_them()
{
//Arrange
const int milliSecondsSinceSent = 500;
var outbox = new InMemoryOutbox();
var commandProcessor = new FakeCommandProcessor();
var sweeper = new OutboxSweeper(milliSecondsSinceSent, outbox, commandProcessor);
var messages = new Message[] { new MessageTestDataBuilder(), new MessageTestDataBuilder(), new MessageTestDataBuilder() };
foreach (var message in messages)
{
outbox.Add(message);
commandProcessor.Post(message.ToStubRequest());
}
//Act
sweeper.Sweep();
//Assert
commandProcessor.Dispatched.Count.Should().Be(3);
commandProcessor.Posted.Count.Should().Be(0);
}
public async Task when_handling_the_command()
{
async Task should_invoke_the_command_processor()
{
var result = await Subject.Handle(new FakeCommand()) as OkResult;
result.StatusCode.Should().Be(200);
}
async Task should_handle_CommandProcessorException()
{
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Throws(new CommandProcessorException("fail"));
var result = await Subject.Handle(new FakeCommand());
result.ShouldBeError("fail", 400);
}
async Task should_handle_CommandException()
{
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Throws(new CommandException("invalid"));
var result = await Subject.Handle(new FakeCommand());
result.ShouldBeError("invalid", 400);
}
async Task should_handle_Exception()
{
FakeCommandProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeCommand>())).Throws(new Exception("fail"));
var result = await Subject.Handle(new FakeCommand());
result.ShouldBeError("fail", 500);
}
}
public async Task When_trying_to_update_a_locked_Account()
{
var commandProcessor = new FakeCommandProcessor();
using (var uow = new AccountContext(_options))
{
//Add new account directly via repository not handler (needs both entries so no unit of work)
var id = Guid.NewGuid();
var account = new Account()
{
AccountId = id,
Name = new Name {
FirstName = "Jack", LastName = "Torrance"
},
Addresses = new List <Address>
{
new Address("Overlook Hotel", AddressType.Billing, "CO", "80517")
},
ContactDetails = new ContactDetails
{
Email = "*****@*****.**", TelephoneNumber = "666-6666"
},
CardDetails = new CardDetails {
CardNumber = "4104231121998973", CardSecurityCode = "517"
},
};
var repository = new AccountRepositoryAsync(new EFUnitOfWork(uow));
await repository.AddAsync(account);
//create update command
var updateCommand = new UpdateExistingAccountCommand
(
id,
new Name {
FirstName = "Here's", LastName = "Johnny!!!"
},
new List <Address>
{
new Address("Overlook Hotel", AddressType.Billing, "CO", "80517")
},
new ContactDetails {
Email = "*****@*****.**", TelephoneNumber = "666-6666"
},
new CardDetails {
CardNumber = "4104231121998973", CardSecurityCode = "517"
}
);
updateCommand.LockBy = "GRADY";
//Lock the existing account
var aggregateLock = await repository.LockAsync(id.ToString(), "SYS");
//now try to update whilst locked
var handler = new UpdateExistingAccountCommandHandlerAsync(_options, commandProcessor);
Assert.ThrowsAsync <CannotGetLockException>(async() => await handler.HandleAsync(updateCommand));
//release the lock
await aggregateLock.ReleaseAsync();
//now we should be able to get the lock and update
await handler.HandleAsync(updateCommand);
var amendedAccount = await repository.GetAsync(id);
Assert.That(amendedAccount.Name.FirstName, Is.EqualTo(updateCommand.Name.FirstName));
}
}
public async Task When_updating_an_account()
{
var commandProcessor = new FakeCommandProcessor();
using (var uow = new AccountContext(_options))
{
var id = Guid.NewGuid();
var account = new Account()
{
AccountId = id,
Name = new Name {
FirstName = "Jack", LastName = "Torrance"
},
Addresses = new List <Address>
{
new Address("Overlook Hotel", AddressType.Billing, "CO", "80517")
},
ContactDetails =
new ContactDetails {
Email = "*****@*****.**", TelephoneNumber = "666-6666"
},
CardDetails = new CardDetails {
CardNumber = "4104231121998973", CardSecurityCode = "517"
}
};
var repository = new AccountRepositoryAsync(new EFUnitOfWork(uow));
await repository.AddAsync(account);
//create update command
var updateCommand = new UpdateExistingAccountCommand
(
id,
new Name {
FirstName = "Here's", LastName = "Johnny!!!"
},
new List <Address>
{
new Address("Overlook Hotel", AddressType.Billing, "CO", "80517")
},
new ContactDetails {
Email = "*****@*****.**", TelephoneNumber = "666-6666"
},
new CardDetails {
CardNumber = "4104231121998973", CardSecurityCode = "517"
}
);
var handler = new UpdateExistingAccountCommandHandlerAsync(_options, commandProcessor);
//act
//issue update command
await handler.HandleAsync(updateCommand);
//assert
//versions and change to current state
var updateAccount = await repository.GetAsync(id);
Assert.That(updateAccount.AccountId, Is.EqualTo(id));
Assert.That(updateAccount.Name.FirstName, Is.EqualTo(updateCommand.Name.FirstName));
Assert.That(updateAccount.Name.LastName, Is.EqualTo(updateCommand.Name.LastName));
}
}
