public void CreateEmployeeForCompany_ValidInputCreatesEmployeeyAndReturnsAnOkResult_WithAnEmployee()
{
// Arrange
var existingCompany = SeedTestData.GetTestCompany();
Guid companyId = existingCompany.Id;
var testEmployee = SeedTestData.GetTestEmployee();
mockRepo.Setup(repo => repo.Company.GetCompany(companyId, false)).Returns(existingCompany).Verifiable();
mockRepo.Setup(repo => repo.Employee.CreateEmployeeForCompany(companyId, It.IsAny <Employee>()))
.Verifiable();
var controller = new EmployeesController(mockRepo.Object, _mapper);
EmployeeForCreationDto newEmployeeDto = new EmployeeForCreationDto()
{
Name = testEmployee.Name,
Age = testEmployee.Age,
Position = testEmployee.Position
};
// Act
var result = controller.CreateEmployeeForCompany(companyId, newEmployeeDto);
// Assert
Assert.IsInstanceOf <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.That(okResult.Value, Is.TypeOf <Employee>());
Employee resultEmp = okResult.Value as Employee;
Assert.AreEqual(resultEmp.Name, newEmployeeDto.Name);
Assert.AreEqual(resultEmp.Age, newEmployeeDto.Age);
Assert.AreEqual(resultEmp.Position, newEmployeeDto.Position);
mockRepo.Verify(repo => repo.Company.GetCompany(companyId, false), Times.Once);
mockRepo.Verify();
}
public void CreateCompany_ValidInputCreatesCompanyAndReturnsAnOkResult_WithAnCompany()
{
// Arrange
var newCompany = SeedTestData.GetTestCompany();
mockRepo.Setup(repo => repo.Company.CreateCompany(It.IsAny <Company>()))
.Verifiable();
var controller = new CompaniesController(mockRepo.Object, _mapper);
CompanyForCreationDto newCompanyDto = new CompanyForCreationDto()
{
Name = newCompany.Name,
Address = newCompany.Address,
Country = newCompany.Country
};
// Act
var result = controller.CreateCompany(newCompanyDto);
// Assert
Assert.IsInstanceOf <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.That(okResult.Value, Is.TypeOf <Company>());
Company resultComp = okResult.Value as Company;
Assert.AreEqual(resultComp.Name, newCompany.Name);
Assert.AreEqual(resultComp.Address, newCompany.Address);
Assert.AreEqual(resultComp.Country, newCompany.Country);
mockRepo.Verify();
}
public void Initialize()
{
mockRepo = new Mock <IRepositoryManager>();
mockRepo.Setup(repo => repo.Company.GetAllCompaniesAsync(false).Result)
.Returns(SeedTestData.GetTestCompanies());
mockRepo.Setup(repo => repo.Employee.GetAllEmployeesAsync(false).Result)
.Returns(SeedTestData.GetTestEmployees());
}
public void CreateEmployeeForCompany__InValidInputNull_ReturnsBadRequestObjectResult()
{
// Arrange
var existingCompany = SeedTestData.GetTestCompany();
Guid companyId = existingCompany.Id;
var controller = new EmployeesController(mockRepo.Object, _mapper);
EmployeeForCreationDto newEmployeeDto = null;
// Act
var result = controller.CreateEmployeeForCompany(companyId, newEmployeeDto);
// Assert
Assert.IsInstanceOf <BadRequestObjectResult>(result);
mockRepo.Verify(repo => repo.Employee.CreateEmployeeForCompany(companyId, It.IsAny <Employee>()), Times.Never);
}
public void UpdateCompany_UnExistingCompanyId_ReturnsNotFoundResult()
{
// Arrange
Company companyToUpdate = SeedTestData.GetTestCompany();
CompanyForUpdateDto companyForUpdateDto = null;
var controller = new CompaniesController(mockRepo.Object, _mapper);
// Act
var result = controller.UpdateCompany(companyToUpdate.Id, companyForUpdateDto);
// Assert
Assert.IsInstanceOf <BadRequestObjectResult>(result);
mockRepo.Verify(repo => repo.Company.GetCompany(companyToUpdate.Id, true), Times.Never);
mockRepo.Verify(repo => repo.Save(), Times.Never);
}
public void DeleteCompany_ForExistingId_RemovesCompanyAndReturnsNoContentResult()
{
// Arrange
var testDeleteCompany = SeedTestData.GetTestCompany();
mockRepo.Setup(repo => repo.Company.GetCompany(testDeleteCompany.Id, false))
.Returns(testDeleteCompany).Verifiable();
var controller = new CompaniesController(mockRepo.Object, _mapper);
// Act
var result = controller.DeleteCompany(testDeleteCompany.Id);
// Assert
Assert.IsInstanceOf <NoContentResult>(result);
mockRepo.Verify(repo => repo.Company.GetCompany(testDeleteCompany.Id, false), Times.Once);
}
public void UpdateEmployee_InValidInputNull_ReturnsBadRequestObjectResult()
{
// Arrange
Employee employeeToUpdate = SeedTestData.GetTestEmployee();
EmployeeForUpdateDto employeeForUpdateDto = null;
var controller = new EmployeesController(mockRepo.Object, _mapper);
// Act
var result = controller.UpdateEmployee(employeeToUpdate.Id, employeeForUpdateDto);
// Assert
Assert.IsInstanceOf <BadRequestObjectResult>(result);
mockRepo.Verify(repo => repo.Employee.GetEmployee(employeeToUpdate.Id, true), Times.Never);
mockRepo.Verify(repo => repo.Save(), Times.Never);
}
public void DeleteEmployee_ForExistingId_RemovesEmployeeAndReturnsNoContentResult()
{
// Arrange
var testDeleteEmployee = SeedTestData.GetTestEmployee();
mockRepo.Setup(repo => repo.Employee.GetEmployee(testDeleteEmployee.Id, false))
.Returns(testDeleteEmployee).Verifiable();
var controller = new EmployeesController(mockRepo.Object, _mapper);
// Act
var result = controller.DeleteEmployee(testDeleteEmployee.Id);
// Assert
Assert.IsInstanceOf <NoContentResult>(result);
mockRepo.Verify(repo => repo.Employee.GetEmployee(testDeleteEmployee.Id, false), Times.Once);
}
public void GetCompanies_ReturnsOkResult_WithListOfCompanies()
{
// Arrange
var controller = new CompaniesController(mockRepo.Object, _mapper);
// Act
var result = controller.GetCompanies();
// Assert
Assert.IsInstanceOf <OkObjectResult>(result.Result);
var okResult = result.Result as OkObjectResult;
Assert.IsInstanceOf <IEnumerable <CompanyDto> >(okResult.Value);
var items = okResult.Value as IEnumerable <CompanyDto>;
Assert.AreEqual(2, items.Count());
//bv eerste van de testCompanies testen op Id:
Assert.IsTrue(items.Where(comp => comp.Id == SeedTestData.GetTestCompany().Id).Any());
}
public void UpdateEmployee_ValidInput_ReturnsOkObjectResult_WithUpdatedEmployee()
{
// Arrange
Employee employeeToUpdate = SeedTestData.GetTestEmployee();
employeeToUpdate.Name = "gewijzigde naam";
employeeToUpdate.Age = 25;
employeeToUpdate.Position = "gewijzigde positie";
EmployeeForUpdateDto employeeForUpdateDto = new EmployeeForUpdateDto
{
Name = employeeToUpdate.Name,
Age = employeeToUpdate.Age,
Position = employeeToUpdate.Position,
};
mockRepo.Setup(repo => repo.Employee.GetEmployee(employeeToUpdate.Id, true))
.Returns(employeeToUpdate).Verifiable();
mockRepo.Setup(repo => repo.Save()).Verifiable();
var controller = new EmployeesController(mockRepo.Object, _mapper);
//Act
var result = controller.UpdateEmployee(employeeToUpdate.Id, employeeForUpdateDto);
// Assert
Assert.IsInstanceOf <OkObjectResult>(result);
OkObjectResult okResult = result as OkObjectResult;
Assert.IsInstanceOf <Employee>(okResult.Value);
var updatedEmployee = okResult.Value as Employee;
Assert.AreEqual(employeeToUpdate.Name, updatedEmployee.Name);
Assert.AreEqual(employeeToUpdate.Age, updatedEmployee.Age);
Assert.AreEqual(employeeToUpdate.Position, updatedEmployee.Position);
mockRepo.Verify(repo => repo.Employee.GetEmployee(updatedEmployee.Id, true), Times.Once);
mockRepo.Verify(repo => repo.Save(), Times.Once);
}
public void GetCompany_ForCompanyId_ReturnsCompanyDto()
{
//Arrange
Company testCompany = SeedTestData.GetTestCompany();
Guid testCompanyId = testCompany.Id;
mockRepo.Setup(r => r.Company.GetCompany(testCompanyId, It.IsAny <bool>())).Returns(testCompany);
CompaniesController controller = new CompaniesController(mockRepo.Object, _mapper); //CompaniesController is sut(System Under Test)
//Act
var result = controller.GetCompany(testCompanyId);
//Assert
Assert.IsInstanceOf <OkObjectResult>(result);
OkObjectResult okResult = result as OkObjectResult;
Assert.That(okResult.Value, Is.TypeOf <CompanyDto>());
CompanyDto companyDto = okResult.Value as CompanyDto; //of CompanyDto company = (CompanyDto)viewResult.Value;
Assert.AreEqual(testCompanyId, companyDto.Id);
Assert.AreEqual(testCompany.Name, companyDto.Name);
Assert.AreEqual(testCompany.Address + " " + testCompany.Country, companyDto.FullAddress);
}
public void GetEmployee_ForEmployeeId_ReturnsEmployeeDto()
{
//Arrange
Employee testEmployee = SeedTestData.GetTestEmployee();
Guid testEmployeeId = testEmployee.Id;
mockRepo.Setup(r => r.Employee.GetEmployee(testEmployeeId, It.IsAny <bool>())).Returns(testEmployee);
EmployeesController controller = new EmployeesController(mockRepo.Object, _mapper); //EmployeesController is sut(System Under Test)
//Act
var result = controller.GetEmployee(testEmployeeId);
//Assert
Assert.IsInstanceOf <OkObjectResult>(result);
OkObjectResult okResult = result as OkObjectResult;
Assert.That(okResult.Value, Is.TypeOf <EmployeeDto>());
EmployeeDto employeeDto = okResult.Value as EmployeeDto; //of EmployeeDto employeeDto = (EmployeeDto)viewResult.Value;
Assert.AreEqual(testEmployeeId, employeeDto.Id);
Assert.AreEqual(testEmployee.Name, employeeDto.Name);
Assert.AreEqual(testEmployee.Age, employeeDto.Age);
}
public void UpdateCompany_ValidInput_ReturnsOkObjectResult_WithUpdatedCompany()
{
// Arrange
Company companyToUpdate = SeedTestData.GetTestCompany();
companyToUpdate.Name = "gewijzigde naam";
companyToUpdate.Address = "gewijzigd adres";
companyToUpdate.Country = "gewijzigd land";
CompanyForUpdateDto companyForUpdateDto = new CompanyForUpdateDto
{
Name = companyToUpdate.Name,
Address = companyToUpdate.Address,
Country = companyToUpdate.Country
};
mockRepo.Setup(repo => repo.Company.GetCompany(companyToUpdate.Id, true))
.Returns(companyToUpdate).Verifiable();
mockRepo.Setup(repo => repo.Save()).Verifiable();
var controller = new CompaniesController(mockRepo.Object, _mapper);
//Act
var result = controller.UpdateCompany(companyToUpdate.Id, companyForUpdateDto);
// Assert
Assert.IsInstanceOf <OkObjectResult>(result);
OkObjectResult okResult = result as OkObjectResult;
Assert.IsInstanceOf <Company>(okResult.Value);
var updatedCompany = okResult.Value as Company;
Assert.AreEqual(companyToUpdate.Name, updatedCompany.Name);
Assert.AreEqual(companyToUpdate.Address, updatedCompany.Address);
Assert.AreEqual(companyToUpdate.Country, updatedCompany.Country);
mockRepo.Verify(repo => repo.Company.GetCompany(companyToUpdate.Id, true), Times.Once);
mockRepo.Verify(repo => repo.Save(), Times.Once);
}
