monorepo/LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/OrganizationServiceTest.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.Organizations;
using LCU.Library.Internal.Exceptions;

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class OrganizationServiceTest
    {
        private readonly IOrganizationService _organizationService;
        private readonly Mock<IOrganizationDao> _mockOrganizationDao;

        public OrganizationServiceTest()
        {
            _mockOrganizationDao = new Mock<IOrganizationDao>();

            _organizationService = new OrganizationService(_mockOrganizationDao.Object);
        }
        
        [Test]
        public async Task GetOrganizationByOrganizationNumber_Returns_Organization()
        {
            var testOrganizationResult = OrganizationFactory();
            var testOrganizationsResult = new List<Organization> { testOrganizationResult };

            _mockOrganizationDao.Setup(x => x.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(),
                                                          It.Is<OrganizationSearchRequest>(request => request.OrgNbr == 1234))).ReturnsAsync(testOrganizationsResult).Verifiable();

            var results = await _organizationService.GetOrganizationByOrganizationNumber(1234);

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

            Assert.AreEqual(testOrganizationResult.Name, result?.Name);
            _mockOrganizationDao.Verify();
        }
        
        [Test]
        public void GetOrganizationByOrganizationNumber_Exception_ThrowsServiceException()
        {
           
            _mockOrganizationDao.Setup(x => x.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(),
                It.Is<OrganizationSearchRequest>(request => request.OrgNbr == 1234))).ThrowsAsync(new Exception("Exception thrown from unit test.")).Verifiable();

            Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByOrganizationNumber(1234));
            _mockOrganizationDao.Verify();
        }
        
        [Test]
        public async Task GetOrganizationByMemberAgreementNbr_Returns_Organization()
        {
            var testOrganizationResult = OrganizationFactory();

            _mockOrganizationDao.Setup(x => x.FindOrganizationByMemberAgreeNbr(It.IsAny<CoreRequestParameters>(),
                                                          It.Is<MemberNbrRequest>(request => request.MemberNbr == 12345))).ReturnsAsync(testOrganizationResult).Verifiable();

            var result = await _organizationService.GetMemberByMemberAgreeNbr(12345);

            Assert.NotNull(result);
            Assert.AreEqual(testOrganizationResult.Name, result.Name);
            _mockOrganizationDao.Verify();
        }

        [Test]
        public void GetOrganizationByMemberAgreementNbr_Exception_ThrowsServiceException()
        {
            _mockOrganizationDao.Setup(x => x.FindOrganizationByMemberAgreeNbr(It.IsAny<CoreRequestParameters>(),
                It.Is<MemberNbrRequest>(request => request.MemberNbr == 12345))).ThrowsAsync(new Exception("Exception thrown from unit test")).Verifiable();

            Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetMemberByMemberAgreeNbr(12345));
            _mockOrganizationDao.Verify();
        }

        [Test]
        public void GetOrganizationByName_SearchThrowsException_ThrowsServiceException()
        {
            var organizationName = Guid.NewGuid().ToString();
            var searchException = new Exception(Guid.NewGuid().ToString());
            _mockOrganizationDao
                .Setup(o => o.FindByOrganizationsSearch
                (
                    It.IsAny<CoreRequestParameters>(),
                    It.Is<OrganizationSearchRequest>(r => r.OrgName == organizationName)
                ))
                .ThrowsAsync(searchException);

            var thrownException = Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByName(organizationName));

            StringAssert.Contains(organizationName, thrownException.Message);
        }

        [Test]
        public async Task GetOrganizationByName_SearchSucceeds_ReturnsResults()
        {
            var organizationName = Guid.NewGuid().ToString();
            var actualOrganizations = new[]
            {
                OrganizationFactory()
            };
            _mockOrganizationDao
                .Setup(o => o.FindByOrganizationsSearch
                (
                    It.IsAny<CoreRequestParameters>(),
                    It.Is<OrganizationSearchRequest>(r => r.OrgName == organizationName)
                ))
                .ReturnsAsync(actualOrganizations);

            var organizations = await _organizationService.GetOrganizationByName(organizationName);

            Assert.AreSame(actualOrganizations, organizations);
        }

        [Test]
        public async Task GetOrganizationByNameLike_DaoReturnsOrgNumbersAndOrgsForNumbers_ReturnsOrganizations()
        {
            var organizationName = Guid.NewGuid().ToString();
            var partialName = organizationName[5..^5];
            var organizations = new []
            {
                OrganizationFactory(organizationName),
                OrganizationFactory(),
                OrganizationFactory(organizationName)
            };
            var nameMatchedOrganizations = organizations
                .Where(o => o.Name == organizationName)
                .ToArray();
            var limit = nameMatchedOrganizations.Length / 2;
            _mockOrganizationDao
                .Setup(dao => dao.FindOrganizationNumbersByNameSearch(It.IsAny<string>(), It.IsAny<int>()))
                .Returns<string, int>((name, count) => Task.FromResult(organizations.Where(o => o.Name.Contains(name)).Take(count).Select(o => o.OrganizationNumber)));
            _mockOrganizationDao
                .Setup(dao => dao.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<OrganizationSearchRequest>()))
                .Returns<CoreRequestParameters, OrganizationSearchRequest>((_, search) => Task.FromResult(nameMatchedOrganizations.Where(o => search.OrgNbr == o.OrganizationNumber)));

            var foundOrganizations = await _organizationService.GetOrganizationByNameLike(partialName, limit);

            CollectionAssert.AreEquivalent(nameMatchedOrganizations.Take(limit), foundOrganizations);
        }

        [Test]
        public void GetOrganizationByNameLike_DaoThrowsFromFindOrganizationNumbersByNameSearch_ThrowsServiceException()
        {
            var organizationName = Guid.NewGuid().ToString();
            var limit = DateTime.Now.Millisecond;
            _mockOrganizationDao
                .Setup(dao => dao.FindOrganizationNumbersByNameSearch(organizationName, limit))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByNameLike(organizationName, limit));
        }

        [Test]
        public void GetOrganizationByNameLike_DaoThrowsFromFindByOrganizationsSearch_ThrowsServiceException()
        {
            var organizationName = Guid.NewGuid().ToString();
            var limit = DateTime.Now.Millisecond;
            var organizations = new []
            {
                OrganizationFactory(organizationName),
                OrganizationFactory(),
                OrganizationFactory(organizationName)
            };
            _mockOrganizationDao
                .Setup(dao => dao.FindOrganizationNumbersByNameSearch(It.IsAny<string>(), It.IsAny<int>()))
                .Returns<string, int>((name, count) => Task.FromResult(organizations.Where(o => o.Name.Contains(name)).Take(count).Select(o => o.OrganizationNumber)));
            _mockOrganizationDao
                .Setup(dao => dao.FindByOrganizationsSearch(It.IsAny<CoreRequestParameters>(), It.IsAny<OrganizationSearchRequest>()))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<ServiceException>(() => _organizationService.GetOrganizationByNameLike(organizationName, limit));
        }
        
        [Test]
        public async Task CountOrganizationNumbersByName_DaoReturnsCount_ReturnsCount()
        {
            var organizationName = Guid.NewGuid().ToString();
            var partialName = organizationName[5..^5];
            var organizations = new []
            {
                OrganizationFactory(organizationName),
                OrganizationFactory(),
                OrganizationFactory(organizationName)
            };
            var nameMatchedOrganizations = organizations
                .Where(o => o.Name == organizationName)
                .ToArray();
            _mockOrganizationDao
                .Setup(dao => dao.CountOrganizationNumbersByName(It.IsAny<string>()))
                .Returns<string>(name => Task.FromResult<long>(organizations.Count(o => o.Name.Contains(name))));

            var count = await _organizationService.CountOrganizationNumbersByName(partialName);

            Assert.AreEqual(count, nameMatchedOrganizations.Length);
        }

        [Test]
        public void CountOrganizationNumbersByName_DaoThrowsFromCountOrganizationNumbersByName_ThrowsServiceException()
        {
            var organizationName = Guid.NewGuid().ToString();
            _mockOrganizationDao
                .Setup(dao => dao.CountOrganizationNumbersByName(organizationName))
                .ThrowsAsync(new Exception());

            Assert.ThrowsAsync<ServiceException>(() => _organizationService.CountOrganizationNumbersByName(organizationName));
        }

        private static Random _organizationNumberSeries = new Random(DateTime.Now.Millisecond);

        private static Organization OrganizationFactory(string name = null, long? number = null)
        {
            return new Organization
            {
                Name = name ?? "Test Organization",
                OrganizationNumber = number ?? _organizationNumberSeries.Next()
            };
        }
    }
}