public void Update_When_airplaneTypeDto_is_null_Then_throw_NullBodyException()
{
AirplaneTypeDto nullDto = null;
int id = 1;
Assert.Throws <NullBodyException>(() => _service.Update(id, nullDto));
}
public void AddEntity_When_InvallidAirplaneTypeDto_Then_ReturnBadRequestException()
{
var invalidAirplaneTypeDto = new AirplaneTypeDto()
{
Model = "Airbus A310"
};
Assert.Throws <BadRequestException>(() => _service.AddEntityAsync(invalidAirplaneTypeDto));
}
public void UpdateEntity_When_InvalidAirplaneTypeDto_Then_Return_AirplaneTypeDto()
{
var airplaneType = _context.AirplaneTypes.First();
var invalidAirplaneTypeDto = new AirplaneTypeDto();
_mapper.Map(airplaneType, invalidAirplaneTypeDto);
invalidAirplaneTypeDto.NumberOfSeats = 1200;
Assert.Throws <BadRequestException>(() => _service.UpdateEntityAsync(invalidAirplaneTypeDto));
}
public void Add_When_airplaneTypeModel_is_not_valid_Then_throw_ValidationException()
{
var notValidDto = new AirplaneTypeDto
{
AirplaneModel = "Y",
CarryingCapacity = -200,
SeatsCount = 987
};
Assert.Throws <ValidationException>(() => _service.Add(notValidDto));
}
public void Update_When_id_is_not_exist_Then_throw_NotExistException()
{
var validDto = new AirplaneTypeDto
{
AirplaneModel = "YZ-222",
CarryingCapacity = 14000,
SeatsCount = 987
};
int notExistId = 2;
Assert.Throws <NotExistException>(() => _service.Update(notExistId, validDto));
}
public void OnSelectedItem(object sender, RoutedEventArgs e)
{
SelectedItem = GetSelected(sender, e);
if (SelectedItem != null)
{
TextId.Text = SelectedItem.Id.ToString();
TextAirplaneModel.Text = SelectedItem.Model;
TextNumberOfSeats.Text = SelectedItem.NumberOfSeats.ToString();
TextLoadCapacity.Text = SelectedItem.LoadCapacity.ToString();
}
}
public void Update_When_airplaneTypeModel_is_not_valid_and_id_is_exist_Then_throw_ValidationException()
{
var notValidDto = new AirplaneTypeDto
{
AirplaneModel = "Y",
CarryingCapacity = -200,
SeatsCount = 987
};
int existId = 3;
Assert.Throws <ValidationException>(() => _service.Update(existId, notValidDto));
}
public void Add_When_airplaneTypeModel_is_valid_Then_return_created_model_id()
{
var validDto = new AirplaneTypeDto
{
AirplaneModel = "YZ-222",
CarryingCapacity = 14000,
SeatsCount = 987
};
var result = _service.Add(validDto);
Assert.AreEqual(result, 1);
}
public async Task <IActionResult> Post([FromBody] AirplaneTypeDto airplaneTypeDto)
{
try
{
var airplaneTypeToReturn = await _airplaneTypeService.AddEntityAsync(airplaneTypeDto);
return(CreatedAtRoute("GetAirplaneType", new { id = airplaneTypeToReturn.Id }, airplaneTypeToReturn));
}
catch (BadRequestException)
{
return(BadRequest());
}
}
public async Task AddEntity_When_ValidAirplaneTypeDto_Then_Return_AirplaneTypeDto()
{
var validAirplaneTypeDto = new AirplaneTypeDto()
{
Model = "Airbus A310",
NumberOfSeats = 183,
LoadCapacity = 164000
};
var result = await _service.AddEntityAsync(validAirplaneTypeDto);
Assert.AreEqual(validAirplaneTypeDto.NumberOfSeats, result.NumberOfSeats);
}
public void UpdateEntity_When_ValidAirplaneTypeDto_Then_Return_AirplaneTypeDto()
{
var airplaneType = _context.AirplaneTypes.First();
var airplaneTypeDto = new AirplaneTypeDto();
_mapper.Map(airplaneType, airplaneTypeDto);
airplaneTypeDto.Model = "Boeing-747";
var entity = _service.UpdateEntityAsync(airplaneTypeDto);
Assert.NotNull(entity);
Assert.AreEqual(airplaneType.Id, entity.Id);
}
public AirplaneTypeView()
{
this.InitializeComponent();
_airplaneTypeService = new AirplaneTypeService();
AirplaneTypeDtos = new ObservableCollection <AirplaneTypeDto>();
SelectedItem = new AirplaneTypeDto();
AirplaneTypesList.ItemsSource = AirplaneTypeDtos;
HideDetailFields();
HideAddAndSaveButtons();
}
public void Update_When_airplaneTypeModel_is_valid_and_id_is_exist_Then_call_Update_method()
{
var validDto = new AirplaneTypeDto
{
AirplaneModel = "YZ-222",
CarryingCapacity = 14000,
SeatsCount = 987
};
int existId = 3;
_service.Update(existId, validDto);
A.CallTo(() => _repository.Update(A <int> ._, A <AirplaneType> ._)).MustHaveHappened();
}
public async Task Post_When_AirplaneTypeDto_Invalid_Then_Return_400BadRequest()
{
var airplaneTypeDtoInvalid = new AirplaneTypeDto()
{
Model = "Boeing-737"
};
var airplaneTypeService = A.Fake <IService <AirplaneTypeDto> >();
A.CallTo(() => airplaneTypeService.AddEntityAsync(airplaneTypeDtoInvalid)).Throws(new BadRequestException());
var airplaneTypesController = new AirplaneTypesController(airplaneTypeService);
var result = await airplaneTypesController.Post(airplaneTypeDtoInvalid) as StatusCodeResult;
Assert.NotNull(result);
Assert.AreEqual(400, result.StatusCode);
}
public IActionResult Post([FromBody] AirplaneTypeDto dto)
{
try
{
var createdId = _airplaneTypesService.Add(dto);
return(CreatedAtAction("Get",
_airplaneTypesService.GetById(createdId)));
}
catch (ValidationException ex)
{
return(BadRequest(ex.Errors));
}
catch (NullBodyException)
{
return(BadRequest());
}
}
public async Task Put_When_AirplaneTypeDto_Invalid_Then_Return_400BadRequest()
{
var airplaneTypeDtoInvalid = new AirplaneTypeDto()
{
Id = new Guid("45320c5e-f58a-4b1f-b63a-8ee07a840bdf"),
Model = "Boeing-737"
};
var airplaneTypeService = A.Fake <IService <AirplaneTypeDto> >();
A.CallTo(() => airplaneTypeService.UpdateEntityAsync(airplaneTypeDtoInvalid)).Throws(new BadRequestException());
var airplaneTypesController = new AirplaneTypesController(airplaneTypeService);
var result = await airplaneTypesController.Put(airplaneTypeDtoInvalid.Id, airplaneTypeDtoInvalid) as StatusCodeResult;
Assert.NotNull(result);
Assert.AreEqual(400, result.StatusCode);
}
public async Task <IActionResult> Put(Guid id, [FromBody] AirplaneTypeDto airplaneTypeDto)
{
try
{
airplaneTypeDto.Id = id;
await _airplaneTypeService.UpdateEntityAsync(airplaneTypeDto);
return(NoContent());
}
catch (BadRequestException)
{
return(BadRequest());
}
catch (NotFoundException)
{
return(NotFound());
}
}
public void Post_When_Request_ValidAirplaneType_Then_Respons_201OK()
{
var validAirplaneTypeDto = new AirplaneTypeDto()
{
Model = "Airbus A310",
NumberOfSeats = 183,
LoadCapacity = 164000
};
_restMethods.Post(_airplaneTypeUrl, out HttpWebResponse response, validAirplaneTypeDto);
var stream = response.GetResponseStream();
var reader = new StreamReader(stream);
var result = JsonConvert
.DeserializeObject <AirplaneTypeDto>(reader.ReadToEnd());
Assert.NotNull(result);
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.AreEqual(validAirplaneTypeDto.NumberOfSeats, result.NumberOfSeats);
}
public async Task Put_When_AirplaneTypeDto_Valid_Then_Return_204NoContent()
{
var airplaneTypeDtoValid = new AirplaneTypeDto()
{
Id = new Guid("45320c5e-f58a-4b1f-b63a-8ee07a840bdf"),
Model = "Boeing-737",
NumberOfSeats = 400,
LoadCapacity = 52800
};
var airplaneTypeService = A.Fake <IService <AirplaneTypeDto> >();
A.CallTo(() => airplaneTypeService.UpdateEntityAsync(airplaneTypeDtoValid)).Returns(airplaneTypeDtoValid);
var airplaneTypesController = new AirplaneTypesController(airplaneTypeService);
var result = await airplaneTypesController.Put(airplaneTypeDtoValid.Id, airplaneTypeDtoValid) as StatusCodeResult;
Assert.NotNull(result);
Assert.AreEqual(204, result.StatusCode);
}
public IActionResult Put(int id, [FromBody] AirplaneTypeDto dto)
{
try
{
_airplaneTypesService.Update(id, dto);
return(Ok());
}
catch (NotExistException)
{
return(NotFound());
}
catch (ValidationException ex)
{
return(BadRequest(ex.Errors));
}
catch (NullBodyException)
{
return(BadRequest());
}
}
public void Post_When_Request_InvalidAirplaneType_Then_Respons_400BadRequest()
{
var invalidAirplaneTypeDto = new AirplaneTypeDto()
{
Model = "Airbus A310"
};
var result = new HttpWebResponse();
try
{
_restMethods.Post(_airplaneTypeUrl, out HttpWebResponse response, invalidAirplaneTypeDto);
}
catch (WebException e)
{
result = e.Response as HttpWebResponse;
}
Assert.NotNull(result);
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public async Task Post_When_AirplaneTypeDto_Valid_Then_Return_201OK()
{
var airplaneTypeDtoValid = new AirplaneTypeDto()
{
Model = "Boeing-737",
NumberOfSeats = 140,
LoadCapacity = 52800
};
var airplaneTypeService = A.Fake <IService <AirplaneTypeDto> >();
A.CallTo(() => airplaneTypeService.AddEntityAsync(airplaneTypeDtoValid))
.Invokes(() => { airplaneTypeDtoValid.Id = Guid.NewGuid(); })
.Returns(airplaneTypeDtoValid);
var airplaneTypesController = new AirplaneTypesController(airplaneTypeService);
var result = await airplaneTypesController.Post(airplaneTypeDtoValid) as ObjectResult;
Assert.NotNull(result);
Assert.AreEqual(201, result.StatusCode);
}
public async Task <IActionResult> Post([FromBody] AirplaneTypeDto dto)
{
try
{
var createdId = await _airplaneTypesService.AddAsync(dto);
return(CreatedAtAction("Get",
await _airplaneTypesService.GetByIdAsync(createdId)));
}
catch (ValidationException ex)
{
return(BadRequest(ex.Errors));
}
catch (NullBodyException)
{
return(BadRequest());
}
catch (DbUpdateException ex)
{
return(BadRequest(ex.InnerException.Message));
}
}
public void Add_When_airplaneTypeDto_is_null_Then_throw_NullBodyException()
{
AirplaneTypeDto nullDto = null;
Assert.Throws <NullBodyException>(() => _service.Add(nullDto));
}
