public async Task DeactivateReservation_ReturnsTrue()
{
//arrange
var reservation = new Reservation {
id = 1, eventId = "1", vendorId = 1, vendorServiceId = 1, status = "New"
};
//act
_reservationsQueryMock.Setup(x => x.Deactivate(reservation.id.Value))
.Returns(Task.Factory.StartNew(() => true));
var task = await _sut.Delete(reservation.id.Value);
// assert
Assert.IsType <OkObjectResult>(task);
var result = task as OkObjectResult;
var usersResult = result.Value as bool?;
Assert.True(usersResult);
}
public void Delete_With_Id_Calls_Repo_Remove()
{
// Arrange
var mockRepo = new Mock <IRepository <Reservation> >();
mockRepo.Setup(mock => mock.Remove(It.IsAny <int>()));
ReservationsController controller = new ReservationsController(mockRepo.Object);
// Act
controller.Delete(1);
// Assert
mockRepo.Verify(mock => mock.Remove(It.Is <int>(x => x == 1)), Times.Once);
}
public void TestDeleteShouldPassHotelAndReservationIdToDAO()
{
// Arrange
Reservation testReservation = reservations[1];
String hotelID = "ABCD1234";
int reservationID = testReservation.Id;
_dao.Setup(dao => dao.Get(hotelID, testReservation.Id)).Returns(testReservation);
// Act
_controller.Delete(hotelID, reservationID);
// Assert
_dao.Verify(dao => dao.Delete(hotelID, reservationID));
}
public async Task And_No_Error_Then_Returns_Ok(
Guid reservationId,
bool employerDeleted,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
var result = await controller.Delete(reservationId, employerDeleted) as NoContentResult;
mockMediator.Verify(x =>
x.Send(
It.Is <DeleteReservationCommand>(c =>
c.ReservationId.Equals(reservationId) &&
c.EmployerDeleted.Equals(employerDeleted)),
It.IsAny <CancellationToken>()), Times.Once);
result.Should().NotBeNull();
result.StatusCode.Should().Be(204);
}
public async Task And_InvalidOperationException_Then_Returns_BadRequest(
Guid reservationId,
bool employerDeleted,
InvalidOperationException invalidOperationException,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <DeleteReservationCommand>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(invalidOperationException);
var result = await controller.Delete(reservationId, employerDeleted) as BadRequestResult;
result.Should().NotBeNull();
result.StatusCode.Should().Be(400);
}
public async Task And_EntityNotFoundException_Then_Returns_Gone(
Guid reservationId,
bool employerDeleted,
EntityNotFoundException <Domain.Entities.Reservation> notFoundException,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <DeleteReservationCommand>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(notFoundException);
var result = await controller.Delete(reservationId, employerDeleted) as StatusCodeResult;
result.Should().NotBeNull();
result.StatusCode.Should().Be(410);
}
public async Task And_ArgumentException_Then_Returns_BadRequest(
Guid reservationId,
bool employerDeleted,
ArgumentException argumentException,
[Frozen] Mock <IMediator> mockMediator,
ReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <DeleteReservationCommand>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(argumentException);
var result = await controller.Delete(reservationId, employerDeleted) as BadRequestObjectResult;
result.Should().NotBeNull();
result.StatusCode.Should().Be(400);
var error = result.Value as ArgumentErrorViewModel;
error.Should().NotBeNull();
error.Message.Should().Be(argumentException.Message);
error.Params.Should().Be(argumentException.ParamName);
}
private async void BtnDelete_Click(object sender, EventArgs e)
{
if (nameOfFormOpen.Equals("VenuesGUI") && VenuesGUI.Instance.idFromTable != -1)
{
try {
VenuesController vCtrl = new VenuesController();
VenuesGUI.Instance.UseWaitCursor = true;
await vCtrl.Delete(VenuesGUI.Instance.idFromTable);
VenuesGUI.Instance.UseWaitCursor = false;
}
catch (Exception) {
MessageBox.Show("Error...occured");
VenuesGUI.Instance.UseWaitCursor = false;
}
}
else if (nameOfFormOpen.Equals("TablesGUI") && TablesGUI.Instance.idFromTable != -1)
{
try {
TablesController tCtrl = new TablesController();
TablesGUI.Instance.UseWaitCursor = true;
await tCtrl.Delete(TablesGUI.Instance.idFromTable);
TablesGUI.Instance.UseWaitCursor = false;
}
catch (Exception) {
MessageBox.Show("Error...occured");
TablesGUI.Instance.UseWaitCursor = false;
}
}
else if (nameOfFormOpen.Equals("TablePackagesGUI") && TablePackagesGUI.Instance.idFromTable != -1)
{
try {
TablePackagesController tpCtrl = new TablePackagesController();
TablePackagesGUI.Instance.UseWaitCursor = true;
await tpCtrl.Delete(TablePackagesGUI.Instance.idFromTable);
TablePackagesGUI.Instance.UseWaitCursor = false;
}
catch (Exception) {
MessageBox.Show("Error...occured");
TablePackagesGUI.Instance.UseWaitCursor = false;
}
}
else if (nameOfFormOpen.Equals("EmployeesGUI") && EmployeesGUI.Instance.IdFromTable != -1)
{
try {
EmployeesController eCtrl = new EmployeesController();
EmployeesGUI.Instance.UseWaitCursor = true;
await eCtrl.Delete(EmployeesGUI.Instance.IdFromTable);
EmployeesGUI.Instance.UseWaitCursor = false;
}
catch (Exception) {
MessageBox.Show("Error...occured");
EmployeesGUI.Instance.UseWaitCursor = false;
}
}
else if (nameOfFormOpen.Equals("ReservationsGUI") && ReservationsGUI.Instance.IdFromTable != -1)
{
try {
ReservationsController rCtrl = new ReservationsController();
ReservationsGUI.Instance.UseWaitCursor = true;
await rCtrl.Delete(ReservationsGUI.Instance.IdFromTable);
ReservationsGUI.Instance.UseWaitCursor = false;
}
catch (Exception) {
MessageBox.Show("Error...occured");
EmployeesGUI.Instance.UseWaitCursor = false;
}
}
else
{
MessageBox.Show("Please select a " + newTitle + " from the list");
}
}
public void Delete_RedirectsWhenInputDataIsIncorrect()
{
var result = _controller.Delete(-1) as NotFoundResult;
Assert.AreEqual(404, result.StatusCode);
}