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