public async Task Update(DepartureDto item)
{
var updItem = _mapper.Map <DepartureDto, Departure>(item);
await _unitOfWork.Repository <Departure>().Update(updItem);
await _unitOfWork.SaveAsync();
}
public void Update_When_departureDto_is_null_Then_throw_NullBodyException()
{
DepartureDto nullDto = null;
int id = 1;
Assert.Throws <NullBodyException>(() => _service.Update(id, nullDto));
}
public void Update_WhenDtoIsPassed_ThenReturnedTheSameWithPassedId()
{
// Arrange
var id = Guid.NewGuid();
var crewId = Guid.NewGuid();
var airplaneId = Guid.NewGuid();
var dto = new DepartureDto()
{
Time = new DateTime(2018, 7, 17, 13, 0, 0),
CrewId = crewId,
AirplaneId = airplaneId
};
A.CallTo(() => unitOfWorkFake.CrewRepositiry.Get(crewId)).Returns(new Crew {
Id = crewId
});
A.CallTo(() => unitOfWorkFake.AeroplaneRepository.Get(airplaneId)).Returns(new Aeroplane {
Id = airplaneId
});
var service = new DepartureService(unitOfWorkFake, mapper, alwaysValidValidator);
// Act
var returnedDto = service.Update(id, dto);
// Assert
Assert.True(returnedDto.Id != default(Guid));
Assert.AreEqual(dto.CrewId, returnedDto.CrewId);
Assert.AreEqual(dto.AirplaneId, returnedDto.AirplaneId);
Assert.AreEqual(dto.Time, returnedDto.Time);
}
public void Update_Valid()
{
//arange
DeparturesService service = new DeparturesService(unitOfWork, mapper, validator);
var expected = new Departure
{
Id = 1, FlightId = 1, FlightNumber = "QW11", DepartureTime = Convert.ToDateTime("2018-07-13T08:22:56.6404304+03:00")
};
var DtoToMake = new DepartureDto
{
Id = 1, FlightId = 1, FlightNumber = "QW11", DepartureTime = Convert.ToDateTime("2018-07-13T08:22:56.6404304+03:00")
};
//act
service.Update(DtoToMake);
var actual = (unitOfWork.Set <Departure>() as FakeRpository <Departure>).updatedItem;
//assert
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.FlightId, actual.FlightId);
Assert.AreEqual(expected.FlightNumber, actual.FlightNumber);
Assert.AreEqual(expected.DepartureTime, actual.DepartureTime);
}
public async Task Create(DepartureDto item)
{
var newItem = _mapper.Map <DepartureDto, Departure>(item);
await _unitOfWork.Repository <Departure>().Create(newItem);
await _unitOfWork.SaveAsync();
}
public async Task <IActionResult> Post([FromBody] DepartureDto entity)
{
var result = await _departuresSrvice.AddAsync(entity);
//if (result == null) return NotFound();
return(Ok(result));
}
public IActionResult Get(int id)
{
DepartureDto Departure = service.GetById(id);
if (Departure == null)
{
return(NotFound());
}
return(Ok(Departure));
}
public async Task <IActionResult> Get(int id)
{
DepartureDto Departure = await service.GetById(id);
if (Departure == null)
{
return(NotFound());
}
return(Ok(Departure));
}
public async Task <IActionResult> Put(int id, [FromBody] DepartureDto entity)
{
var result = await _departuresSrvice.UpdateAsync(entity, id);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public Departure MapDeparture(DepartureDto value)
{
return(new Departure
{
Id = value.ID,
Date = value.Date,
Crew = unitOfWork.Crew.Get(value.CrewId),
Flight = unitOfWork.Flights.Get().SingleOrDefault(x => x.Number == value.Number),
Plane = unitOfWork.Planes.Get(value.PlaneId)
});
}
public IActionResult Delete([FromBody] DepartureDto departure)
{
try
{
service.Delete(departure);
return(NoContent());
}
catch (Exception ex)
{
return(NotFound(ex));
}
}
public DepartureDto Update(Guid id, DepartureDto departureDto)
{
var departure = mapper.Map <DepartureDto, Departure>(departureDto);
departure.Id = id;
departure.Airplane = db.AeroplaneRepository.Get(departureDto.AirplaneId);
departure.Crew = db.CrewRepositiry.Get(departureDto.CrewId);
db.DepartureRepository.Update(departure);
return(mapper.Map <Departure, DepartureDto>(departure));
}
public DepartureDto Create(DepartureDto departureDto)
{
var departure = mapper.Map <DepartureDto, Departure>(departureDto);
departure.Id = Guid.NewGuid();
departure.Crew = db.CrewRepositiry.Get(departureDto.CrewId);
departure.Airplane = db.AeroplaneRepository.Get(departureDto.AirplaneId);
db.DepartureRepository.Create(departure);
return(mapper.Map <Departure, DepartureDto>(departure));
}
public async Task <IActionResult> Post([FromBody] DepartureDto departureDto)
{
try
{
var departureToReturn = await _departureService.AddEntityAsync(departureDto);
return(CreatedAtRoute("GetDeparture", new { id = departureToReturn.Id }, departureToReturn));
}
catch (BadRequestException)
{
return(BadRequest());
}
}
public void Create(DepartureDto departure)
{
var validationResult = validator.Validate(departure);
if (validationResult.IsValid)
{
unit.Departures.Create(mapper.MapDeparture(departure));
}
else
{
throw new ValidationException(validationResult.Errors);
}
}
public async Task <int> Create(DepartureDto departure)
{
var validationResult = validator.Validate(departure);
if (validationResult.IsValid)
{
return(await unit.Departures.Create(await mapper.MapDeparture(departure)));
}
else
{
throw new ValidationException(validationResult.Errors);
}
}
public async Task <Departure> MapDeparture(DepartureDto value)
{
var list = await unitOfWork.Flights.Get();
return(new Departure
{
Id = value.ID,
Date = value.Date,
Crew = await unitOfWork.Crew.Get(value.Crew.ID),
Flight = list.SingleOrDefault(x => x.Number == value.Flight.Number),
Plane = await unitOfWork.Planes.Get(value.Plane.ID)
});
}
public async Task <IActionResult> Update([FromBody] DepartureDto departure)
{
if (ModelState.IsValid)
{
await _service.Update(departure);
return(Ok(departure));
}
else
{
return(new BadRequestObjectResult(ModelState));
}
}
public void Create_WhenDtoIsEmpty_ThenThrowValidExeption()
{
// Arrange
var dto = new DepartureDto()
{
};
var service = new DepartureService(unitOfWorkFake, mapper, validator);
// Act
// Assert
Assert.Throws <ValidationException>(() => service.Create(dto));
}
public IActionResult Post([FromBody] DepartureDto value)
{
try
{
service.Create(value);
return(Ok());
}
catch (ValidationException e)
{
return(BadRequest(e.Message));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public IActionResult Post([FromBody] DepartureDto dto)
{
try
{
var createdId = _departureService.Add(dto);
return(CreatedAtAction("Get",
_departureService.GetById(createdId)));
}
catch (ValidationException ex)
{
return(BadRequest(ex.Errors));
}
catch (NullBodyException)
{
return(BadRequest());
}
}
public void Create_When_DepartureModel_is_valid_Then_returns_id()
{
var flightService = new FlightService(unitOfWork, mapper, new FlightValidator());
var expectedDeparture = new DepartureDto()
{
Date = DateTime.Now,
Number = flightService.Get(1).Number,
CrewId = 1,
PlaneId = 1
};
var id = service.Create(expectedDeparture);
var actualDeparture = service.Get(id);
Assert.AreEqual(expectedDeparture.Date, actualDeparture.Date);
Assert.AreEqual(expectedDeparture.Number, actualDeparture.Number);
}
public IActionResult Put(int id, [FromBody] DepartureDto Departure)
{
if (Departure == null)
{
ModelState.AddModelError("", "Не указаны данные для вылета");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
service.Update(Departure);
return(Ok(Departure));
}
public IActionResult Post([FromBody] DepartureDto Departure)
{
if (Departure == null)
{
ModelState.AddModelError("", "Не указаны данные для вылета");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
service.Create(Departure);
return(Created("api/Departures", Departure));
}
public void Update_UnValid()
{
//arange
DeparturesService service = new DeparturesService(unitOfWork, mapper, validator);
var DtoToMake = new DepartureDto
{
Id = 1, FlightId = 1, FlightNumber = "1", DepartureTime = Convert.ToDateTime("2018-07-13T08:22:56.6404304+03:00")
};
//act
service.Update(DtoToMake);
var actual = (unitOfWork.Set <Departure>() as FakeRpository <Departure>).updatedItem;
//assert
Assert.IsNull(actual);
}
public async Task <IActionResult> Put(Guid id, [FromBody] DepartureDto departureDto)
{
try
{
departureDto.Id = id;
await _departureService.UpdateEntityAsync(departureDto);
return(NoContent());
}
catch (BadRequestException)
{
return(BadRequest());
}
catch (NotFoundException)
{
return(NotFound());
}
}
public async Task <Departure> CreateOrUpdate(Guid?departureId, DepartureDto createdDepartureData)
{
Departure departure;
if (departureId.HasValue)
{
await _departureRepository.UpdateAsync(departureId.Value, createdDepartureData);
departure = await _departureRepository.GetAsync(departureId.Value);
}
else
{
departure = _departureRepository.Add(createdDepartureData);
}
await _domainContext.SaveChangesAsync();
return(departure);
}
public void Update_When_departureModel_is_valid_and_id_is_exist_Then_call_Update_method()
{
var validDto = new DepartureDto
{
Airplane = new Airplane
{
Name = "Airflot",
ExploitationTerm = TimeSpan.FromDays(1000),
ReleaseDate = new DateTime(1970, 5, 21),
Type = new AirplaneType
{
AirplaneModel = "YZ-222",
CarryingCapacity = 14000,
SeatsCount = 987
}
},
Crew = new Crew
{
Pilot = new Pilot
{
FirstName = "Petro",
LastName = "Boroda",
Birthdate = new DateTime(1989, 10, 12),
Experience = 4
},
Stewardesses = new List <Stewardesse> {
new Stewardesse {
FirstName = "Maria",
LastName = "Alexandrovna",
Birthdate = new DateTime(1990, 3, 1)
}
}
},
DepartureTime = new DateTime(2018, 07, 16, 20, 21, 0),
FlightNumber = "YM-2343"
};
int existId = 3;
_service.Update(existId, validDto);
A.CallTo(() => _repository.Update(A <int> ._, A <Departure> ._)).MustHaveHappened();
}
public IActionResult Put(Guid id, [FromBody] DepartureDto departureDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { Type = "ValidationError", ErrorMessage = "Required fields is empty" }));
}
DepartureDto resultDto;
try
{
resultDto = departureService.Update(id, departureDto);
}
catch (Exception ex)
{
return(BadRequest(new { ErrorType = ex.GetType().Name, ex.Message }));
}
return(Ok(resultDto));
}
public IActionResult Put(int id, [FromBody] DepartureDto dto)
{
try
{
_departureService.Update(id, dto);
return(Ok());
}
catch (NotExistException)
{
return(NotFound());
}
catch (ValidationException ex)
{
return(BadRequest(ex.Errors));
}
catch (NullBodyException)
{
return(BadRequest());
}
}
