monorepo/LCU.API.Internal.RepoApi/LCU.API.Internal.RepoApiTests/ServiceTests/RepoAccountProcessorTests.cs

using LCU.API.Internal.RepoApi.Models.Old_Repo_Models;
using LCU.API.Internal.RepoApi.Old_Repo_DataAccess;
using LCU.API.Internal.RepoApi.Old_Repo_Exceptions;
using LCU.API.Internal.RepoApi.Repos.Models;
using LCU.API.Internal.RepoApi.Repos.Models.Producer;
using LCU.API.Internal.RepoApi.Old_Repo_Services.Producer;
using LCU.API.Internal.RepoApi.Old_Repo_Services;
using LCU.API.Collections.CollectionsApiLib.Models;
using LCU.API.Internal.RepoApi.Repos.Models.Consumer;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using LCU.API.Internal.RepoApi.Repos.Models.Settings;
using System.IO;
using System.Reflection;

namespace LCU.API.Internal.RepoApiTests.ServiceTests
{
    public class RepoAccountProcessorTests
    {
        private readonly Mock<IRepoAccountProcessorService> _mockRepoAccountProcessorService;
        private readonly Mock<IAccountAlertCheckService> _mockAccountAlertCheckService;
        private readonly Mock<IEmailer> _mockEmailer;
        private readonly Mock<ISettingsService> _mockSettingsService;
        private readonly Mock<ICollectionsDao> _mockCollectionsDao;
        private readonly Mock<ICoreDao> _mockCoreDao;
        private readonly Mock<IRepoAccountService> _mockRepoAccountService;
        private readonly Mock<IRepoLetterService> _mockRepoLetterService;
        private readonly Mock<IAuctionAssignmentService> _mockAuctionAssignmentService;
        private readonly RepoAccountProcessor _processor;
        private readonly JObject _mockJObject;


        public RepoAccountProcessorTests()
        {
            _mockRepoAccountProcessorService = new Mock<IRepoAccountProcessorService>();
            _mockAccountAlertCheckService = new Mock<IAccountAlertCheckService>();
            _mockEmailer = new Mock<IEmailer>();
            _mockSettingsService = new Mock<ISettingsService>();
            _mockCollectionsDao = new Mock<ICollectionsDao>();
            _mockCoreDao = new Mock<ICoreDao>();
            _mockRepoAccountService = new Mock<IRepoAccountService>();
            _mockRepoLetterService = new Mock<IRepoLetterService>();
            _mockAuctionAssignmentService = new Mock<IAuctionAssignmentService>();

            _processor = new RepoAccountProcessor(
                _mockRepoAccountProcessorService.Object,
                _mockAccountAlertCheckService.Object,
                _mockCollectionsDao.Object,
                _mockEmailer.Object,
                _mockSettingsService.Object,
                _mockRepoAccountService.Object,
                _mockRepoLetterService.Object,
                _mockCoreDao.Object,
                _mockAuctionAssignmentService.Object
            );

            JsonSerializer se = new JsonSerializer();

            string testFile = "./RepoTestData.json";

            using (StreamReader r = new StreamReader(testFile))
            {
                string json = r.ReadToEnd();
                JsonTextReader reader = new JsonTextReader(new StringReader(json));
                _mockJObject = JObject.Load(reader);
            }
        }

        [Fact]
        public async Task HandleAccount_ShouldReturnAutoclosed()
        {
            var accountNumber = _mockJObject["RepoTest"]["Repo"]["AccountNo"].ToString();
            var item = new ProcessingItem { AccountNo = accountNumber };
            var processingSlip = new RepoAccountProcessingSlip
            {
                AccountNo = accountNumber,
                RecoveryAccount = null,
                ExistingRepoAccount = _mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>()
            };

            _mockRepoAccountService.Setup(x => x.GetNewestOpenAccount(processingSlip.AccountNo)).ReturnsAsync(processingSlip.ExistingRepoAccount);

            var result = await _processor.HandleAccount(item);

            Assert.Equal(RepoProcessingResult.Autoclosed, result);
        }

        [Fact]
        public async Task HandleAccount_IsUnconvertedIntellectAccount()
        {
            var accountNumber = _mockJObject["RepoTest"]["Repo"]["AccountNo"].ToString();
            var item = new ProcessingItem { AccountNo = accountNumber };

            TemenosAccount recoveryAccount = new TemenosAccount() {Cases = new List<TemenosCase> { _mockJObject["RepoTest"]["TemenosCaseSuccess"].ToObject<TemenosCase>() } };

            recoveryAccount.CustomFieldMap = new Dictionary<string, string> { { "User Status Code 1", "04R" } };

            _mockRepoAccountService.Setup(x => x.GetNewestOpenAccount(accountNumber)).ReturnsAsync(_mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>());
            _mockCollectionsDao.Setup(x => x.RetrieveAccountAsync(accountNumber)).ReturnsAsync(recoveryAccount);
            _mockSettingsService.Setup(x => x.GetCachedRepoSettingsAsync()).ReturnsAsync(_mockJObject["RepoTest"]["Settings"].ToObject<Settings>());

            var result = await _processor.HandleAccount(item);

            Assert.Equal(RepoProcessingResult.Unconverted, result);
        }

