public void Run_WithCancelReservationOptionAndNoExistingReservation_ShouldCancelReservation()
{
// Arrange.
var car = new Car {
CarId = 1, Model = "Camry", Quantity = 2
};
var user = new User {
UserId = 2, Email = "*****@*****.**", FirstName = "Ananth", LastName = "Tatachar"
};
var reservationOption = new ReservationOptions
{
NewReservation = false,
CancelReservation = true,
CarModel = car.Model,
Email = user.Email,
FromDate = new DateTime(2018, 01, 03),
ToDate = new DateTime(2018, 01, 05),
UserName = $"{user.FirstName} {user.LastName}"
};
_carInfoProvider.GetCar(reservationOption.CarModel).ReturnsForAnyArgs(car);
_userInfoProvider.GetUser(new Tuple <string, string>(user.FirstName, user.LastName), user.Email).ReturnsForAnyArgs(user);
_reservationsRepository.GetReservation(user.UserId, car.CarId, reservationOption.FromDate,
reservationOption.ToDate).ReturnsNullForAnyArgs();
_reservationsService.TryCancel(null, car, user).Returns(1);
// Act + Assert.
var ex = Assert.Throws <ArgumentException>(() => _target.Run(reservationOption));
Assert.That(ex.ToString().Contains("Reservation does not exist"));
}
public void Run_WithMakeReservationOption_ShouldMakeNewReservation()
{
// Arrange.
var car = new Car {
CarId = 1, Model = "Camry", Quantity = 2
};
var user = new User {
UserId = 2, Email = "*****@*****.**", FirstName = "Ananth", LastName = "Tatachar"
};
var reservationOption = new ReservationOptions
{
NewReservation = true, CancelReservation = false, CarModel = car.Model, Email = user.Email,
FromDate = new DateTime(2018, 01, 03), ToDate = new DateTime(2018, 01, 05),
UserName = $"{user.FirstName} {user.LastName}"
};
_carInfoProvider.GetCar(reservationOption.CarModel).ReturnsForAnyArgs(car);
_userInfoProvider.GetUser(new Tuple <string, string>(user.FirstName, user.LastName), user.Email).ReturnsForAnyArgs(user);
_reservationsRepository.GetReservation(user.UserId, car.CarId, reservationOption.FromDate,
reservationOption.ToDate).ReturnsNullForAnyArgs();
_reservationsService.TryReserve(reservationOption, car, user).Returns(1);
// Act.
var result = _target.Run(reservationOption);
// Assert.
Assert.That(result == 1);
}
public void TryReserve_WithZeroCarQtyAndPreviousNonOverLappingBookings_ShouldBeReserved()
{
// Arrange .
const int carQuantity = 0;
var car = new Car {
CarId = 1, Model = "Camry", Quantity = carQuantity
};
var user = new User {
UserId = 2, Email = "*****@*****.**", FirstName = "Ananth", LastName = "Tatachar"
};
var reservationOption = new ReservationOptions
{
NewReservation = true,
CancelReservation = false,
CarModel = car.Model,
Email = user.Email,
FromDate = new DateTime(2018, 01, 01),
ToDate = new DateTime(2018, 01, 05),
UserName = $"{user.FirstName} {user.LastName}"
};
_reservationsRepository.GetCountOfPreviousReservation(car.CarId, reservationOption.FromDate)
.ReturnsForAnyArgs(1);
// Act .
var result = _target.TryReserve(reservationOption, car, user);
// Assert .
Assert.That(result == 1);
}
public void TryReserve_ValidArguments_ShouldBeReserved()
{
// Arrange .
const int carQuantity = 2;
var car = new Car {
CarId = 1, Model = "Camry", Quantity = carQuantity
};
var user = new User {
UserId = 2, Email = "*****@*****.**", FirstName = "Ananth", LastName = "Tatachar"
};
var reservationOption = new ReservationOptions
{
NewReservation = true,
CancelReservation = false,
CarModel = car.Model,
Email = user.Email,
FromDate = new DateTime(2018, 01, 01),
ToDate = new DateTime(2018, 01, 05),
UserName = $"{user.FirstName} {user.LastName}"
};
// Act .
var result = _target.TryReserve(reservationOption, car, user);
// Assert .
Assert.That(result == 1);
Assert.That(car.Quantity == carQuantity - 1);
}
public void ValidateAction(ReservationOptions reservationOptions)
{
if (!reservationOptions.NewReservation || !reservationOptions.CancelReservation)
{
return;
}
const string errorMessage = "Cannot cancel and make reservation at the same time";
Logger.Error(errorMessage);
throw new ArgumentException(errorMessage);
}
public void ValidateBookingDates_WithValidBookingDates_ShouldNotThrowException()
{
// Arrange .
var reservationOptions = new ReservationOptions
{
FromDate = new DateTime(2018, 01, 01), ToDate = new DateTime(2018, 01, 04)
};
// Act + Arrange .
_target.ValidateBookingDates(reservationOptions);
}
public void ValidateBookingDates(ReservationOptions reservationOptions)
{
if (reservationOptions.ToDate > reservationOptions.FromDate)
{
return;
}
{
var errorMessage = $" {reservationOptions.FromDate} should be less than {reservationOptions.ToDate} ";
Logger.Error(errorMessage);
throw new ArgumentException(errorMessage);
}
}
public void ValidateAction_WithMakeReservationAndCancelReservationSet_ShouldThrowError()
{
// Arrange.
var reservationOption = new ReservationOptions {
CancelReservation = true, NewReservation = true
};
// Act + Arrange .
var ex = Assert.Throws <ArgumentException>(() => _target.ValidateAction(reservationOption));
Assert.That(ex.ToString().Contains("Cannot cancel and make reservation at the same time"));
}
public void ValidateBookingDates_WithInvalidBookingDates_ShouldThrowException()
{
// Arrange .
var reservationOptions = new ReservationOptions
{
FromDate = new DateTime(2018, 01, 04), ToDate = new DateTime(2018, 01, 02)
};
// Act + Arrange .
var ex = Assert.Throws <ArgumentException>(() => _target.ValidateBookingDates(reservationOptions));
Assert.That(ex.ToString().Contains($" {reservationOptions.FromDate} should be less than {reservationOptions.ToDate} "));
}
public void Validate(ReservationOptions reservationOptions)
{
ValidateAction(reservationOptions);
ValidateBookingDates(reservationOptions);
ValidateAndRegisterUserIfNotExist(reservationOptions.UserName, reservationOptions.Email);
if (_carInfoProvider.CarExists(reservationOptions.CarModel))
{
return;
}
var errorMessage =
$" Invalid car model: {reservationOptions.CarModel}, available car models are: . {Environment.NewLine} {_carInfoProvider.GetAllCarModels()}";
Logger.Error(errorMessage);
throw new ArgumentException(errorMessage);
}
public void Validate_WithInvalidCarModelOption_ShouldThrowException()
{
// Arrange .
var reservationOptions = new ReservationOptions
{
UserName = "******", NewReservation = true, CancelReservation = false, CarModel = "Unknown",
Email = "*****@*****.**", FromDate = new DateTime(2018, 01, 02),
ToDate = new DateTime(2018, 01, 04)
};
_carInfoProvider.CarExists(reservationOptions.CarModel).ReturnsForAnyArgs(false);
_carInfoProvider.GetAllCarModels().ReturnsForAnyArgs(new StringBuilder("Benz"));
// Act + Arrange .
var ex = Assert.Throws <ArgumentException>(() => _target.Validate(reservationOptions));
Assert.That(ex.ToString().Contains("Invalid car model"));
}
public int TryReserve(ReservationOptions reservationOptions, Car car, User user)
{
var countOfPreviousReservations =
_reservationsRepository.GetCountOfPreviousReservation(car.CarId, reservationOptions.FromDate);
if (car.Quantity <= 0 && (car.Quantity + countOfPreviousReservations) <= 0)
{
Logger.Error("Unable to make reservation as no cars of this model are available.");
return(0);
}
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
var transaction = connection.BeginTransaction();
try
{
car.Quantity = car.Quantity - 1;
_carInfoProvider.ReserveCar(car, connection, transaction);
_reservationsRepository.MakeReservation(
new Reservation
{
CarId = car.CarId,
UserId = user.UserId,
Status = Constants.ReservationStatus.Reserved,
FromDate = reservationOptions.FromDate,
ToDate = reservationOptions.ToDate
}, connection, transaction);
transaction.Commit();
return(1);
}
catch (Exception e)
{
transaction.Rollback();
Logger.Error(e.ToString());
throw;
}
}
}
public int Run(ReservationOptions reservationOptions)
{
var user = GetUser(reservationOptions);
var car = _carInfoProvider.GetCar(reservationOptions.CarModel);
var existingReservation = _reservationsRepository.GetReservation(user.UserId, car.CarId,
reservationOptions.FromDate, reservationOptions.ToDate);
if (reservationOptions.NewReservation)
{
if (existingReservation != null)
{
const string errorMessage = " Reservation already exists ";
Logger.Error(errorMessage);
throw new ArgumentException(errorMessage);
}
var result = _reservationsService.TryReserve(reservationOptions, car, user);
Logger.Info(result == 1 ? "Reservation made successfully." : "Unable to make reservation.");
return(result);
}
if (!reservationOptions.CancelReservation)
{
return(0);
}
{
if (existingReservation == null && reservationOptions.CancelReservation)
{
const string errorMessage = " Reservation does not exist ";
Logger.Error(errorMessage);
throw new ArgumentException(errorMessage);
}
var result = _reservationsService.TryCancel(existingReservation, car, user);
Logger.Info(result == 1 ? "Reservation cancelled successfully." : "Unable to make reservation.");
return(result);
}
}
private User GetUser(ReservationOptions reservationOptions)
{
var userName = _userInfoProvider.GetFirstAndLastNames(reservationOptions.UserName);
return(_userInfoProvider.GetUser(userName, reservationOptions.Email));
}
