public void AcceptWhenOtherReservationsEndBeforeReservationStarts(
double seatingDuration,
int[] seats,
int[] reservations,
int quantity)
{
var dt = new DateTime(2019, 11, 22, 18, 30, 0);
var reservation = new Reservation
{
Date = dt,
Quantity = quantity
};
var sut = new MaîtreD(
TimeSpan.FromMinutes(seatingDuration),
seats.Select(s => new Table(s)).ToArray());
var actual = sut.CanAccept(
reservations.Select(x =>
new Reservation
{
Date = dt.Subtract(TimeSpan.FromMinutes(seatingDuration)),
Quantity = x
}).ToArray(),
reservation);
Assert.True(actual);
}
public void CanAcceptReturnsCorrectResult(
int[] seats,
int[] reservations,
int quantity,
bool expected)
{
var dt = new DateTime(2019, 11, 21);
var reservation = new Reservation
{
Date = dt,
Quantity = quantity
};
var sut = new MaîtreD(
TimeSpan.FromHours(2),
seats.Select(s => new Table(s)).ToArray());
var actual = sut.CanAccept(
reservations
.Select(x => new Reservation {
Date = dt, Quantity = x
})
.ToList(),
reservation);
Assert.Equal(expected, actual);
}
public void RejectWhenRestaurantHasNoTables(int quantity)
{
var reservation = new Reservation
{
Date = new DateTime(2019, 11, 21),
Quantity = quantity
};
var sut = new MaîtreD(TimeSpan.FromHours(2));
var actual = sut.CanAccept(new Reservation[0], reservation);
Assert.False(actual);
}
public void AcceptWhenTableIsAvailable(int quantity)
{
var reservation = new Reservation
{
Date = new DateTime(2019, 11, 20),
Quantity = quantity
};
var sut = new MaîtreD(TimeSpan.FromHours(2), new Table(quantity));
var actual = sut.CanAccept(new Reservation[0], reservation);
Assert.True(actual);
}
public void TryAcceptReturnsNothingOnInsufficientCapacity(
Reservation reservation,
Reservation[] reservations,
MaîtreD sut)
{
var reservedSeats = reservations.Sum(r => r.Quantity);
sut = sut.WithCapacity(reservedSeats + reservation.Quantity - 1);
var actual = sut.TryAccept(reservations, reservation);
Assert.True(actual.IsNothing);
Assert.False(reservation.IsAccepted);
}
public void TryAcceptReturnsNullOnReservationInThePast(
Reservation reservation,
IReadOnlyCollection <Reservation> reservations,
int id,
MaîtreD sut)
{
reservation.IsAccepted = false;
var actual = sut.TryAccept(reservation);
Assert.True(
actual.Accept(new StubReservationsVisitor <IMaybe <int> >(false, reservations, id)).IsNothing());
Assert.False(reservation.IsAccepted);
}
public void TryAcceptReturnsNullOnReservationInThePast(
Reservation reservation,
IReadOnlyCollection <Reservation> reservations,
int id,
MaîtreD sut)
{
reservation.IsAccepted = false;
var actual = sut.TryAccept(reservation);
Assert.Null(
actual.Run(new StubReservationsHandler(false, reservations, id)).Result);
Assert.False(reservation.IsAccepted);
}
public void TryAcceptReturnsReservationInHappyPathScenario(
Reservation reservation,
Reservation[] reservations,
MaîtreD sut,
int excessCapacity)
{
var reservedSeats = reservations.Sum(r => r.Quantity);
sut = sut.WithCapacity(
reservedSeats + reservation.Quantity + excessCapacity);
var actual = sut.TryAccept(reservations, reservation);
Assert.Equal(new Maybe <Reservation>(reservation.Accept()), actual);
}
public void TryAcceptReturnsNullOnInsufficientCapacity(
Reservation reservation,
IReadOnlyCollection <Reservation> reservations,
int id,
MaîtreD sut)
{
reservation.IsAccepted = false;
var reservedSeats = reservations.Sum(r => r.Quantity);
sut = sut.WithCapacity(reservedSeats + reservation.Quantity - 1);
var actual = sut.TryAccept(reservation);
Assert.True(
actual.Accept(new StubReservationsVisitor <IMaybe <int> >(true, reservations, id)).IsNothing());
Assert.False(reservation.IsAccepted);
}
public void RejectAnyReservationLargerThanTheBiggestTable(int[] seats)
{
var dt = new DateTime(2019, 10, 10);
var biggestTable = seats.Max();
var reservation = new Reservation
{
Date = dt,
Quantity = biggestTable + 1
};
var sut = new MaîtreD(
TimeSpan.FromHours(2),
seats.Select(s => new Table(s)).ToArray());
var actual = sut.CanAccept(new Reservation[0], reservation);
Assert.False(actual);
}
public void TryAcceptReturnsNullOnInsufficientCapacity(
Reservation reservation,
IReadOnlyCollection <Reservation> reservations,
int id,
MaîtreD sut)
{
reservation.IsAccepted = false;
var reservedSeats = reservations.Sum(r => r.Quantity);
sut = sut.WithCapacity(reservedSeats + reservation.Quantity - 1);
var actual = sut.TryAccept(reservation);
Assert.Null(
actual.Run(new StubReservationsHandler(true, reservations, id)).Result);
Assert.False(reservation.IsAccepted);
}
public void RejectReservationOverTotalCapacity(int[] seats)
{
var dt = new DateTime(2017, 3, 8);
var capacity = seats.Sum();
var reservation = new Reservation
{
Date = dt,
Quantity = capacity + 1
};
var sut = new MaîtreD(
TimeSpan.FromHours(2),
seats.Select(s => new Table(s)).ToArray());
var actual = sut.CanAccept(new Reservation[0], reservation);
Assert.False(actual);
}
public void CanAcceptWhenCommunalTableHasEnoughCapacity(
string date,
int quantity,
int capacity)
{
var reservation = new Reservation
{
Date = DateTime.Parse(date),
Quantity = quantity
};
var sut = new MaîtreD(
TimeSpan.FromHours(2),
new Table(capacity));
var actual = sut.CanAccept(new Reservation[0], reservation);
Assert.True(actual);
}
public void RejectReservationWhenTableIsAlreadyTaken(int quantity)
{
var dt = new DateTime(2019, 10, 3);
var reservation = new Reservation
{
Date = dt,
Quantity = quantity
};
var sut = new MaîtreD(TimeSpan.FromHours(2), new Table(quantity));
var actual = sut.CanAccept(
new[] { new Reservation {
Date = dt, Quantity = quantity
} },
reservation);
Assert.False(actual);
}
public void UsageExample()
{
var connectionString = ConnectionStrings.Reservations;
var maîtreD = new MaîtreD(10);
var reservation = new Reservation
{
Date = DateTimeOffset.Now.AddDays(27),
Name = "Mark Seemann",
Email = "*****@*****.**",
Quantity = 2
};
var p = maîtreD.TryAccept(reservation);
var id = p.Accept(new SqlReservationsProgramVisitor <int?>(connectionString));
Assert.NotNull(id);
Assert.NotEqual(default(int), id);
}
public void TryAcceptReturnsReservationIdInHappyPathScenario()
{
//Arrange
Reservation reservation = new Reservation {
Quantity = 10
};
var expected = 1;
var repo = new Mock <IReservationsRepository>();
repo.Setup(r => r.ReadReservations(It.IsAny <DateTime>())).Returns(Enumerable.Empty <Reservation>());
repo.Setup(r => r.Create(reservation)).Returns(expected);
MaîtreD sut = new MaîtreD(20, repo.Object);
//Act
var actual = sut.TryAccept(reservation);
//Assert
Assert.Equal(expected, actual);
}
public void TryAcceptReturnsReservationIdInHappyPathScenario(
Reservation reservation,
IReadOnlyCollection <Reservation> reservations,
MaîtreD sut,
int excessCapacity,
int expected)
{
var reservedSeats = reservations.Sum(r => r.Quantity);
reservation.IsAccepted = false;
sut = sut.WithCapacity(
reservedSeats + reservation.Quantity + excessCapacity);
var actual = sut.TryAccept(reservation);
Assert.Equal(
new Just <int>(expected),
actual.Accept(new StubReservationsVisitor <IMaybe <int> >(true, reservations, expected)));
Assert.True(reservation.IsAccepted);
}
public void TryAcceptOnInsufficientCapacity()
{
Reservation reservation = new Reservation {
Quantity = 21
};
var id = 1;
var repo = new Mock <IReservationsRepository>();
repo.Setup(r => r.ReadReservations(It.IsAny <DateTime>())).Returns(Enumerable.Empty <Reservation>());
repo.Setup(r => r.Create(reservation)).Returns(id);
MaîtreD sut = new MaîtreD(20, repo.Object);
int?expected = null;
//Act
var actual = sut.TryAccept(reservation);
//Assert
Assert.Equal(expected, actual);
}
public void CanNotAcceptWhenCommunalTableHasInsufficientCapacity(
int quantity,
int capacity)
{
DateTime dt = new DateTime(2018, 8, 30);
var reservation = new Reservation
{
Date = dt,
Quantity = quantity
};
var sut = new MaîtreD(TimeSpan.FromHours(2), new Table(capacity));
var actual = sut.CanAccept(
new[] { new Reservation {
Date = dt, Quantity = 7
} },
reservation);
Assert.False(actual);
}
public Property CanAcceptReturnsReservationInHappyPathScenario()
{
return(Prop.ForAll((
from rs in GenerateReservation.ListOf()
from r in GenerateReservation
from cs in Arb.Default.NonNegativeInt().Generator
select(rs, r, cs.Item)).ToArbitrary(),
x =>
{
var(reservations, reservation, capacitySurplus) = x;
var reservedSeats = reservations.Sum(r => r.Quantity);
var capacity =
reservation.Quantity + reservedSeats + capacitySurplus;
var sut = new MaîtreD(capacity);
var actual = sut.CanAccept(reservations, reservation);
Assert.True(actual);
}));
}
public void RejectAnyReservationWhenSoldOut(int[] seats)
{
var dt = new DateTime(2018, 3, 2);
var reservation = new Reservation
{
Date = dt,
Quantity = 1
};
var sut = new MaîtreD(
TimeSpan.FromHours(2),
seats.Select(s => new Table(s)).ToArray());
var actual = sut.CanAccept(
seats.Select(s => new Reservation {
Date = dt, Quantity = s
}),
reservation);
Assert.False(actual);
}
public Property CanAcceptOnInsufficientCapacity()
{
return(Prop.ForAll((
from r in GenerateReservation
from eq in Arb.Default.PositiveInt().Generator
from cs in Arb.Default.NonNegativeInt().Generator
from rs in GenerateReservation.ListOf()
select(r, eq.Item, cs.Item, rs)).ToArbitrary(),
x =>
{
var(reservation, excessQuantity, capacitySurplus, reservations) = x;
var reservedSeats = reservations.Sum(r => r.Quantity);
var quantity = capacitySurplus + excessQuantity;
var capacity = capacitySurplus + reservedSeats;
reservation.Quantity = quantity;
var sut = new MaîtreD(capacity);
var actual = sut.CanAccept(reservations, reservation);
Assert.False(actual);
}));
}
public static MaîtreD WithCapacity(
this MaîtreD maîtreD,
int newCapacity)
{
return(new MaîtreD(newCapacity));
}