        [Fact]
        public void VerifyAccountNo_ShouldThrowException_WhenItemIsNull()
        {
            // Act & Assert
            Assert.Throws<IneligibleAccountException>(() => _processor.VerifyAccountNo(null));
        }

        [Fact]
        public async Task CreateProcessingSlip_ShouldReturnSlip_WithValidData()
        {
            // Arrange
            var item = new ProcessingItem { AccountNo = "12345", CaseId = "1" };
            var recoveryAccount = new TemenosAccount();
            var loan = new LoanDetail();

            _mockCollectionsDao
                .Setup(x => x.RetrieveAccountAsync("12345"))
                .ReturnsAsync(recoveryAccount);

            _mockCoreDao
                .Setup(x => x.RetrieveLoanAsync("12345"))
                .ReturnsAsync(loan);

            // Act
            var result = await _processor.CreateProcessingSlip(item);

            // Assert
            Assert.NotNull(result);
            Assert.Equal("12345", result.AccountNo);
            Assert.Equal(recoveryAccount, result.RecoveryAccount);
            Assert.Equal(loan, result.Loan);
        }

        [Fact]
        public async Task HandleAccount_ShouldReturnIneligible_WhenNotPossiblyRepossessionCase()
        {
            // Arrange
            var accountNumber = _mockJObject["RepoTest"]["Repo"]["AccountNo"].ToString();
            var item = new ProcessingItem { AccountNo = accountNumber, CaseId = "10" };

            TemenosAccount recoveryAccount = new TemenosAccount() { Cases = new List<TemenosCase> { _mockJObject["RepoTest"]["TemenosCaseFailure"].ToObject<TemenosCase>() } };

            RepoAccount existingAccount = _mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>();
            existingAccount.Collaterals = new List<Collateral>
           {
              _mockJObject["RepoTest"]["Collateral"].ToObject<Collateral>()
           };

            _mockRepoAccountService.Setup(x => x.GetNewestOpenAccount(accountNumber)).ReturnsAsync(existingAccount);
            _mockRepoAccountProcessorService.Setup(x => x.UpdateRepoAccountFromParts(It.IsAny<RepoAccountProcessingSlip>()))
                .Returns(_mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>());
            _mockCollectionsDao.Setup(x => x.RetrieveAccountAsync(accountNumber)).ReturnsAsync(recoveryAccount);
            _mockCoreDao.Setup(x => x.RetrieveLoanAsync(accountNumber)).ReturnsAsync(_mockJObject["RepoTest"]["Loan"].ToObject<LoanDetail>());
            _mockRepoLetterService.Setup(x => x.ListByAccountIdAsync(recoveryAccount.AccountId)).ReturnsAsync(new List<RepoLetter>());
            _mockRepoAccountProcessorService.Setup(x => x.CreateRepoAccount(It.IsAny<TemenosAccount>(), It.IsAny<TemenosCase>(), It.IsAny<LoanDetail>()))
                .Returns(new RepoAccount());
            _mockSettingsService.Setup(x => x.GetCachedRepoSettingsAsync()).ReturnsAsync(_mockJObject["RepoTest"]["Settings"].ToObject<Settings>());

            // Act
            var result = await _processor.HandleAccount(item);

            // Assert
            Assert.Equal(RepoProcessingResult.Ineligible, result);
        }

        [Fact]
        public async Task HandleAccount_ShouldThrowException_WhenExistingRepoAccountHasNoCollateral()
        {
            // Arrange
            var accountNumber = "12345";
            var item = new ProcessingItem { AccountNo = accountNumber };
           // var existingRepoAccount = new RepoAccount { Collateral = null };
            var processingSlip = new RepoAccountProcessingSlip
            {
                AccountNo = accountNumber,
                RecoveryAccount = new TemenosAccount(),
                ExistingRepoAccount = _mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>()
            };

            _mockRepoAccountService.Setup(x => x.GetNewestOpenAccount(accountNumber)).ReturnsAsync(_mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>());
            _mockCollectionsDao.Setup(x => x.RetrieveAccountAsync(accountNumber)).ReturnsAsync(processingSlip.RecoveryAccount);
            _mockSettingsService.Setup(x => x.GetCachedRepoSettingsAsync()).ReturnsAsync(new Settings());

            // Act & Assert
            await Assert.ThrowsAsync<MissingRequirementException>(() => _processor.HandleAccount(item));
        }

