public void WithQuantityReturnsCorrectResult(RequestReservationCommand sut, int newQuantity) { RequestReservationCommand actual = sut.WithQuantity(newQuantity); sut.AsSource().OfLikeness <RequestReservationCommand>() .With(d => d.Quantity).EqualsWhen((s, d) => d.Quantity == newQuantity) .Without(d => d.Id) .ShouldEqual(actual); }
public void ReserveDoesNotThrowWhenQuantityIsEqualToRemaining( Capacity sut, RequestReservationCommand command) { var request = command.WithQuantity(sut.Remaining); var @event = request.ReserveCapacity(); Assert.DoesNotThrow(() => sut.Apply(@event)); }
public void CanReserveReturnsTrueWhenQuantityIsEqualToRemaining( Capacity sut, RequestReservationCommand command) { var request = command.WithQuantity(sut.Remaining); var @event = request.ReserveCapacity(); var actual = sut.CanApply(@event); Assert.True(actual); }
public void ReserveThrowsWhenQuantityIsGreaterThanRemaining( Capacity sut, RequestReservationCommand command) { var greaterQuantity = sut.Remaining + 1; var request = command.WithQuantity(greaterQuantity); var @event = request.ReserveCapacity(); Assert.Throws <ArgumentOutOfRangeException>(() => sut.Apply(@event)); }
public void ReserveDoesNotThrowWhenQuantityIsLessThanRemaining( Capacity sut, RequestReservationCommand command) { var lesserQuantity = sut.Remaining - 1; var request = command.WithQuantity(lesserQuantity); var @event = request.ReserveCapacity(); Assert.DoesNotThrow(() => sut.Apply(@event)); }
public void CanReserveReturnsFalseWhenQuantityIsGreaterThanRemaining( Capacity sut, RequestReservationCommand command) { var greaterQuantity = sut.Remaining + 1; var request = command.WithQuantity(greaterQuantity); var @event = request.ReserveCapacity(); bool actual = sut.CanApply(@event); Assert.False(actual); }
public void ReserveReturnsInstanceWithCorrectlyDecrementedRemaining( int quantity, Capacity sut, RequestReservationCommand command) { var expected = sut.Remaining - quantity; var @event = command.WithQuantity(quantity).ReserveCapacity(); Capacity actual = sut.Apply(@event); Assert.Equal(expected, actual.Remaining); }
public void CanReserveIsConsistentAccrossReplays( Capacity initial, RequestReservationCommand command) { var remaining = initial.Remaining; var request = command.WithQuantity(remaining); var @event = request.ReserveCapacity(); var sut = initial.Apply(@event); var result = sut.CanApply(@event); Assert.True(result); }
public void ConsumeDoesNotWriteEventToRepositoryWhenCapacityIsExceeded( [Frozen] Mock <ICapacityRepository> repositoryMock, CapacityGate sut, RequestReservationCommand command, Capacity capacity) { repositoryMock .Setup(r => r.Read(command.Date.Date)) .Returns(capacity.ToMaybe()); sut.Execute(command.WithQuantity(capacity.Remaining + 1)); repositoryMock.Verify(r => r.Append(command.Date.Date, It.IsAny <CapacityReservedEvent>()), Times.Never()); }
public void ConsumeAcceptsRequestWithinDefaultCapacityWhenRepositoryReturnsNoCapacity( [Frozen] Mock <ICapacityRepository> repositoryStub, [Frozen] Mock <IChannel <ReservationAcceptedEvent> > channelMock, CapacityGate sut, RequestReservationCommand command) { repositoryStub .Setup(r => r.Read(command.Date.Date)) .Returns(Maybe.Empty <Capacity>()); sut.Execute(command.WithQuantity(Capacity.Default.Remaining)); channelMock.Verify(c => c.Send(It.IsAny <ReservationAcceptedEvent>())); }
public void ConsumeDoesNotSendReservedEventWhenCapacityIsExceeded( [Frozen] Mock <ICapacityRepository> repositoryStub, [Frozen] Mock <IChannel <CapacityReservedEvent> > channelMock, CapacityGate sut, RequestReservationCommand command, Capacity capacity) { repositoryStub .Setup(r => r.Read(command.Date.Date)) .Returns(capacity.ToMaybe()); sut.Execute(command.WithQuantity(capacity.Remaining + 1)); channelMock.Verify(c => c.Send(It.IsAny <CapacityReservedEvent>()), Times.Never()); }
public void ConsumeSendsSoldOutEventWhenSoldOut( [Frozen] Mock <ICapacityRepository> repositoryStub, [Frozen] Mock <IChannel <SoldOutEvent> > channelMock, CapacityGate sut, RequestReservationCommand command, Capacity capacity) { repositoryStub .Setup(r => r.Read(command.Date.Date)) .Returns(capacity.ToMaybe()); sut.Execute(command.WithQuantity(capacity.Remaining)); var expected = command.Date.Date; channelMock.Verify(c => c.Send(It.Is <SoldOutEvent>(e => e.Date == expected))); }
public void ConsumeWritesEventToRepositoryWhenCapacityIsAvailable( [Frozen] Mock <ICapacityRepository> repositoryMock, CapacityGate sut, RequestReservationCommand command, Capacity capacity) { repositoryMock .Setup(r => r.Read(command.Date.Date)) .Returns(capacity.ToMaybe()); var requestWithinCapacity = command.WithQuantity(capacity.Remaining - 1); sut.Execute(requestWithinCapacity); var expected = requestWithinCapacity.ReserveCapacity().Id; repositoryMock.Verify(r => r.Append(requestWithinCapacity.Date.Date, It.Is <CapacityReservedEvent>(e => e.Id == expected))); }
public void ConsumeSendsRejectEventWhenRequestExceedsCapacity( [Frozen] Mock <ICapacityRepository> repositoryStub, [Frozen] Mock <IChannel <ReservationRejectedEvent> > channelMock, CapacityGate sut, RequestReservationCommand command, Capacity capacity) { repositoryStub .Setup(r => r.Read(command.Date.Date)) .Returns(capacity.ToMaybe()); var requestExceedingCapacity = command.WithQuantity(capacity.Remaining + 1); sut.Execute(requestExceedingCapacity); var expected = requestExceedingCapacity.Reject().Id; channelMock.Verify(c => c.Send(It.Is <ReservationRejectedEvent>(e => e.Id == expected))); }
public void ConsumeDoesNotForwardReplayedEvent( [Frozen] Mock <ICapacityRepository> repositoryMock, [Frozen] Mock <IChannel <CapacityReservedEvent> > capacityChannelMock, [Frozen] Mock <IChannel <SoldOutEvent> > soldOutChannelMock, CapacityGate sut, RequestReservationCommand command, Capacity originalCapacity) { var requestWithinCapacity = command.WithQuantity(originalCapacity.Remaining - 1); var newCapacity = originalCapacity.Apply(requestWithinCapacity.ReserveCapacity()); repositoryMock .Setup(r => r.Read(command.Date.Date)) .Returns(newCapacity.ToMaybe()); sut.Execute(requestWithinCapacity); repositoryMock.Verify(r => r.Append(requestWithinCapacity.Date.Date, It.IsAny <CapacityReservedEvent>()), Times.Never()); capacityChannelMock.Verify(r => r.Send(It.IsAny <CapacityReservedEvent>()), Times.Never()); soldOutChannelMock.Verify(r => r.Send(It.IsAny <SoldOutEvent>()), Times.Never()); }