monorepo/LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/AgreeServiceTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Moq;
using NUnit.Framework;
using LCU.Api.Internal.CoreApiWrapper.Services;
using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Agreements;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class AgreeServiceTest
    {
        private AgreeService _agreeService;
        private Mock<IAgreeDao> _mockAgreeDao;

        [SetUp]
        public void SetUp()
        {
            _mockAgreeDao = new Mock<IAgreeDao>();
            _agreeService = new AgreeService(_mockAgreeDao.Object);
        }

        [Test]
        public async Task GetAgreeUsersByAccountNumbers_OK()
        {
            _mockAgreeDao
                .Setup(x => x.FindAgreeUsersByAccountNumbers(It.IsAny<List<string>>()))
                .ReturnsAsync(
                    new List<AgreeUserAccount>()
                    {
                        new AgreeUserAccount()
                        {
                            AccountNumber = 100010,
                            AgreeNumber = 1000,
                            UserId = "101010"
                        },
                        new AgreeUserAccount()
                        {
                            AccountNumber = 200020,
                            AgreeNumber = 2000,
                            UserId = "202020"
                        }
                    })
                .Verifiable();

            var accountNumbers = new List<string>()
            {
                "100010",
                "200020"
            };
            var results = await _agreeService.GetAgreeUsersByAccountNumbers(accountNumbers);

            var resultsList = results.ToList();
            Assert.NotNull(results);
            Assert.AreEqual(2, resultsList.Count);
            Assert.True(resultsList.Any(x => x.AccountNumber == 100010));
            Assert.True(resultsList.Any(x => x.AccountNumber == 200020));
            Assert.True(resultsList.Any(x => x.AgreeNumber == 1000));
            Assert.True(resultsList.Any(x => x.AgreeNumber == 2000));
            Assert.True(resultsList.Any(x => x.UserId == "101010"));
            Assert.True(resultsList.Any(x => x.UserId == "202020"));

            _mockAgreeDao.Verify(x =>
                x.FindAgreeUsersByAccountNumbers(
                    It.Is<List<string>>(ls => ls.Count == 2 && ls.Contains("100010") && ls.Contains("200020"))));
        }

        [Test]
        public void GetAgreeUsersByAccountNumbers_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreeUsersByAccountNumbers(It.IsAny<List<string>>()))
                .Throws(new Exception("Ohh nooo"));

            var accountNumbers = new List<string>()
            {
                "100010",
                "200020"
            };
            Assert.ThrowsAsync<Exception>(async () =>
                await _agreeService.GetAgreeUsersByAccountNumbers(accountNumbers));
        }

        [Test]
        public async Task GetAgreeUsersByPersonNumber_OK()
        {
            var personNumbers = new List<string> { "5436", "44889" };
            _mockAgreeDao
                .Setup(x => x.FindAgreeUserByPersonNumber(123L))
                .ReturnsAsync(personNumbers).Verifiable();
            
            var result = await _agreeService.GetAgreeUsersByPersonNumber(123L);

            Assert.NotNull(result);
            Assert.AreEqual("5436", result.FirstOrDefault());
            _mockAgreeDao.Verify();
        }

        [Test]
        public void GetAgreeUsersByPersonNumber_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreeUserByPersonNumber(123L))
                .Throws(new Exception("Exception from unit test")).Verifiable();
            
            Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreeUsersByPersonNumber(123L));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public async Task GetAgreeUserByOrganizationNumber_OK()
        {
            _mockAgreeDao
                .Setup(x => x.FindAgreeUserByOrganizationNumber(123L))
                .ReturnsAsync("5436").Verifiable();
            
            var result = await _agreeService.GetAgreeUserByOrganizationNumber(123L);

            Assert.NotNull(result);
            Assert.AreEqual("5436", result);
            _mockAgreeDao.Verify();
        }

        [Test]
        public void GetAgreeUserByOrganizationNumber_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreeUserByOrganizationNumber(123L))
                .Throws(new Exception("Exception from unit test")).Verifiable();
            
            Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreeUserByOrganizationNumber(123L));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public async Task GetEAgreementsByAccountId_OK()
        {
            var returnedEAgreements = new List<Agreement>()
            {
                new()
                {
                    UserId = "101010",
                    AgreementNumber = 123,
                    PersonNumber = 1234,
                    FirstName = "John",
                    MiddleName = "Doe",
                    MiddleInitial = "D",
                    LastName = "Smith",
                    Suffix = "Jr.",
                },
                new()
                {
                    UserId = "101011"
                }
            };

            _mockAgreeDao
                .Setup(x => x.FindAgreementsByAccountId(123))
                .ReturnsAsync(returnedEAgreements).Verifiable();

            var results = await _agreeService.GetAgreementsByAccountId(123);

            var resultsList = results.ToList();
            Assert.NotNull(results);
            Assert.AreEqual(2, resultsList.Count);

            var firstResult = resultsList.First();
            Assert.AreEqual(firstResult.AgreementNumber, 123L);
            Assert.AreEqual(firstResult.UserId, "101010");
            Assert.AreEqual(firstResult.PersonNumber, 1234L);
            Assert.AreEqual(firstResult.FirstName, "John");
            Assert.AreEqual(firstResult.MiddleName, "Doe");
            Assert.AreEqual(firstResult.MiddleInitial, "D");
            Assert.AreEqual(firstResult.LastName, "Smith");
            Assert.AreEqual(firstResult.Suffix, "Jr.");

            var secondResult = resultsList.Last();
            Assert.AreEqual(secondResult.UserId, "101011");
            _mockAgreeDao.Verify();
        }

        [Test]
        public void GetEAgreementsByAccountId_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreementsByAccountId(123))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementsByAccountId(123));
            _mockAgreeDao.Verify();
        }

        [Test]
        public async Task GetEAgreementByUserId_OK()
        {
            var returnedEAgreement = new Agreement()
                {
                    UserId = "101010",
                    AgreementNumber = 123,
                    PersonNumber = 1234,
                    FirstName = "John",
                    MiddleName = "Doe",
                    MiddleInitial = "D",
                    LastName = "Smith",
                    Suffix = "Jr.",
                };
            
            _mockAgreeDao
                .Setup(x => x.FindAgreementByUserId("123"))
                .ReturnsAsync(returnedEAgreement).Verifiable();

            var result = await _agreeService.GetAgreementByUserId("123");

            Assert.NotNull(result);

            Assert.AreEqual(result.AgreementNumber, 123L);
            Assert.AreEqual(result.UserId, "101010");
            Assert.AreEqual(result.PersonNumber, 1234L);
            Assert.AreEqual(result.FirstName, "John");
            Assert.AreEqual(result.MiddleName, "Doe");
            Assert.AreEqual(result.MiddleInitial, "D");
            Assert.AreEqual(result.LastName, "Smith");
            Assert.AreEqual(result.Suffix, "Jr.");
        }

        [Test]
        public void GetEAgreementByUserId_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreementByUserId("123"))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementByUserId("123"));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public async Task GetEAgreementByAgreementId_OK()
        {
            var returnedEAgreement = new Agreement
            {
                UserId = "101010",
                AgreementNumber = 123,
                PersonNumber = 1234,
                FirstName = "John",
                MiddleName = "Doe",
                MiddleInitial = "D",
                LastName = "Smith",
                Suffix = "Jr.",
            };
            
            _mockAgreeDao
                .Setup(x => x.FindAgreementByAgreementId(123))
                .ReturnsAsync(returnedEAgreement).Verifiable();
            
            var result = await _agreeService.GetAgreementByAgreementId(123);

            Assert.NotNull(result);

            Assert.AreEqual(result.AgreementNumber, 123L);
            Assert.AreEqual(result.UserId, "101010");
            Assert.AreEqual(result.PersonNumber, 1234L);
            Assert.AreEqual(result.FirstName, "John");
            Assert.AreEqual(result.MiddleName, "Doe");
            Assert.AreEqual(result.MiddleInitial, "D");
            Assert.AreEqual(result.LastName, "Smith");
            Assert.AreEqual(result.Suffix, "Jr.");
        }

        [Test]
        public void GetEAgreementByAgreementId_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreementByAgreementId(123))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementByAgreementId(123));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public async Task GetEAgreementAccountsByUserId_OK()
        {
            var returnedAgreementAccounts = new List<AgreementAccount>
            {
                new()
                {
                    AccountDescription = "Test Account",
                    AccountNumber = 12345,
                    TaxReportForPersonNumber = 12345666,
                    TaxReportForOrgNumber = null,
                    OvrDeliveryMethCD = "PRNT"
                },
                new()
                {
                    AccountDescription = "Test Account 2",
                    AccountNumber = 12346,
                    TaxReportForPersonNumber = null,
                    TaxReportForOrgNumber = 12345666,
                    OvrDeliveryMethCD = "WWW"
                }
            };
            
            var returnedAccountOwners = new List<AgreementAccountOwner>
            {
                new()
                {
                    AccountNumber = 12345,
                    PersonNumber = 123,
                    UserId = "111"
                },
                new()
                {
                    AccountNumber = 12346,
                    PersonNumber = 124,
                    UserId = "222"
                }
            };

            _mockAgreeDao
                .Setup(x => x.FindAgreementAccountsByUserId("123"))
                .ReturnsAsync(returnedAgreementAccounts).Verifiable();

            _mockAgreeDao
                .Setup(x => x.FindAgreementOwnerByAccountNumbers(It.Is<IEnumerable<long>>(x => x.Contains(12345L) && x.Contains(12346L))))
                .ReturnsAsync(returnedAccountOwners).Verifiable();
            
            var results = await _agreeService.GetAgreementAccountsByUserId("123");

            var resultsList = results.ToList();
            Assert.NotNull(results);
            Assert.AreEqual(2, resultsList.Count);

            var firstResult = resultsList.First();
            Assert.AreEqual(firstResult.AccountNumber, 12345L);
            Assert.AreEqual(firstResult.AccountDescription, "Test Account");
            Assert.AreEqual(firstResult.TaxReportForPersonNumber, 12345666);
            Assert.IsNull(firstResult.TaxReportForOrgNumber);
            Assert.AreEqual(firstResult.OvrDeliveryMethCD, "PRNT");
            Assert.AreEqual(firstResult.AccountOwner.PersonNumber, 123);

            var secondResult = resultsList.Last();
            Assert.AreEqual(secondResult.AccountNumber, 12346L);
            Assert.AreEqual(secondResult.AccountDescription, "Test Account 2");
            Assert.AreEqual(secondResult.TaxReportForOrgNumber, 12345666);
            Assert.IsNull(secondResult.TaxReportForPersonNumber);
            Assert.AreEqual(secondResult.OvrDeliveryMethCD, "WWW");
            Assert.AreEqual(secondResult.AccountOwner.PersonNumber, 124);

            _mockAgreeDao.Verify();
        }

                [Test]
        public async Task GetEAgreementAccountsByOrganizationId_OK()
        {
            var returnedAgreementAccounts = new List<AgreementAccount>
            {
                new()
                {
                    AccountDescription = "Test Account",
                    AccountNumber = 12345,
                    TaxReportForPersonNumber = null,
                    TaxReportForOrgNumber = 12345666,
                    OvrDeliveryMethCD = "PRNT"
                },
                new()
                {
                    AccountDescription = "Test Account 2",
                    AccountNumber = 12346,
                    TaxReportForPersonNumber = null,
                    TaxReportForOrgNumber = 12345667,
                    OvrDeliveryMethCD = "WWW"
                }
            };
            
            var returnedAccountOwners = new List<AgreementAccountOwner>
            {
                new()
                {
                    AccountNumber = 12345,
                    PersonNumber = 123,
                    UserId = "111"
                }
            };

            _mockAgreeDao
                .Setup(x => x.FindAgreementAccountsByOrganizationId(123))
                .ReturnsAsync(returnedAgreementAccounts).Verifiable();

            _mockAgreeDao
                .Setup(x => x.FindAgreementOwnerByAccountNumbers(It.Is<IEnumerable<long>>(x => x.Contains(12345L) && x.Contains(12346L))))
                .ReturnsAsync(returnedAccountOwners).Verifiable();
            
            var results = await _agreeService.GetAgreementAccountsByOrganizationId(123);

            var resultsList = results.ToList();
            Assert.NotNull(results);
            Assert.AreEqual(2, resultsList.Count);

            var firstResult = resultsList.First();
            Assert.AreEqual(firstResult.AccountNumber, 12345L);
            Assert.AreEqual(firstResult.AccountDescription, "Test Account");
            Assert.IsNull(firstResult.TaxReportForPersonNumber);
            Assert.AreEqual(firstResult.TaxReportForOrgNumber, 12345666L);
            Assert.AreEqual(firstResult.OvrDeliveryMethCD, "PRNT");
            Assert.AreEqual(firstResult.AccountOwner.PersonNumber, 123);

            var secondResult = resultsList.Last();
            Assert.AreEqual(secondResult.AccountNumber, 12346L);
            Assert.AreEqual(secondResult.AccountDescription, "Test Account 2");
            Assert.IsNull(secondResult.TaxReportForPersonNumber);
            Assert.AreEqual(secondResult.TaxReportForOrgNumber, 12345667L);
            Assert.AreEqual(secondResult.OvrDeliveryMethCD, "WWW");
            Assert.IsNull(secondResult.AccountOwner);

            _mockAgreeDao.Verify();
        }

        [Test]
        public void GetEAgreementAccountsByOrganizationId_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreementAccountsByOrganizationId(123))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementAccountsByOrganizationId(123));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public void GetEAgreementAccountsByUserId_Exception()
        {
            _mockAgreeDao.Setup(x => x.FindAgreementAccountsByUserId("123"))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.GetAgreementAccountsByUserId("123"));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public async Task AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained_OK()
        {
            var returnedAccountNumbers = new List<long>
            {
                12345,
                12346
            };

            _mockAgreeDao
                .Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()))
                .ReturnsAsync(returnedAccountNumbers).Verifiable();

            var results = await _agreeService.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(DateTime.Now);

            var resultsList = results.ToList();
            Assert.NotNull(results);
            Assert.AreEqual(2, resultsList.Count);

            var firstResult = resultsList.First();
            Assert.AreEqual(firstResult, 12345L);

            var secondResult = resultsList.Last();
            Assert.AreEqual(secondResult, 12346L);
            _mockAgreeDao.Verify();
        }

        [Test]
        public void AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained_Exception()
        {
            _mockAgreeDao.Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(DateTime.Now));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public async Task AuditOrganizationChangesByDateLastMaintained_OK()
        {
            var returnedAccountNumbers = new List<long>
            {
                12345,
                12346
            };

            _mockAgreeDao
                .Setup(x => x.AuditAccountOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()))
                .ReturnsAsync(returnedAccountNumbers).Verifiable();

            var results = await _agreeService.AuditOrganizationChangesByDateLastMaintained(DateTime.Now);

            var resultsList = results.ToList();
            Assert.NotNull(results);
            Assert.AreEqual(2, resultsList.Count);

            var firstResult = resultsList.First();
            Assert.AreEqual(firstResult, 12345L);

            var secondResult = resultsList.Last();
            Assert.AreEqual(secondResult, 12346L);
            _mockAgreeDao.Verify();
        }

        [Test]
        public void AuditOrganizationChangesByDateLastMaintained_Exception()
        {
            _mockAgreeDao.Setup(x => x.AuditAccountOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.AuditOrganizationChangesByDateLastMaintained(DateTime.Now));
            _mockAgreeDao.Verify();
        }
        
        [Test]
        public async Task AuditAgreementChangesByDateLastMaintained_OK()
        {
            var returnedAccountNumbers = new List<long>
            {
                12345,
                12346
            };

            _mockAgreeDao
                .Setup(x => x.AuditAccountAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()))
                .ReturnsAsync(returnedAccountNumbers).Verifiable();

            var results = await _agreeService.AuditAgreementChangesByDateLastMaintained(DateTime.Now);

            var resultsList = results.ToList();
            Assert.NotNull(results);
            Assert.AreEqual(2, resultsList.Count);

            var firstResult = resultsList.First();
            Assert.AreEqual(firstResult, 12345L);

            var secondResult = resultsList.Last();
            Assert.AreEqual(secondResult, 12346L);
            _mockAgreeDao.Verify();
        }

        [Test]
        public void AuditAgreementChangesByDateLastMaintained_Exception()
        {
            _mockAgreeDao.Setup(x => x.AuditAccountAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()))
                .Throws(new Exception("Exception from unit test")).Verifiable();

            Assert.ThrowsAsync<Exception>(async () => await _agreeService.AuditAgreementChangesByDateLastMaintained(DateTime.Now));
            _mockAgreeDao.Verify();
        }
    }
}