public void succesful_reservation()
{
var rendition = new ReservationRendition
{
Quantity = 3,
Date = "02-07-2020"
};
var response = reservationController
.Post(rendition)
.ExecuteAsync(new CancellationToken())
.Result;
Assert.AreEqual(response.StatusCode,
HttpStatusCode.OK);
}
public void Post_ValidIntervalRatePlanData_Returns200Ok()
{
var reservation = new ReservationModel
{
AmountOfAdults = 1,
AmountOfChildren = 0,
RatePlanId = -3,
ReservationStart = new DateTime(2020, 08, 01),
ReservationEnd = new DateTime(2020, 08, 03),
RoomId = -1
};
var connection = new SqliteConnection("Data Source=:memory:");
connection.Open();
var dbContextOptions = new DbContextOptionsBuilder <InventoryContext>()
.UseSqlite(connection)
.Options;
var context = new InventoryContext(dbContextOptions);
context.Database.EnsureCreated();
var controller = new ReservationsController(context);
var response = controller.Post(reservation);
Assert.IsType <OkObjectResult>(response);
}
public async Task Post_WithRoomAndProfiles_AddsReservation()
{
var newReservation = new NewReservation
{
From = DateTime.Today.AddDays(3),
To = DateTime.Today.AddDays(7),
RoomId = 3,
GuestIds = new List <int> {
2
}
};
using var context = new PrimeDbContext(dbContextOptions);
var result = await controller.Post(newReservation);
var okResult = result.As <OkObjectResult>();
var reservationId = okResult.Value.As <int>();
var addedReservation = await context.Reservations
.Include(p => p.Profiles)
.Include(r => r.Room)
.FirstOrDefaultAsync(r => r.Id == reservationId);
addedReservation.Should().NotBeNull();
addedReservation.Profiles.Should().NotBeNull();
addedReservation.Profiles.Count.Should().Be(1);
addedReservation.Profiles[0].Id.Should().Be(2);
addedReservation.Room.Should().NotBeNull();
addedReservation.Room.Id.Should().Be(3);
}
public void Post_With_Book_Calls_Repo_Borrow()
{
// Arrange
var mockRepo = new Mock <IReservationRepository <Reservation, Book, User> >();
mockRepo.Setup(mock => mock.Borrow(It.IsAny <Book>(), It.IsAny <User>()));
Mock <IPrincipal> mockPrincipal = new Mock <IPrincipal>();
mockPrincipal.SetupGet(p => p.Identity.Name).Returns("Alice");
var requestContext = new Mock <HttpRequestContext>();
requestContext.Setup(x => x.Principal).Returns(mockPrincipal.Object);
ReservationsController controller = new ReservationsController(mockRepo.Object)
{
RequestContext = requestContext.Object
};
Book newBook = new Book()
{
Id = 0
};
// Act
controller.Post(newBook);
// Assert
mockRepo.Verify(mock => mock.Borrow(It.Is <Book>(b => b == newBook), It.Is <User>(u => u.Name == "Alice")), Times.Once);
}
public void PostWithValidDataSavesReservation(string mobileNumber, string destination)
{
try
{
// Arrange
var sut = new ReservationsController();
this.makeReservation.MobileNumber = mobileNumber;
this.makeReservation.Destination = destination;
// Act
sut.Post(this.makeReservation);
// Assert
var json = File.ReadAllText(this.JsonFilePath);
var actual = JsonConvert.DeserializeObject <MakeReservation>(json);
Assert.Equal(this.makeReservation.Name, actual.Name);
Assert.Equal(this.makeReservation.NumberOfPeople, actual.NumberOfPeople);
Assert.Equal(this.makeReservation.Destination, actual.Destination);
Assert.Equal(this.makeReservation.MobileNumber, actual.MobileNumber);
Assert.Equal(this.makeReservation.StartDate, actual.StartDate);
Assert.Equal(this.makeReservation.EndDate, actual.EndDate);
}
finally
{
// Teardown
File.Delete(this.JsonFilePath);
}
}
public void PostReturnsConflictResultWhenDuplicateReservationIsSaved()
{
try
{
// Arrange
var sut = new ReservationsController();
sut.Post(this.makeReservation);
// Act
var actual = sut.Post(this.makeReservation);
// Assert
Assert.IsType <ConflictResult>(actual);
}
finally
{
// Teardown
File.Delete(this.JsonFilePath);
}
}
public void PostInvalidDto(PositiveInt capacity)
{
var sut = new ReservationsController(
new FakeReservationsRepository(),
capacity.Item);
var dto = new ReservationDto {
};
var actual = sut.Post(dto);
var br = Assert.IsAssignableFrom <BadRequestObjectResult>(actual);
var msg = Assert.IsAssignableFrom <string>(br.Value);
Assert.NotEmpty(msg);
}
public async Task ReservationFails()
{
var repo = new FakeReservationsRepository();
var sut = new ReservationsController(10, repo);
var reservation = new Reservation(
date: new DateTimeOffset(2018, 8, 13, 16, 53, 0, TimeSpan.FromHours(2)),
email: "*****@*****.**",
name: "Mark Seemann",
quantity: 11);
var actual = await sut.Post(reservation);
Assert.False(reservation.IsAccepted);
Assert.False(repo.Contains(reservation));
Assert.IsAssignableFrom <InternalServerErrorActionResult>(actual);
}
public void PostInvalidDto(int capacity)
{
var sut = new ReservationsController(
TimeSpan.FromHours(2.5),
new[] { new Table(capacity) },
new FakeReservationsRepository(),
new SystemClock());
var dto = new ReservationDto {
};
var actual = sut.Post(dto);
var br = Assert.IsAssignableFrom <BadRequestObjectResult>(actual);
var msg = Assert.IsAssignableFrom <string>(br.Value);
Assert.NotEmpty(msg);
}
public async Task ReservationSucceeds()
{
var repo = new FakeReservationsRepository();
var sut = new ReservationsController(10, repo);
var reservation = new Reservation(
date: new DateTimeOffset(2018, 8, 13, 16, 53, 0, TimeSpan.FromHours(2)),
email: "*****@*****.**",
name: "Mark Seemann",
quantity: 4);
var actual = await sut.Post(reservation);
Assert.True(repo.Contains(reservation.Accept()));
var expectedId = repo.GetId(reservation.Accept());
var ok = Assert.IsAssignableFrom <OkActionResult>(actual);
Assert.Equal(expectedId, ok.Value);
}
public void PostValidDtoWhenNoPriorReservationsExist(
NonNegativeInt capacitySurplus,
PositiveInt quantity)
{
var repository = new FakeReservationsRepository();
var capacity = capacitySurplus.Item + quantity.Item;
var sut = new ReservationsController(repository, capacity);
var dto = new ReservationDto
{
Date = "2019-08-20",
Quantity = quantity.Item
};
var actual = sut.Post(dto);
Assert.IsAssignableFrom <OkObjectResult>(actual);
Assert.NotEmpty(repository);
}
public void PostWithValidDataReturnsOkResult()
{
try
{
// Arrange
var sut = new ReservationsController();
// Act
ActionResult actual = sut.Post(this.makeReservation);
// Assert
Assert.IsType <OkResult>(actual);
}
finally
{
// Teardown
File.Delete(this.JsonFilePath);
}
}
public void PostValidDtoWhenSoldOut(
PositiveInt capacity,
PositiveInt excessQuantity)
{
var repository = new FakeReservationsRepository();
var quantity = capacity.Item + excessQuantity.Item;
var sut = new ReservationsController(repository, capacity.Item);
var dto = new ReservationDto
{
Date = "2019-08-20",
Quantity = quantity
};
var actual = sut.Post(dto);
var c = Assert.IsAssignableFrom <ObjectResult>(actual);
Assert.Equal(StatusCodes.Status500InternalServerError, c.StatusCode);
}
public void PostReturnsCorrectResultWhenDateisInvalid()
{
var sut = new ReservationsController(
new Mock <IReservationsRepository>().Object);
var actual =
sut.Post(
new ReservationDto
{
Date = "Not a date",
Name = "Mark Seemann",
Email = "*****@*****.**",
Quantity = 4
});
var badReq =
Assert.IsAssignableFrom <BadRequestErrorMessageResult>(actual);
Assert.Equal("Invalid date.", badReq.Message);
}
public void PostWithInvalidMobileNumberReturnsBadRquest(string invalidMobilNumber)
{
try
{
// Arrange
var sut = new ReservationsController();
this.makeReservation.MobileNumber = invalidMobilNumber;
// Act
var actual = sut.Post(this.makeReservation);
// Assert
Assert.IsType <BadRequestResult>(actual);
}
finally
{
// Teardown
File.Delete(this.JsonFilePath);
}
}
public void PostValidDtoWhenSoldOut(int capacity, int quantity)
{
var repository = new FakeReservationsRepository();
var now = new DateTime(2019, 9, 27);
var sut = new ReservationsController(
TimeSpan.FromHours(2.5),
new[] { new Table(capacity) },
repository,
new ConstantClock(now));
var dto = new ReservationDto
{
Date = now.AddDays(2).ToString(),
Quantity = quantity
};
var actual = sut.Post(dto);
var c = Assert.IsAssignableFrom <ObjectResult>(actual);
Assert.Equal(StatusCodes.Status500InternalServerError, c.StatusCode);
}
public void Post_With_Reservation_Calls_Repo_Add()
{
// Arrange
var mockRepo = new Mock <IRepository <Reservation> >();
mockRepo.Setup(mock => mock.Add(It.IsAny <Reservation>()));
ReservationsController controller = new ReservationsController(mockRepo.Object);
Reservation newReservation = new Reservation()
{
bookId = 1,
startDate = new System.DateTime(2016, 1, 1, 1, 0, 0),
endDate = new System.DateTime(2016, 1, 1, 2, 0, 0),
};
// Act
controller.Post(newReservation);
// Assert
mockRepo.Verify(mock => mock.Add(It.Is <Reservation>(b => b == newReservation)), Times.Once);
}
public void PostValidDtoWhenNoPriorReservationsExist(
int capacity,
int quantity)
{
var repository = new FakeReservationsRepository();
var now = new DateTime(2019, 9, 24);
var sut = new ReservationsController(
TimeSpan.FromHours(2.5),
new[] { new Table(capacity) },
repository,
new ConstantClock(now));
var dto = new ReservationDto
{
Date = now.AddDays(1).ToString(),
Quantity = quantity
};
var actual = sut.Post(dto);
Assert.IsAssignableFrom <OkResult>(actual);
Assert.NotEmpty(repository);
}
public void PostReturnsCorrectResultWhenCapacityIsInsufficient()
{
var repo = new Mock <IReservationsRepository>();
var sut = new ReservationsController(repo.Object);
repo
.Setup(r => r.ReadReservedSeats(It.IsAny <DateTime>()))
.Returns(sut.Capacity);
var actual =
sut.Post(
new ReservationDto
{
Date = "2016-05-31",
Name = "Mark Seemann",
Email = "*****@*****.**",
Quantity = 1
});
var statusCode = Assert.IsAssignableFrom <StatusCodeResult>(actual);
Assert.Equal(HttpStatusCode.Forbidden, statusCode.StatusCode);
}
public void PostReturnsCorrectResultAndHasCorrectStateOnAcceptableRequest()
{
var json =
new ReservationDto
{
Date = "2016-05-31",
Name = "Mark Seemann",
Email = "*****@*****.**",
Quantity = 1
};
var repo = new Mock <IReservationsRepository>();
repo
.Setup(r => r.ReadReservedSeats(new DateTime(2016, 5, 31)))
.Returns(0);
var sut = new ReservationsController(repo.Object);
var actual = sut.Post(json);
Assert.IsAssignableFrom <OkResult>(actual);
repo.Verify(
r => r.SaveReservation(new DateTime(2016, 5, 31), json));
}
public void PostValidDtoWhenEnoughCapacityExists()
{
//Arrange
var expected = 1;
var dto = new ReservationDto {
Quantity = 10
};
Mock <IValidator> validator = GetValidator(dto);
Mock <IMapper> mapper = GetMapper(dto);
var md = new Mock <IMaîtreD>();
md.Setup(m => m.TryAccept(It.IsAny <Reservation>())).Returns(expected);
ReservationsController sut = new ReservationsController(validator.Object, mapper.Object, md.Object);
//Act
var actual = sut.Post(dto);
//Assert
var ok = Assert.IsAssignableFrom <OkObjectResult>(actual);
Assert.Equal(expected, ok.Value);
}
public void PostInvalidDto()
{
//Arrange
ReservationDto dto = new ReservationDto();
var validator = new Mock <IValidator>();
validator.Setup(v => v.Validate(dto)).Returns(It.IsAny <string>());
Mock <IMapper> mapper = GetMapper(dto);
var maîtreD = new Mock <IMaîtreD>();
maîtreD.Setup(maî => maî.TryAccept(It.IsAny <Reservation>()));
ReservationsController sut = new ReservationsController(validator.Object, mapper.Object, maîtreD.Object);
//Act
var actual = sut.Post(dto);
//Assert
var br = Assert.IsAssignableFrom <BadRequestObjectResult>(actual);
var expected = sut.Response;
Assert.Equal(expected, br.Value);
}
public void PostPastReservationWhenNoPriorReservationsExist(
int capacity,
int quantity)
{
var repository = new FakeReservationsRepository();
var now = new DateTime(2019, 8, 21);
var sut = new ReservationsController(
TimeSpan.FromHours(2.5),
new[] { new Table(capacity) },
repository,
new ConstantClock(now));
var dto = new ReservationDto
{
Date = now.Subtract(TimeSpan.FromDays(1)).ToString(),
Quantity = quantity
};
var actual = sut.Post(dto);
var br = Assert.IsAssignableFrom <BadRequestObjectResult>(actual);
var msg = Assert.IsAssignableFrom <string>(br.Value);
Assert.NotEmpty(msg);
}
public void PostValidDtoWhenSoldOut()
{
//Arrange
var dto = new ReservationDto {
Date = "01/01/1970"
};
Mock <IValidator> validator = GetValidator(dto);
Mock <IMapper> mapper = GetMapper(dto);
var md = new Mock <IMaîtreD>();
md.Setup(m => m.TryAccept(It.IsAny <Reservation>())).Returns((int?)null);
ReservationsController sut = new ReservationsController(validator.Object, mapper.Object, md.Object);
//Act
var actual = sut.Post(dto);
//Assert
var c = Assert.IsAssignableFrom <ObjectResult>(actual);
var expected = 500;
Assert.Equal(expected, c.StatusCode);
}