        [Fact]
        public async Task HandleAccount_ShouldReturnUpdated_WhenExistingAccountIsUpdated()
        {
            // Arrange
            var accountNumber = _mockJObject["RepoTest"]["Repo"]["AccountNo"].ToString();
            var item = new ProcessingItem { AccountNo = accountNumber, CaseId = "10" };

            TemenosAccount recoveryAccount = new TemenosAccount() { Cases = new List<TemenosCase> { _mockJObject["RepoTest"]["TemenosCaseSuccess"].ToObject<TemenosCase>() } };

            RepoAccount existingAccount = _mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>();
            existingAccount.Collaterals = new List<Collateral>
           {
              _mockJObject["RepoTest"]["Collateral"].ToObject<Collateral>()
           };

            List<CoreTransaction> transactions = new List<CoreTransaction> 
            {
                _mockJObject["RepoTest"]["Transaction"].ToObject<CoreTransaction>()
            };

            _mockRepoAccountService.Setup(x => x.GetNewestOpenAccount(accountNumber)).ReturnsAsync(existingAccount);
            _mockRepoAccountProcessorService.Setup(x => x.UpdateRepoAccountFromParts(It.IsAny<RepoAccountProcessingSlip>()))
                .Returns(_mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>());
            _mockCollectionsDao.Setup(x => x.RetrieveAccountAsync(accountNumber)).ReturnsAsync(recoveryAccount);
            _mockSettingsService.Setup(x => x.GetCachedRepoSettingsAsync()).ReturnsAsync(_mockJObject["RepoTest"]["Settings"].ToObject<Settings>());
            _mockCoreDao.Setup(x => x.RetrieveLoanAsync(accountNumber)).ReturnsAsync(_mockJObject["RepoTest"]["Loan"].ToObject<LoanDetail>());
            _mockCoreDao.Setup(x => x.RetrieveTransactionsAsync(accountNumber)).ReturnsAsync(transactions);
            _mockCoreDao.Setup(x => x.RetrieveMemberAsync(accountNumber)).ReturnsAsync(_mockJObject["RepoTest"]["Member"].ToObject<MemberDetail>());
            _mockRepoLetterService.Setup(x => x.ListByAccountIdAsync(recoveryAccount.AccountId)).ReturnsAsync(new List<RepoLetter>());
            _mockAuctionAssignmentService.Setup(x => x.GetListByIdsAsync(It.IsAny<List<int>>()))
                .ReturnsAsync(new List<AuctionAssignment> { _mockJObject["RepoTest"]["AuctionAssignment"].ToObject<AuctionAssignment>() });
            _mockRepoAccountProcessorService.Setup(x => x.UpdateRepoAccountFromParts(It.IsAny<RepoAccountProcessingSlip>()))
                .Returns(_mockJObject["RepoTest"]["Repo"].ToObject<RepoAccount>());

            // Act
            var result = await _processor.HandleAccount(item);

            // Assert
            Assert.Equal(RepoProcessingResult.Updated, result);
        }

        [Fact]
        public async Task HandleAccount_ShouldThrowException_WhenProcessingItemIsNull()
        {
            // Act & Assert
            await Assert.ThrowsAsync<IneligibleAccountException>(() => _processor.HandleAccount(null));
        }

        [Fact]
        public async Task HandleAccount_ShouldReturnUnconverted_WhenRecoveryAccountHasOldIntellectStatus()
        {
            // Arrange
            var accountNumber = "12345";
            var item = new ProcessingItem { AccountNo = accountNumber };
            var recoveryAccount = new TemenosAccount
            {
                CustomFieldMap = new Dictionary<string, string> { { RepoAccountProcessor.UserStatusFieldOld, "OldStatus" } }
            };
            var existingRepoAccount = new RepoAccount { Status = "OldStatus" };
            var processingSlip = new RepoAccountProcessingSlip
            {
                AccountNo = accountNumber,
                RecoveryAccount = recoveryAccount,
                ExistingRepoAccount = existingRepoAccount
            };

            _mockRepoAccountService.Setup(x => x.GetNewestOpenAccount(accountNumber)).ReturnsAsync(existingRepoAccount);
            _mockCollectionsDao.Setup(x => x.RetrieveAccountAsync(accountNumber)).ReturnsAsync(recoveryAccount);
            _mockSettingsService.Setup(x => x.GetCachedRepoSettingsAsync()).ReturnsAsync(new Settings());

            // Act
            var result = await _processor.HandleAccount(item);

            // Assert
            Assert.Equal(RepoProcessingResult.Unconverted, result);
        }
    }
}