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

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

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class PersonServiceTest
    {
        private readonly PersonService _personService;
        private readonly Mock<IPersonDao> _mockPersonDao;

        public PersonServiceTest()
        {
            _mockPersonDao = new Mock<IPersonDao>();
            _personService = new PersonService(_mockPersonDao.Object);
        }

        [Test]
        public async Task GetPersonsByName_Returns_Person()
        {            
            var coreRequestParameters = new CoreRequestParameters();
            var personNameRequest = new PersonNameRequest
            {
                FirstName = "Tester"
            };

            var testPersonResult = new Person
            {
                PersonNumber = 1,
                FirstName = "Tester",
                MiddleName = "Person",
                LastName = "Guy",
                NameFull = "Tester Person Guy",
                Suffix = "",
                TaxId = "1231232132",
                BirthDate = "1/1/2021"
            };
            var testPersonsResult = new List<Person> { testPersonResult };

            _mockPersonDao.Setup(x => x.FindByPersonsName(It.IsAny<CoreRequestParameters>(),
                                                          It.IsAny<PersonNameRequest>())).ReturnsAsync(testPersonsResult);

            var results = await _personService.GetPersonsByName(coreRequestParameters, personNameRequest);

            Assert.NotNull(results);
            Assert.AreEqual(1, results.ToList().Count);
            var result = results.FirstOrDefault();

            Assert.AreEqual(1, result.PersonNumber);
            Assert.AreEqual("Tester", result.FirstName);
            Assert.AreEqual("Person", result.MiddleName);
            Assert.AreEqual("Guy", result.LastName);
            Assert.AreEqual("1231232132", result.TaxId);
            Assert.AreEqual("1/1/2021", result.BirthDate);
        }

        [Test]
        public void GetPersonsByName_Exception_Returns_Null()
        {
            var coreRequestParameters = new CoreRequestParameters();
            var personNameRequest = new PersonNameRequest
            {
                FirstName = "Tester"
            };

            _mockPersonDao.Setup(x => x.FindByPersonsName(It.IsAny<CoreRequestParameters>(),
                                                          It.IsAny<PersonNameRequest>())).Throws(new Exception());

            Assert.ThrowsAsync<Exception>(() => _personService.GetPersonsByName(coreRequestParameters, personNameRequest));
        }

        [Test]
        public async Task GetPersonsBySearch_Returns_Person()
        {
            var coreRequestParameters = new CoreRequestParameters();
            var personSearchRequest = new PersonSearchRequest
            {
                PersNbr = 1
            };

            var testPersonResult = new Person
            {
                PersonNumber = 1,
                FirstName = "Tester",
                MiddleName = "Person",
                LastName = "Guy",
                NameFull = "Tester Person Guy",
                Suffix = "",
                TaxId = "1231232132",
                BirthDate = "1/1/2021"
            };
            var testPersonsResult = new List<Person> { testPersonResult };

            _mockPersonDao.Setup(x => x.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(),
                                                          It.IsAny<PersonSearchRequest>())).ReturnsAsync(testPersonsResult);

            var results = await _personService.GetPersonsBySearch(coreRequestParameters, personSearchRequest);

            Assert.NotNull(results);
            Assert.AreEqual(1, results.ToList().Count);
            var result = results.FirstOrDefault();

            Assert.AreEqual(1, result.PersonNumber);
            Assert.AreEqual("Tester", result.FirstName);
            Assert.AreEqual("Person", result.MiddleName);
            Assert.AreEqual("Guy", result.LastName);
            Assert.AreEqual("1231232132", result.TaxId);
            Assert.AreEqual("1/1/2021", result.BirthDate);
        }

        [Test]
        public void GetPersonsBySearch_Exception_Returns_Null()
        {
            var coreRequestParameters = new CoreRequestParameters();
            var personSearchRequest = new PersonSearchRequest
            {
                FirstName = "Tester"
            };

            _mockPersonDao.Setup(x => x.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(),
                                                            It.IsAny<PersonSearchRequest>())).Throws(new Exception());

            Assert.ThrowsAsync<Exception>(() => _personService.GetPersonsBySearch(coreRequestParameters, personSearchRequest));
        }


        [Test]
        public async Task GetPersonsByMemberAgreementNbr_Returns_Person()
        {
            var coreRequestParameters = new CoreRequestParameters();
            var personMemberAgreementNbrRequest = new MemberNbrRequest
            {
                MemberNbr = 100
            };

            var testPersonResult = new Person
            {
                PersonNumber = 1,
                FirstName = "Tester",
                MiddleName = "Person",
                LastName = "Guy",
                NameFull = "Tester Person Guy",
                Suffix = "",
                TaxId = "1231232132",
                BirthDate = "1/1/2021"
            };

            _mockPersonDao.Setup(x => x.FindByPersonMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                          It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);

            var result = await _personService.GetPersonsByMemberAgreementNbr(coreRequestParameters, personMemberAgreementNbrRequest);

            Assert.NotNull(result);

            Assert.AreEqual(1, result.PersonNumber);
            Assert.AreEqual("Tester", result.FirstName);
            Assert.AreEqual("Person", result.MiddleName);
            Assert.AreEqual("Guy", result.LastName);
            Assert.AreEqual("1231232132", result.TaxId);
            Assert.AreEqual("1/1/2021", result.BirthDate);
        }

        [Test]
        public void GetPersonsByMemberAgreementNbr_Exception_Returns_Null()
        {
            var coreRequestParameters = new CoreRequestParameters();
            var personMemberAgreementNbrRequest = new MemberNbrRequest
            {
                MemberNbr = 100
            };

            _mockPersonDao.Setup(x => x.FindByPersonMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                            It.IsAny<MemberNbrRequest>())).Throws(new Exception());

            Assert.ThrowsAsync<Exception>(() => _personService.GetPersonsByMemberAgreementNbr(coreRequestParameters, personMemberAgreementNbrRequest));
        }

        [Test]
        public async Task GetPersonByMemberAgreementNbr_Returns_Person()
        {
            var testPersonResult = PersonFactory();

            _mockPersonDao.Setup(x => x.FindByPersonMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
                                                          It.Is<MemberNbrRequest>(request => request.MemberNbr == 12345))).ReturnsAsync(testPersonResult).Verifiable();

            var result = await _personService.GetMemberByMemberAgreeNbr(12345);

            Assert.NotNull(result);
            Assert.AreEqual(testPersonResult.FirstName, result.FirstName);
            _mockPersonDao.Verify();
        }

        [Test]
        public async Task GetPersonsByNameLike_LimitSupplied_GetsUpToLimitPersons()
        {
            var request = PersonNameRequestFactory();
            var limit = DateTime.Now.Millisecond;
            var people = Enumerable.Repeat<Func<Person>>(PersonFactory, limit).Select(f => f()).ToArray();
            _mockPersonDao
                .Setup(d => d.GetPersonNumbersByNameLike(request.FirstName, request.MdlName, request.LastName, limit))
                .ReturnsAsync(people.Select(p => (long)p.PersonNumber));
            _mockPersonDao
                .Setup(d => d.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<PersonSearchRequest>()))
                .Returns<CoreRequestParameters, PersonSearchRequest>((_, search) => Task.FromResult(people.Where(p => search.PersNbr == p.PersonNumber)));

            var actualPeople = await _personService.GetPersonsByNameLike(request, limit);
            
            CollectionAssert.AreEquivalent(people, actualPeople);
        }
        
        [Test]
        public async Task GetPersonsByNameLike_LimitNotSupplied_GetsUpTo1000Persons()
        {
            var request = PersonNameRequestFactory();
            var people = Enumerable.Repeat<Func<Person>>(PersonFactory, 1000).Select(f => f()).ToArray();
            _mockPersonDao
                .Setup(d => d.GetPersonNumbersByNameLike(request.FirstName, request.MdlName, request.LastName, 1000))
                .ReturnsAsync(people.Select(p => (long)p.PersonNumber));
            _mockPersonDao
                .Setup(d => d.FindByPersonsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<PersonSearchRequest>()))
                .Returns<CoreRequestParameters, PersonSearchRequest>((_, search) => Task.FromResult(people.Where(p => search.PersNbr == p.PersonNumber)));

            var actualPeople = await _personService.GetPersonsByNameLike(request, null);
            
            CollectionAssert.AreEquivalent(people, actualPeople);
        }
        
        [Test]
        public async Task CountPersonsByNameLike_AllCases_ReturnsPersonDaoCount()
        {
            var request = PersonNameRequestFactory();
            var count = DateTime.Now.Millisecond;
            _mockPersonDao
                .Setup(d => d.CountPersonsByNameLike(request.FirstName, request.MdlName, request.LastName))
                .ReturnsAsync(count);

            var actualCount = await _personService.CountPersonsByNameLike(request);
            
            Assert.AreEqual(count, actualCount);
        }

        private static PersonNameRequest PersonNameRequestFactory()
            => new()
            {
                FirstName = Guid.NewGuid().ToString(),
                MdlName = Guid.NewGuid().ToString(),
                LastName = Guid.NewGuid().ToString()
            };

        private static Random _personNumberSeries = new(DateTime.Now.Millisecond);
        private static Person PersonFactory()
        {
            return new Person
            {
                FirstName = "Test Organization",
                PersonNumber = _personNumberSeries.Next()
            };
        }
    }
}