monorepo/LCU.API.Collections.RepoApi-old/LCU.API.Collections.RepoApiTests/Services/RepoAccountServiceTest.cs

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));
        }
    }
}