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

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

namespace LCU.Api.Internal.CoreApiWrapperTest.Service
{
    public class AgreePersonServiceTest
    {
        private AgreePersonService _agreePersonService;
        private Mock<IAgreePersonDao> _mockAgreePersonDao;

        [SetUp]
        public void SetUp()
        {
            _mockAgreePersonDao = new Mock<IAgreePersonDao>();
            _agreePersonService = new AgreePersonService(_mockAgreePersonDao.Object);
        }

        [Test]
        public async Task GetByUserId_OK()
        {
            _mockAgreePersonDao.Setup(x => x.FindByUserId(It.IsAny<string>())).ReturnsAsync(
                new AgreePerson()
                {
                    AgreeNumber = 100,
                    PersonNumber = 10,
                    UserId = "1"
                }).Verifiable();

            var result = await _agreePersonService.GetByUserId("1");

            Assert.NotNull(result);
            Assert.AreEqual(100, result.AgreeNumber);
            Assert.AreEqual(10, result.PersonNumber);
            Assert.AreEqual("1", result.UserId);
        }

        [Test]
        public void GetByUserId_Exception()
        {
            _mockAgreePersonDao.Setup(x => x.FindByUserId(It.IsAny<string>())).Throws(new Exception("Dang"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _agreePersonService.GetByUserId("1"));
        }

        [Test]
        public async Task GetAgreePersonsWithHyphenatedUserId_OK()
        {
            _mockAgreePersonDao.Setup(x => x.FindAgreePersonsWithHyphenatedUserId()).ReturnsAsync(
                new List<AgreePerson>()
                {
                    new AgreePerson()
                    {
                        AgreeNumber = 100,
                        PersonNumber = 10,
                        UserId = "1-1"
                    },
                    new AgreePerson()
                    {
                        AgreeNumber = 200,
                        PersonNumber = 20,
                        UserId = "2-2"
                    }
                }).Verifiable();

            var results = await _agreePersonService.GetAgreePersonsWithHyphenatedUserId();

            Assert.NotNull(results);
            Assert.AreEqual(2, results.Count());
            var result1 = results.FirstOrDefault();
            Assert.AreEqual(100, result1.AgreeNumber);
            Assert.AreEqual(10, result1.PersonNumber);
            Assert.AreEqual("1-1", result1.UserId);
        }

        [Test]
        public void GetAgreePersonsWithHyphenatedUserId_Exception()
        {
            _mockAgreePersonDao.Setup(x => x.FindAgreePersonsWithHyphenatedUserId())
                                .Throws(new Exception("Dang"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _agreePersonService.GetAgreePersonsWithHyphenatedUserId());
        }

        [Test]
        public async Task GetActiveCustodialVruCardAgreementAgreePersons_OK()
        {
            _mockAgreePersonDao.Setup(x => x.FindActiveCustodialVruCardAgreementAgreePersons()).ReturnsAsync(
                new List<AgreePerson>()
                {
                    new AgreePerson()
                    {
                        AgreeNumber = 100,
                        PersonNumber = 10,
                        UserId = "11"
                    },
                    new AgreePerson()
                    {
                        AgreeNumber = 200,
                        PersonNumber = 20,
                        UserId = null
                    }
                }).Verifiable();

            var results = await _agreePersonService.GetActiveCustodialVruCardAgreementAgreePersons();

            Assert.NotNull(results);
            Assert.AreEqual(2, results.Count());
            var result1 = results.FirstOrDefault();
            Assert.AreEqual(100, result1.AgreeNumber);
            Assert.AreEqual(10, result1.PersonNumber);
            Assert.AreEqual("11", result1.UserId);
        }

        [Test]
        public void GetActiveCustodialVruCardAgreementAgreePersons_Exception()
        {
            _mockAgreePersonDao.Setup(x => x.FindActiveCustodialVruCardAgreementAgreePersons())
                                .Throws(new Exception("Dang"));

            Assert.ThrowsAsync<Exception>(async () =>
                await _agreePersonService.GetActiveCustodialVruCardAgreementAgreePersons());
        }

        [Test]
        public async Task UpdatePersonAgreementDetailTypes_OK()
        {
            _mockAgreePersonDao.Setup(x => x.UpdatePersonAgreementDetailTypes(It.IsAny<PersonAgreementDetailTypeRequest>())).ReturnsAsync(
                new BasicResponse
                {
                    Success = true,
                    Errors = new List<string>()
                }).Verifiable();

            var personAgreementDetailTypeRequest = new PersonAgreementDetailTypeRequest()
            {
                PersonNumber = 1,
                AgreeNumber = 2,
                AgreeTypeCode = "VRUTEST",
                DetailTypes = new List<DetailType>()
                {
                    new DetailType()
                    {
                        DetailTypeCode = "STATUSTEST",
                        DetailValue = "CLOSTEST"
                    }
                }
            };
            var result = await _agreePersonService.UpdatePersonAgreementDetailTypes(personAgreementDetailTypeRequest);

            Assert.NotNull(result);
            Assert.IsTrue(result.Success);
            Assert.IsEmpty(result.Errors);
        }

        [Test]
        public void UpdatePersonAgreementDetailTypes_Exception()
        {
            _mockAgreePersonDao.Setup(x => x.UpdatePersonAgreementDetailTypes(It.IsAny<PersonAgreementDetailTypeRequest>()))
                                .Throws(new Exception("Dang"));

            var personAgreementDetailTypeRequest = new PersonAgreementDetailTypeRequest()
            {
                PersonNumber = 1,
                AgreeNumber = 2,
                AgreeTypeCode = "VRUTEST",
                DetailTypes = new List<DetailType>()
                {
                    new DetailType()
                    {
                        DetailTypeCode = "STATUSTEST",
                        DetailValue = "CLOSTEST"
                    }
                }
            };
            Assert.ThrowsAsync<Exception>(async () =>
                await _agreePersonService.UpdatePersonAgreementDetailTypes(personAgreementDetailTypeRequest));
        }
    }
}