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