monorepo/LCU.API.Operations.IncentiveAPI/LCU.API.Internal.Operations.IncentiveApi.UnitTests/Services/ExternalActivity/NewDebtProtectionEligibleLoanStrategyTest.cs

using System;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApi.Models.ExternalActivities;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
using LCU.API.Internal.Operations.IncentiveApi.Services.ExternalActivity;
using LCU.API.Internal.Operations.IncentiveApi.Models.DataTransfer;

namespace Application.UnitTests.Services.ExternalActivity
{
    public class NewDebtProtectionEligibleLoanStrategyTest
    {
        private  Mock<IUserService> _mockUserService;
        private  Mock<IDepartmentRepository> _mockDepartmentRepository;
        private  NewDebtProtectionEligibleLoanStrategy _externalActivityService;
        [SetUp]
        public void Setup()
        {
            _mockUserService = new Mock<IUserService>();
            _mockDepartmentRepository = new Mock<IDepartmentRepository>();
            _externalActivityService = new NewDebtProtectionEligibleLoanStrategy(_mockUserService.Object, _mockDepartmentRepository.Object);
        }


        [Test]
        public async Task NewDebtProtectionEligibleLoan_Ok()
        {
            var externalActivity = new NewLoanSaleActivity()
            {
                SubjectAccountNbr = 1,
                OriginatingPersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
                EmployeeEmail = "[email protected]",
                MinorAccountType = "SG01"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(new AppUser()
            {
                AdEmail = "[email protected]",
                EmployeeId = "7624"
            });
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
                new Department()
                {
                    Id = 10
                });

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.DebtProtectionEligibleLoan);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(10, activity.DepartmentId);
            Assert.AreEqual("7624", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "[email protected]")), Times.Once);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

        [Test]
        public async Task NewDebtProtectionEligibleLoan_NoEmail_Ok()
        {
            var externalActivity = new NewLoanSaleActivity()
            {
                SubjectAccountNbr = 1,
                OriginatingPersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
                MinorAccountType = "SG01"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser) null);
            _mockUserService.Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>())).ReturnsAsync(
            new AppUser()
                {
                    AdEmail = "[email protected]",
                    EmployeeId = "7624"
                }
            );

            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
                new Department()
                {
                    Id = 10
                });

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.DebtProtectionEligibleLoan);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(10, activity.DepartmentId);
            Assert.AreEqual("7624", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.IsAny<string>()), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

        [Test]
        public async Task NewDebtProtectionEligibleLoan_NoUser_Ok()
        {
            var externalActivity = new NewLoanSaleActivity()
            {
                SubjectAccountNbr = 1,
                OriginatingPersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
                MinorAccountType = "SG01"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync((AppUser) null);
            _mockUserService
                .Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()))
                .ReturnsAsync((AppUser)null);

            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync(
                new Department()
                {
                    Id = 10
                });

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.DebtProtectionEligibleLoan);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual(null, activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.IsAny<string>()), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Exactly(1));
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()), Times.Never());
        }

        [Test]
        public async Task NewDebtProtectionEligibleLoan_NoDepartment_Ok()
        {
            var externalActivity = new NewLoanSaleActivity()
            {
                SubjectAccountNbr = 1,
                OriginatingPersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
                EmployeeEmail = "[email protected]",
                MinorAccountType = "SG01"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ReturnsAsync(new AppUser()
            {
                AdEmail = "[email protected]",
                EmployeeId = "7624"
            });
            _mockDepartmentRepository.Setup(x => x.FindUserHomeDepartment(It.IsAny<AppUser>())).ReturnsAsync((Department)null);

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.True(activity.Product == Product.DebtProtectionEligibleLoan);
            Assert.True(activity.Type == ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual("7624", activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "[email protected]")), Times.Once);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Never);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.Is<AppUser>(x => x.EmployeeId == "7624")), Times.Once);
        }

        [Test]
        public async Task NewDebtProtectionEligibleLoan_ExceptionReturnsBasic()
        {
            var externalActivity = new NewLoanSaleActivity()
            {
                SubjectAccountNbr = 1,
                OriginatingPersonNbr = 1234,
                BranchOrgName = "West Bend-Main Branch",
                BranchOrgNbr = 400,
                TaxOrgNbr = "300",
                TaxPersonNbr = "200",
                CurrentAccountStatus = "Active",
                ActivityDateTime = DateTime.Parse("2021-09-10"),
                AssociateFirst = "John",
                AssociateLast = "Smith",
                AssociateMiddleInit = "B",
                MinorAccountType = "SG01"
            };

            _mockUserService.Setup(x => x.GetUserByAdEmailAsync(It.IsAny<string>())).ThrowsAsync(new Exception("OOPS"));
            _mockUserService
                .Setup(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()))
                .ThrowsAsync(new Exception("OOPS"));

            var activity = await _externalActivityService.MapToActivityManagerActivity(externalActivity);
            Assert.AreEqual(activity.Product, Product.DebtProtectionEligibleLoan);
            Assert.AreEqual(activity.Type, ActivityType.Sale);
            Assert.AreEqual(-1, activity.DepartmentId);
            Assert.AreEqual(null, activity.EmployeeId);

            _mockUserService.Verify(x => x.GetUserByAdEmailAsync(It.Is<string>(x => x == "[email protected]")), Times.Never);
            _mockUserService.Verify(x => x.TryFindSingleUserByName(It.IsAny<UserNameSearchRequest>()), Times.Once);
            _mockDepartmentRepository.Verify(x => x.FindUserHomeDepartment(It.IsAny<AppUser>()), Times.Never);

        }
    }
}