public void ReserveCapacityReturnsCorrectResult(RequestReservationCommand sut) { CapacityReservedEvent actual = sut.ReserveCapacity(); sut.AsSource().OfLikeness <CapacityReservedEvent>() .ShouldEqual(actual); }
public void MakeReservationReturnsCorrectResult(BookingViewModel sut) { RequestReservationCommand actual = sut.MakeReservation(); var expected = sut.AsSource().OfLikeness <RequestReservationCommand>().Without(d => d.Id); expected.ShouldEqual(actual); }
public void ReserveDoesNotHaveSideEffects( RequestReservationCommand request, CapacityReservedEvent @event, Capacity sut) { var actual = sut.Apply(@event); Assert.NotEqual(actual, sut); }
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 ReserveReturnsInstanceWithWithoutDecrementingRemainingWhenRequestWasAlreadyAccepted( RequestReservationCommand request, CapacityReservedEvent @event, Capacity sut) { var expected = sut.Apply(@event); var actual = expected.Apply(@event); Assert.Equal(expected, actual); }
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 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 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 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 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 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 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 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 ConsumeRequestWithEnoughCapacitySendsCorrectEvent( [Frozen] Mock <ICapacityRepository> repositoryStub, [Frozen] Mock <IChannel <ReservationAcceptedEvent> > channelMock, CapacityGate sut, RequestReservationCommand command, Capacity capacity) { repositoryStub .Setup(r => r.Read(It.IsAny <DateTime>())) .Returns(capacity.ToMaybe()); sut.Execute(command); var expected = command.Accept().Id; channelMock.Verify(c => c.Send(It.Is <ReservationAcceptedEvent>(e => e.Id == expected))); }
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()); }
public void SutIsMessage(RequestReservationCommand sut) { Assert.IsAssignableFrom <IMessage>(sut); }
public void EnvelopReturnsCorrectBody(RequestReservationCommand sut) { var actual = sut.Envelop(); Assert.Equal(sut, actual.Body); }
public void NameIsCorrect([Frozen] string expected, RequestReservationCommand sut) { Assert.Equal <string>(expected, sut.Name); }
public void DateIsCorrect([Frozen] DateTime expected, RequestReservationCommand sut) { Assert.Equal <DateTime>(expected, sut.Date); }
public void QuantityIsCorrect([Frozen] int expected, RequestReservationCommand sut) { Assert.Equal <int>(expected, sut.Quantity); }
public void IdIsUnique(RequestReservationCommand sut, RequestReservationCommand other) { Assert.NotEqual(sut.Id, other.Id); }
public void IdIsStable(RequestReservationCommand sut) { Assert.Equal(sut.Id, sut.Id); }
public void EnvelopReturnsCorrectVersion(RequestReservationCommand sut) { var actual = sut.Envelop(); Assert.Equal("1", actual.Version); }
public void AcceptReturnsCorrectResult(RequestReservationCommand sut) { ReservationAcceptedEvent actual = sut.Accept(); sut.AsSource().OfLikeness <ReservationAcceptedEvent>().ShouldEqual(actual); }