public void RegisterMotorcycle_WithoutCC_ShouldReturnException()
{
// Arrange (preparación, organizar)
var entryBuilder = new EntryDTOBuilder();
DtoEntry entry = entryBuilder
.WithCC(null)
.Build();
// cuando se ejecute este método en el entry service va a retornar true en la validacion de ExistsQuotaByVehicleType
_cellService.Setup(cs => cs.ExistsQuotaByVehicleType(VehicleTypeEnum.motorcycle)).Returns(true);
_placaService.Setup(ps => ps.GetLastNumberOfIdVehicle(entry.IdVehicleType, entry.IdVehicle)).Returns("5");
var entryService = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);
// Act
try
{
entryService.RegistryVehicle(entry);
}
catch (Exception e)
{
var message = "Falta la información del cilindraje de la motocicleta";
// Assert (confirmacion)
Assert.IsInstanceOfType(e, typeof(EntryException));
Assert.AreEqual(e.Message, message);
}
}
public void RegisterVehicle_WithoutCellAvaliable_ShouldReturnException()
{
// Arrange (preparación, organizar)
var entryBuilder = new EntryDTOBuilder()
.WithVehicleId("SFL555")
.WithVehicleType(VehicleTypeEnum.car);
_cellService.Setup(cs => cs.ExistsQuotaByVehicleType(VehicleTypeEnum.car)).Returns(false);
var entryService = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);
DtoEntry entry = entryBuilder.Build();
// Act
try
{
entryService.RegistryVehicle(entry);
}
catch (Exception e)
{
var message = "No hay cupos disponibles";
// Assert (confirmacion)
Assert.IsInstanceOfType(e, typeof(CellException));
Assert.AreEqual(e.Message, message);
}
}
public ActionResult <IEnumerable <DtoEntry> > SaveEntry(EntryModel entry)
{
DtoEntry added = new DtoEntry();
if (ModelState.IsValid)
{
try
{
added = _entryService.RegistryVehicle(EntryMapper.convertModelToDTO(entry));
}
catch (Exception e)
{
if (e is AppException)
{
return(UnprocessableEntity(e.Message));
}
else
{
return(BadRequest(e.Message));
}
}
}
return(CreatedAtAction(nameof(GetEntry), new { id = added.Id }, added));
}
public void RegisterCar_WithBadIdVehicleFormat_ShouldReturnException()
{
// Arrange (preparación, organizar)
var entryBuilder = new EntryDTOBuilder()
.WithVehicleId("SFL55A")
.WithVehicleType(VehicleTypeEnum.car);
DtoEntry entry = entryBuilder.Build();
_cellService.Setup(cs => cs.ExistsQuotaByVehicleType(VehicleTypeEnum.car)).Returns(true);
var entryService = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);
// Act
try
{
entryService.RegistryVehicle(entry);
}
catch (Exception e)
{
var message = "Hubo un problema al leer la placa del vehículo. Verifique el tipo de vehículo e intente de nuevo";
// Assert (confirmacion)
Assert.IsInstanceOfType(e, typeof(EntryException));
Assert.AreEqual(e.Message, message);
}
}
public static DtoEntry convertModelToDTO(EntryModel entry)
{
DtoEntry dtoEntry = new DtoEntry();
if (entry != null)
{
dtoEntry.CC = entry.CC;
dtoEntry.IdVehicle = entry.IdVehicle;
dtoEntry.IdVehicleType = entry.IdVehicleType;
}
return(dtoEntry);
}
public static DtoEntry ConvertEntityToDTO(EntryEntity entry)
{
DtoEntry entryEntity = new DtoEntry();
if (entry != null)
{
entryEntity.CC = entry.CC;
entryEntity.IdVehicle = entry.IdVehicle;
entryEntity.IdVehicleType = entry.IdVehicleType;
entryEntity.Id = entry.Id;
entryEntity.EntryTime = entry.EntryTime;
}
return(entryEntity);
}
public static EntryEntity ConvertDTOToEntity(DtoEntry entry)
{
EntryEntity entryEntity = new EntryEntity();
if (entry != null)
{
entryEntity.CC = entry.CC;
entryEntity.EntryTime = DateTime.Now;
entryEntity.IdVehicle = entry.IdVehicle;
entryEntity.IdVehicleType = entry.IdVehicleType;
entryEntity.Id = Guid.NewGuid().ToString();
}
return(entryEntity);
}
public static EntryModel convertDTOToModel(DtoEntry entry)
{
EntryModel entryModel = new EntryModel();
if (entry != null)
{
entryModel.CC = entry.CC;
entryModel.IdVehicle = entry.IdVehicle;
entryModel.IdVehicleType = entry.IdVehicleType;
entryModel.Id = entry.Id;
entryModel.EntryTime = entry.EntryTime;
}
return(entryModel);
}
public DtoEntry RegistryVehicle(DtoEntry entry)
{
var lastEntryByIdVehicle = _entryRepository.List(e => e.IdVehicle == entry.IdVehicle).LastOrDefault();
if (lastEntryByIdVehicle != null)
{
var departure = _departureService.GetDepartureByEntryId(lastEntryByIdVehicle.Id);
if (departure == null)
{
throw new EntryException("El vehículo que está registrando posee una salida pendiente");
}
}
if (!_cellService.ExistsQuotaByVehicleType(entry.IdVehicleType))
{
throw new CellException("No hay cupos disponibles");
}
string lastNumberIdVehicle = _placaService.GetLastNumberOfIdVehicle(entry.IdVehicleType, entry.IdVehicle);
bool isParsed = short.TryParse(lastNumberIdVehicle, out short numberResult);
if (!isParsed)
{
throw new EntryException("Hubo un problema al leer la placa del vehículo. Verifique el tipo de vehículo e intente de nuevo");
}
if (_placaService.HasPicoPlaca(entry.IdVehicleType, (int)DateTime.Now.DayOfWeek, numberResult))
{
throw new EntryException("El vehículo no puede ser registrado, tiene pico y placa.");
}
if ((entry.IdVehicleType == VehicleTypeEnum.motorcycle) && string.IsNullOrEmpty(entry.CC))
{
throw new EntryException("Falta la información del cilindraje de la motocicleta");
}
var entryEntity = _entryRepository.Add(EntryMapper.ConvertDTOToEntity(entry));
if (entryEntity == null)
{
throw new EntryException("Ocurrio un problema al guardar el registro");
}
_cellService.DecreaseCell(entryEntity.IdVehicleType, 1);
return(EntryMapper.ConvertEntityToDTO(entryEntity));
}
public void RegisterVehicle_WithPendingDeparture_ShouldReturnException()
{
// Arrange (preparación, organizar)
var entryBuilder = new EntryDTOBuilder()
.WithVehicleId("SFL55D")
.WithVehicleType(VehicleTypeEnum.motorcycle)
.WithCC("1000");
var uniqueId = Guid.NewGuid().ToString();
var entryList = new List <EntryEntity>();
var entryEntity = new EntryEntityBuilder().Build();
entryList.Add(entryEntity);
var departureEntity = new DepartureEntityBuilder()
.WithIdEntry(uniqueId)
.Build();
DtoEntry entry = entryBuilder.Build();
entryRepository.Setup(er => er.List(e => e.IdVehicle == entry.IdVehicle)).Returns(entryList);
var entryService = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);
// Act
try
{
entryService.RegistryVehicle(entry);
}
catch (Exception e)
{
var message = "El vehículo que está registrando posee una salida pendiente";
// Assert (confirmacion)
Assert.IsInstanceOfType(e, typeof(EntryException));
Assert.AreEqual(e.Message, message);
}
}
