public void Run(EmployeeCostDto employeeCost, CompanyCostsDto companyCosts)
{
if (string.IsNullOrWhiteSpace(employeeCost.Employee.Id))
{
employeeCost.Employee.Id = Guid.NewGuid().ToString();
}
}
private decimal CalculateEmployeeCosts(EmployeeCostDto employeeCost, CompanyCostsDto companyCosts, List <IPersonDiscount> personDiscounts)
{
var employeeDiscounts = personDiscounts.Where(x => x.AppliedToEmployee).ToList();
var person = employeeCost.Employee;
var cost = companyCosts.EmployeeCost;
var totalDiscount = GetTotalDiscount(person, cost, employeeDiscounts);
return(cost - totalDiscount);
}
protected override void Context()
{
base.Context();
_employeeCost = new EmployeeCostDto()
{
Employee = new EmployeeDto()
{
FirstName = "Anne",
LastName = "Barber",
Dependents = new List <DependentDto>()
{
new DependentDto()
{
FirstName = "Alex",
LastName = "Barber"
},
new DependentDto()
{
FirstName = "Foo",
LastName = "Barber"
}
}
}
};
_companyCosts = new CompanyCostsDto()
{
EmployeeCost = 1000m,
DependentCost = 500m,
Discounts = new List <DiscountDto>()
{
new NameDiscountDto()
{
StartsWith = "A",
Percent = 10m,
AppliedToEmployee = true,
AppliedToDependent = true
}
}
};
_expectedEmployeeCost = 900m;
_expectedDependentCost = 950m;
_mockDiscount = new Mock <IPersonDiscount>();
_mockDiscount.SetupGet(x => x.AppliedToEmployee).Returns(true);
_mockDiscount.SetupGet(x => x.AppliedToDependent).Returns(true);
_mockDiscount.Setup(x => x.GetDiscount(_employeeCost.Employee, _companyCosts.EmployeeCost)).Returns(100m);
_mockDiscount.Setup(x => x.GetDiscount(_employeeCost.Employee.Dependents.First(), _companyCosts.DependentCost)).Returns(50m);
_mockDiscount.Setup(x => x.GetDiscount(_employeeCost.Employee.Dependents[1], _companyCosts.DependentCost)).Returns(0);
PersonDiscountFactoryMock
.Setup(x => x.AddDiscount(It.IsAny <IList <IPersonDiscount> >(), _companyCosts.Discounts.First()))
.Callback((IList <IPersonDiscount> discounts, DiscountDto discount) => { discounts.Add(_mockDiscount.Object); })
;
}
protected override void Context()
{
base.Context();
_companyId = 1;
_employeeDto = new EmployeeDto();
_companyCosts = new CompanyCostsDto();
_employeeCost = new EmployeeCostDto();
BenefitsRepositoryMock.Setup(x => x.GetCompanyCosts(_companyId)).Returns(_companyCosts);
EmployeeCostPipeMock.Setup(x => x.GetEmployeeCost(_employeeDto, _companyCosts)).Returns(_employeeCost);
}
public void Run(EmployeeCostDto employeeCost, CompanyCostsDto companyCosts)
{
var personDiscounts = new List <IPersonDiscount>();
foreach (var companyCostsDiscount in companyCosts.Discounts)
{
_personDiscountFactory.AddDiscount(personDiscounts, companyCostsDiscount);
}
employeeCost.EmployeeCost = CalculateEmployeeCosts(employeeCost, companyCosts, personDiscounts);
employeeCost.DependentCost = CalculateDependentCosts(employeeCost, companyCosts, personDiscounts);
employeeCost.TotalCost = employeeCost.EmployeeCost + employeeCost.DependentCost;
}
protected override void Context()
{
base.Context();
_employeeCost = new EmployeeCostDto()
{
Employee = new EmployeeDto()
{
Id = string.Empty,
}
};
_companyCosts = new CompanyCostsDto();
}
protected override void Context()
{
base.Context();
_employeeId = Guid.NewGuid().ToString();
_employeeCost = new EmployeeCostDto()
{
Employee = new EmployeeDto()
{
Id = _employeeId,
}
};
_companyCosts = new CompanyCostsDto();
}
public EmployeeCostDto GetEmployeeCost(EmployeeDto employee, CompanyCostsDto companyCosts)
{
var employeeCost = new EmployeeCostDto()
{
Employee = employee
};
foreach (var employeeCostFilter in _filters)
{
employeeCostFilter.Run(employeeCost, companyCosts);
}
return(employeeCost);
}
private decimal CalculateDependentCosts(EmployeeCostDto employeeCost, CompanyCostsDto companyCosts, List <IPersonDiscount> personDiscounts)
{
var dependentDiscounts = personDiscounts.Where(x => x.AppliedToDependent).ToList();
var totalCost = 0m;
var totalDiscount = 0m;
var cost = companyCosts.DependentCost;
foreach (var person in employeeCost.Employee.Dependents)
{
totalCost += cost;
totalDiscount += GetTotalDiscount(person, cost, dependentDiscounts);
}
return(totalCost - totalDiscount);
}
protected override void Context()
{
base.Context();
_employeeCost = new EmployeeCostDto()
{
EmployeeCost = 900m,
DependentCost = 950m,
TotalCost = 1850m
};
_companyCosts = new CompanyCostsDto()
{
NumberOfPaychecks = 26
};
_expectedTotalCostPerPaycheck = _employeeCost.TotalCost / _companyCosts.NumberOfPaychecks;
_expectedGrossPaycheck = 2000m;
_expectedPaycheckAmountAfterDeduction = _expectedGrossPaycheck - _expectedTotalCostPerPaycheck;
}
public void Run(EmployeeCostDto employeeCost, CompanyCostsDto companyCosts)
{
employeeCost.TotalCostPerPaycheck = employeeCost.TotalCost / companyCosts.NumberOfPaychecks;
employeeCost.GrossPaycheck = 2000m; // Note: If we ever make this be calculated by employee, we would want to include this on the employee.
employeeCost.PaycheckAmountAfterDeduction = employeeCost.GrossPaycheck - employeeCost.TotalCostPerPaycheck;
}
protected override void Because()
{
PipeUnderTest.RegisterFilters(_employeeCostFilterMock.Object);
_result = PipeUnderTest.GetEmployeeCost(_employee, _companyCosts);
}
private bool VerifyEmployeeCost(EmployeeCostDto dto)
{
Assert.AreSame(dto.Employee, _employee);
return(true);
}
protected override void Because()
{
_result = ServiceUnderTest.GetEmployeeCost(_companyId, _employeeDto);
}
