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";
}
}
