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