public void ShouldCreateValidReservation(string start, string end)
{
IReservationRepository resRepo = new ReservationRepoDouble();
IHostRepository hostRepo = new HostRepoDouble();
IGuestRepository guestRepo = new GuestRepoDouble();
ReservationService service = new ReservationService(resRepo, guestRepo, hostRepo);
Host host = hostRepo.ReadAll()[0];
Guest guest = guestRepo.ReadAll()[0];
Reservation toAdd = new Reservation
{
StartDate = DateTime.Parse(start),
EndDate = DateTime.Parse(end),
Guest = guest,
Host = host
};
Result <Reservation> result = service.Create(toAdd);
Assert.IsTrue(result.Success);
Assert.AreEqual(2, result.Value.ID);
Assert.AreEqual(host, result.Value.Host);
Assert.AreEqual(guest, result.Value.Guest);
Assert.AreEqual(DateTime.Parse(start), result.Value.StartDate);
Assert.AreEqual(DateTime.Parse(end), result.Value.EndDate);
}
public void CreateShouldNotAllowNonListedHost()
{
IReservationRepository resRepo = new ReservationRepoDouble();
IHostRepository hostRepo = new HostRepoDouble();
IGuestRepository guestRepo = new GuestRepoDouble();
ReservationService service = new ReservationService(resRepo, guestRepo, hostRepo);
Host host = new Host
{
Email = "*****@*****.**",
LastName = "Duper",
ID = "abc-123",
City = "Chicago",
State = "IL",
StandardRate = 50M,
WeekendRate = 100M
};
Guest guest = guestRepo.ReadAll()[0];
Reservation toAdd = new Reservation
{
StartDate = DateTime.Parse("2022,02,02"),
EndDate = DateTime.Parse("2022,02,06"),
Guest = guest,
Host = host
};
Result <Reservation> result = service.Create(toAdd);
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Messages[0].Contains("host"));
Assert.IsNull(result.Value);
}
public void ReservationCreateTest()
{
var roomMapper = new MapperConfiguration(
cfg =>
{
cfg.CreateMap<Room, RoomDTO>().ReverseMap();
cfg.CreateMap<PriceCategory, PriceCategoryDTO>().ReverseMap();
cfg.CreateMap<Category, CategoryDTO>().ReverseMap();
}).CreateMapper();
var clientMapper = new MapperConfiguration(
cfg => cfg.CreateMap<Client, ClientDTO>()).CreateMapper();
var reservationDTO = new ReservationDTO()
{
ReservationID = 5,
ReservationDate = DateTime.Parse("12.07.2021"),
ArrivalDate = DateTime.Parse("01.08.2021"),
DepartureDate = DateTime.Parse("11.08.2021"),
SettledIn = false,
RoomReservation = roomMapper.Map<Room, RoomDTO>(DataForTests.Rooms[0]),
ClientResevation = clientMapper.Map<Client, ClientDTO>(DataForTests.Clients[2])
};
EFWorkUnitMock.Setup(x => x.Reservations.Create(fromDTOMapper.Map<ReservationDTO, Reservation>(reservationDTO)));
var reservationService = new ReservationService(EFWorkUnitMock.Object);
reservationService.Create(reservationDTO);
EFWorkUnitMock.Verify(x => x.Reservations.Create(fromDTOMapper.Map<ReservationDTO, Reservation>(reservationDTO)));
}
public ActionResult <Reservation> Create([FromBody] Reservation reservation)
{
if (reservation == null)
{
return(NotFound("Reservering is null"));
}
var amountOfTables = (int)Math.Ceiling((double)reservation.Guests / 6);
var tables = _tableService.Get().Where(x => x.IsAvailable && x.Setting == reservation.Setting)
.Take(amountOfTables).ToList();
if (tables.Count <= 0 || !tables.Any())
{
return(NotFound("Er zijn geen tafels beschikbaar voor deze reservering!"));
}
foreach (var table in tables)
{
table.IsAvailable = false;
_tableService.Update(table);
}
reservation.TableIds = new List <string>();
reservation.TableIds.AddRange(tables.Select(x => x.Id).ToList());
reservation.ReservationArrival = reservation.ReservationArrival.ToLocalTime();
reservation.ReservationDepature = reservation.ReservationArrival.AddHours(1.0).ToLocalTime();
_reservationService.Create(reservation);
return(Ok(reservation));
}
public void AddShouldNotAllowNullHost()
{
IReservationRepository resRepo = new ReservationRepoDouble();
IHostRepository hostRepo = new HostRepoDouble();
IGuestRepository guestRepo = new GuestRepoDouble();
ReservationService service = new ReservationService(resRepo, guestRepo, hostRepo);
Host host = null;
Guest guest = guestRepo.ReadAll()[0];
Reservation toAdd = new Reservation
{
StartDate = DateTime.Parse("2022,02,02"),
EndDate = DateTime.Parse("2022,02,06"),
Guest = guest,
Host = host
};
Result <Reservation> result = service.Create(toAdd);
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Messages[0].Contains("host"));
Assert.IsNull(result.Value);
}
public async Task <ActionResult> Create(ReservationCreateDTO Reservation)
{
var result = await _ReservationService.Create(Reservation);
return(CreatedAtAction(
"GetById",
new { id = result.ReservationId },
result));
}
public IActionResult Reserve(ReservationModel model)
{
if (model.FormOption == "DELETE" && model.ReservationId != null)
{
_reservationService.Delete(model.ReservationId);
TempData["message"] = new AlertMessage {
CssClass = "alert-success", Id = string.Empty, Title = "Reservering verwijderd", Message = "Uw Reservering is succesvol verwijderd!"
};
return(Reserve());
}
if (!ModelState.IsValid)
{
return(Reserve());
}
if (model.FormOption == null)
{
_reservationService.Create(new Reservation
{
ArriveDate = model.ArriveDate,
DepartureDate = model.DepartureDate,
EmailAddress = model.EmailAddress,
PhoneNumber = model.PhoneNumber,
UserId = User.FindFirstValue(ClaimTypes.UserData)
});
TempData["message"] = new AlertMessage {
CssClass = "alert-success", Id = string.Empty, Title = "Reservering gemaakt", Message = "Uw Reservering is succesvol aangemaakt!"
};
}
else
{
var reservationToUpdate = _reservationService.Get(model.ReservationId);
// Reservation does not exists return view
if (reservationToUpdate == null)
{
return(Reserve());
}
reservationToUpdate.EmailAddress = model.EmailAddress;
reservationToUpdate.PhoneNumber = model.PhoneNumber;
reservationToUpdate.ArriveDate = model.ArriveDate;
reservationToUpdate.DepartureDate = model.DepartureDate;
// Update reservation
_reservationService.Update(reservationToUpdate);
TempData["message"] = new AlertMessage {
CssClass = "alert-success", Id = string.Empty, Title = "Reservering bijgewerkt.", Message = "Uw reservering is succesvol bijgewerkt!"
};
}
return(Reserve());
}
public void Create_ReservationObject_IdReservation()
{
var mock = new Mock <IReservationRepository>();
var reserv = new Reserv()
{
Id = 2
};
mock.Setup(repo => repo.Create(It.IsAny <Reserv>())).Returns(22);
var service = new ReservationService(mock.Object);
Assert.AreEqual(reserv.Id, service.Create(reserv));
}
public void Retrieve_PriorityReservations()
{
ReservationService.Create(new ReservationRequest()
{
Owner = "Juanjo", Prepaid = true
});
ReservationService.Create(new ReservationRequest()
{
Owner = "Juanjo"
});
var priorityReservations = ReservationService.PriorityReservations();
priorityReservations.Count.ShouldBe(1);
}
public async Task <ActionResult <Reservation> > Post([FromBody] Reservation reservation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
Reservation res = await _reservationService.Create(reservation);
return(CreatedAtAction(nameof(Get), res.Id, res));
}
catch (ArgumentException exception)
{
return(BadRequest(exception.Message));
}
}
public static void CreateShouldNotAllowNullReservation()
{
IReservationRepository resRepo = new ReservationRepoDouble();
IHostRepository hostRepo = new HostRepoDouble();
IGuestRepository guestRepo = new GuestRepoDouble();
ReservationService service = new ReservationService(resRepo, guestRepo, hostRepo);
Host host = hostRepo.ReadAll()[0];
Guest guest = guestRepo.ReadAll()[0];
Reservation toAdd = null;
Result <Reservation> result = service.Create(toAdd);
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Messages[0].Contains("reservation"));
Assert.IsNull(result.Value);
}
public void Create_ShouldSuccessfulyAdd_To_Database()
{
//Arrange
var data = flights.AsQueryable();
var TicketsData = ticketTypes.AsQueryable();
var mockSet = new Mock <DbSet <Reservation> >();
var mockSetTickets = new Mock <DbSet <TicketType> >();
mockSetTickets.As <IQueryable <TicketType> >().Setup(m => m.Provider).Returns(TicketsData.Provider);
mockSetTickets.As <IQueryable <TicketType> >().Setup(m => m.Expression).Returns(TicketsData.Expression);
mockSetTickets.As <IQueryable <TicketType> >().Setup(m => m.ElementType).Returns(TicketsData.ElementType);
mockSetTickets.As <IQueryable <TicketType> >().Setup(m => m.GetEnumerator()).Returns(() => TicketsData.GetEnumerator());
var mockSetFlight = new Mock <DbSet <Flight> >();
mockSetFlight.As <IQueryable <Flight> >().Setup(m => m.Provider).Returns(data.Provider);
mockSetFlight.As <IQueryable <Flight> >().Setup(m => m.Expression).Returns(data.Expression);
mockSetFlight.As <IQueryable <Flight> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSetFlight.As <IQueryable <Flight> >().Setup(m => m.GetEnumerator()).Returns(() => data.GetEnumerator());
var mockContext = new Mock <FlightManagerDbContext>();
mockContext.Setup(x => x.Flights).Returns(mockSetFlight.Object);
mockContext.Setup(x => x.TicketTypes).Returns(mockSetTickets.Object);
mockContext.Setup(x => x.Reservations).Returns(mockSet.Object);
var flight = data.FirstOrDefault(x => x.UniquePlaneNumber == 123456);
reservationListView.Reservations = reservation;
//Act
var service = new ReservationService(mockContext.Object);
service.Create(reservationListView, flight.UniquePlaneNumber);
//Assert
mockContext.Verify(x => x.SaveChanges(), Times.AtLeastOnce());
}
public void UpdateShouldNotAllowInvalidDates(string newStart, string newEnd)
{
IReservationRepository resRepo = new ReservationRepoDouble();
IHostRepository hostRepo = new HostRepoDouble();
IGuestRepository guestRepo = new GuestRepoDouble();
ReservationService service = new ReservationService(resRepo, guestRepo, hostRepo);
Host host = hostRepo.ReadAll()[0];
Guest guest = guestRepo.ReadAll()[0];
Reservation toAdd = new Reservation
{
StartDate = new DateTime(2021, 12, 28),
EndDate = new DateTime(2021, 12, 29),
Guest = guest,
Host = host
};
toAdd.SetTotal();
Reservation toUpdate = new Reservation
{
StartDate = DateTime.Parse(newStart),
EndDate = DateTime.Parse(newEnd),
Host = host,
Guest = guest,
ID = 2
};
var adddingResult = service.Create(toAdd);
var result = service.Update(2, toUpdate);
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Messages[0].Contains("date"));
Assert.IsNull(result.Value);
Assert.AreEqual(adddingResult.Value, service.ViewByHost(hostRepo.ReadAll()[0]).Value[0]);
Assert.AreEqual(2, service.ViewByHost(hostRepo.ReadAll()[0]).Value.Count);
}
public void CreateShouldNotAllowInvalidReservationDates(string start, string end)
{
IReservationRepository resRepo = new ReservationRepoDouble();
IHostRepository hostRepo = new HostRepoDouble();
IGuestRepository guestRepo = new GuestRepoDouble();
ReservationService service = new ReservationService(resRepo, guestRepo, hostRepo);
Host host = hostRepo.ReadAll()[0];
Guest guest = guestRepo.ReadAll()[0];
Reservation toAdd = new Reservation
{
StartDate = DateTime.Parse(start),
EndDate = DateTime.Parse(end),
Guest = guest,
Host = host
};
Result <Reservation> result = service.Create(toAdd);
Assert.IsFalse(result.Success);
Assert.IsNull(result.Value);
Assert.IsTrue(result.Messages[0].Contains("date"));
}
public ActionResult Create(Reservation reservation)
{
_service.Create(reservation);
return(Ok(reservation));
}
public IHttpActionResult Reserve([FromBody] ReservationRequest reservation)
{
ReservationService.Create(reservation);
return(Ok());
}
private void Add()
{
ConsoleIO.DisplayLine("*** Add Reservation ***");
//get the host list and resrvations
Result <List <Reservation> > reservationsResult = GetReservations();
ConsoleIO.DisplayStatus(reservationsResult.Success, reservationsResult.Messages);
if (reservationsResult.Success)
{
ConsoleIO.DisplayReservationList(reservationsResult.Value);
}
else
{
return;
}
//instantiate a host
Host host = reservationsResult.Value.FirstOrDefault().Host;
//get guest & instantiate
string guestEmail = ConsoleIO.PromptString("Enter guest email", false);
Result <Guest> guestResult = reservationService.FindGuestByEmail(guestEmail);
if (!guestResult.Success)
{
ConsoleIO.DisplayStatus(guestResult.Success, guestResult.Messages);
return;
}
else
{
ConsoleIO.DisplayLine("Guest found");
ConsoleIO.DisplayLine("");
}
Guest guest = guestResult.Value;
//get start date (required)
DateTime startDate = ConsoleIO.PromptDateTime("Reservation start date", false);
//get end date (required)
DateTime endDate = ConsoleIO.PromptDateTime("Reservation end date", false);
//perform Create and display result
Reservation toAdd = new Reservation
{
StartDate = startDate,
EndDate = endDate,
Guest = guest,
Host = host
};
toAdd.SetTotal();
ConsoleIO.DisplayReservationSummary(toAdd);
if (!ConsoleIO.PromptYesNo())
{
ConsoleIO.DisplayLine("Reservation was not added");
return;
}
Result <Reservation> createResult = reservationService.Create(toAdd);
ConsoleIO.DisplayStatus(createResult.Success, createResult.Messages);
if (createResult.Success)
{
ConsoleIO.DisplayLine($"Reservation with ID {createResult.Value.ID} created");
}
}