public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb()
{
var result = _controller.DeleteEmployee(1);
_employeeStorage.Verify(s => s.DeleteEmployee(1)); // ensures that storage layer method called w/ expected parameter
Assert.That(result, Is.TypeOf <RedirectResult>()); // ensures that expected return type comes back
}
public void DeleteEmployeeTest()
{
EmployeeController controller = new EmployeeController();
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
string locationUrl = "http://*****:*****@luizalabs.com", Department = "Commerce"
};
IHttpActionResult response = controller.PostEmployee(employee);
Assert.AreNotSame(employee.Id, 0);
response = controller.DeleteEmployee(Convert.ToInt32(employee.Id));
Assert.IsNotNull(response);
}
public async Task TestDeleteView()
{
var controller = new EmployeeController(_manager);
var result = await controller.DeleteEmployee(1) as ViewResult;
Assert.AreEqual("DeleteEmployee", result?.ViewName);
}
private void btn_Delete_Click(object sender, EventArgs e)
{
if (rowIndex < 0)
{
MessageBox.Show("Vui lòng chọn Employee cần xóa!", "Thông báo");
return;
}
string ID = this.dtgv_ListEmployee.Rows[rowIndex].Cells[0].Value.ToString();
if (ProjectController.GetListProjectsByIDLeader(ID) != null)
{
MessageBox.Show("Nhân viên hiện là Leader dự án không thể xóa", "Cảnh báo báo!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (EmployeeController.DeleteEmployee(ID) == true)
{
MessageBox.Show("Xóa nhân viên thành công", "Thông báo!", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Xóa nhân viên không thành công", "Lỗi !", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
dtgv_ListEmployee.DataSource = EmployeeController.GetListEmployee();
ClearControls();
}
public void DeletemployeeById_ReturnsViewResult()
{
int id = 20;
var result = _employeeController.DeleteEmployee(id);
Assert.That(result, Is.TypeOf <ViewResult>());
}
public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb()
{
//Arrange
//_employeeStorage.Setup
//Act
_employeeController.DeleteEmployee(1);
// En este caso no nos importa el resultado, solo queremos probar la interacción de este controlador con
// el objeto storage
// Setup lets you make the mock object return a specific object when a specific method is called.
//Verify is to assert that a specific method was called.
//Assert
_employeeStorage.Verify(s => s.DeleteEmployee(1));
}
public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb()
{
var id = _fixture.Create <int>();
_sut.DeleteEmployee(id);
_employeeStorage.Verify(s => s.DeleteEmployee(id));
}
public void DeleteEmployee_WhenCalled_DeleteEmployeeFromDb()
{
var result = _employeeController.DeleteEmployee(1);
_employeeRepository.Verify(repository => repository.DeleteEmployee(1));
Assert.That(result, Is.TypeOf <RedirectResult>());
}
public void IfEmployeeIdIsInvalidShouldReturnBadRequest()
{
//Setting Data.
int Id = -8;
var response = controller.DeleteEmployee(Id) as BadRequestObjectResult;
var dataResponse = JToken.Parse(JsonConvert.SerializeObject(response.Value));
var dataResponseSuccess = dataResponse["Success"].ToObject <bool>();
var dataResponseMessage = dataResponse["Message"].ToString();
//Expected Values.
string Message = "INVALID_FIELD_EXCEPTION";
//Asserting Values.
Assert.IsInstanceOf <BadRequestObjectResult>(response);
Assert.IsFalse(dataResponseSuccess);
Assert.AreEqual(Message, dataResponseMessage);
}
public void DeleteEmployee_WhenCalled_ReturnsRedirectResult()
{
var storage = new Mock <IEmployeeStorage>();
var controller = new EmployeeController(storage.Object);
var result = controller.DeleteEmployee(1);
Assert.That(result, Is.InstanceOf <RedirectResult>());
}
public void DeleteEmployee_AfterDeleted_ReturnRedirectResultObject()
{
var controller = new EmployeeController(_storage.Object);
var result = controller.DeleteEmployee(1);
_storage.Verify(s => s.DeleteEmployee(1));
Assert.That(result, Is.TypeOf <RedirectResult>());
}
private void Delete_Button_Click(object sender, EventArgs e)
{
this.Id_Box.Text = this.metroGrid.CurrentRow.Cells["Id"].Value.ToString();
this.Username_Box.Text = this.metroGrid.CurrentRow.Cells["Username"].Value.ToString();
EmployeeController.DeleteEmployee(Id_Box.Text);
LoginController.DeleteLogin(Username_Box.Text);
metroGrid.DataSource = EmployeeController.GetAllEmployees();
}
public void DeleteEmployee_TakesIdAndDeleteEmployee_DeleteEmployee()
{
var db = new Mock <IEmployeeRepository>();
var controller = new EmployeeController(db.Object);
controller.DeleteEmployee(1);
db.Verify(d => d.DeleteEmployee(1));
}
public async Task DeleteEmployee_ReturnOK()
{
var result = await _controller.DeleteEmployee(100);
var status = result as ObjectResult;
Assert.AreEqual(200, status.StatusCode);
}
public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb()
{
var controller = new EmployeeController(_storage.Object);
controller.DeleteEmployee(1);
_storage.Verify(s => s.DeleteEmployee(1));
}
public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb2()
{
var storage = new Mock <IEmpStore>();
var controller = new EmployeeController(storage.Object);
var result = controller.DeleteEmployee(1);
Assert.That(result, Is.TypeOf <RedirectResult>());
}
public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb()
{
var storage = new Mock <IEmployeeStorage>();
var controller = new EmployeeController(storage.Object);
controller.DeleteEmployee(3);
storage.Verify(s => s.DeleteEmployee(3));
}
public void DeleteEmployee_WhenCalled_DeletesEmployeeFromDb()
{
const int employeeId = 1;
_employeeController.DeleteEmployee(employeeId);
_employeeStorage.Verify(es => es.RemoveEmployee(employeeId));
}
public void DeleteEmployee_WhenCalled_DeleteEmployeeFormDB()
{
var storage = new Mock <IEmployeeStorage>();
var controller = new EmployeeController(storage.Object);
controller.DeleteEmployee(1);
storage.Verify(s => s.deleteEmployee(1));
}
public void DeleteEmployee_WhenCalled_ReturnRedirectObject()
{
var storage = new Mock <IEmployeeStorage>();
var controller = new EmployeeController(storage.Object);
var result = controller.DeleteEmployee(1);
Assert.That(result.GetType() == typeof(RedirectResult));
}
public void DeleteEmployee_WhenCalled_DeleteEmployeeFromDb()
{
var repository = new Mock <IEmployeeRepository>();
var controller = new EmployeeController(repository.Object);
controller.DeleteEmployee(1);
repository.Verify(s => s.DeleteEmployee(1));
}
public void DeleteEmployee_Call_Delete_Method_On_Repository()
{
var mockRepository = new Mock <IEmployeeRepository>();
var employeeController = new EmployeeController(mockRepository.Object);
employeeController.DeleteEmployee("123-45-4321");
mockRepository.Verify(x => x.Delete(It.IsAny <Employee>()), Times.AtMostOnce());
}
public void DeleteEmploee_WhenCalled_RedirectToEmpleeAction()
{
var storage = new Mock <IEmploeeStorage>();
var controller = new EmployeeController(storage.Object);
var result = controller.DeleteEmployee(1);
var viewResult = Assert.IsType <RedirectResult>(result);
}
public void EmployeeTest_WhenCalled_DeletesEmployee()
{
var remover = new Mock <IEmployeeRemover>();
var controller = new EmployeeController(remover.Object);
controller.DeleteEmployee(1);
remover.Verify(s => s.RemoveEmployee(1));
}
public void DeleteEmployee_WhenCalled_ReturnRedirectToActionMethod()
{
var db = new Mock <IEmployeeRepository>();
var controller = new EmployeeController(db.Object);
var result = controller.DeleteEmployee(1);
Assert.That(result, Is.InstanceOf <RedirectResult>());
}
public void DeleteEmployee_WhenCalled_DeletesARecord()
{
var employeeStorage = new Mock <IEmployeeStorage>();
var employeeController = new EmployeeController(employeeStorage.Object);
employeeController.DeleteEmployee(1);
employeeStorage.Verify(t => t.DeleteEmployee(1));
}
public void DeleteEmployee_WhenCalled_ShouldDeleteEmployeeFromDatabase()
{
var storage = new Mock <IEmployeeStorage>();
var controller = new EmployeeController(storage.Object);
controller.DeleteEmployee(1);
storage.Verify(s => s.DeleteEmployee(1));
}
public void DeleteEmployee_WhenCalled_ReturnsRedirectResult()
{
var repository = new Mock <IEmployeeRepository>();
var controller = new EmployeeController(repository.Object);
var result = controller.DeleteEmployee(1);
Assert.That(result, Is.TypeOf <RedirectResult>());
}
public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb()
{
var mock = new Mock <IEmployeeRepository>();
var controller = new EmployeeController(mock.Object);
controller.DeleteEmployee(1);
mock.Verify(m => m.Delete(1));
}
public void DeleteEmployee_WhenCalled_DeleteTheEmployeeFromDb()
{
var storage = new Mock <IEmployeeStorage>();
var controller = new EmployeeController(storage.Object);
controller.DeleteEmployee(1);
storage.Verify(s => s.DeleteEmployee(1)); //overenie ze bola urcita metoda s urcitym parametrom volana
}
