public void ReturnsBonusPoolCalculation()
{
// arrange
var serviceMock = new Mock <IBonusPoolService>();
var allStubEmployees = _stubEmployees;
var bonusPoolCalculatorResultModel = new BonusPoolCalculatorResultDomainModel
{
BonusPoolAllocation = 100,
HrEmployee = allStubEmployees.Last()
};
serviceMock
.Setup(s => s.Calculate(It.IsAny <BonusPoolCalculatorDomainModel>()))
.Returns(bonusPoolCalculatorResultModel);
// act
var result = new BonusPoolController(serviceMock.Object, new MappingHelper <ApiMapperProfile>())
.Calculate(new BonusPoolCalculatorViewModel
{
BonusPoolAmount = 100,
SelectedEmployeeId = allStubEmployees.Last().Id
})
as ViewResult;
var actual = result?.Model as BonusPoolCalculatorResultViewModel;
//assert
Assert.IsNotNull(actual);
Assert.AreEqual(Json.Encode(bonusPoolCalculatorResultModel.BonusPoolAllocation), Json.Encode(actual.BonusPoolAllocation));
}
public void CanCreate()
{
var serviceMock = new Mock <IBonusPoolService>();
var sut = new BonusPoolController(serviceMock.Object, new MappingHelper <ApiMapperProfile>());
Assert.IsNotNull(sut);
}
public BonusPoolControllerTests()
{
_fixture = new Fixture();
_mockedEmployeeService = new Mock <IEmployeeService>();
_mockedBonusCalculator = new Mock <IBonusCalculator>();
SUT = new BonusPoolController(_mockedEmployeeService.Object, _mockedBonusCalculator.Object);
}
public async Task CalculateBonus_Should_Return_Null_When_EmployeeId_Is_Zero()
{
// Arrange
var bonusPoolServiceMock = new Mock <IBonusPoolService>();
int selectedEmployeeId = 0;
int totalCompanySalaryBudget = 100000;
var request = new CalculateBonusDto
{
SelectedEmployeeId = selectedEmployeeId,
TotalBonusPoolAmount = totalCompanySalaryBudget
};
bonusPoolServiceMock
.Setup(x => x.CalculateAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync((BonusPoolCalculatorResultDto)null);
var controller = new BonusPoolController(bonusPoolServiceMock.Object);
// Act
var result = await controller.CalculateBonus(request);
var objectResult = result as ObjectResult;
// Assert
Assert.IsNull(objectResult.Value);
Assert.IsInstanceOfType(result, typeof(IActionResult));
}
public void Calculate_Throws_An_Exception_When_The_Employye_Is_Not_Found()
{
// Arrange
var sut = new BonusPoolController(_bonusCalculatorService.Object, _hrEmployeeRepository.Object);
// Assert
Assert.ThrowsException <Exception>(() => sut.Calculate(NewBonusPoolCalculatorModel()));
}
public void Calculate_Uses_Calculate_From_IBonusCalculatorService_To_Calculate_The_Bonus()
{
// Arrange
_hrEmployeeRepository.Setup(r => r.GetById(It.IsAny <int>())).Returns(NewHrEmployee());
var sut = new BonusPoolController(_bonusCalculatorService.Object, _hrEmployeeRepository.Object);
// Act
sut.Calculate(NewBonusPoolCalculatorModel());
// Assert
_bonusCalculatorService.Verify(s => s.Calculate(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()), Times.Once);
}
public void Index_Uses_GetAll_From_IHrEmployeesRepository_To_Retrieve_All_The_HrEmployees()
{
// Arrange
_hrEmployeeRepository.Setup(r => r.GetById(It.IsAny <int>())).Returns(NewHrEmployee());
var sut = new BonusPoolController(_bonusCalculatorService.Object, _hrEmployeeRepository.Object);
// Act
sut.Index();
// Assert
_hrEmployeeRepository.Verify(r => r.GetAll(), Times.Once);
}
public async Task CalculateBonus_Should_Return_Correct_Results()
{
// Arrange
var bonusPoolServiceMock = new Mock <IBonusPoolService>();
int selectedEmployeeId = 1;
int totalCompanySalaryBudget = 100000;
int bonusPoolAmount = 10000;
var request = new CalculateBonusDto
{
SelectedEmployeeId = selectedEmployeeId,
TotalBonusPoolAmount = totalCompanySalaryBudget
};
var employee = new Employee(1, "Amanda Woods", "Product Owner", 60000, 1);
var department = new DepartmentDto()
{
Title = "IT",
Description = "The software development department for the company"
};
var mappedEmployee = new EmployeeDto()
{
Id = 1,
Fullname = "Amanda Woods",
JobTitle = "Product Owner",
Salary = 60000,
Department = department
};
decimal expectedEmployeeBonusPercentage = (decimal)employee.Salary / (decimal)totalCompanySalaryBudget;
int expectedBonusAmount = (int)(expectedEmployeeBonusPercentage * bonusPoolAmount);
var mappedBonusPoolCalculatorResult = new BonusPoolCalculatorResultDto
{
Employee = mappedEmployee,
Amount = expectedBonusAmount
};
bonusPoolServiceMock
.Setup(x => x.CalculateAsync(It.IsAny <int>(), It.IsAny <int>()))
.ReturnsAsync(mappedBonusPoolCalculatorResult);
var controller = new BonusPoolController(bonusPoolServiceMock.Object);
// Act
var result = await controller.CalculateBonus(request);
var objectResult = result as ObjectResult;
var expectedStatusCode = StatusCodes.Status200OK;
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IActionResult));
Assert.AreEqual(expectedStatusCode, objectResult.StatusCode);
Assert.AreEqual(mappedBonusPoolCalculatorResult, objectResult.Value);
}
public void Setup()
{
MockEmployeeRepository = new Mock <IEmployeeRepository>();
MockDepartmentRepository = new Mock <IDepartmentRepository>();
EmployeeRepository = new EmployeeRepository();
DepartmentRepository = new DepartmentRepository();
BonusPoolCalculatorService = new BonusPoolCalculatorService();
BonusPoolCalculatorModel = new BonusPoolCalculatorModel();
BonusPoolCalculatorResultModel = new BonusPoolCalculatorResultModel();
Target = new BonusPoolController(EmployeeRepository, DepartmentRepository, BonusPoolCalculatorService, BonusPoolCalculatorModel, BonusPoolCalculatorResultModel);
}
public async Task GetAll_Should_Return_Correct_Results()
{
// Arrange
var bonusPoolServiceMock = new Mock <IBonusPoolService>();
var employees = new List <Employee>
{
new Employee(1, "Amanda Woods", "Product Owner", 60000, 1),
new Employee(2, "Ross Green", "Software Developer", 70000, 1),
};
var department = new DepartmentDto()
{
Title = "IT",
Description = "The software development department for the company"
};
var mappedEmployees = new List <EmployeeDto>
{
new EmployeeDto()
{
Id = 1,
Fullname = "Amanda Woods",
JobTitle = "Product Owner",
Salary = 60000,
Department = department
},
new EmployeeDto()
{
Id = 2,
Fullname = "Ross Green",
JobTitle = "Software Developer",
Salary = 70000,
Department = department
},
};
bonusPoolServiceMock.Setup(x => x.GetEmployeesAsync()).ReturnsAsync(mappedEmployees);
var controller = new BonusPoolController(bonusPoolServiceMock.Object);
// Act
var result = await controller.GetAll();
var objectResult = result as ObjectResult;
var expectedStatusCode = StatusCodes.Status200OK;
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IActionResult));
Assert.AreEqual(expectedStatusCode, objectResult.StatusCode);
Assert.AreEqual(mappedEmployees, objectResult.Value);
}
public void ReturnsAllEmployees()
{
var serviceMock = new Mock <IBonusPoolService>();
var allStubEmployees = _stubEmployees;
serviceMock
.Setup(s => s.GetAll())
.Returns(_stubEmployees);
var sut = new BonusPoolController(serviceMock.Object, new MappingHelper <ApiMapperProfile>());
var result = sut.Index() as ViewResult;
var actual = (result.Model as BonusPoolCalculatorViewModel).AllEmployees;
Assert.AreEqual(Json.Encode(allStubEmployees), Json.Encode(actual));
}
public void Before_each()
{
//NOTE: yes, I did not use an interface here - please see the readme
var calculatorModel = new BonusPoolCalculatorModel {
AllEmployees = new List <Employee> {
new Employee {
Id = 0, FullName = "Alf Stokes", Salary = 10000
},
new Employee {
Id = 1, FullName = "Bender Rodriguez", Salary = 1000
}
}
};
_mockIndexService = Substitute.For <IBonusPoolIndexService>();
_mockIndexService.GenerateIndexModel().Returns(calculatorModel);
_mockCalculatorService = Substitute.For <IBonusPoolCalculatorService>();
_controller = new BonusPoolController(_mockIndexService, _mockCalculatorService);
}
public void CalculationWhereUserNotFoundReturns404()
{
var serviceMock = new Mock <IBonusPoolService>();
serviceMock
.Setup(s => s.GetAll())
.Returns(_stubEmployees);
serviceMock.Setup(x =>
x.Calculate(It.IsAny <BonusPoolCalculatorDomainModel>()))
.Throws <EmployeeNotFoundException>();
var model = new BonusPoolCalculatorViewModel();
var actual =
new BonusPoolController(serviceMock.Object, new MappingHelper <ApiMapperProfile>())
.Calculate(model);
Assert.IsInstanceOfType(actual, typeof(HttpNotFoundResult));
}
