public async Task IdOfNonExistentCustomer_DeleteCustomer_CustomerNotDeleted()
{
const int customerId = -1;
var response = await _customerController.DeleteCustomer(customerId);
Assert.IsType <NotFoundResult>(response);
}
public async Task VerifyDeleteCustomerSuccess()
{
var delRes = await _controller.DeleteCustomer(1);
Assert.IsType <OkObjectResult>(delRes.Result);
var res = await _controller.GetCustomers();
Assert.All((List <Customer>)((OkObjectResult)res.Result).Value, customer => Assert.NotEqual(1, customer.CustomerId));
}
public async Task DeleteCustomer_ShouldReturnBadRequest_WhenModelStateIsInvalid()
{
//Arrange
_customersController.ModelState.AddModelError("Error", "Modal State is invalid");
//Act
var result = await _customersController.DeleteCustomer(3);
//Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public void Remove_NotExistingIdPassed_ReturnsNotFoundResponse()
{
// Arrange
_auth.IsAuthenticated(null).Returns(true);
var notExistingId = 5;
// Act
var badResponse = _controller.DeleteCustomer(notExistingId).Result;
// Assert
Assert.IsType<NotFoundResult>(badResponse.Result);
}
public void DeleteCustomer_DeleteCustomerWithCorrectId_ReturnOk()
{
Customer customer = new Customer()
{
CustomerId = 2
};
_mockRepository.Setup(r => r.GetCustomerById(customer.CustomerId)).Returns(customer);
var result = _controller.DeleteCustomer(customer.CustomerId);
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public void Delete_Should_Return_As_204NoContentResult()
{
//Arrange
_mediator.Setup(s => s.Send(It.IsAny <DeleteCustomerCommand>(), default)).Returns(Task.FromResult(_result.Object));
_result.Setup(t => t.Success).Returns(true);
_result.Setup(t => t.StatusCode).Returns(StatusCodes.Status204NoContent);
//Act
var actual = _sut.DeleteCustomer(_customerId).GetAwaiter().GetResult();
//Assert
actual.GetType().Should().Equals(StatusCodes.Status204NoContent);
}
public void DeleteCustomerById_CustomerExists_ReturnOk(int id)
{
_mapper
.Setup(x => x.Map <CustomerControllerModel>(It.IsAny <CustomerServiceModel>()))
.Returns(_customerControllerModel);
_mockContainer
.Setup(x => x.Delete(id))
.Returns(true);
var result = custController.DeleteCustomer(id);
Assert.True(result.GetType().Equals(typeof(OkResult)));
}
public void DeleteCustomerShouldReturnCopyOfCustomerUponDeletion()
{
// ARRANGE
mockCustomerService.Setup(cs => cs.Delete(1)).Returns(new CustomerDTO.WithRelations
{
Id = 1
});
// ACT
var result = customerController.DeleteCustomer(1) as OkNegotiatedContentResult <CustomerDTO.WithRelations>;
// ASSERT
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <CustomerDTO.WithRelations>));
Assert.AreEqual(1, result.Content.Id);
}
private void deleteCustomerButton_Click(object sender, EventArgs e)
{
try
{
if (idTextBox.Text != "")
{
int customerId = Convert.ToInt32(idTextBox.Text);
bool success = CustomersController.DeleteCustomer(customerId);
if (success)
{
MessageBox.Show(deleteSuccessString);
ClearCustomerFields();
customersListView.Clear();
populateListView();
CustomersController.PopulateMainCustomersViewList(customersListView);
}
else
{
MessageBox.Show(deleteNoSuccessString);
}
}
else
{
MessageBox.Show(deleteNoSuccessString);
}
}
catch
{
MessageBox.Show(deleteNoSuccessString);
}
}
public void DeleteCustomer_DeleteCustomerWithCorrectId_ReturnOk()
{
using (new TransactionScope())
{
Customer customer = CreateTestObjects.CreateNewCustomer("Kiira", "Toivonen", "Helsinki", "Helsingintie 16");
_context.Customers.Add(customer);
_context.SaveChanges();
var checkIfExistsInDB = _controller.GetCustomers(customer.CustomerId) as OkNegotiatedContentResult <Customer>;
var result = _controller.DeleteCustomer(customer.CustomerId);
var checkIfDeleted = _controller.GetCustomers(customer.CustomerId) as OkNegotiatedContentResult <Customer>;
Assert.IsInstanceOfType(result, typeof(OkResult));
}
}
public async Task DeleteCustomer_ReturnBadRequest_ExistRelatedEntity()
{
//Arrange
int id = 1;
List <PurchaseOrder> list = new List <PurchaseOrder>();
list.Add(new PurchaseOrder());
_mockrepo.Setup(repo => repo.PurchaseOrder.PurchaseOrdersByCustomer(id)).ReturnsAsync(list);
_mockrepo.Setup(repo => repo.Customer.DeleteCustomer((Customer)null));
//Act
var result = await _controller.DeleteCustomer(id);
//Assert
var badRequest = Assert.IsType <BadRequestObjectResult>(result);
badRequest.Value.Should().Be(LogMessage.DeleteError(nameof(Customer), id, nameof(PurchaseOrder)));
}
public async Task DeleteCustomer_ReturnsNotFound_WhenIsIsInvalid()
{
var controller = new CustomersController(_context);
var result = await controller.DeleteCustomer(99);
Assert.IsType <NotFoundResult>(result);
}
public async Task DeleteCustomer_ReturnsOk_WhenCustomerDeleted()
{
var controller = new CustomersController(_context);
var result = await controller.DeleteCustomer(2);
Assert.IsType <OkObjectResult>(result);
}
public void DeleteCustomerById_CustomerExists_ReturnInternalError()
{
custController = new CustomersController(null, null, _logger.Object);
var result = custController.DeleteCustomer(_customerId);
Assert.IsType <StatusCodeResult>(result);
var objectResponse = result as StatusCodeResult;
Assert.Equal(500, objectResponse.StatusCode);
}
public async void TestDeleteCustomer()
{
var customerService = new Mock <ICustomersService>();
customerService.Setup(repo => repo.DeleteCustomer(It.IsAny <int>()));
var controller = new CustomersController(customerService.Object, AutoMapperConfiguration.ConfigureForWeb().CreateMapper());
var response = await controller.DeleteCustomer(1);
Assert.Equal("Microsoft.AspNetCore.Mvc.OkResult", response.GetType().ToString());
}
public async Task CustomerController_DeleteCustomer_Ok()
{
var db = _contextBuilder.ConfigureInMemory().Add1Customer().Build();
var repository = new Repository <Models.Customer>(db);
var controller = new CustomersController(repository);
var response = (await controller.DeleteCustomer(1)).Result as OkObjectResult;
var values = (bool)response.Value;
values.Should().BeTrue();
}
public void DeleteCustomer_ShouldReturnOK()
{
var context = new CustomersWebApiContext();
var cust = GetTestCustomers();
context.Customers.Add(cust);
var controller = new CustomersController(context);
var result = controller.DeleteCustomer(3) as OkNegotiatedContentResult <Customer>;
Assert.IsNotNull(result);
Assert.AreEqual(cust.Id, result.Content.Id);
}
public void Can_remove_Customer_and_all_associated_tags()
{
SeedOptions();
using (var context = new CustomerContext(ContextOptions))
{
var controller = new CustomersController(context);
var result = controller.DeleteCustomer(2);
Assert.Equal(2, result.Result.Value.Id);
}
}
public async Task DeleteCustomer_ValidParams_ReturnsNoContent()
{
var mockRepository = Substitute.For <ICustomersRepository>();
var controller = new CustomersController(mockRepository);
var response = await controller.DeleteCustomer(1);
response.Should().NotBeNull();
response.Should().BeOfType <NoContentResult>()
.Which.StatusCode.Should().Be((int)HttpStatusCode.NoContent);
await mockRepository.Received().DeleteCustomerAsync(Arg.Any <int>());
}
public async Task DeleteCustomer_InvalidParams_ReturnsBadRequest()
{
var mockRepository = Substitute.For <ICustomersRepository>();
mockRepository.DeleteCustomerAsync(Arg.Any <int>()).Throws <ValidationException>();
var controller = new CustomersController(mockRepository);
Func <Task <ActionResult <CustomerDto> > > response = async() => await controller.DeleteCustomer(1);
await response.Should().ThrowAsync <ValidationException>();
await mockRepository.Received().DeleteCustomerAsync(Arg.Any <int>());
}
public void DeleteCustomer_ReturnsNotFound_GivenBadId()
{
var customersRepo = new Mock <ICustomerRepository>();
customersRepo.Setup(x => x.DeleteCustomerById(It.IsAny <int>())).Returns(false);
var customersManipulation = new CustomerManipulation(customersRepo.Object);
var controller = new CustomersController(customersManipulation);
int id = 100;
// Act
var result = controller.DeleteCustomer(id);
// Assert
Assert.IsType <NotFoundObjectResult>(result);
}
public void ShouldNot_DeleteCustomer_NotFound()
{
Customer testCustomer = new Customer {
Id = 10
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.Customers.GetById(10)).Returns((Customer)null);
CustomersController controller = new CustomersController(mock.Object, null);
var result = controller.DeleteCustomer(10);
Assert.IsType <NotFoundResult>(result);
}
public async Task <IActionResult> DeleteCustomer(string customerId)
{
IServiceProvider provider = TestServiceProvider.CreateProvider();
using (IServiceScope scope = provider.CreateScope())
{
await SeedRepository(scope.ServiceProvider);
CustomersController controller = scope.ServiceProvider.GetRequiredService <CustomersController>();
IActionResult result = await controller.DeleteCustomer(customerId, scope.ServiceProvider.GetRequiredService <DeleteCustomerCommand>());
await SnapshotRepository(scope.ServiceProvider);
return(result);
}
}
public async Task BasicRentTest()
{
IDataAccess da = new DataAccess(new CostCalculator());
var bikesController = new BikesController(da);
var customersController = new CustomersController(da);
var rentalsController = new RentalsController(da);
var result = await bikesController.PostBike(new BikeRental.Model.Bike
{
Brand = "brand",
PurchaseDate = new DateTime(2019, 11, 11),
RentalPriceInEuroForEachAdditionalHour = 3,
RentalPriceInEuroForFirstHour = 5,
BikeCategory = BikeCategory.Mountainbike,
});
var bikeId = ((Bike)((CreatedAtActionResult)result.Result).Value).BikeId;
var result2 = await customersController.PostCustomer(new Customer
{
Gender = CustomerGender.Unknown,
FirstName = "fname",
LastName = "lname",
Birthday = new DateTime(1999, 1, 1),
Street = "street",
ZipCode = "A-1234",
Town = "town",
});
var customerId = ((Customer)((CreatedAtActionResult)result2.Result).Value).CustomerId;
var result3 = await rentalsController.PostRental(new Rental
{
RenterId = customerId,
BikeId = bikeId,
});
var rentalId = ((Rental)((CreatedAtActionResult)result3.Result).Value).RentalId;
await rentalsController.EndRental(rentalId);
await rentalsController.PayRental(rentalId);
await customersController.DeleteCustomer(customerId);
await bikesController.DeleteBike(bikeId);
}
public void ShouldNot_DeleteCustomer_ModelStateError()
{
Customer testCustomer = new Customer {
Id = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.Customers.Delete(testCustomer)).Returns(true);
CustomersController controller = new CustomersController(mock.Object, null);
controller.ModelState.AddModelError("TestError", "Error");
var result = controller.DeleteCustomer(1);
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task DeleteCustomer_ShouldReturn_BadrequestResult()
{
//Arrange
var customerService = new Mock <ICustomerService>();
customerService
.Setup(x => x.DeleteCustomer(It.IsAny <int>()))
.ReturnsAsync(false);
var customersController = new CustomersController(customerService.Object, null);
//Act
var result = await customersController.DeleteCustomer(1);
//Assert
result
.Should()
.BeOfType <BadRequestResult>();
}
private void BtnEditDelete_Click(object sender, RoutedEventArgs e)
{
CustomersController controller = new CustomersController();
controller.DeleteCustomer(TxtEditName.Text);
StackListOfCustomers.Children.Clear();
List <Button> listOfBtns = controller.GenerateCustomerList();
foreach (var button in listOfBtns)
{
StackListOfCustomers.Children.Add(button);
}
TxtEditName.Clear();
TxtEditMail.Clear();
TxtEditPhoneNo.Clear();
TxtEditUrl.Clear();
}
public async Task DeleteCustomer_ShouldReturn_OkResult()
{
//Arrange
var customerServiceMock = new Mock <ICustomerService>();
var kafkaServiceMock = new Mock <IKafkaService>();
customerServiceMock
.Setup(x => x.DeleteCustomer(It.IsAny <int>()))
.ReturnsAsync(true);
var customersController = new CustomersController(customerServiceMock.Object, kafkaServiceMock.Object);
//Act
var result = await customersController.DeleteCustomer(1);
//Assert
result
.Should()
.BeOfType <OkResult>();
}
public async void TestDeleteCustomer()
{
var dbContext = DbContextMocker.GetContext(nameof(this.TestDeleteCustomer));
var customersRepository = new CustomersRepository(dbContext);
var customerService = new CustomersService(customersRepository, null);
var controller = new CustomersController(customerService, AutoMapperConfiguration.ConfigureForWeb().CreateMapper());
var parameters = new JObject()
{
new JProperty("customerName", "test"),
new JProperty("managerId", "1"),
};
Assert.NotNull(dbContext.Customers.Find(2));
var response = await controller.DeleteCustomer(2);
Assert.Null(dbContext.Customers.Find(2));
dbContext.Dispose();
}
public void Should_DeleteCustomer()
{
Customer testCustomer = new Customer {
Id = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.Customers.GetById(1)).Returns(testCustomer);
mock.Setup(f => f.Customers.Delete(testCustomer)).Returns(true);
var userStore = new Mock <IUserStore <User> >();
Mock <UserManager <User> > mockUserManager = new Mock <UserManager <User> >(userStore.Object, null, null, null, null, null, null, null, null);
mockUserManager.Setup(f => f.FindByIdAsync(It.IsAny <string>())).Returns(Task.FromResult(new User {
Id = "test"
}));
mockUserManager.Setup(f => f.DeleteAsync(It.IsAny <User>())).Returns(Task.FromResult(IdentityResult.Success));
CustomersController controller = new CustomersController(mock.Object, mockUserManager.Object);
var result = controller.DeleteCustomer(1);
Assert.IsType <OkObjectResult>(result);
}
