public void TestDeleteEmployees() { onSetUp(); var employeeBuilder = new EmployeeBuilder().setName(NAME); employeeRepository.AddEmployees(new List <Employee>() { employeeBuilder.CreateEmployee() }); var removeEmployeeRequest = new RemoveEmployeeRequest() { Name = NAME }; employeeController.Delete(removeEmployeeRequest); try { employeeController.Get(NAME); Assert.Fail("Expected exception to be thrown."); } catch (NoSuchEntityException e) { Assert.IsTrue(e.Message.Contains(NAME)); } }
public void DeleteEmployeeOkResult() { var employeeId = "001_ID1"; _mockEmployeeService.Setup(repo => repo.RemoveEmployee(employeeId)).Returns(Task.FromResult(true)); var response = _employeeController.Delete(employeeId).Result; Assert.IsInstanceOfType(response, typeof(NoContentResult)); }
public void Remove_ExistingGuidPassed_RemovesOneItem() { // Arrange var existingGuid = 4; // Act var okResponse = _controller.Delete(existingGuid); // Assert Assert.Equal(3, _service.GetAll().Count); }
public void DeleteEmployee() { controller.Delete(3); var Result = controller.Get(3); Assert.Null(Result); }
public void EmployeeTaskAssignTest() { var newEmployeeTask = new EmployeeTask() { TaskName = "CRUDTestAssignment", StartTime = DateTime.Now, Deadline = DateTime.Now.AddDays(1) }; EmployeeTaskController.Post(newEmployeeTask); var newEmployee = new Employee() { FirstName = "UnitTest", LastName = "Employee1", HiredDate = DateTime.Now, EmployeeTasks = string.Format(jsonFormat, newEmployeeTask.EmployeeTaskID) }; EmployeeController.Post(newEmployee); List <EmployeeViewModel> _allEmployee = EmployeeController.Get(); EmployeeViewModel toCompare = _allEmployee.Where(x => x.EmployeeID == newEmployee.EmployeeID).FirstOrDefault(); var assignedTask = JsonConvert.DeserializeObject <List <EmployeeTask> >(toCompare.EmployeeTasks).FirstOrDefault(); Assert.IsTrue(toCompare != null && newEmployeeTask.TaskName == assignedTask.TaskName); EmployeeController.Delete(newEmployee.EmployeeID); EmployeeTaskController.Delete(newEmployeeTask.EmployeeTaskID); }
public async Task Delete_WhenEmployeeRecordNotFound_ThenNotFoundErrorViewReturned() { _mockAuthService .Setup(a => a.IsAuthenticated(_user)) .Returns(true); _mockRepository .Setup(r => r.DeleteAsync(1)) .ReturnsAsync(EmployeeProvider.GetOneTestEmployee); var controller = new EmployeeController(_mockAuthService.Object, _mockRepository.Object, _mockService.Object); controller.ControllerContext = new ControllerContext() { HttpContext = new DefaultHttpContext() { User = _user } }; var actual = await controller.Delete(5) as ViewResult; Assert.IsNotNull(actual); Assert.IsInstanceOf <ViewResult>(actual); Assert.IsTrue(actual.ViewName == "_NotFound"); }
public void NegativeTest_DeleteSecondEmployee_GetById_OfSecondEmployee_EmployeeNotFound() { var employeeControllerSUT = new EmployeeController(new List <Employee>()); var employee1 = new Employee() { FirstName = "FirstName1", LastName = "LastName1", AnualSalary = 1000, PaymentStartDate = new DateTime(2018, 03, 31), SuperRate = 9 }; var employee2 = new Employee() { FirstName = "FirstName2", LastName = "LastName2", AnualSalary = 1000, PaymentStartDate = new DateTime(2018, 03, 31), SuperRate = 9 }; var id1 = employeeControllerSUT.Post(employee1 as Employee).Result; var id2 = (employeeControllerSUT.Post(employee2 as Employee).Result as OkNegotiatedContentResult <int>).Content; employeeControllerSUT.Delete(id2); var fromGet = employeeControllerSUT.Get(id2).Result; Assert.IsInstanceOfType(fromGet, typeof(NotFoundResult)); }
public async Task UpdateEntityTests() { var controller2 = new EmployeeController(); controller2.SetFakeAuthenticatedControllerContext(); controller2.rESTAPIWrapperClinet = new RESTAPIWrapperClinet(ServiceConfig.SectionName); var dto = CreateDTO(); //create bool flag = await controller2.Post(dto); Assert.True(flag); //Get and Find it var getDto = await controller2.Find(dto, 1, 1); Assert.NotNull(getDto.Data); var dbEntity = getDto.Data as EasyuiDatagridData <EmployeeDto>; Assert.NotNull(dbEntity); Assert.NotEmpty(dbEntity.Rows); var pendingUpdateDto = dbEntity.Rows.FirstOrDefault(); pendingUpdateDto.Title = "xxxx"; //Update bool updateflag = await controller2.Put(pendingUpdateDto); Assert.True(updateflag); //Delete bool deleteflag = await controller2.Delete(pendingUpdateDto.EmployeeID); Assert.True(deleteflag); }
public async Task Delte_Employee_Should_Call_Service() { IActionResult response = await employeeController.Delete(); response.Should().BeOfType <AcceptedResult>(); employeeServiceMock.Verify(e => e.Delete(), Times.Once); employeeServiceMock.VerifyNoOtherCalls(); }
public async Task Delete_Get_ModelIsValid_AsksForDeleteView() { Mock <EmployeeService> mock = new Mock <EmployeeService>(); EmployeeController controller = GetNewEmployeeController(mock.Object, null, null); ViewResult result = (await controller.Delete(1)) as ViewResult; Assert.AreEqual("Delete", result.ViewName); }
public async Task Emp_Delete() { EmployeeRepository empRepo = new EmployeeRepository(_context); EmployeeController con = new EmployeeController(empRepo); Employee lastEmp = _context.Employee.OrderByDescending(p => p.Id).FirstOrDefault(); var m = await con.Delete(lastEmp.Id); Assert.IsNull(m.Value); }
public void GetDelete_IncorrectId_404NotFound() { // Arrange EmployeeController controller = new EmployeeController(mock.Object); // Act HttpNotFoundResult result = (HttpNotFoundResult)controller.Delete(1000); // Assert Assert.IsTrue(result.StatusCode == 404); }
private void btnDelete_Click(object sender, EventArgs e) { if (EmployeeController.SelectEmployee == null) { ResetForm(); return; } EmployeeController.Delete(); this.Close(); }
public void Controller_Delete() { var mockMapper = new Mock <IMapper <EmployeeVm> >(); var controller = new EmployeeController(mockMapper.Object); var result = controller.Delete(10); Assert.IsType <bool>(result); Assert.True(result); }
public async Task Delete_Get_ModelIsInvalid_AsksForErrorView() { Mock <EmployeeService> mock = new Mock <EmployeeService>(); mock.Setup(m => m.FindByIdAsync(It.IsAny <int?>())).Throws(new ValidationException("FindByIdAsync method throws Exception", "")); EmployeeController controller = GetNewEmployeeController(mock.Object, null, null); ViewResult result = (await controller.Delete(1)) as ViewResult; Assert.AreEqual("Error", result.ViewName); }
public void Test_Success_Delete_Existing_Employee() { //Arrange var employee = _sqlEmployeeList.Where(e => e.Id == 1).FirstOrDefault(); //Act _employeeController.Delete(employee); //Assert _sqlEmployeeServiceMock.Verify(e => e.DeleteEmployee(employee), Times.Once); }
public void throws_exception_when_employee_not_found_during_delete() { //arrange var controller = new EmployeeController(_searchEmployee, _employeeService, _logger, _mapper); _employeeService.GetById(100).ReturnsNull(); //act Assert.ThrowsException <Exception>(() => controller.Delete(100)); //assert _employeeService.DidNotReceive().Delete(Arg.Any <Employee.DomainObject.Employee>()); }
public async void Delete_employee_Test() { var employeeId = 2; _IEmployeeRepository.Setup(x => x.Delete(employeeId)) .ReturnsAsync(true); var response = await _employeeController.Delete(employeeId); Assert.IsType <OkResult>(response); }
public async Task Delete_Get_ModelIsInvalid_RetrievesExceptionMessageFromModel() { Mock <EmployeeService> mock = new Mock <EmployeeService>(); mock.Setup(m => m.FindByIdAsync(It.IsAny <int?>())).Throws(new ValidationException("FindByIdAsync method throws Exception", "")); EmployeeController controller = GetNewEmployeeController(mock.Object, null, null); ViewResult result = (await controller.Delete(1)) as ViewResult; string[] model = result.ViewData.Model as string[]; Assert.AreEqual("FindByIdAsync method throws Exception", model[0]); }
public async void DeleteEmployee_Return_NotFoundResult() { //Arrange var controller = new EmployeeController(employeeRepository); var empid = 5; //Act var data = await controller.Delete(empid); //Assert Assert.IsType <NotFoundResult>(data); }
public async Task DeleteEmployee_Returns_BadRequest() { var employeeController = new EmployeeController(_mockEmployeeManager.Object) { Request = new HttpRequestMessage(), Configuration = new System.Web.Http.HttpConfiguration() }; var result = await employeeController.Delete(0); //asert if returns ok status code Assert.IsTrue(result.StatusCode == System.Net.HttpStatusCode.BadRequest); }
public void Delete_ReturnBadRequestResultWhenEmployeeIsNotFound() { // Arrange var repo = new EmployeeRepository(Context); var service = new EmployeeService(repo); var controller = new EmployeeController(service); // Act var result = controller.Delete(-1); // Assert Assert.IsType <BadRequestResult>(result); }
public void DeleteEmployeeTest() { int intEmployeeId = 1009; var objmoq = new Mock <IEmployeeDAL>(); objmoq.Setup(X => X.DeleteEmployee(intEmployeeId)).Returns(true); EmployeeController objEmployeeController = new EmployeeController(objmoq.Object); var result = (RedirectToRouteResult)objEmployeeController.Delete(intEmployeeId); Assert.AreEqual("Index", result.RouteValues["Action"]); }
private void dataGridView1_DoubleClick(object sender, EventArgs e) { var emp = (Employee)dataGridView1.CurrentRow.DataBoundItem; Data.employee = emp; Data.departmentsList = departmentController.GetDepartments(); EmployeeForm empForm = new EmployeeForm(); if (empForm.ShowDialog() == DialogResult.OK) { if (Data.employee.FirstName != null) { employeeController.Update(Data.employee); } else { employeeController.Delete(Data.employee.ID); } } UpdateDataGrid(emp.DepartmentID); Data.employee = null; }
public void Delete_Test() { // Arrange var mockService = new Mock <IEmployeeService>(); var controller = new EmployeeController(mockService.Object); int id = 10; int userId = 1; // Act IHttpActionResult actionResult = controller.Delete(id, userId); // Assert Assert.IsInstanceOfType(actionResult, typeof(OkResult)); }
public void Delete_DeletesEmployeeAndReturnOkResult() { // Arrange var repo = new EmployeeRepository(Context); var service = new EmployeeService(repo); var controller = new EmployeeController(service); var employee = service.Create(GetTestEmployee(0)); // Act var result = controller.Delete(employee.Id); // Assert Assert.IsType <OkResult>(result); }
public void EmployeeController_Delete() { // Arrange int id = 0; // Set up Prerequisites var controller = new EmployeeController(employeeRepository, paginatedQueryRepo); // Act on Test - For Delete var response = controller.Delete(id); // Assert the result Assert.IsNotNull(response); Assert.Pass(); }
public void DeleteTestOk() { IEmployeeService _employeeService = new EmployeeService(); var employees = _employeeService.List(1, 1); Employee employee = employees[0]; _controller.Request = new HttpRequestMessage(); var result = _controller.Delete(employee.Id); var deletedResult = result as NegotiatedContentResult <string>; Assert.IsNotNull(deletedResult); Assert.AreEqual("", deletedResult.Content); Assert.AreEqual(HttpStatusCode.OK, deletedResult.StatusCode); }
public void Checking_Delete_Integration() { emp.Id = 1; bool expected = true; var actionresult = employeeController.Delete(emp.Id); JsonResult json = (JsonResult)actionresult; var orginal = json.Data; Assert.AreEqual(expected, orginal); // // TODO: Add test logic here // }
/// <summary> /// Deletes an employee based on the Id entered /// </summary> /// <param name="id"></param> private void DeleteEmployeeById(int id) { ResultsEnum result = _empController.Delete(id); if (result == ResultsEnum.Success) { lblStatus.Text = @"Employee Deleted"; LoadEmployeeData(); // update the home page ClearTextFields(); } else { lblStatus.Text = @"Could not delete, check all the fields and try again"; } }