public void UpdateEntity_Should_Update_planeType_typeof_PlaneType()
{
// Arrange
PlaneTypeDTO planeTypeDTO = new PlaneTypeDTO
{
Id = 1,
Carrying = 240000,
Model = "Passenger's",
Seats = 200
};
PlaneType planeType = new PlaneType
{
Id = 1,
Carrying = 240000,
Model = "Passenger's",
Seats = 200
};
var planeTypeRepository = A.Fake <IRepository <PlaneType> >();
A.CallTo(() => planeTypeRepository.Get(A <int> ._)).Returns(new PlaneType {
Id = 1
});
var planeTypeService = new PlaneTypeService(planeTypeRepository);
//Act
planeTypeService.UpdateEntity(1, planeTypeDTO);
var result = planeTypeRepository.Get(1);
// Assert
Assert.AreEqual(planeType, result);
}
public void AddDeletePlaneType_Returns_CreatedResult_And_PlaneType_ShoudBe_AddedTo_Database_And_Then_ShouldBe_Deleted()
{
// Arrange
MSSQLContext context = new MSSQLContext();
PlaneTypesRepository planeTypesRepository = new PlaneTypesRepository();
PlanesRepository planesRepository = new PlanesRepository();
AircraftUnitOfWork uow = new AircraftUnitOfWork(planesRepository, planeTypesRepository, context);
AircraftService service = new AircraftService(uow);
PlaneTypesController controller = new PlaneTypesController(mapper.GetDefaultMapper(), service);
// add act
var newPlaneTypeDTO = new PlaneTypeDTO()
{
Capacity = 100,
CargoCapacity = 5000,
Model = "Hurricane"
};
var addResult = controller.AddPlaneType(newPlaneTypeDTO);
// add assert
Assert.IsInstanceOf <CreatedResult>(addResult);
Assert.IsInstanceOf <PlaneTypeDTO>((addResult as CreatedResult).Value);
// delete act
var addedPlaneTypeDTO = (addResult as CreatedResult).Value as PlaneTypeDTO;
var deleteResult = controller.DeletePlaneType(addedPlaneTypeDTO.Id);
// delete assert
Assert.IsInstanceOf <OkResult>(deleteResult);
Assert.IsInstanceOf <NotFoundObjectResult>(controller.GetPlaneType(addedPlaneTypeDTO.Id));
}
public async Task <IActionResult> Update(int id, [FromBody] PlaneTypeDTO item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
item.Id = id;
await service.GetById(id);
await service.Update(item);
await service.SaveChanges();
return(Ok(item));
}
catch (NotFoundException e)
{
return(NotFound(e.Message));
}
catch (Exception)
{
return(BadRequest());
}
}
[Test] // behaviour test
public void Create_When_entity_is_created_Then_it_makes_calls_to_repository_and_unit_of_work()
{
// Arrange
var planeTypeDTOToCreate = new PlaneTypeDTO()
{
Model = "AAABBBCCC",
Seats = 500,
Carrying = 400
};
var planeTypeRepositoryFake = A.Fake <IPlaneTypeRepository>();
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <PlaneType>()).Returns(planeTypeRepositoryFake);
var planeTypeService = new PlaneTypeService(unitOfWorkFake, AlwaysValidValidator);
// Act
var result = planeTypeService.Create(planeTypeDTOToCreate);
// Assert. Just behaviour
A.CallTo(() => planeTypeRepositoryFake.Create(A <PlaneType> ._)).MustHaveHappenedOnceExactly();
A.CallTo(() => unitOfWorkFake.Set <PlaneType>()).MustHaveHappenedOnceExactly();
A.CallTo(() => unitOfWorkFake.SaveChanges()).MustHaveHappenedOnceExactly();
}
public async Task ValidationMappingPlaneType_when_validate_pilot_OK_then_map()
{
var validator = new PlaneTypeDTOValidator();
PlaneTypeDTO correct = new PlaneTypeDTO()
{
Id = 1,
Model = "Model"
};
PlaneTypeDTO incorrect = new PlaneTypeDTO()
{
Id = 2,
NumberOfSeats = 25
};
bool correctRes = validator.Validate(correct).IsValid;
Assert.True(correctRes);
var mapped = _mapper.Map <PlaneTypeDTO, PlaneType>(correct);
if (correctRes)
{
await _service.Post(mapped);
}
bool incorrectRes = validator.Validate(incorrect).IsValid;
Assert.False(incorrectRes);
var mappedIncorrect = _mapper.Map <PlaneTypeDTO, PlaneType>(incorrect);
if (incorrectRes)
{
await _service.Post(mapped);
}
}
private void Create_Click(object sender, RoutedEventArgs e)
{
var turple = RenderCreate();
var btnCreate = turple.Item1;
var model = turple.Item2;
var places = turple.Item3;
var carrying = turple.Item4;
btnCreate.Click += async(object sen, RoutedEventArgs evArgs) =>
{
var planetype = new PlaneTypeDTO()
{
Model = model.Text, Places = int.Parse(places.Text), Carrying = double.Parse(carrying.Text)
};
try
{
await service.CreateAsync(planetype);
}
catch (Exception) { }
planetypesList.Add(planetype);
UpdateList();
SingleItem.Children.Clear();
};
}
[Test] // behaviour test
public void Create_When_entity_is_invalid_Then_it_makes_no_calls_to_repository_and_unit_of_work()
{
// Arrange
var planeTypeDTOToCreate = new PlaneTypeDTO()
{
Model = "AAABBBCCC",
Seats = 500,
Carrying = 400
};
var planeTypeRepositoryFake = A.Fake <IPlaneTypeRepository>();
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <PlaneType>()).Returns(planeTypeRepositoryFake);
var planeTypeService = new PlaneTypeService(unitOfWorkFake, AlwaysInValidValidator);
// Act + Assert
var exception = Assert.Throws <BadRequestException>(() => planeTypeService.Create(planeTypeDTOToCreate));
// Assert. Just behaviour
A.CallTo(() => planeTypeRepositoryFake.Create(A <PlaneType> ._)).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.PlaneTypeRepository).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.Set <PlaneType>()).MustNotHaveHappened();
A.CallTo(() => unitOfWorkFake.SaveChanges()).MustNotHaveHappened();
}
public void Create_When_entity_is_invalid_Then_bad_request_exception_is_thrown()
{
// Arrange
var planeTypeMock = new PlaneType()
{
Id = 2,
Model = "AAABBBCCC",
Seats = 500,
Carrying = 400
};
var planeTypeDTOToCreate = new PlaneTypeDTO()
{
Model = "AAABBBCCC",
Seats = 500,
Carrying = 400
};
var planeTypeRepositoryFake = A.Fake <IPlaneTypeRepository>();
A.CallTo(() => planeTypeRepositoryFake.Create(A <PlaneType> ._)).Returns(planeTypeMock);
var unitOfWorkFake = A.Fake <IUnitOfWork>();
A.CallTo(() => unitOfWorkFake.Set <PlaneType>()).Returns(planeTypeRepositoryFake);
var planeTypeService = new PlaneTypeService(unitOfWorkFake, AlwaysInValidValidator);
// Act + Assert
var exception = Assert.Throws <BadRequestException>(() => planeTypeService.Create(planeTypeDTOToCreate), "");
Assert.AreEqual(exception.Message, "Is Invalid");
}
public void CreateEntity_Should_Create_planeType_typeof_PlaneType()
{
// Arrange
PlaneTypeDTO planeTypeDTO = new PlaneTypeDTO
{
Id = 1,
Carrying = 240000,
Model = "Passenger's",
Seats = 200
};
PlaneType planeType = new PlaneType
{
Id = 1,
Carrying = 240000,
Model = "Passenger's",
Seats = 200
};
var planeTypeRepository = new FakeRepository <PlaneType>();
var planeTypeService = new PlaneTypeService(planeTypeRepository);
// Act
planeTypeService.CreateEntity(planeTypeDTO);
var result = planeTypeRepository.Get(1);
// Assert
Assert.AreEqual(planeType, result);
}
public void CreatePlaneType(PlaneTypeDTO planeType)
{
if (planeType != null)
{
PlaneType newPlaneType = mapper.Map <PlaneTypeDTO, PlaneType>(planeType);
unitOfWork.TypeRepository.Create(newPlaneType);
}
}
public void UpdateType(PlaneTypeDTO planeType)
{
if (planeType != null)
{
PlaneType updtPlaneType = mapper.Map <PlaneTypeDTO, PlaneType>(planeType);
unitOfWork.TypeRepository.Insert(updtPlaneType);
}
}
public void Put(int id, [FromBody] PlaneTypeDTO planeType)
{
if (ModelState.IsValid)
{
Response.StatusCode = 200;
planeTypeService.UpdatePlaneType(id, planeType);
}
else
{
Response.StatusCode = 400;
}
}
public IActionResult ModifyPlaneType([FromBody] PlaneTypeDTO type)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var entity = service.ModifyPlaneType(mapper.Map <PlaneType>(type));
return(entity == null?StatusCode(304) as IActionResult
: Ok(mapper.Map <PlaneTypeDTO>(entity)));
}
public HttpResponseMessage Put(int id, [FromBody] PlaneTypeDTO planeType)
{
if (ModelState.IsValid && planeType != null)
{
_service.Update <PlaneType>(id, Mapper.Map <PlaneTypeDTO, PlaneType>(planeType));
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public void Post([FromBody] PlaneTypeDTO planeType)
{
if (ModelState.IsValid)
{
Response.StatusCode = 200;
planeTypeService.CreatePlaneType(planeType);
}
else
{
Response.StatusCode = 400;
}
}
public async Task <IActionResult> ModifyPlaneType(long id, [FromBody] PlaneTypeDTO type)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var entity = await service.ModifyPlaneTypeAsync(id, mapper.Map <PlaneType>(type));
return(entity == null?StatusCode(304) as IActionResult
: Ok(mapper.Map <PlaneTypeDTO>(entity)));
}
public void CreatePlaneType(PlaneTypeDTO planeType)
{
if (planeType != null)
{
PlaneType newPlaneType = mapper.Map <PlaneTypeDTO, PlaneType>(planeType);
unit.PlaneTypesRepo.Insert(newPlaneType);
unit.SaveChanges();
}
else
{
throw new ArgumentNullException();
}
}
public void UpdateType(PlaneTypeDTO planeType)
{
if (planeType != null)
{
PlaneType updtPlaneType = mapper.Map <PlaneTypeDTO, PlaneType>(planeType);
unit.PlaneTypesRepo.Update(updtPlaneType);
unit.SaveChanges();
}
else
{
throw new ArgumentNullException();
}
}
public async Task <IActionResult> AddPlaneType([FromBody] PlaneTypeDTO type)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var entity = await service.AddPlaneTypeAsync(mapper.Map <PlaneType>(type));
return(entity == null?StatusCode(409) as IActionResult
: Created($"{Request?.Scheme}://{Request?.Host}{Request?.Path}{entity.Id}",
mapper.Map <PlaneTypeDTO>(entity)));
}
public async Task <IActionResult> Get(int id)
{
PlaneTypeDTO temp = await planeTypeService.GetPlaneTypeById(id);
if (temp != null)
{
return(Ok(temp));
}
else
{
return(NotFound(temp));
}
}
public async Task <IActionResult> Post([FromBody] PlaneTypeDTO value)
{
var validationResult = await _planeTypeModelValidator.ValidateAsync(value);
if (!validationResult.IsValid)
{
throw new BadRequestException(validationResult.Errors);
}
var entity = await _planeTypeService.CreateAsync(value);
return(Json(entity));
}
public HttpResponseMessage Post([FromBody] PlaneTypeDTO planeType)
{
if (ModelState.IsValid && planeType != null)
{
_service.Post <PlaneType>(Mapper.Map <PlaneTypeDTO, PlaneType>(planeType));
_service.SaveChanges();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public async Task <IActionResult> Put(int id, [FromBody] PlaneTypeDTO planeTypeDTO)
{
planeTypeDTO.Id = id;
try
{
await planeTypeService.UpdateEntityAsync(id, planeTypeDTO);
}
catch (ValidationException e)
{
return(BadRequest(new { Exception = e.Message }));
}
return(Ok(await planeTypeService.GetEntityAsync(id)));
}
public async Task <IActionResult> Put(int id, [FromBody] PlaneTypeDTO planeType)
{
if (ModelState.IsValid)
{
//Response.StatusCode = 200;
await planeTypeService.UpdatePlaneType(id, planeType);
return(Ok(planeType));
}
else
{
return(BadRequest());
}
}
public IActionResult Put(int id, [FromBody] PlaneTypeDTO value)
{
var validationResult = _planeTypeModelValidator.Validate(value);
if (!validationResult.IsValid)
{
throw new BadRequestException(validationResult.Errors);
}
value.Id = id;
var entity = _planeTypeService.Update(value);
return(Json(entity));
}
public async Task <HttpResponseMessage> Put(int id, [FromBody] PlaneTypeDTO planeType)
{
if (ModelState.IsValid && planeType != null && validator.Validate(planeType).IsValid)
{
await _service.Update <PlaneType>(id, Mapper.Map <PlaneTypeDTO, PlaneType>(planeType));
await _service.SaveChanges();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public IActionResult Put(int id, [FromBody] PlaneTypeDTO planeTypeDTO)
{
planeTypeDTO.Id = id;
try
{
planeTypeService.UpdateEntity(planeTypeDTO);
}
catch (ValidationException e)
{
return(BadRequest(new { Exception = e.Message }));
}
return(Ok(planeTypeService.GetEntity(id)));
}
public PlaneTypeDTO Get(int id)
{
PlaneTypeDTO temp = planeTypeService.GetPlaneTypeById(id);
if (temp != null)
{
Response.StatusCode = 200;
}
else
{
Response.StatusCode = 404;
}
return(temp);
}
public async Task <PlaneTypeDTO> UpdateType(PlaneTypeDTO planeType)
{
if (planeType != null)
{
PlaneType updtPlaneType = mapper.Map <PlaneTypeDTO, PlaneType>(planeType) ?? throw new AutoMapperMappingException("Error: Can't map the planeTypeDTO into planeType");
var result = await unit.PlaneTypesRepo.Update(updtPlaneType);
await unit.SaveChangesAsync();
return(mapper.Map <PlaneType, PlaneTypeDTO>(result) ?? throw new AutoMapperMappingException("Error: Can't map the planeType into planeTypeDTO"));
}
else
{
throw new ArgumentNullException();
}
}
public IActionResult Post([FromBody] PlaneTypeDTO value)
{
try
{
if (ModelState.IsValid)
{
airport.CreatePlaneType(value);
return(Ok());
}
return(BadRequest(ModelState));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
