public Bonus(Character character, string source, BonusCalculator bonusCalculator)
{
Source = source;
_character = character;
_bonusCalculator = bonusCalculator;
}
public Bonus(Character character, BonusCalculator bonusCalculator, string condition)
{
_character = character;
_bonusCalculator = bonusCalculator;
Condition = condition;
}
public void BonusCalculator_BonusTime_BasicTest()
{
StringAssert.AreEqualIgnoringCase("$100000", BonusCalculator.BonusTime(10000, true));
StringAssert.AreEqualIgnoringCase("$250000", BonusCalculator.BonusTime(25000, true));
StringAssert.AreEqualIgnoringCase("$10000", BonusCalculator.BonusTime(10000, false));
StringAssert.AreEqualIgnoringCase("$60000", BonusCalculator.BonusTime(60000, false));
StringAssert.AreEqualIgnoringCase("$20", BonusCalculator.BonusTime(2, true));
StringAssert.AreEqualIgnoringCase("$78", BonusCalculator.BonusTime(78, false));
StringAssert.AreEqualIgnoringCase("$678900", BonusCalculator.BonusTime(67890, true));
}
public void CalculateBonus(int employeeSalary, int allEmployeesSalary, int bonusPool, int expectedBonus)
{
// Arrange
var sut = new BonusCalculator();
// Act
var actualBonus = sut.Calculate(employeeSalary, allEmployeesSalary, bonusPool);
// Assert
Assert.That(actualBonus, Is.EqualTo(expectedBonus));
}
public BonusSource(Character character, string name, BonusCalculator calculator = null)
{
Name = name;
_character = character;
_bonuses = new List<Bonus>();
if (calculator != null)
{
AddBonus(calculator);
}
}
private void AssignRideToCar(Ride ride, Car car)
{
ride.GotBonus = BonusCalculator.CalculateBonus(car, ride, _problemData.PerRideBonus) > 0;
car.Rides.Add(ride);
car.OccupiedUntil = StepCalculator.CalculateStepAfterRide(car, ride);
car.CurrentColumn = ride.RideFinishColumn;
car.CurrentRow = ride.RideFinishRow;
_problemData.RidesToDo.Remove(ride);
}
public void BonusCalculatorGivesBonusesForGoldAccounts(
decimal balance,
decimal amountOfDeposit,
decimal expectedBonusAmount)
{
var bonusCalculator = new BonusCalculator();
decimal bonus = bonusCalculator.CalculateBonusForBankAccountDeposits(
balance, amountOfDeposit);
Assert.Equal(expectedBonusAmount, bonus);
}
public void GetTotalSalary_GivenHrEmployeeList()
{
// Arrange
var hrEmployees = GetHrEmployees();
var expectedTotalSalary = 3000;
var sut = new BonusCalculator();
// Act
var actualTotalSalary = sut.GetTotalSalary(hrEmployees);
// Assert
Assert.That(actualTotalSalary, Is.EqualTo(expectedTotalSalary));
}
public void When_EmployeeNotFound_Then_Exception()
{
var mockEmployeeService = new Mock <IEmployeeService>();
mockEmployeeService.Setup(x => x.GetAsync(It.IsAny <int>())).ReturnsAsync((EmployeeDto)null);
var testEmployeeId = 5;
var bonusCalculator = new BonusCalculator(mockEmployeeService.Object);
Func <Task> action = async() => { await bonusCalculator.Calculate(testEmployeeId, 1000); };
action.Should().Throw <EmployeeNotFoundException>().WithMessage($"Employee not found for id - {testEmployeeId }");
}
public void BonusCalculator_BonusTime_RandomTest([Values(1)] int a, [Random(-1, 1, 40)] double d)
{
RgTest rg = new RgTest((int)d * 10000);
int salary = rg.Salary();
bool bonus = rg.Bonus();
string output = "";
if (bonus)
{
output = "$" + (salary * 10);
}
else
{
output = "$" + salary;
}
StringAssert.AreEqualIgnoringCase(output, BonusCalculator.BonusTime(salary, bonus));
}
public void CalculateMagicRatio(Car car, ProblemData problemData)
{
var stepsToGoToRideStart = StepCalculator.CalculateStepsFromCarToRideStart(car, this);
int waitTime = StepCalculator.CalculateWaitTime(car, this);
var endRideStep = StepCalculator.CalculateStepAfterRide(car, this);
// Si le trajet peut etre fini avant la fin de la simu
// ou si le trajet peut etre fini avant la fin du ride
if ((endRideStep >= problemData.NumberOfSteps) ||
(endRideStep >= RideLatestFinish))
{
MagicNumber = 0;
return;
}
var bonus = BonusCalculator.CalculateBonus(car, this, problemData.PerRideBonus);
var totalPoint = RidePointsWithoutBonus + bonus;
var totalTime = stepsToGoToRideStart + waitTime + RidePointsWithoutBonus;
var wastedTime = stepsToGoToRideStart + waitTime;
float ponderation = 1F / (1F + wastedTime);
MagicNumber = (totalPoint / (float)totalTime) * ponderation;
}
public async Task When_EmployeeFound_Then_CalculateBonus(int employeeId, int totalBonusPool, decimal expectedBonus)
{
var dbContextOptionBuilder = new DbContextOptionsBuilder <AppDbContext>();
dbContextOptionBuilder.UseInMemoryDatabase(databaseName: "HrDb");
var context = new AppDbContext(dbContextOptionBuilder.Options);
//test can break if seed data changes.
// we should have our own seed/mock data
if (!context.Employees.Any())
{
DbContextGenerator.SeedData(context);
}
var employeeService = new EmployeeService(context);
var bonusCalculator = new BonusCalculator(employeeService);
var bonus = await bonusCalculator.Calculate(employeeId, totalBonusPool);
bonus.Should().NotBeNull().And.BeOfType <BonusPoolCalculatorResultDto>();
bonus.Amount.Should().Be(expectedBonus);
}
public Bonus(Character character, BonusCalculator bonusCalculator)
: this(character, bonusCalculator, string.Empty)
{
}
public void AddBonus(string condition, BonusCalculator bonusCalculator)
{
_bonuses.Add(new Bonus(_character, bonusCalculator, condition));
}
public void AddBonus(BonusCalculator bonusCalculator)
{
AddBonus(string.Empty, bonusCalculator);
}
public BonusCalculatorTests()
{
SUT = new BonusCalculator();
}
