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