public void ShouldCreateBookingByCabType() { var pickupLocation = new GeoCoordinate(12.99711, 77.61469); var bookingRepo = new Mock <IBookingRepository>(); var availableCabsService = new Mock <IAvailableCabsService>(); var availableCab = new Domain.Cab("3", "Toyota Etios", CabType.Pink); availableCabsService.Setup(a => a.GetNearestCab(pickupLocation, new[] { CabType.Pink })).Returns(availableCab); var bookingService = new BookingService(bookingRepo.Object, availableCabsService.Object); var createBookingRequest = new CreateBookingRequest() { PickupLocation = pickupLocation, Destination = new GeoCoordinate(13, 77), Time = DateTime.Now, UserId = "1", CabType = "Pink" }; var booking = bookingService.CreateBooking(createBookingRequest); Assert.That(booking != null); Assert.That(booking.CabId == availableCab.Id); Assert.That(booking.UserId == createBookingRequest.UserId); Assert.That(booking.PickupLocation.Equals(createBookingRequest.PickupLocation)); Assert.That(booking.Destination.Equals(createBookingRequest.Destination)); Assert.That(booking.Time.Equals(createBookingRequest.Time)); availableCabsService.Verify(a => a.GetNearestCab(createBookingRequest.PickupLocation, new[] { CabType.Pink })); bookingRepo.Verify(b => b.Save(booking)); }
public async Task HandleWithValidCreateRequestCallSaveAsExpectedResult() { // Arrange var watchListModel = new WatchListModel { MovieId = 299536, Comments = "Avengers: Infinity is good" }; var config = new MapperConfiguration(m => { m.CreateMap <WatchList, WatchListModel>(); }); var mapper = new Mapper(config); repository = new Mock <IRepository>(); repository.Setup(m => m.Get <WatchList>(It.IsAny <int>())) .Returns((WatchList)null); createWatchList = new CreateBooking(repository.Object, mapper); createWatchListRequest = new CreateBookingRequest(watchListModel); // Act CancellationToken cancellationToken; var result = await createWatchList.Handle(createWatchListRequest, cancellationToken); // Assert Assert.NotNull(result); Assert.Equal(watchListModel.Comments, result.Comments); Assert.Equal(watchListModel.MovieId, result.MovieId); }
public void Create_WhenFlightDoesNotExsit_ShouldThrowAppropriateException() { // Arrange var expectedErrorMessage = "Flight with specified ID does not exist."; var flight = PrepareFlightDetails(); var bookingPassenger = new BookingPassenger { Name = "Test", DateBirth = DateTime.Now.Date, Gender = Gender.Male, Address = "TestAddress", Email = "*****@*****.**" }; var createBookingRequest = new CreateBookingRequest { FlightId = 1, Passengers = new List <BookingPassenger> { bookingPassenger } }; Mapper.Reset(); Mapper.Initialize(cfg => cfg.CreateMap <Booking, BookingDto>()); var mockPersonRepository = new Mock <IRepository <Person> >(); var mockBookingRepository = new Mock <IRepository <Booking> >(); var mockFlightRepository = new Mock <IRepository <Flight> >(); mockFlightRepository.Setup(x => x.GetAll()).Returns(new List <Flight>()); mockBookingRepository.Setup(x => x.GetAll()).Returns(new List <Booking>()); mockPersonRepository.Setup(x => x.GetAll()).Returns(new List <Person>()); var bookingService = new BookingService(Mapper.Instance, mockPersonRepository.Object, mockBookingRepository.Object, mockFlightRepository.Object); // Act & Assert var exception = Assert.Throws <WingsOnNotFoundException>(() => bookingService.CreateBooking(createBookingRequest)); Assert.AreEqual(exception.Message, expectedErrorMessage); }
private Booking PrepareBookingDetails(CreateBookingRequest createBookingRequest) { var bookings = _bookingRepository.GetAll(); var newBookingId = bookings != null && bookings.Any() ? bookings.Max(booking => booking.Id) + 1 : 0; var passengers = createBookingRequest.Passengers .Select(passenger => new Person() { Name = passenger.Name, DateBirth = passenger.DateBirth, Gender = (GenderType)passenger.Gender, Address = passenger.Address, Email = passenger.Email }) .ToList(); UpdateNewBookingPassengers(passengers); var flight = _flightRepository.Get(createBookingRequest.FlightId) ?? throw new WingsOnNotFoundException("Flight with specified ID does not exist."); return(new Booking { Id = newBookingId, Number = GenerateNewBookingNumber(), Flight = flight, Customer = passengers?.FirstOrDefault(), Passengers = passengers, DateBooking = DateTime.Now }); }
public void Create_WhenCorrectData_ShouldReturnSuccessfulResponseWithBookingNumber() { // Arrange var flight = PrepareFlightDetails(); var bookingPassenger = new BookingPassenger { Name = "Test", DateBirth = DateTime.Now.Date, Gender = Gender.Male, Address = "TestAddress", Email = "*****@*****.**" }; var createBookingRequest = new CreateBookingRequest { FlightId = 1, Passengers = new List <BookingPassenger> { bookingPassenger } }; Mapper.Reset(); Mapper.Initialize(cfg => cfg.CreateMap <Booking, BookingDto>()); var mockPersonRepository = new Mock <IRepository <Person> >(); var mockBookingRepository = new Mock <IRepository <Booking> >(); var mockFlightRepository = new Mock <IRepository <Flight> >(); mockFlightRepository.Setup(x => x.Get(It.Is <int>(m => m == flight.Id))).Returns(flight); mockBookingRepository.Setup(x => x.GetAll()).Returns(new List <Booking>()); mockPersonRepository.Setup(x => x.GetAll()).Returns(new List <Person>()); var bookingService = new BookingService(Mapper.Instance, mockPersonRepository.Object, mockBookingRepository.Object, mockFlightRepository.Object); // Act var expectedCreateBookingResponse = bookingService.CreateBooking(createBookingRequest); // Assert Assert.IsNotNull(expectedCreateBookingResponse.BookingNumber); }
private async Task <GenericReadModelResponse <string> > CreateBookingAsync(ProceedBookingRequest webRequest, string paxId) { var response = new GenericReadModelResponse <string>(); var bookingProductModel = new BookingProductModel { ProductId = webRequest.ProductId, DateCheckIn = webRequest.BookDate, PaxIds = new string[] { paxId }, Nights = 1 }; var apiRequest = new CreateBookingRequest(); apiRequest.BookingProducts.Add(bookingProductModel); var apiResponse = await this._heroApiManager.CreateBookingAsync(apiRequest); if (apiResponse.IsError()) { response.AddErrorMessages(apiResponse.GetErrorMessages()); return(response); } response.Model = apiResponse.Model.Id; return(response); }
public async Task HandleWithValidCreateRequestCallSaveAsExpectedResultAsync() { // Arrange var bookingModel = new Booking { Id = 299536, DropLocation = "Chennai, Chrompet" }; var config = new MapperConfiguration(m => { m.CreateMap <Entities.Booking, Booking>(); m.CreateMap <Booking, Entities.Booking>(); }); var mapper = new Mapper(config); var bookingList = MockBookingListResponse().ToList().AsQueryable(); repository = new Mock <IRepository>(); repository.Setup(m => m.Query <Entities.Booking>()) .Returns(bookingList); underTest = new CreateBooking(repository.Object, mapper); request = new CreateBookingRequest(bookingModel); // Act CancellationToken cancellationToken; var result = await underTest.Handle(request, cancellationToken); // Assert Assert.NotNull(result); Assert.Equal(bookingModel.Id, result.Id); Assert.Equal(bookingModel.DropLocation, result.DropLocation); }
public void ShouldReturnCabToPoolIfCreateBookingFails() { var pickupLocation = new GeoCoordinate(12.99711, 77.61469); var bookingRepo = new Mock <IBookingRepository>(); bookingRepo.Setup(b => b.Save(It.IsAny <Domain.Booking>())).Throws <Exception>(); var availableCabsService = new Mock <IAvailableCabsService>(); var availableCab = new Domain.Cab("3", "Toyota Etios", CabType.Pink); availableCabsService.Setup(a => a.GetNearestCab(pickupLocation, new CabType[] { CabType.Regular, CabType.Pink })).Returns(availableCab); var bookingService = new BookingService(bookingRepo.Object, availableCabsService.Object); var createBookingRequest = new CreateBookingRequest() { PickupLocation = pickupLocation, Destination = new GeoCoordinate(13, 77), Time = DateTime.Now, UserId = "1" }; Assert.Throws <Exception>(() => bookingService.CreateBooking(createBookingRequest)); availableCabsService.Verify(a => a.GetNearestCab(createBookingRequest.PickupLocation, new CabType[] { CabType.Regular, CabType.Pink })); availableCabsService.Verify(a => a.ReturnCabToPool(availableCab)); }
public ActionResult <string> CreateBooking(CreateBookingRequest request) { try { // Check if the request is for the authorized accountId if (request.AccountId != _accountService.GetAccountIdFromClaimsPrincipal(this.User)) { _logger.LogWarning("Unauthorized access attempt! Attempt made to create a booking for accountId {accountId} - different to the one that has been authenticated!", request.AccountId); return(StatusCode((int)HttpStatusCode.Unauthorized)); } _roomBookingService.CreateBooking(request); _logger.LogInformation("Booking for (accountId {accountId}, roomId {roomId}) created successfully.", request.AccountId, request.RoomId); return(Ok()); } catch (Exception e) { _logger.LogWarning(e, "Error creating booking for (accountId {accountId}, roomId {roomId})!", request.AccountId, request.RoomId); // Default status code int httpStatusCode = (int)HttpStatusCode.InternalServerError; if (e is NotFoundException || e is RoomCapacityInsufficentException || e is RoomNotAvailableException) { httpStatusCode = (int)HttpStatusCode.UnprocessableEntity; } return(StatusCode(httpStatusCode, e.GetType().Name)); } }
public async Task HandleWithNullCreateRequestCallRetrunNullWithThrowsException() { // Arrange var watchListEntity = new WatchList { MovieId = 299536, Comments = "Avengers: Infinity War is good" }; var watchListModel = new WatchListModel { MovieId = 299536, Comments = "Avengers: Infinity War" }; var config = new MapperConfiguration(m => { m.CreateMap <WatchList, WatchListModel>(); }); var mapper = new Mapper(config); repository = new Mock <IRepository>(); repository.Setup(m => m.Get <WatchList>(It.IsAny <int>())) .Returns(watchListEntity); createWatchList = new CreateBooking(repository.Object, mapper); createWatchListRequest = new CreateBookingRequest(watchListModel); // Act CancellationToken cancellationToken; var result = await createWatchList.Handle(createWatchListRequest, cancellationToken); // Assert Assert.Null(result); }
public CreateBookingResponse CreateBooking(CreateBookingRequest request) { string test = FLEET_API_ROOT_URL + "bookings" + "?access_token=" + FLEET_ACCESS_TOKEN; JsonServiceClient client = new JsonServiceClient(FLEET_API_ROOT_URL); CreateBookingResponse response = client.Post <CreateBookingResponse>("bookings" + "?access_token=" + FLEET_ACCESS_TOKEN, request); return(response); }
public async Task <IActionResult> Create(CreateBookingRequest createBookingRequest) { var response = await Mediator.Send(Mapper.Map <CreateBookingCommand>(createBookingRequest)); return(Created( ApiRoutes.Bookings.Get.Replace("{bookingId}", response.Id.ToString()), Mapper.Map <BookingResponse>(response))); }
public void Limit_int_range_revisited(CreateBookingRequest request) { // arrange // not much here!! // act request.Quantity.Should().BeInRange(1, 10); }
public CreateBookingResponse CreateBooking(CreateBookingRequest createBookingRequest) { var booking = PrepareBookingDetails(createBookingRequest); _bookingRepository.Save(booking); return(new CreateBookingResponse { BookingNumber = booking.Number }); }
// create a new booking and persist it to our fake database. public void CreateBooking(CreateBookingRequest request) { var totalAmount = priceCalculator.GetPriceForBookingWith(1, 2); var capturePaymentWasSuccessful = paymentGateway.CapturePayment(totalAmount); if (capturePaymentWasSuccessful) { repository.AddBooking(new Booking(request.Id, request.Date)); } }
private static CreateBookingRequest CreateBookingRequest() { var bookingRequest = new CreateBookingRequest() { RoomId = 1, Organiser = "test", StartTime = new DateTime(2018, 1, 1, 10, 30, 0), EndTime = new DateTime(2018, 1, 1, 11, 30, 0), }; return(bookingRequest); }
public void ValidateThrowsWhenInvalid() { var request = new CreateBookingRequest { Booking = new Booking { Pax = new List <Pax>() } }; Assert.Throws <InvalidBookingInformationException>(() => request.Validate()); }
public void ValidateDoesNotThrowWhenValid() { var request = new CreateBookingRequest { Booking = new Booking { Pax = new List <Pax> { new Pax() } } }; Assert.DoesNotThrow(() => request.Validate()); }
public ActionResult CreateBooking([FromBody] CreateBookingRequest request) { Console.WriteLine($"Creating booking"); if (request == null) { Console.WriteLine("Create booking request was null or invalid"); return(null); } _bookingService.CreateBooking(request.Name, request.Email, request.BookingId, request.Operation); var result = "Booking request sent"; return(Ok(result)); }
public async Task <IActionResult> CreateBooking([FromBody] CreateBookingRequest data) { if (data.ProductId <= 0) { return(BadRequest("Need a valid productid")); } var product = await _productService.GetProductItem(data.ProductId); if (product == null) { return(BadRequest($"No product found for id {data.ProductId}")); } await _bookingClient.CreateBooking(product.Id, product.Name, product.Price, data.Quantity); return(Ok()); }
public Domain.Booking CreateBooking(CreateBookingRequest createBookingRequest) { var cabTypes = new List <CabType>(); if (!string.IsNullOrEmpty(createBookingRequest.CabType)) { CabType cabType; Enum.TryParse(createBookingRequest.CabType, true, out cabType); cabTypes.Add(cabType); } else { cabTypes.Add(CabType.Regular); cabTypes.Add(CabType.Pink); } var availableCab = AvailableCabsService.GetNearestCab(createBookingRequest.PickupLocation, cabTypes.ToArray()); if (availableCab != null) { try { var booking = new Domain.Booking( Guid.NewGuid().ToString(), createBookingRequest.UserId, availableCab.Id, createBookingRequest.PickupLocation, createBookingRequest.Destination, createBookingRequest.Time, BookingStatus.Accepted ); BookingRepository.Save(booking); return(booking); } catch (Exception) { AvailableCabsService.ReturnCabToPool(availableCab); throw; } } throw new Exception("No cars available"); }
public void ShouldThrowExceptionIfCabsAreNotAvailable() { var pickupLocation = new GeoCoordinate(12.99711, 77.61469); var bookingRepo = new Mock <IBookingRepository>(); var availableCabsService = new Mock <IAvailableCabsService>(); availableCabsService.Setup(a => a.GetNearestCab(pickupLocation, new CabType[] { CabType.Regular, CabType.Pink })).Returns(() => { return(null); }); var bookingService = new BookingService(bookingRepo.Object, availableCabsService.Object); var createBookingRequest = new CreateBookingRequest() { PickupLocation = pickupLocation, Destination = new GeoCoordinate(13, 77), Time = DateTime.Now, UserId = "1" }; Assert.Throws <Exception>(() => bookingService.CreateBooking(createBookingRequest)); availableCabsService.Verify(a => a.GetNearestCab(createBookingRequest.PickupLocation, new CabType[] { CabType.Regular, CabType.Pink })); }
public Booking Post(CreateBookingRequest request) { var bookingCtr = new BookingCtr(); var cafeData = new Cafe { ID = request.CafeID }; var customerData = new Customer { ID = request.PersonID }; var bookingData = new Booking { StartDate = request.StartDate, EndDate = request.EndDate, Customer = customerData }; bookingCtr.CreateBooking(cafeData, bookingData, request.NoOfPeople); return(bookingData); }
public ActionResult Create(CreateBookingRequest request) { try { var booking = new Booking(request.BookingDate.DateTime, request.BookingCount); _bookingStorageHelper.AddBooking(booking); ViewBag.Message = "Created"; return(ViewBooking(booking.Id)); } catch (NotEnoughPeopleException e) { ViewBag.Error = e; return(Create()); } catch (BookingOutsideHoursException e) { ViewBag.Error = e; return(Create()); } }
// Creates a new booking public void CreateBooking(CreateBookingRequest request) { // Get the room var room = _context.Rooms.Where(rb => rb.RoomId == request.RoomId).FirstOrDefault(); // Was the room found? if (room == null) { throw new NotFoundException(); } // Check to see if the room capacity is sufficient if (request.PersonCount > room.Capacity || request.PersonCount < 1) { throw new RoomCapacityInsufficentException(); } // Check to see if there are any conflicting bookings on the room if (_context.RoomBookings.Where(rb => rb.RoomId == request.RoomId && rb.StartDate <= request.EndDate && rb.EndDate >= request.StartDate).ToList().Count > 0) { throw new RoomNotAvailableException(); } // We are OK to insert the booking... var roomBooking = new RoomBooking { RoomId = request.RoomId, AccountId = request.AccountId, StartDate = request.StartDate, EndDate = request.EndDate, PersonCount = request.PersonCount, CalculatedPrice = CalculateBookingPrice(request.StartDate, request.EndDate, room.Price) }; _context.RoomBookings.Add(roomBooking); _context.SaveChanges(); }
// create a new booking and persist it to our fake database. public void CreateBooking(CreateBookingRequest request) { // not part of the test, but is an example of why // we use a separate CreateBookingRequest object // than the domain object Booking itself as parameter // the request has properties that aren't relevant // to persist in the data store. if (!HasPermission(request.RequestedBy)) { throw new InvalidOperationException("You don't have permission."); } // get the price from the price calculator var totalAmount = priceCalculator.GetPriceForBookingWith(1, 2); // assume everything is ok with the booking // usually do more things here var capturePaymentResult = paymentGateway.CapturePayment(totalAmount); if (capturePaymentResult == true) { repository.AddBooking(new Booking(request.Id)); } }
public async Task <ActionResult <Booking> > CreateBooking([FromBody] CreateBookingRequest booking) { return(await Mediator.Send(new CreateBookingCommand(booking))); }
public IActionResult CreateBooking([FromBody] CreateBookingRequest request) { bookingService.CreateBooking(new BookingService.CreateBookingRequest(request.Id, request.RequestedBy, request.Date)); return(Ok()); }
public CreateBookingResponse CreateBooking(CreateBookingRequest request) { string test = FLEET_API_ROOT_URL + "bookings" + "?access_token=" + FLEET_ACCESS_TOKEN; JsonServiceClient client = new JsonServiceClient(FLEET_API_ROOT_URL); CreateBookingResponse response = client.Post<CreateBookingResponse>("bookings" + "?access_token=" + FLEET_ACCESS_TOKEN, request); return response; }
public async Task <GenericReadModelResponse <BookingModel> > CreateBookingAsync(CreateBookingRequest createBookingRequest) { var response = new GenericReadModelResponse <BookingModel>(); var JsonBodyContent = JsonConvert.SerializeObject(createBookingRequest); var httpContent = new StringContent(JsonBodyContent, Encoding.UTF8, "application/json"); var httpTask = _httpClient.PostAsync("bookings", httpContent); var apiResult = await SendApiRequest <BookingModel>(response, httpTask); if (response.IsError()) { return(response); } response.Model = apiResult; return(response); }
public ActionResult <CreateBookingResponse> Put([FromBody] CreateBookingRequest createBookingRequest) { return(Ok(_bookingService.CreateBooking(createBookingRequest))); }