946 lines
42 KiB
C#
946 lines
42 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services;
|
|
using CsvHelper;
|
|
using LCU.Library.Internal.IncentiveApiModels.Entities;
|
|
using LCU.Library.Internal.IncentiveApiModels.Enums;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services.Allied;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
|
|
using LCU.Library.Internal.IncentiveApiModels.Requests;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Models.Allied;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Models;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;
|
|
using LCU.Library.Internal.FileOperationsModels.Models.NameSettings;
|
|
using LCU.Library.Internal.FileOperationsModels.Models;
|
|
|
|
namespace Application.UnitTests.Services.Allied
|
|
{
|
|
public class AlliedTransactionImportServiceTest
|
|
{
|
|
private IAlliedGapMbpTransactionImportService _service;
|
|
private IUserRepository _userRepository;
|
|
private IActivityService _activityService;
|
|
private IActivityDecisionService _activityDecisionService;
|
|
private IActivityDetailService _activityDetailService;
|
|
private DebtProtectionAccessoryService _debtProtectionAccessoryService;
|
|
private IDnaService _dnaService;
|
|
private IFileOperationsApiService _fileOperationsApiService;
|
|
private Mock<IDeadActivityService> _deadActivityService;
|
|
private IGapInsuranceActivityService _gapInsuranceActivityService;
|
|
private Mock<IActivityRepository> _activityRepository;
|
|
private Mock<IUnitOfWork> _unitOfWork;
|
|
private int _expectedRecordCount;
|
|
private string _testDataFilePath;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
var strategies = new List<IDecisionStrategy>
|
|
{
|
|
new DebtProtectionEligibleLoanDecisionStrategy(),
|
|
new GapDecisionStrategy(),
|
|
new ManualDecisionStrategy(),
|
|
new MbpDecisionStrategy(),
|
|
new MortgageSaleDecisionStrategy(),
|
|
new NewCheckingDecisionStrategy(),
|
|
new ReferralDecisionStrategy(),
|
|
new VehicleDecisionStrategy()
|
|
};
|
|
_userRepository = Mock.Of<IUserRepository>();
|
|
_fileOperationsApiService = Mock.Of<IFileOperationsApiService>();
|
|
_activityService = Mock.Of<IActivityService>();
|
|
_activityDetailService = Mock.Of<IActivityDetailService>();
|
|
_debtProtectionAccessoryService = new DebtProtectionAccessoryService(_activityService, _activityDetailService);
|
|
_dnaService = Mock.Of<IDnaService>();
|
|
_activityDecisionService = new ActivityDecisionService(strategies, _activityService, _activityDetailService, _debtProtectionAccessoryService, _dnaService);
|
|
_deadActivityService = new Mock<IDeadActivityService>();
|
|
_activityRepository = new Mock<IActivityRepository>();
|
|
_unitOfWork = new Mock<IUnitOfWork>();
|
|
_gapInsuranceActivityService = new GapInsuranceActivityService(_activityDetailService, _activityRepository.Object, _activityService, _unitOfWork.Object);
|
|
_service = new AlliedGapMbpTransactionImportService(
|
|
_userRepository,
|
|
_gapInsuranceActivityService,
|
|
_fileOperationsApiService,
|
|
_activityService,
|
|
_activityDecisionService,
|
|
_activityDetailService,
|
|
_deadActivityService.Object
|
|
);
|
|
_expectedRecordCount = 12;
|
|
_testDataFilePath = @"Services/Allied/SalesWithCancellationsByEmployee.csv";
|
|
}
|
|
|
|
public StreamReader GetAlliedFile()
|
|
{
|
|
var path = _testDataFilePath;
|
|
var reader = new StreamReader(path);
|
|
return reader;
|
|
}
|
|
|
|
[Test]
|
|
public async Task ProcessFileNames_OK()
|
|
{
|
|
var department = new Department()
|
|
{
|
|
DepartmentName = "Dept1",
|
|
Id = 55,
|
|
State = DepartmentState.Active
|
|
};
|
|
var user = new AppUser()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11771",
|
|
FullName = "John Doe",
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
var assignment = new UserDepartment()
|
|
{
|
|
Id = 99,
|
|
Department = department,
|
|
Employee = user,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
};
|
|
user.Departments.Add(assignment);
|
|
|
|
var request = new AlliedGapMbpRequest
|
|
{
|
|
DynamicFileName = "alliedgapmbp",
|
|
FilePath = "clean",
|
|
DynamicFileSettings = new DynamicNameSetting() { }
|
|
};
|
|
|
|
var files = new string[]
|
|
{
|
|
"x"
|
|
};
|
|
|
|
byte[] array = File.ReadAllBytes(_testDataFilePath);
|
|
|
|
//Setup
|
|
Mock.Get(_fileOperationsApiService).Setup(x => x.BuildDynamicFileList(It.IsAny<DynamicFileListRequest>())).ReturnsAsync(files);
|
|
Mock.Get(_fileOperationsApiService).Setup(x => x.GetFileContent(It.IsAny<string>())).ReturnsAsync(array.ToString());
|
|
Mock.Get(_userRepository).Setup(s => s.SearchUsersAsync(It.IsAny<UserSearchRequest>())).ReturnsAsync(new List<AppUser>() { user });
|
|
|
|
var results = await _service.ImportTransactions<AlliedSaleRow>(request);
|
|
var activities = await _service.CreateActivity(It.IsAny<IEnumerable<AlliedSaleRow>>());
|
|
Mock.Get(_fileOperationsApiService).Verify(x => x.GetFileContent(It.IsAny<string>()), Times.Once);
|
|
Assert.AreEqual("alliedgapmbp", request.DynamicFileName);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ProcessCsv_OK()
|
|
{
|
|
SetupTestUsers();
|
|
SetupTestActivities();
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
var alliedSaleRows = transactions.ToList();
|
|
Assert.IsNotEmpty(alliedSaleRows);
|
|
Assert.AreEqual(_expectedRecordCount, alliedSaleRows.Count());
|
|
|
|
var results = await _service.CreateActivity(alliedSaleRows);
|
|
Assert.NotNull(results);
|
|
Assert.AreEqual(_expectedRecordCount, results.Count);
|
|
Assert.AreEqual(_expectedRecordCount, results.Count(x => x.SourceSystem == SystemType.Allied));
|
|
}
|
|
|
|
public IEnumerable<AlliedSaleRow> ImportTestTransactions()
|
|
{
|
|
var input = GetAlliedFile();
|
|
var csvReader = new CsvReader(input, CultureInfo.InvariantCulture);
|
|
return csvReader.GetRecords<AlliedSaleRow>().ToList();
|
|
}
|
|
|
|
public void SetupTestUsers()
|
|
{
|
|
var department = new Department()
|
|
{
|
|
DepartmentName = "Dept1",
|
|
Id = 55,
|
|
State = DepartmentState.Active
|
|
};
|
|
|
|
var testUsers = new List<AppUser>
|
|
{
|
|
new()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11771",
|
|
FullName = "Abraham TestAssociate1",
|
|
Id = Guid.NewGuid(),
|
|
Departments = new List<UserDepartment>
|
|
{
|
|
new()
|
|
{
|
|
Id = 99,
|
|
Department = department,
|
|
Employee = null,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
}
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11772",
|
|
FullName = "Franchelie TestAssociate2",
|
|
Id = Guid.NewGuid(),
|
|
Departments = new List<UserDepartment>
|
|
{
|
|
new()
|
|
{
|
|
Id = 100,
|
|
Department = department,
|
|
Employee = null,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
}
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11773",
|
|
FullName = "Stefani TestAssociate3",
|
|
Id = Guid.NewGuid(),
|
|
Departments = new List<UserDepartment>
|
|
{
|
|
new()
|
|
{
|
|
Id = 101,
|
|
Department = department,
|
|
Employee = null,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
}
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11774",
|
|
FullName = "Amarisa TestAssociate4",
|
|
Id = Guid.NewGuid(),
|
|
Departments = new List<UserDepartment>
|
|
{
|
|
new()
|
|
{
|
|
Id = 102,
|
|
Department = department,
|
|
Employee = null,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
}
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11774",
|
|
FullName = "Amalia TestAssociate5",
|
|
Id = Guid.NewGuid(),
|
|
Departments = new List<UserDepartment>
|
|
{
|
|
new()
|
|
{
|
|
Id = 103,
|
|
Department = department,
|
|
Employee = null,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
foreach (var user in testUsers)
|
|
{
|
|
user.Departments.First().Employee = user;
|
|
Mock.Get(_userRepository)
|
|
.Setup(r => r.SearchUsersAsync(It.Is<UserSearchRequest>(x => x.Query == user.FullName)))
|
|
.ReturnsAsync(new List<AppUser> { testUsers.First(x => x.FullName == user.FullName) });
|
|
}
|
|
}
|
|
|
|
public void SetupTestActivities()
|
|
{
|
|
var existingActivities = new List<Activity>
|
|
{
|
|
new()
|
|
{
|
|
Id = 1,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceSystem = SystemType.Allied,
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail()
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
Id = 2,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceSystem = SystemType.Allied,
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail()
|
|
{
|
|
AccountNumber = "8675309861",
|
|
MemberName = "ORLANDO TESTCUSTOMER11"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
Id = 3,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceSystem = SystemType.Allied,
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail()
|
|
{
|
|
AccountNumber = "8675309862",
|
|
MemberName = "ORLANDO TESTCUSTOMER12"
|
|
}
|
|
}
|
|
};
|
|
|
|
foreach (var queryActivity in existingActivities)
|
|
{
|
|
Mock.Get(_activityService)
|
|
.Setup(r => r
|
|
.GetActivityForStateUpdate(It.Is<Activity>(x => x.EmployeeId == queryActivity.EmployeeId
|
|
&& x.Product == queryActivity.Product
|
|
&& x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
|
|
)))
|
|
.ReturnsAsync(existingActivities.First(x => x.EmployeeId == queryActivity.EmployeeId
|
|
&& x.Product == queryActivity.Product
|
|
&& x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
|
|
));
|
|
|
|
Mock.Get(_activityService)
|
|
.Setup(r => r
|
|
.GetActivityForDetailUpdate(It.Is<Activity>(x => x.EmployeeId == queryActivity.EmployeeId
|
|
&& x.Product == queryActivity.Product
|
|
&& x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
|
|
)))
|
|
.ReturnsAsync(existingActivities.First(x => x.EmployeeId == queryActivity.EmployeeId
|
|
&& x.Product == queryActivity.Product
|
|
&& x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
|
|
));
|
|
|
|
Mock.Get(_activityService)
|
|
.Setup(r => r
|
|
.GetActivity(It.IsAny<int>()))
|
|
.ReturnsAsync(existingActivities.First(x => x.Id == queryActivity.Id
|
|
));
|
|
|
|
Mock.Get(_activityService)
|
|
.Setup(r => r
|
|
.CreateAndRetrieveActivity(It.Is<Activity>(x =>
|
|
x.AppUserId == queryActivity.AppUserId
|
|
&& x.EmployeeId == queryActivity.EmployeeId
|
|
&& x.Product == queryActivity.Product
|
|
&& x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
|
|
&& x.Detail.SubAccountNumber == queryActivity.Detail.SubAccountNumber
|
|
)))
|
|
.ReturnsAsync(existingActivities.First(x =>
|
|
x.AppUserId == queryActivity.AppUserId
|
|
&& x.EmployeeId == queryActivity.EmployeeId
|
|
&& x.Product == queryActivity.Product
|
|
&& x.Detail.AccountNumber == queryActivity.Detail.AccountNumber
|
|
&& x.Detail.SubAccountNumber == queryActivity.Detail.SubAccountNumber
|
|
));
|
|
}
|
|
|
|
Mock.Get(_activityService)
|
|
.Setup(r => r
|
|
.CreateAndRetrieveActivity(It.IsAny<Activity>()))
|
|
.ReturnsAsync(new Activity()
|
|
{
|
|
AppUserId = Guid.NewGuid(),
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceSystem = SystemType.Allied,
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail()
|
|
{
|
|
AccountNumber = "8675309862",
|
|
MemberName = "ORLANDO TESTCUSTOMER12"
|
|
}
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task SavesDeadActivity_WhenNoUserFound()
|
|
{
|
|
Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser)null);
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(_expectedRecordCount, transactions.Count());
|
|
|
|
var results = await _service.CreateActivity(transactions);
|
|
Assert.NotNull(results);
|
|
Assert.IsEmpty(results);
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count() == _expectedRecordCount &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SavesDeadActivity_WhenFindingUserFails()
|
|
{
|
|
Mock.Get(_userRepository)
|
|
.Setup(s => s.FindUserByAdEmailAsync(It.IsAny<string>()))
|
|
.Throws(new Exception("OOops"));
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(_expectedRecordCount, transactions.Count());
|
|
|
|
var results = await _service.CreateActivity(transactions);
|
|
Assert.NotNull(results);
|
|
Assert.IsEmpty(results);
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count() == _expectedRecordCount &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SavesDeadActivity_WhenTooManyUserFound()
|
|
{
|
|
Mock.Get(_userRepository)
|
|
.Setup(s => s.SearchUsersAsync(It.IsAny<UserSearchRequest>()))
|
|
.ReturnsAsync(new List<AppUser>()
|
|
{ new() { EmployeeId = "One" }, new() { EmployeeId = "Two" } });
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(_expectedRecordCount, transactions.Count());
|
|
|
|
var results = await _service.CreateActivity(transactions);
|
|
Assert.NotNull(results);
|
|
Assert.IsEmpty(results);
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count() == _expectedRecordCount &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SavesDeadActivity_WhenNoHomeDepartmentFound()
|
|
{
|
|
//Use one user for all lines for simplicity
|
|
var user = new AppUser()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11771",
|
|
FullName = "John Doe",
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
|
|
Mock.Get(_userRepository).Setup(s => s.SearchUsersAsync(It.IsAny<UserSearchRequest>())).ReturnsAsync(new List<AppUser> { user });
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(_expectedRecordCount, transactions.Count());
|
|
|
|
var results = await _service.CreateActivity(transactions);
|
|
Assert.NotNull(results);
|
|
Assert.IsEmpty(results);
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count() == _expectedRecordCount &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("reliably determinable home")))));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SavesDeadActivity_BothKinds()
|
|
{
|
|
var noHomeDepartmentUser = new AppUser()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11773",
|
|
FullName = "Stefani TestAssociate3",
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
|
|
Mock.Get(_userRepository)
|
|
.Setup(s => s.SearchUsersAsync(It.Is<UserSearchRequest>(x => x.Query == noHomeDepartmentUser.FullName)))
|
|
.ReturnsAsync(new List<AppUser> { noHomeDepartmentUser });
|
|
|
|
var transactions = ImportTestTransactions();
|
|
var expectedHomelessDeadRecordCount = transactions.Count(x => x.Quoter == noHomeDepartmentUser.FullName);
|
|
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(_expectedRecordCount, transactions.Count());
|
|
|
|
var results = await _service.CreateActivity(transactions);
|
|
Assert.NotNull(results);
|
|
Assert.IsEmpty(results);
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(y =>
|
|
y.Reason == DeadActivityReason.MissingRequiredField &&
|
|
y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")) ==
|
|
_expectedRecordCount - expectedHomelessDeadRecordCount)));
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(y =>
|
|
y.Reason == DeadActivityReason.MissingRequiredField &&
|
|
y.ReasonNote.ToLowerInvariant().Contains("reliably determinable home")) == expectedHomelessDeadRecordCount)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task FailToSaveDeadActivity_DoesntThrow()
|
|
{
|
|
Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser)null);
|
|
_deadActivityService.Setup(x => x.SaveDeadActivityRange(It.IsAny<List<DeadActivity>>()))
|
|
.ThrowsAsync(new Exception("Oops"));
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(_expectedRecordCount, transactions.Count());
|
|
|
|
List<Activity> results = null;
|
|
Assert.DoesNotThrowAsync(async () =>
|
|
{
|
|
var res = await _service.CreateActivity(transactions);
|
|
results = res.ToList();
|
|
});
|
|
Assert.NotNull(results);
|
|
Assert.IsEmpty(results);
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count() == _expectedRecordCount &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("allied import, no user for")))));
|
|
}
|
|
|
|
[Test]
|
|
public async Task FilterAndOrderUpdates_DefaultWithNullExisting()
|
|
{
|
|
var sourceCreatedNewer = DateTime.Today.Subtract(TimeSpan.FromDays(3));
|
|
var sourceCreatedOlder = DateTime.Today.Subtract(TimeSpan.FromDays(7));
|
|
|
|
var activityProcessingOrder = new ActivityProcessingOrder
|
|
{
|
|
ExistingActivity = null,
|
|
ActivityUpdateItems = new List<Activity>()
|
|
{
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Cancelled",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Flagged",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedNewer,
|
|
SourceCreated = sourceCreatedNewer,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Sold",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Reinstated",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Sold",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new Activity()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Cancelled/Re-Quoted",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
activityProcessingOrder = _service.FilterAndOrderUpdates(activityProcessingOrder);
|
|
|
|
Assert.AreEqual(6, activityProcessingOrder.ActivityUpdateItems.Count);
|
|
|
|
Assert.AreEqual(0, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Flagged"));
|
|
Assert.AreEqual(1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Sold" && x.SourceCreated == sourceCreatedOlder));
|
|
Assert.AreEqual(2, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled/Re-Quoted"));
|
|
Assert.AreEqual(3, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled"));
|
|
Assert.AreEqual(4, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Reinstated"));
|
|
Assert.AreEqual(5, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.SourceCreated == sourceCreatedNewer));
|
|
}
|
|
|
|
[Test]
|
|
public async Task FilterAndOrderUpdates_DefaultWithNonNullExisting()
|
|
{
|
|
var sourceCreatedNewer = DateTime.Today.Subtract(TimeSpan.FromDays(3));
|
|
var sourceCreatedOlder = DateTime.Today.Subtract(TimeSpan.FromDays(7));
|
|
|
|
var activityProcessingOrder = new ActivityProcessingOrder
|
|
{
|
|
ExistingActivity = new Activity
|
|
{
|
|
Id = 1,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Cancelled/Re-Quoted",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
ActivityUpdateItems = new List<Activity>()
|
|
{
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Cancelled",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Flagged",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedNewer,
|
|
SourceCreated = sourceCreatedNewer,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Sold",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Reinstated",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Sold",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
},
|
|
new Activity()
|
|
{
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.MechanicalBreakdownProtection,
|
|
Accepted = sourceCreatedOlder,
|
|
SourceCreated = sourceCreatedOlder,
|
|
SourceId = "1",
|
|
State = ActivityState.Accepted,
|
|
Detail = new ActivityDetail
|
|
{
|
|
AccountNumber = "867530986",
|
|
AccountStatus = "Cancelled/Re-Quoted",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "8675309-AAG"
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
activityProcessingOrder = _service.FilterAndOrderUpdates(activityProcessingOrder);
|
|
|
|
Assert.AreEqual(4, activityProcessingOrder.ActivityUpdateItems.Count);
|
|
|
|
// These items should return an index of -1 since they should be removed in order to not run already run updates against the existing item
|
|
Assert.AreEqual(-1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Flagged"));
|
|
Assert.AreEqual(-1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Sold" && x.SourceCreated == sourceCreatedOlder));
|
|
Assert.AreEqual(0, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled/Re-Quoted"));
|
|
Assert.AreEqual(1, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Cancelled"));
|
|
Assert.AreEqual(2, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.Detail.AccountStatus == "Reinstated"));
|
|
Assert.AreEqual(3, activityProcessingOrder.ActivityUpdateItems.FindIndex(x => x.SourceCreated == sourceCreatedNewer));
|
|
}
|
|
|
|
[TestCase(ActivityState.PendingTransfer, 0, true)] // Activity exists, is pending transfer, and not updated
|
|
[TestCase(ActivityState.Rejected, 0, true)] // Activity exists, is pending transfer, and not updated
|
|
[TestCase(ActivityState.Transferred, 0, true)] // Activity exists, is pending transfer, and not updated
|
|
[TestCase(ActivityState.Accepted, 1, false)] // Activity does not exist and is created
|
|
[TestCase(ActivityState.Accepted, 0, true)] // Activity exists and is not created
|
|
[Test]
|
|
public async Task CreateActivity_ExistingActivityInVariousStates_ReturnsExpectedResultsCount(ActivityState activityState, int expectedResultCount, bool returnsActivity)
|
|
{
|
|
SetupTestUsers();
|
|
var transactions = new List<AlliedSaleRow>()
|
|
{
|
|
new AlliedSaleRow()
|
|
{
|
|
AccountNumber = "1234",
|
|
Origin = "LenderWebsite",
|
|
ProductType = "GAP",
|
|
Status = "Sold",
|
|
SaleDate = DateTime.Now.ToString(),
|
|
Buyer = "Buyer",
|
|
SalesContractNumber = "1",
|
|
Issuer = "Abraham TestAssociate1"
|
|
}
|
|
};
|
|
|
|
var existingActivity = new Activity()
|
|
{
|
|
Id = 1,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceSystem = SystemType.Allied,
|
|
State = activityState,
|
|
Detail = new ActivityDetail()
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "1",
|
|
AccountStatus = "Sold"
|
|
}
|
|
};
|
|
|
|
var newlyCreatedActivity = new Activity()
|
|
{
|
|
Id = 1,
|
|
DepartmentId = 55,
|
|
EmployeeId = "11774",
|
|
Type = ActivityType.Sale,
|
|
Product = Product.GAPInsurance,
|
|
Accepted = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceCreated = DateTime.Today.Subtract(TimeSpan.FromDays(7)),
|
|
SourceSystem = SystemType.Allied,
|
|
State = returnsActivity == true ? activityState : ActivityState.Created, // if an activity does not exist, the new activity is initially in Created state
|
|
Detail = new ActivityDetail()
|
|
{
|
|
AccountNumber = "867530986",
|
|
MemberName = "ORLANDO TESTCUSTOMER10",
|
|
SubAccountNumber = "1",
|
|
AccountStatus = "Sold"
|
|
}
|
|
};
|
|
|
|
Mock.Get(_activityService)
|
|
.Setup(a => a.GetActivityForDetailUpdate(It.IsAny<Activity>()))
|
|
.ReturnsAsync(returnsActivity == true ? existingActivity : (Activity)null);
|
|
|
|
Mock.Get(_activityService)
|
|
.Setup(a => a.CreateAndRetrieveActivity(It.IsAny<Activity>()))
|
|
.ReturnsAsync(newlyCreatedActivity);
|
|
|
|
var resutls = await _service.CreateActivity(transactions);
|
|
|
|
Assert.IsNotNull(resutls);
|
|
Assert.AreEqual(expectedResultCount, resutls.Count);
|
|
}
|
|
}
|
|
}
|