Adding

2026-04-20 14:47:24 -05:00
parent 89057eceea
commit 8b3ea92501
485 changed files with 71042 additions and 0 deletions
@@ -0,0 +1,544 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using LCU.API.Collections.RepoApi.Exceptions;
+using LCU.API.Collections.RepoApi.Models;
+using LCU.API.Collections.RepoApi.Models.Filters;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using LCU.Shared.Collections.RepoApiLib.Models.Producer;
+using LCU.Shared.Collections.RepoApiLib.Models.Results;
+using LCU.Shared.Collections.RepoApiLib.Repositories;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Services
+{
+    public class RepoAccountServiceTest
+    {
+        private readonly Mock<IRepoAccountRepository> _mockRepoAccountRepository;
+        private readonly Mock<IRepoStatusChangeRepository> _mockStatusChangeRepository;
+        private readonly Mock<IRepoManualStatusRepository> _mockRepoManualStatusRepository;
+        private readonly IRepoAccountService _repoAccountService;
+
+        public RepoAccountServiceTest()
+        {
+            _mockRepoAccountRepository = new Mock<IRepoAccountRepository>();
+            _mockStatusChangeRepository = new Mock<IRepoStatusChangeRepository>();
+            _mockRepoManualStatusRepository = new Mock<IRepoManualStatusRepository>();
+            var mockUnitOfWrk = new Mock<IUnitOfWork>();
+            _repoAccountService = new RepoAccountService(_mockRepoAccountRepository.Object, _mockStatusChangeRepository.Object,
+                _mockRepoManualStatusRepository.Object, mockUnitOfWrk.Object);
+        }
+
+        [Fact]
+        public async void ListAccounts_Ok()
+        {
+            // arrange
+            var repos = new List<RepoAccount>
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98"
+                }
+            };
+            var paged = new PagedResult<RepoAccount>() { Total = 1, Items = repos };
+            _mockRepoAccountRepository
+                .Setup(x => x.ListAsync(It.IsAny<List<int?>>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int?>(), It.IsAny<bool?>()))
+                .ReturnsAsync(paged);
+
+            // act
+            var result = await _repoAccountService.ListAll(new PageFilter());
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(1, result.Total);
+            Assert.True(repos.SequenceEqual(result.Items));
+        }
+
+        [Fact]
+        public async void List_Pollable_Accounts_Ok()
+        {
+            // arrange
+            var statusList = new List<string>
+            {
+                "O4R", "REPO", "REDEEMED"
+            };
+            var repos = new List<ProcessingItem>
+            {
+                new ProcessingItem()
+                {
+                    AccountNo = "1234567-98"
+                }
+            };
+
+            _mockRepoManualStatusRepository.Setup(x => x.ListWatchStatusesAsync())
+                .ReturnsAsync(statusList);
+            _mockRepoAccountRepository
+                .Setup(x => x.GetItemsForProcessing(statusList))
+                .ReturnsAsync(repos);
+
+            // act
+            var result = await _repoAccountService.GetItemsForProcessing();
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(1, result.Count);
+        }
+
+        [Fact]
+        public async void Save_With_Borrower_OK()
+        {
+            // arrange
+            var repo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98",
+                Status = "O4R",
+                Borrowers = new List<Borrower>()
+                {
+                    new Borrower()
+                    {
+                        IndividualName = "John Doe",
+                        OwnershipType = 6,
+                        IndividualId = "123456"
+                    }
+                }
+            };
+            var statusChange = new RepoStatusChange()
+            {
+                RepoId = 5,
+                ChangedBy = "System",
+                StatusTo = "O4R",
+                StatusFrom = "None"
+            };
+            _mockRepoAccountRepository.Setup(x => x.AddAsync(It.IsAny<RepoAccount>())).ReturnsAsync(repo);
+            _mockStatusChangeRepository.Setup(x => x.AddAsync(It.IsAny<RepoStatusChange>())).ReturnsAsync(statusChange);
+
+            // act
+            var result = await _repoAccountService.SaveAsync(repo);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(repo, result);
+
+            _mockStatusChangeRepository.Verify(x => x.AddAsync(It.IsAny<RepoStatusChange>()), Times.Once);
+        }
+
+        [Fact]
+        public async void Update_With_Borrower_OK()
+        {
+            // arrange
+            var oldRepo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98",
+                Status = "O4R",
+                Borrowers = new List<Borrower>()
+                {
+                    new Borrower()
+                    {
+                        IndividualName = "John Doe",
+                        OwnershipType = 6,
+                        IndividualId = "123456"
+                    }
+                },
+                Collaterals = new List<Collateral>()
+                {
+                    new Collateral()
+                    {
+                        Description = "used mitsubishi",
+                        Inoperable = true, // Inoperable = (Make == "Mitsubishi")
+                        Make = "Mitsubishi",
+                        RepoId = 5,
+                        CollateralId = 919,
+                        RetitledInLandmarkName = null
+                    }
+                }
+            };
+            var repo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98",
+                Status = "REPO",
+                Borrowers = new List<Borrower>()
+                {
+                    new Borrower()
+                    {
+                        IndividualName = "John Doe",
+                        OwnershipType = 6,
+                        IndividualId = "123456"
+                    }
+                },
+                Collaterals = new List<Collateral>()
+                {
+                    new Collateral()
+                    {
+                        Description = "used mitsubishi",
+                        Inoperable = true, // Inoperable = (Make == "Mitsubishi")
+                        Make = "Mitsubishi",
+                        RepoId = 5,
+                        CollateralId = 919,
+                        RetitledInLandmarkName = null
+                    }
+                }
+            };
+            var statusChange = new RepoStatusChange()
+            {
+                RepoId = 5,
+                ChangedBy = "System",
+                StatusTo = "O4R",
+                StatusFrom = "None"
+            };
+            _mockRepoAccountRepository.Setup(x => x.Update(It.IsAny<RepoAccount>())).Verifiable();
+            _mockRepoAccountRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(oldRepo);
+            _mockStatusChangeRepository.Setup(x => x.AddAsync(It.IsAny<RepoStatusChange>())).ReturnsAsync(statusChange);
+
+            // act
+            var result = await _repoAccountService.UpdateAsync(repo, new AppUser()
+            {
+                FirstName = "TEst",
+                LastName = "test"
+            });
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(oldRepo, result);
+            Assert.Equal("REPO", oldRepo.Status);
+
+            _mockStatusChangeRepository.Verify(x => x.AddAsync(It.IsAny<RepoStatusChange>()), Times.Once);
+        }
+
+        [Fact]
+        public async void Update_With_Borrower_No_Status_Change_OK()
+        {
+            // arrange
+            var oldRepo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98",
+                Status = "REPO",
+                Borrowers = new List<Borrower>()
+                {
+                    new Borrower()
+                    {
+                        IndividualName = "John Doe",
+                        OwnershipType = 6,
+                        IndividualId = "123456"
+                    }
+                },
+                Collaterals = new List<Collateral>()
+                {
+                    new Collateral()
+                    {
+                        Description = "used mitsubishi",
+                        Inoperable = true, // Inoperable = (Make == "Mitsubishi")
+                        Make = "Mitsubishi",
+                        RepoId = 5,
+                        CollateralId = 919,
+                        RetitledInLandmarkName = null
+                    }
+                }
+            };
+            var repo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98",
+                Status = "REPO",
+                Collector = "collector_changed",
+                Borrowers = new List<Borrower>()
+                {
+                    new Borrower()
+                    {
+                        IndividualName = "John Doe",
+                        OwnershipType = 6,
+                        IndividualId = "123456"
+                    }
+                },
+                Collaterals = new List<Collateral>()
+                {
+                    new Collateral()
+                    {
+                        Description = "used mitsubishi",
+                        Inoperable = true, // Inoperable = (Make == "Mitsubishi")
+                        Make = "Mitsubishi",
+                        RepoId = 5,
+                        CollateralId = 919,
+                        RetitledInLandmarkName = null
+                    }
+                }
+            };
+            var statusChange = new RepoStatusChange()
+            {
+                RepoId = 5,
+                ChangedBy = "System",
+                StatusTo = "O4R",
+                StatusFrom = "None"
+            };
+            _mockRepoAccountRepository.Setup(x => x.Update(It.IsAny<RepoAccount>())).Verifiable();
+            _mockRepoAccountRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(oldRepo);
+            _mockStatusChangeRepository.Setup(x => x.AddAsync(It.IsAny<RepoStatusChange>())).ReturnsAsync(statusChange);
+
+            // act
+            var result = await _repoAccountService.UpdateAsync(repo, new AppUser()
+            {
+                FirstName = "TEst",
+                LastName = "test"
+            });
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(oldRepo, result);
+            Assert.Equal("REPO", oldRepo.Status);
+
+            _mockStatusChangeRepository.Verify(x => x.AddAsync(It.IsAny<RepoStatusChange>()), Times.Never);
+        }
+
+        [Fact]
+        public async void GetAccount_Id_Ok()
+        {
+            // arrange
+            var repo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98"
+            };
+            _mockRepoAccountRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(repo);
+
+            // act
+            var result = await _repoAccountService.Get(4);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(repo, result);
+        }
+
+        [Fact]
+        public async void GetAccount_AccountNo_Ok()
+        {
+            // arrange
+            var repos = new List<RepoAccount>()
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98"
+                }
+            };
+            _mockRepoAccountRepository.Setup(x => x.FindByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(repos);
+
+            // act
+            var result = await _repoAccountService.GetByAccountNo("4567");
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(repos, result);
+        }
+
+        [Fact]
+        public async void GetNewestOpenAccount_AccountNo_Open_Ok()
+        {
+
+            // arrange
+            var repos = new List<RepoAccount>()
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Parse("12-01-2010")
+                },
+                 new RepoAccount()
+                {
+                    RepoId = 6,
+                    AccountNo = "1234567-98",
+                    DateClosed = null
+                }
+            };
+            _mockRepoAccountRepository.Setup(x => x.FindByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(repos);
+
+            // act
+            var result = await _repoAccountService.GetNewestOpenAccount("4567");
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.True(result.RepoId == 6 && result.DateClosed == null);
+        }
+
+        [Fact]
+        public void SelectAccount_AccountNo_Multi_Ok()
+        {
+
+            // arrange
+            var repos = new List<RepoAccount>()
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Parse("12-01-2010")
+                },
+                 new RepoAccount()
+                {
+                    RepoId = 6,
+                    AccountNo = "1234567-98",
+                    DateClosed = null
+                }
+            };
+            
+            // act
+            var result = _repoAccountService.SelectFirstOpenAccount(repos);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.True(result.RepoId == 6 && result.DateClosed == null);
+        }
+        
+        [Fact]
+        public void SelectAccount_AccountNo_Single_Ok()
+        {
+
+            // arrange
+            var repos = new List<RepoAccount>()
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Parse("12-01-2010")
+                }
+            };
+            
+            // act
+            var result = _repoAccountService.SelectFirstOpenAccount(repos);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.True(result.RepoId == 5 && result.DateClosed != null);
+        }
+
+        [Fact]
+        public async void GetNewestOpenAccount_AccountNo_Newest_Ok()
+        {
+
+            // arrange
+            var repos = new List<RepoAccount>()
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Parse("12-01-2010")
+                },
+                 new RepoAccount()
+                {
+                    RepoId = 6,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Parse("04-01-2019")
+                }
+            };
+            _mockRepoAccountRepository.Setup(x => x.FindByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(repos);
+
+            // act
+            var result = await _repoAccountService.GetNewestOpenAccount("4567");
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.True(result.RepoId == 6 && result.DateClosed == DateTime.Parse("04-01-2019"));
+        }
+
+        [Fact]
+        public async void GetNewestOpenAccount_AccountNo_Single_Ok()
+        {
+
+            // arrange
+            var repos = new List<RepoAccount>()
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Parse("12-01-2010")
+                }
+            };
+            _mockRepoAccountRepository.Setup(x => x.FindByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(repos);
+
+            // act
+            var result = await _repoAccountService.GetNewestOpenAccount("4567");
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.True(result.RepoId == 5 && result.DateClosed == DateTime.Parse("12-01-2010"));
+        }
+
+        [Fact]
+        public async void GetNewestOpenAccount_AccountNo_Null_Ok()
+        {
+            // arrange
+            _mockRepoAccountRepository.Setup(x => x.FindByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(new List<RepoAccount>());
+
+            // act
+            var result = await _repoAccountService.GetNewestOpenAccount("4567");
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public async void DeleteAsync_Ok()
+        {
+            var repo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98",
+                DateClosed = DateTime.Parse("12-01-2010")
+            };
+
+            _mockRepoAccountRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(repo);
+
+            //act
+            var result = await _repoAccountService.DeleteAsync (5);
+
+            //assert
+            Assert.NotNull(result);
+            Assert.Equal(5, result.RepoId);
+        }
+
+        [Fact]
+        public async void DeleteAsync_Existing_Null()
+        {
+            _mockRepoAccountRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<RepoAccount>(null));
+
+            //act
+            await Assert.ThrowsAsync<NotFoundException>(async () => await _repoAccountService.DeleteAsync(5));
+        }
+
+        [Fact]
+        public async void DeleteAsync_Existing_Exception()
+        {
+            _mockRepoAccountRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
+
+            //act
+            await Assert.ThrowsAsync<ServerErrorException>(async () => await _repoAccountService.DeleteAsync(5));
+        }
+
+        [Fact]
+        public async void DeleteAsync_Remove_Exception()
+        {
+            var repo = new RepoAccount()
+            {
+                RepoId = 5,
+                AccountNo = "1234567-98",
+                DateClosed = DateTime.Parse("12-01-2010")
+            };
+
+            _mockRepoAccountRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(repo);
+            _mockRepoAccountRepository.Setup(x => x.Remove(It.IsAny<RepoAccount>())).Throws(new Exception("oops"));
+
+            //act
+            await Assert.ThrowsAsync<ServerErrorException>(async () => await _repoAccountService.DeleteAsync(5));
+        }
+    }
+}