public async Task TerminateOtherBookingGenException()
{
Mock <IBookingsService> mockBookingsService = new Mock <IBookingsService>();
Mock <BookingsController> mockBookingsControler = new Mock <BookingsController>(mockBookingsService.Object)
{
CallBase = true
};
Booking booking = (await GetTestBookings())
.Where(item => item.Id == 1)
.First();
mockBookingsService.Setup(mock => mock.GetAsync(1))
.ReturnsAsync(booking);
// It.IsAny<System.Nullable<T>> not work if arg null
mockBookingsService.Setup(mock => mock.Terminate(It.IsAny <int>(), It.IsAny <string>()))
.Returns(Task.CompletedTask);
mockBookingsControler.SetupGet(mock => mock.IsAdmin).Returns(false);
mockBookingsControler.SetupGet(mock => mock.UserId).Returns((string)null);
BookingUpdateDTO bookingUpdateDTO = new BookingUpdateDTO();
await Assert.ThrowsAsync <BookingApp.Exceptions.OperationRestrictedException>(
async() => await mockBookingsControler.Object.Terminate(1));
mockBookingsService.Verify(
mock => mock.Terminate(It.IsAny <int>(), It.IsAny <string>()), Times.Never());
}
public async Task <BookingDTO> PatchAsync(BookingUpdateDTO dto)
{
this.Logger.LogDebug($"{nameof(BookingUpdateService)} called for client with id = {dto.ClientId}");
return(this.Mapper.Map <BookingDTO>(
await this.BookingUpdateService.UpdateAsync(Mapper.Map <BookingUpdateModel>(dto))));
}
public async Task TerminateOwnedBooking()
{
Mock <IBookingsService> mockBookingsService = new Mock <IBookingsService>();
Mock <BookingsController> mockBookingsControler = new Mock <BookingsController>(mockBookingsService.Object)
{
CallBase = true
};
Booking booking = (await GetTestBookings())
.Where(item => item.Id == 1)
.First();
mockBookingsService.Setup(mock => mock.GetAsync(1))
.ReturnsAsync(booking);
// It.IsAny<System.Nullable<T>> not work if arg null
mockBookingsService.Setup(mock => mock.Terminate(It.IsAny <int>(), It.IsAny <string>()))
.Returns(Task.CompletedTask);
mockBookingsControler.SetupGet(mock => mock.IsAdmin).Returns(false);
mockBookingsControler.SetupGet(mock => mock.UserId).Returns(booking.CreatedUserId);
BookingUpdateDTO bookingUpdateDTO = new BookingUpdateDTO();
var result = await mockBookingsControler.Object.Terminate(1);
var okResult = Assert.IsType <OkResult>(result);
mockBookingsService.Verify(
mock => mock.Terminate(It.IsAny <int>(), It.IsAny <string>()), Times.Once());
}
public async Task <bool> UpdateBooking(string token, BookingUpdateDTO booking)
{
var result = await _httpClient.PutAsJsonAsync($"booking/{token}", booking);
var StatusCode = result.StatusCode;
return(StatusCode != HttpStatusCode.OK ? false : true);
}
public async Task <ActionResult> Put(string token, [FromBody] BookingUpdateDTO booking)
{
// Ensures you dont update wrong object
if (token != booking.Token)
{
ModelState.AddModelError("token", "token in URL must match token in body");
return(BadRequest(ModelState));
}
var response = await _repository.Update(booking);
return(new StatusCodeResult((int)response));
}
public bool EditBooking(BookingDTO booking)
{
var newBooking = new BookingUpdateDTO
{
StartDate = booking.StartDate,
EndDate = booking.EndDate,
BookComment = booking.BookComment,
Complaint = booking.Complaint
};
var resp = Client.PutAsJsonAsync($"api/bookings/{booking.BookingId}", newBooking).Result;
return(resp.IsSuccessStatusCode);
}
public async Task Update_non_existing_booking_unsuccessful()
{
// Arrange
var entity = new BookingUpdateDTO {
Token = "badToken"
};
// Act
var actual = await _repository.Update(entity);
var expected = NotFound;
// Assert
Assert.Equal(expected, actual);
}
public async Task <HttpStatusCode> Update(BookingUpdateDTO Booking)
{
var entity = await _context.Booking.FindAsync(Booking.Token);
if (entity == null)
{
return(NotFound);
}
entity.State = (QueueSafe.Entities.BookingState)Booking.State;
await _context.SaveChangesAsync();
return(OK);
}
public async void Update_existing_booking_returns_ok()
{
// Arrange
var updateBooking = new BookingUpdateDTO
{
Token = "righttoken",
State = BookingState.Expired
};
mockBookingRepository.Setup(m => m.Update(updateBooking)).ReturnsAsync(HttpStatusCode.OK);
var controller = new BookingController(mockBookingRepository.Object);
// Act
var actual = await controller.Put(updateBooking.Token, updateBooking);
// Assert
var result = Assert.IsType <StatusCodeResult>(actual);
Assert.Equal(200, result.StatusCode);
}
public async Task <IActionResult> Update([FromRoute] int bookingId, [FromBody] BookingUpdateDTO item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var bookingData = await bookingService.GetAsync(bookingId);
if (IsAdmin || bookingData.CreatedUserId == UserId)
{
await bookingService.Update(bookingId, item.StartTime, item.EndTime, UserId, item.Note);
return(new OkResult());
}
else
{
throw new Exceptions.OperationRestrictedException("Can not edit not owned booking");
}
}
public async Task Update_existing_booking_successful()
{
// Arrange
var entity = new BookingUpdateDTO {
Token = "goodtoken1", State = Shared.BookingState.Canceled
};
// Act
var actualResponse = await _repository.Update(entity);
var expectedResponse = OK;
var updated = await _repository.Read(entity.Token);
var actualState = updated.State;
var expectedState = Shared.BookingState.Canceled;
// Assert
Assert.Equal(expectedResponse, actualResponse);
Assert.Equal(expectedState, actualState);
}
public IActionResult UpdateBooking([FromRoute] int id, [FromBody] BookingUpdateDTO updateDTO)
{
_hotelService.UpdateBooking(updateDTO, id);
return(NoContent());
}
