monorepo/LCU.API.Operations.IncentiveAPI/LCU.API.Internal.Operations.IncentiveApi.UnitTests/Services/AutoDecision/DebtProtectionAccessoryServiceTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using Moq;
using NUnit.Framework;

namespace Application.UnitTests.Services.AutoDecision
{
    public class DebtProtectionAccessoryServiceTest
    {
        private ActivityDecisionService _activityDecisionService;
        private IActivityService _activityService;
        private IActivityDetailService _activityDetailService;
        private DebtProtectionAccessoryService _debtProtectionAccessoryService;
        private IDnaService _dnaService;

        [SetUp]
        public void Setup()
        {
            var strategies = new List<IDecisionStrategy>()
            {
                new ManualDecisionStrategy(),
                new ReferralDecisionStrategy(),
                new NewCheckingDecisionStrategy(),
                new CardSaleDecisionStrategy(),
                new MortgageSaleDecisionStrategy(),
                new VehicleDecisionStrategy(),
                new DebtProtectionEligibleLoanDecisionStrategy()
            };
            _activityService = Mock.Of<IActivityService>();
            _activityDetailService = Mock.Of<IActivityDetailService>();
            _debtProtectionAccessoryService = new DebtProtectionAccessoryService(_activityService, _activityDetailService);
        }

        [Test]
        public async Task ProcessDpAccessoryUpdates_Product_Vehicle_DP_Eligible_GapEligible_Ok()
        {
            var saleactivity = new List<Activity>()
            {
                new Activity ()
                {
                    Id = 123,
                    DepartmentId = 56,
                    EmployeeId = "11771",
                    Type = ActivityType.Sale,
                    MatchingDpAccessoryActivityId = 0,

                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        DebtProtectionAddDate = DateTime.UtcNow, 
                        IsDebtProtectionEligible = true,
                        IsGapInsuranceEligible = true
                    },
                    Created = DateTime.Parse("2021/11/23 10:00:00"),
                    Product = Product.Vehicle,
                    Accepted = DateTime.Today
                }
            };

            var updatedActivities = await _debtProtectionAccessoryService.ProcessDpAccessoryUpdates(saleactivity);
            Mock.Get(_activityService).Verify();
            Assert.NotNull(updatedActivities);
            Assert.AreEqual(updatedActivities.First().Detail.IsDebtProtectionEligible, true);
            Assert.AreEqual(updatedActivities.First().Detail.IsGapInsuranceEligible, true);
        }

        [Test]
        public async Task ProcessDpAccessoryUpdates_Product_Mortgage_DP_NotEligible_Gap_NotEligible_Ok()
        {
            var saleactivity = new List<Activity>()
            {
                new Activity ()
                {
                    Id = 123,
                    DepartmentId = 56,
                    EmployeeId = "11771",
                    Type = ActivityType.Sale,
                    MatchingDpAccessoryActivityId = 0,

                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        DebtProtectionAddDate = DateTime.UtcNow, 
                        IsDebtProtectionEligible = false,
                        IsGapInsuranceEligible = false
                    },
                    Created = DateTime.Parse("2021/11/23 10:00:00"),
                    Product = Product.Vehicle,
                    Accepted = DateTime.Today
                }
            };

            var updatedActivities = await _debtProtectionAccessoryService.ProcessDpAccessoryUpdates(saleactivity);
            Mock.Get(_activityService).Verify();
            Assert.AreEqual(0, updatedActivities.Count());
        }

        [Test]
        public async Task ProcessDpAccessoryUpdates_Product_DebtProtection_DP_Eligible_Gap_NotEligible_Ok()
        {
            var saleactivity = new List<Activity>()
            {
                new Activity ()
                {
                    Id = 123,
                    DepartmentId = 56,
                    EmployeeId = "11771",
                    Type = ActivityType.Sale,
                    MatchingDpAccessoryActivityId = 0,

                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        DebtProtectionRemoveDate = DateTime.UtcNow,
                        DebtProtectionAddDate = DateTime.UtcNow.AddMonths(-1),  
                        IsDebtProtectionEligible = true,
                        IsGapInsuranceEligible = false
                    },
                    Created = DateTime.Parse("2021/11/23 10:00:00"),
                    Product = Product.DebtProtectionEligibleLoan,
                    Accepted = DateTime.Today
                }
            };

            var updatedActivities = await _debtProtectionAccessoryService.ProcessDpAccessoryUpdates(saleactivity);
            Mock.Get(_activityService).Verify();
            Assert.NotNull(updatedActivities);
            Assert.AreEqual(updatedActivities.First().Detail.IsDebtProtectionEligible, true);
            Assert.AreEqual(updatedActivities.First().Detail.IsGapInsuranceEligible, false);
        }

        [Test]
        public async Task ProcessDpAccessoryUpdates_Product_Vehicle_NoMatchingAccessoryNoAddDate_Ok()
        {
            var saleactivity = new List<Activity>()
            {
                new Activity ()
                {
                    Id = 123,
                    DepartmentId = 56,
                    EmployeeId = "11771",
                    Type = ActivityType.Sale,
                    MatchingDpAccessoryActivityId = 0,

                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        DebtProtectionAddDate = null,
                        IsDebtProtectionEligible = true,
                        IsGapInsuranceEligible = true
                    },
                    Created = DateTime.Parse("2021/11/23 10:00:00"),
                    Product = Product.Vehicle,
                    Accepted = DateTime.Today
                }
            };

            var updatedActivities = await _debtProtectionAccessoryService.ProcessDpAccessoryUpdates(saleactivity);
            Mock.Get(_activityService).Verify();
            Assert.NotNull(updatedActivities);
            Assert.AreEqual(updatedActivities.Count(), 0);
        }
    }
}