731 lines
30 KiB
C#
731 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services;
|
|
using LCU.Library.Internal.IncentiveApiModels.Entities;
|
|
using LCU.Library.Internal.IncentiveApiModels.Enums;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services.DispersalStrategy;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Models;
|
|
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
|
|
using LCU.Library.Internal.IncentiveApiModels.Requests;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Models.GoalDispersal;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Extensions;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;
|
|
|
|
namespace Application.UnitTests.Services
|
|
{
|
|
public class GoalDispersalServiceTest
|
|
{
|
|
private Mock<IGoalService> _mockGoalService;
|
|
private Mock<IDepartmentRepository> _mockDepartmentRepository;
|
|
private Mock<INotificationApiService> _mockNotificationService;
|
|
private Mock<IUserService> _mockUserService;
|
|
private Mock<IGoalChangeRepository> _mockGoalChangeRepository;
|
|
private Mock<IDispersalStrategyService> _mockDispersalStrategyService;
|
|
private IGoalDispersalService _goalDispersalService;
|
|
|
|
[SetUp]
|
|
public void SetUp()
|
|
{
|
|
_mockGoalService = new Mock<IGoalService>();
|
|
_mockGoalChangeRepository = new Mock<IGoalChangeRepository>();
|
|
_mockDepartmentRepository = new Mock<IDepartmentRepository>();
|
|
_mockUserService = new Mock<IUserService>();
|
|
_mockDispersalStrategyService = new Mock<IDispersalStrategyService>();
|
|
_mockNotificationService = new Mock<INotificationApiService>();
|
|
_goalDispersalService = new GoalDispersalService(_mockUserService.Object, _mockGoalService.Object,
|
|
_mockDepartmentRepository.Object, _mockNotificationService.Object,
|
|
_mockDispersalStrategyService.Object);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DisperseGoalsByExtrapolatingLastMonth_OK()
|
|
{
|
|
var goalList = new List<Goal>()
|
|
{
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.Mortgage,
|
|
Value = 200,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
},
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.Vehicle,
|
|
Value = 0,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
},
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.CheckCard,
|
|
Value = 0,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
},
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.DirectDeposit,
|
|
Value = 35,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
}
|
|
};
|
|
|
|
var departmentGoal = new DepartmentGoals(10, 2021);
|
|
departmentGoal.ApplyAll(goalList);
|
|
|
|
var personnelGoals = new PersonnelGoals(10, 2021, 1, new List<AppUser>()
|
|
{
|
|
new AppUser()
|
|
{
|
|
PersonId = 5,
|
|
EmployeeId = "5E",
|
|
AdditionalPermissions = new List<UserPermission>(),
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10
|
|
}
|
|
},
|
|
Role = Role.BM
|
|
}
|
|
});
|
|
personnelGoals.ApplyAll(goalList.Select(x =>
|
|
{
|
|
x.EmployeeId = "5E";
|
|
return x;
|
|
}).ToList());
|
|
|
|
|
|
_mockGoalService.Setup(x => x.GetAnnualDepartmentGoalsAsync(It.IsAny<int>(), It.IsAny<int>()))
|
|
.ReturnsAsync(departmentGoal);
|
|
_mockGoalService.Setup(x => x.GetMonthlyPersonnelGoalsAsync(It.IsAny<DepartmentPersonnelSearchRequest>()))
|
|
.ReturnsAsync(personnelGoals);
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.ExtrapolateFromExistingGoals(It.IsAny<ExtrapolationGoalDispersalData>()))
|
|
.Returns(new GoalDispersalReceipt(10, GoalDispersalStrategy.ExtrapolateFromExistingGoals));
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.DefaultWeightedDispersal(It.IsAny<DefaultWeightedGoalDispersalData>()))
|
|
.Returns(new GoalDispersalReceipt(10, GoalDispersalStrategy.DefaultDisperseWithWeights));
|
|
|
|
var results = await _goalDispersalService.DisperseGoalsByExtrapolatingLastMonth(10, 1, 2020);
|
|
Assert.AreEqual(GoalDispersalStrategy.ExtrapolateFromExistingGoals, results.Strategy);
|
|
_mockDispersalStrategyService.Verify(x => x.ExtrapolateFromExistingGoals(It.IsAny<ExtrapolationGoalDispersalData>()), Times.Once);
|
|
_mockGoalService.Verify(x => x.SaveGoalRangeAsync(It.IsAny<List<GoalChange>>()), Times.Once);
|
|
|
|
}
|
|
|
|
[TestCase(1, 2021, 12, 2020)]
|
|
[TestCase(2, 2021, 1, 2021)]
|
|
[TestCase(3, 2021, 2, 2021)]
|
|
[TestCase(4, 2021, 3, 2021)]
|
|
[TestCase(5, 2021, 4, 2021)]
|
|
[TestCase(6, 2021, 5, 2021)]
|
|
[TestCase(7, 2021, 6, 2021)]
|
|
[TestCase(8, 2021, 7, 2021)]
|
|
[TestCase(9, 2021, 8, 2021)]
|
|
[TestCase(10, 2021, 9, 2021)]
|
|
[TestCase(11, 2021, 10, 2021)]
|
|
[TestCase(12, 2021, 11, 2021)]
|
|
public async Task DisperseGoalsByExtrapolatingLastMonth_Calculates_Year_Month_OK(int month, int year, int lastMonth, int lastMonthYear)
|
|
{
|
|
var goalList = new List<Goal>()
|
|
{
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.Mortgage,
|
|
Value = 200,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
}
|
|
};
|
|
|
|
var departmentGoal = new DepartmentGoals(10, 2021);
|
|
departmentGoal.ApplyAll(goalList);
|
|
|
|
var personnelGoals = new PersonnelGoals(10, 2021, 1, new List<AppUser>()
|
|
{
|
|
new AppUser()
|
|
{
|
|
PersonId = 5,
|
|
EmployeeId = "5E",
|
|
AdditionalPermissions = new List<UserPermission>(),
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10
|
|
}
|
|
},
|
|
Role = Role.BM
|
|
}
|
|
});
|
|
personnelGoals.ApplyAll(goalList.Select(x =>
|
|
{
|
|
x.EmployeeId = "5E";
|
|
return x;
|
|
}).ToList());
|
|
|
|
// The goals and personnel don't really matter for testing we just need some values
|
|
_mockGoalService.Setup(x => x.GetAnnualDepartmentGoalsAsync(It.IsAny<int>(), It.IsAny<int>()))
|
|
.ReturnsAsync(departmentGoal);
|
|
_mockGoalService.Setup(x => x.GetMonthlyPersonnelGoalsAsync(It.IsAny<DepartmentPersonnelSearchRequest>()))
|
|
.ReturnsAsync(personnelGoals);
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.ExtrapolateFromExistingGoals(It.IsAny<ExtrapolationGoalDispersalData>()))
|
|
.Returns(new GoalDispersalReceipt(10, GoalDispersalStrategy.ExtrapolateFromExistingGoals));
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.DefaultWeightedDispersal(It.IsAny<DefaultWeightedGoalDispersalData>()))
|
|
.Returns(new GoalDispersalReceipt(10, GoalDispersalStrategy.DefaultDisperseWithWeights));
|
|
|
|
var results = await _goalDispersalService.DisperseGoalsByExtrapolatingLastMonth(10, month, year);
|
|
Assert.NotNull(results);
|
|
_mockGoalService.Verify(
|
|
x => x.GetMonthlyPersonnelGoalsAsync(
|
|
It.Is<DepartmentPersonnelSearchRequest>(x => x.Month == month && x.Year == year)), Times.Once());
|
|
_mockGoalService.Verify(
|
|
x => x.GetMonthlyPersonnelGoalsAsync(
|
|
It.Is<DepartmentPersonnelSearchRequest>(x => x.Month == lastMonth && x.Year == lastMonthYear)),
|
|
Times.Once());
|
|
_mockGoalService.Verify(
|
|
X => X.GetAnnualDepartmentGoalsAsync(It.Is<int>(x => x == 10), It.Is<int>(x => x == year)), Times.AtLeastOnce);
|
|
_mockGoalService.Verify(
|
|
X => X.GetAnnualDepartmentGoalsAsync(It.Is<int>(x => x == 10), It.Is<int>(x => x == lastMonthYear)),
|
|
Times.AtLeastOnce);
|
|
_mockGoalService.Verify(x => x.SaveGoalRangeAsync(It.IsAny<List<GoalChange>>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DisperseGoalsByExtrapolatingLastMonth_Defaults_OK()
|
|
{
|
|
var goalList = new List<Goal>()
|
|
{
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.Mortgage,
|
|
Value = 0,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
},
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.Vehicle,
|
|
Value = 0,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
},
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.CheckCard,
|
|
Value = 0,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
},
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.DirectDeposit,
|
|
Value = 0,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
}
|
|
};
|
|
|
|
var departmentGoal = new DepartmentGoals(10, 2021);
|
|
departmentGoal.ApplyAll(goalList);
|
|
|
|
var personnelGoals = new PersonnelGoals(10, 2021, 1, new List<AppUser>()
|
|
{
|
|
new AppUser()
|
|
{
|
|
PersonId = 5,
|
|
EmployeeId = "5E",
|
|
AdditionalPermissions = new List<UserPermission>(),
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10
|
|
}
|
|
},
|
|
Role = Role.BM
|
|
}
|
|
});
|
|
personnelGoals.ApplyAll(goalList.Select(x =>
|
|
{
|
|
x.EmployeeId = "5E";
|
|
return x;
|
|
}).ToList());
|
|
|
|
// The goals and personnel don't really matter for testing we just need some values
|
|
_mockGoalService.Setup(x => x.GetAnnualDepartmentGoalsAsync(It.IsAny<int>(), It.IsAny<int>()))
|
|
.ReturnsAsync(departmentGoal);
|
|
_mockGoalService.Setup(x => x.GetMonthlyPersonnelGoalsAsync(It.IsAny<DepartmentPersonnelSearchRequest>()))
|
|
.ReturnsAsync(personnelGoals);
|
|
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.ExtrapolateFromExistingGoals(It.IsAny<ExtrapolationGoalDispersalData>()))
|
|
.Returns(new GoalDispersalReceipt(10, GoalDispersalStrategy.ExtrapolateFromExistingGoals));
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.DefaultWeightedDispersal(It.IsAny<DefaultWeightedGoalDispersalData>()))
|
|
.Returns(new GoalDispersalReceipt(10, GoalDispersalStrategy.DefaultDisperseWithWeights));
|
|
|
|
var results = await _goalDispersalService.DisperseGoalsByExtrapolatingLastMonth(10, 1, 2020);
|
|
Assert.AreEqual(GoalDispersalStrategy.DefaultDisperseWithWeights, results.Strategy);
|
|
_mockDispersalStrategyService.Verify(x => x.DefaultWeightedDispersal(It.IsAny<DefaultWeightedGoalDispersalData>()), Times.Once);
|
|
_mockGoalService.Verify(x => x.SaveGoalRangeAsync(It.IsAny<List<GoalChange>>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task DisperseAllDepartmentGoalsForMonth_OK()
|
|
{
|
|
var goalList = new List<Goal>()
|
|
{
|
|
new Goal()
|
|
{
|
|
DepartmentId = 10,
|
|
Product = Product.Mortgage,
|
|
Value = 200,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
}
|
|
};
|
|
|
|
var departmentGoal = new DepartmentGoals(10, 2021);
|
|
departmentGoal.ApplyAll(goalList);
|
|
|
|
var personnelGoals = new PersonnelGoals(10, 2021, 1, new List<AppUser>()
|
|
{
|
|
new AppUser()
|
|
{
|
|
PersonId = 5,
|
|
EmployeeId = "5E",
|
|
AdditionalPermissions = new List<UserPermission>(),
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10
|
|
}
|
|
},
|
|
Role = Role.BM
|
|
}
|
|
});
|
|
personnelGoals.ApplyAll(goalList.Select(x =>
|
|
{
|
|
x.EmployeeId = "5E";
|
|
return x;
|
|
}).ToList());
|
|
|
|
|
|
// The goals and personnel don't really matter for testing we just need some values
|
|
_mockGoalService.Setup(x => x.GetAnnualDepartmentGoalsAsync(It.IsAny<int>(), It.IsAny<int>()))
|
|
.ReturnsAsync(departmentGoal);
|
|
_mockGoalService.Setup(x => x.GetMonthlyPersonnelGoalsAsync(It.IsAny<DepartmentPersonnelSearchRequest>()))
|
|
.ReturnsAsync(personnelGoals);
|
|
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.ExtrapolateFromExistingGoals(It.Is<ExtrapolationGoalDispersalData>(x => x.DepartmentId == 0)))
|
|
.Returns(new GoalDispersalReceipt(0, GoalDispersalStrategy.ExtrapolateFromExistingGoals));
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.ExtrapolateFromExistingGoals(It.Is<ExtrapolationGoalDispersalData>(x => x.DepartmentId == 1)))
|
|
.Returns(new GoalDispersalReceipt(1, GoalDispersalStrategy.DefaultDisperseWithWeights));
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.ExtrapolateFromExistingGoals(It.Is<ExtrapolationGoalDispersalData>(x => x.DepartmentId == 2)))
|
|
.Returns(new GoalDispersalReceipt(2, GoalDispersalStrategy.ExtrapolateFromExistingGoals));
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.ExtrapolateFromExistingGoals(
|
|
It.Is<ExtrapolationGoalDispersalData>(x => x.DepartmentId == 3)))
|
|
.Throws(new Exception("Ooops"));
|
|
|
|
_mockDepartmentRepository.Setup(x => x.GetAllDepartmentsAsync()).ReturnsAsync(new List<Department>()
|
|
{
|
|
new Department()
|
|
{
|
|
Id = 0,
|
|
DepartmentName = "Name0"
|
|
},
|
|
new Department()
|
|
{
|
|
Id = 1,
|
|
DepartmentName = "Name1"
|
|
},
|
|
new Department()
|
|
{
|
|
Id = 2,
|
|
},
|
|
new Department()
|
|
{
|
|
Id = 3,
|
|
DepartmentName = "Name3"
|
|
},
|
|
|
|
});
|
|
|
|
var results = await _goalDispersalService.DisperseAllDepartmentGoalsForMonth(1, 2020);
|
|
Assert.Contains("0 - Name0",results.Keys);
|
|
Assert.Contains("1 - Name1", results.Keys);
|
|
Assert.Contains("2 - ", results.Keys);
|
|
Assert.Contains("3 - Name3", results.Keys);
|
|
|
|
Assert.NotNull(results["0 - Name0"]);
|
|
Assert.NotNull(results["1 - Name1"]);
|
|
Assert.NotNull(results["2 - "]);
|
|
Assert.Null(results["3 - Name3"]);
|
|
|
|
Assert.AreEqual(GoalDispersalStrategy.ExtrapolateFromExistingGoals, results["0 - Name0"].Strategy);
|
|
Assert.AreEqual(GoalDispersalStrategy.DefaultDisperseWithWeights,results["1 - Name1"].Strategy);
|
|
Assert.AreEqual(GoalDispersalStrategy.ExtrapolateFromExistingGoals,results["2 - "].Strategy);
|
|
}
|
|
|
|
[Test]
|
|
public async Task CustomWeightedDispersal_OK()
|
|
{
|
|
var customWeightedDispersalRequest = new CustomWeightedDispersalRequest()
|
|
{
|
|
DepartmentId = 10,
|
|
month = 01,
|
|
year = 2021,
|
|
DispersalProduct = Product.Mortgage,
|
|
DispersalWeightByRole = new Dictionary<string, double>(){ { "BM", .10 }, {"PFO", .25} }
|
|
};
|
|
|
|
var users = new List<AppUser>()
|
|
{
|
|
new AppUser()
|
|
{
|
|
EmployeeId = "ABM1",
|
|
PersonId = 1,
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10,
|
|
Role = Role.ABM
|
|
}
|
|
}
|
|
},
|
|
new AppUser()
|
|
{
|
|
EmployeeId = "BM1",
|
|
PersonId = 2,
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10,
|
|
Role = Role.BM
|
|
}
|
|
}
|
|
},
|
|
new AppUser()
|
|
{
|
|
EmployeeId = "BM2",
|
|
PersonId = 3,
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10,
|
|
Role = Role.BM
|
|
}
|
|
}
|
|
},
|
|
new AppUser()
|
|
{
|
|
EmployeeId = "PFO1",
|
|
PersonId = 4,
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10,
|
|
Role = Role.PFO
|
|
}
|
|
}
|
|
},
|
|
new AppUser()
|
|
{
|
|
EmployeeId = "PFO2",
|
|
PersonId = 5,
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10,
|
|
Role = Role.PFO
|
|
}
|
|
}
|
|
},
|
|
new AppUser()
|
|
{
|
|
EmployeeId = "PFO3",
|
|
PersonId = 6,
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10,
|
|
Role = Role.PFO
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var deptGoals = new DepartmentGoals(10, 2021);
|
|
deptGoals.ApplyAll(new List<Goal>()
|
|
{
|
|
new Goal(){
|
|
DepartmentId = 10,
|
|
Product = Product.Mortgage,
|
|
Value = 200,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-1").EndOfMonth()
|
|
}
|
|
});
|
|
|
|
_mockGoalService.Setup(x => x.GetAnnualDepartmentGoalsAsync(It.IsAny<int>(), It.IsAny<int>()))
|
|
.ReturnsAsync(deptGoals);
|
|
|
|
_mockUserService.Setup(x => x.FindDepartmentAssignments(It.IsAny<DepartmentPersonnelSearchRequest>()))
|
|
.ReturnsAsync(users);
|
|
|
|
_mockDispersalStrategyService
|
|
.Setup(x => x.CustomWeightedDispersal(It.IsAny<CustomWeightedDispersalRequest>(),
|
|
It.IsAny<List<AppUser>>(), It.IsAny<int>()))
|
|
.Returns(new GoalDispersalReceipt(10, GoalDispersalStrategy.CustomWeightedDispersal));
|
|
|
|
var receipt = await _goalDispersalService.CustomWeightedDispersal(customWeightedDispersalRequest);
|
|
Assert.AreEqual(10, receipt.DepartmentId);
|
|
Assert.AreEqual(GoalDispersalStrategy.CustomWeightedDispersal, receipt.Strategy);
|
|
|
|
_mockDispersalStrategyService
|
|
.Verify(x => x.CustomWeightedDispersal(
|
|
It.Is<CustomWeightedDispersalRequest>(x => x.Equals(customWeightedDispersalRequest)),
|
|
It.Is<List<AppUser>>(x => x.Count == 6), It.Is<int>(x => x == 200)));
|
|
|
|
_mockGoalService.Verify(x =>
|
|
x.GetAnnualDepartmentGoalsAsync(It.Is<int>(x => x == 10), It.Is<int>(x => x == 2021)));
|
|
|
|
_mockUserService.Verify(x => x.FindDepartmentAssignments(It.Is<DepartmentPersonnelSearchRequest>(x =>
|
|
x.Month == 1 && x.Year == 2021 && x.IncludeAllPersonnel == true && x.DepartmentId == 10)));
|
|
|
|
_mockGoalService.Verify(x => x.SaveGoalRangeAsync(It.IsAny<List<GoalChange>>()), Times.Once);
|
|
|
|
}
|
|
|
|
[Test]
|
|
public async Task ExecuteMonthStartDispersal_OK()
|
|
{
|
|
var request = new GoalDispersalRequest()
|
|
{
|
|
MonthsBack = 0,
|
|
GoalDispersalNotification = new List<string> { "[email protected]", "[email protected]" }
|
|
};
|
|
|
|
_mockDepartmentRepository.Setup(x => x.GetAllDepartmentsAsync()).ReturnsAsync(new List<Department>()
|
|
{
|
|
new Department()
|
|
{
|
|
Id = 0,
|
|
DepartmentName = "Department0"
|
|
},
|
|
new Department()
|
|
{
|
|
Id = 10,
|
|
Assignments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
Id = 100,
|
|
AppUserId = new Guid("00000000-1111-1111-0000-000000000000"),
|
|
DepartmentId = 10
|
|
}
|
|
},
|
|
DepartmentName = "Department10"
|
|
},
|
|
new Department()
|
|
{
|
|
Id = 2,
|
|
Assignments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
Id = 22,
|
|
AppUserId = new Guid("00000000-2222-0000-0000-000000000000"),
|
|
DepartmentId = 2
|
|
}
|
|
},
|
|
DepartmentName = "Department2"
|
|
},
|
|
new Department()
|
|
{
|
|
Id = 3,
|
|
Assignments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
Id = 33,
|
|
AppUserId = new Guid("00000000-3333-0000-0000-000000000000"),
|
|
DepartmentId = 3
|
|
}
|
|
},
|
|
DepartmentName = "Department3"
|
|
},
|
|
});
|
|
|
|
var goalUpdate = new GoalChange()
|
|
{
|
|
Product = Product.Mortgage,
|
|
DepartmentId = 10,
|
|
Value = 300,
|
|
StartDate = DateTime.Parse("2021-01-01T20:00:00.000").StartOfMonth(),
|
|
EndDate = DateTime.Parse("2021-01-31T23:59:00.000")
|
|
};
|
|
|
|
var goal2Update = new GoalChange()
|
|
{
|
|
Product = Product.Mortgage,
|
|
DepartmentId = 10,
|
|
Value = 301,
|
|
StartDate = DateTime.Parse("2021-01-01T10:00:00.000").StartOfMonth(),
|
|
EndDate = DateTime.Parse("2021-01-31T21:59:00.000")
|
|
};
|
|
|
|
var goal3Update = new GoalChange()
|
|
{
|
|
Product = Product.Mortgage,
|
|
DepartmentId = 10,
|
|
Value = 302,
|
|
StartDate = DateTime.Parse("2021-01-01T11:30:00.000").StartOfMonth(),
|
|
EndDate = DateTime.Parse("2021-01-31T03:59:00.000")
|
|
};
|
|
|
|
var goalChangeList = new List<GoalChange>() { goalUpdate, goal2Update, goal3Update };
|
|
|
|
var goal1 = new Goal()
|
|
{
|
|
Product = Product.Mortgage,
|
|
DepartmentId = 10,
|
|
Value = 303,
|
|
StartDate = DateTime.Parse("2021-01-01T11:30:00.000").StartOfMonth(),
|
|
EndDate = DateTime.Parse("2021-01-31T03:59:00.000")
|
|
};
|
|
|
|
var goalDeptList = new List<Goal>() { goal1 };
|
|
|
|
_mockGoalService.Setup(x => x.SaveGoalRangeAsync(goalChangeList)).ReturnsAsync(goalDeptList);
|
|
|
|
var deptGoals = new DepartmentGoals(10, 2021);
|
|
|
|
deptGoals.ApplyAll(new List<Goal>()
|
|
{
|
|
new Goal(){
|
|
DepartmentId = 10,
|
|
Product = Product.Mortgage,
|
|
Value = 299,
|
|
StartDate = DateTime.Parse("2021-1-1"),
|
|
EndDate = DateTime.Parse("2021-1-31").EndOfMonth()
|
|
},
|
|
new Goal(){
|
|
DepartmentId = 10,
|
|
Product = Product.Mortgage,
|
|
Value = 500,
|
|
StartDate = DateTime.Parse("2021-2-1"),
|
|
EndDate = DateTime.Parse("2021-2-28").EndOfMonth()
|
|
}
|
|
});
|
|
|
|
_mockGoalService.Setup(x => x.GetAnnualDepartmentGoalsAsync(It.IsAny<int>(), It.IsAny<int>())).ReturnsAsync(deptGoals);
|
|
|
|
var personnelGoals = new PersonnelGoals(10, 2021, 1, new List<AppUser>()
|
|
{
|
|
new AppUser()
|
|
{
|
|
PersonId = 5,
|
|
Id = new Guid("00000000-1111-1111-0000-000000000000"),
|
|
EmployeeId = "11111",
|
|
AdditionalPermissions = new List<UserPermission>(),
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10
|
|
}
|
|
},
|
|
Role = Role.BM
|
|
},
|
|
|
|
new AppUser()
|
|
{
|
|
PersonId = 7,
|
|
Id = new Guid("00000000-7777-7777-0000-000000000000"),
|
|
EmployeeId = "77777",
|
|
AdditionalPermissions = new List<UserPermission>(),
|
|
Departments = new List<UserDepartment>()
|
|
{
|
|
new UserDepartment()
|
|
{
|
|
DepartmentId = 10
|
|
}
|
|
},
|
|
Role = Role.Teller
|
|
}
|
|
});
|
|
|
|
personnelGoals.ApplyAll(goalDeptList.Select(x =>
|
|
{
|
|
x.EmployeeId = "11111";
|
|
return x;
|
|
|
|
}).ToList());
|
|
|
|
_mockGoalService.Setup(x => x.GetMonthlyPersonnelGoalsAsync(It.IsAny<DepartmentPersonnelSearchRequest>())).ReturnsAsync(personnelGoals);
|
|
|
|
var receipt = new GoalDispersalReceipt(10, GoalDispersalStrategy.ExtrapolateFromExistingGoals)
|
|
{
|
|
GoalChanges = goalChangeList,
|
|
Strategy = GoalDispersalStrategy.ExtrapolateFromExistingGoals,
|
|
DepartmentId = 10,
|
|
GoalDispersalErrors = new List<GoalDispersalReceiptItem>()
|
|
{
|
|
new GoalDispersalReceiptItem(GoalDispersalError.NewUserRequiresManualEntry, "77777", "New user required manual entry.")
|
|
{
|
|
EmployeeId = "77777",
|
|
ErrorType = GoalDispersalError.NewUserRequiresManualEntry
|
|
}
|
|
},
|
|
};
|
|
|
|
_mockDispersalStrategyService.Setup(x => x.ExtrapolateFromExistingGoals(It.IsAny<ExtrapolationGoalDispersalData>())).Returns(receipt);
|
|
|
|
var results = await _goalDispersalService.DisperseAllDepartmentGoalsForMonth(2, 2021);
|
|
await _goalDispersalService.ExecuteMonthStartDispersal(request);
|
|
|
|
_mockNotificationService.Verify(mock => mock.SendMonthStartGoalDispersalReceipt(results, request.GoalDispersalNotification), Times.Once);
|
|
|
|
Assert.NotNull(results["0 - Department0"]);
|
|
Assert.NotNull(results["10 - Department10"]);
|
|
Assert.AreEqual(3, results["10 - Department10"].GoalChanges.Count());
|
|
Assert.AreEqual(1, results["10 - Department10"].GoalDispersalErrors.Count());
|
|
Assert.NotNull(results["2 - Department2"]);
|
|
Assert.NotNull(results["3 - Department3"]);
|
|
}
|
|
}
|
|
}
|