375 lines
16 KiB
C#
375 lines
16 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.Action;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Models.Action;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;
|
|
using LCU.Library.Internal.IncentiveApiModels.Requests;
|
|
using LCU.Library.Internal.FileOperationsModels.Models;
|
|
using LCU.Library.Internal.FileOperationsModels.Models.NameSettings;
|
|
|
|
namespace Application.UnitTests.Services.Action
|
|
{
|
|
public class ActionVehicleImportServiceTest
|
|
{
|
|
private IActionVehicleImportService _service;
|
|
private IUserRepository _userRepository;
|
|
private IActivityService _activityService;
|
|
private IFileOperationsApiService _fileOperationsApiService;
|
|
private Mock<IDeadActivityService> _deadActivityService;
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
_userRepository = Mock.Of<IUserRepository>();
|
|
_fileOperationsApiService = Mock.Of<IFileOperationsApiService>();
|
|
_activityService = Mock.Of<IActivityService>();
|
|
_deadActivityService = new Mock<IDeadActivityService>();
|
|
_service = new ActionVehicleImportService(_userRepository, _fileOperationsApiService, _activityService, _deadActivityService.Object);
|
|
}
|
|
|
|
public StreamReader GetActionFile()
|
|
{
|
|
var path = @"Services/Action/Action_IndirectVehicleLoanSales.csv";
|
|
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 ActionVehicleRequest
|
|
{
|
|
DynamicFileName = "vehiclesales",
|
|
FilePath = "clean",
|
|
DynamicFileSettings = new DynamicNameSetting() { }
|
|
};
|
|
|
|
var files = new string[]
|
|
{
|
|
"x"
|
|
};
|
|
|
|
byte[] array = File.ReadAllBytes( @"Services/Action/Action_IndirectVehicleLoanSales.csv");
|
|
|
|
//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.FindUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(user);
|
|
Mock.Get(_activityService).Setup(x => x.SaveActivityRangeAsync(It.IsAny<IReadOnlyCollection<Activity>>())).Verifiable();
|
|
|
|
await _service.ImportTransactions<ActionSaleRow>(request);
|
|
|
|
Mock.Get(_fileOperationsApiService).Verify(x => x.GetFileContent(It.IsAny<string>()), Times.Once);
|
|
Mock.Get(_activityService).Verify(x => x.SaveActivityRangeAsync(It.IsAny<IReadOnlyCollection<Activity>>()), Times.Once);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ProcessCsv_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);
|
|
|
|
Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(user);
|
|
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(7, transactions.Count());
|
|
|
|
var results = await _service.CreateActivity(transactions);
|
|
Assert.NotNull(results);
|
|
Assert.AreEqual(7, results.Count());
|
|
}
|
|
|
|
public IEnumerable<ActionSaleRow> ImportTestTransactions()
|
|
{
|
|
var input = GetActionFile();
|
|
var csvReader = new CsvReader(input, CultureInfo.InvariantCulture);
|
|
return csvReader.GetRecords<ActionSaleRow>().ToList();
|
|
}
|
|
|
|
[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(7, 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() == 7 &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("action import, no user for")))));
|
|
|
|
//Our test CSV has email information for every row except 1
|
|
_deadActivityService.Verify(x =>x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(x => !string.IsNullOrWhiteSpace(x.EmployeeEmail)) == 6)));
|
|
}
|
|
|
|
[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(7, 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() == 7 &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("action import, no user for")))));
|
|
|
|
//Our test CSV has email information for every row except 1
|
|
_deadActivityService.Verify(x =>x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(x => !string.IsNullOrWhiteSpace(x.EmployeeEmail)) == 6)));
|
|
}
|
|
|
|
[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.FindUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(user);
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(7, 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() == 7 &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("reliably determinable home"))))); }
|
|
|
|
[Test]
|
|
public async Task SavesDeadActivity_BothKinds()
|
|
{
|
|
var user = new AppUser()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "11771",
|
|
FullName = "John Doe",
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
|
|
//There are 2 entries with this email, they will have a user but no home department
|
|
Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.Is<string>(x => x.ToLowerInvariant() == "[email protected]"))).ReturnsAsync(user);
|
|
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(7, 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("action import, no user for")) == 5)));
|
|
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(y =>
|
|
y.Reason == DeadActivityReason.MissingRequiredField &&
|
|
y.ReasonNote.ToLowerInvariant().Contains("reliably determinable home")) == 2)));
|
|
|
|
}
|
|
|
|
[Test]
|
|
public async Task SomeActivitiesAreDeadJim_Ok()
|
|
{
|
|
var john = new AppUser()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "John",
|
|
FullName = "John Doe",
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
//There are 2 entries with this email, they will have a user but no home department
|
|
Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.Is<string>(x => x.ToLowerInvariant() == "[email protected]"))).ReturnsAsync(john);
|
|
|
|
var department = new Department()
|
|
{
|
|
DepartmentName = "Dept1",
|
|
Id = 55,
|
|
State = DepartmentState.Active
|
|
};
|
|
var mary = new AppUser()
|
|
{
|
|
AdEmail = "[email protected]",
|
|
EmployeeId = "Mary",
|
|
FullName = "Mary Deer",
|
|
Departments = new List<UserDepartment>()
|
|
};
|
|
var assignment = new UserDepartment()
|
|
{
|
|
Id = 99,
|
|
Department = department,
|
|
Employee = mary,
|
|
Role = Role.BM,
|
|
IsHome = true,
|
|
StartDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1),
|
|
EndDate = null
|
|
};
|
|
mary.Departments.Add(assignment);
|
|
//There are 2 entries with this email, they will not have a home department assigned
|
|
Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.Is<string>(x => x.ToLowerInvariant() == "[email protected]"))).ReturnsAsync(john);
|
|
//There are 2 entries with this email, they will have a home department assigned
|
|
Mock.Get(_userRepository).Setup(s => s.FindUserByAdEmailAsync(It.Is<string>(x => x.ToLowerInvariant() == "[email protected]"))).ReturnsAsync(mary);
|
|
|
|
//Everyone else won't exist
|
|
var transactions = ImportTestTransactions();
|
|
Assert.NotNull(transactions);
|
|
Assert.IsNotEmpty(transactions);
|
|
Assert.AreEqual(7, transactions.Count());
|
|
|
|
//Mary should have 2 successful results
|
|
var results = await _service.CreateActivity(transactions);
|
|
Assert.NotNull(results);
|
|
Assert.AreEqual(2,results.Count);
|
|
Assert.True(results.All(x => x.EmployeeId == "Mary"));
|
|
|
|
//John should have 2 entries in dead activity for not having a home department
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(y =>
|
|
y.EmployeeId == john.EmployeeId &&
|
|
y.Reason == DeadActivityReason.MissingRequiredField &&
|
|
y.ReasonNote.ToLowerInvariant().Contains("reliably determinable home")) == 2)));
|
|
|
|
//Everyone else could not be identified
|
|
_deadActivityService.Verify(x => x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(y =>
|
|
(y.EmployeeId != john.EmployeeId && y.EmployeeId != mary.EmployeeId) &&
|
|
y.Reason == DeadActivityReason.MissingRequiredField &&
|
|
y.ReasonNote.ToLowerInvariant().Contains("action import, no user for")) == 3)));
|
|
|
|
}
|
|
|
|
[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(7, 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() == 7 &&
|
|
da.All(y => y.Reason == DeadActivityReason.MissingRequiredField) &&
|
|
da.All(y => y.ReasonNote.ToLowerInvariant().Contains("action import, no user for")))));
|
|
|
|
//Our test CSV has email information for every row except 1
|
|
_deadActivityService.Verify(x =>x.SaveDeadActivityRange(It.Is<List<DeadActivity>>(
|
|
da =>
|
|
da.Count(x => !string.IsNullOrWhiteSpace(x.EmployeeEmail)) == 6)));
|
|
}
|
|
}
|
|
}
|