Adding

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/AccessChannelPersonsControllerTest.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessChannelPersons;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class AccessChannelPersonsControllerTest
+    {
+        private AccessChannelPersonsController _accessChannelPersonsController;
+        private Mock<IAccessChannelPersonsService> _mockAccessChannelPersonsService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockAccessChannelPersonsService = new Mock<IAccessChannelPersonsService>();
+            _accessChannelPersonsController = new AccessChannelPersonsController(_mockAccessChannelPersonsService.Object);
+        }
+
+        [Test]
+        public async Task GetAccessChannelPersons_OK()
+        {
+            var response = new List<AccessChannelPerson>()
+            {
+                new AccessChannelPerson()
+                {
+                    ChannelNumber = 1,
+                    PersonNumber = 2,
+                    UserId = "3"
+                },
+                new AccessChannelPerson()
+                {
+                    ChannelNumber = 4,
+                    PersonNumber = 25,
+                    UserId = "6"
+                }
+            };
+            var coreMessageHeader = new CoreMessageHeader(323000000000);
+            var coreApiMessage = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageHeader, response);
+
+            _mockAccessChannelPersonsService.Setup(x => x.GetAccessChannelPersonCoreApiResponseAsync(It.IsAny<AccessChannelPersonsByPersonRequest>()))
+                                                .ReturnsAsync(coreApiMessage);
+
+            var request = new AccessChannelPersonsByPersonRequest()
+            {
+                PersonNumber = 2
+            };
+            var results = await _accessChannelPersonsController.Get(request);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetAccessChannelPersons_Exception()
+        {
+            _mockAccessChannelPersonsService.Setup(x => x.GetAccessChannelPersonCoreApiResponseAsync(It.IsAny<AccessChannelPersonsByPersonRequest>()))
+                                                .Throws(new Exception("Oops"));
+
+            var request = new AccessChannelPersonsByPersonRequest()
+            {
+                PersonNumber = 2
+            };
+            var results = await _accessChannelPersonsController.Get(request);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task PutAccessChannelPerson_OK()
+        {
+            var response = new AccessChannelPerson()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                UserId = "3"
+            };
+            _mockAccessChannelPersonsService.Setup(x => x.UpdateAccessChannelPersonAsync(It.IsAny<AccessChannelPerson>(),
+                                                                                         It.IsAny<long>()))
+                                                .ReturnsAsync(response);
+
+            var request = new AccessChannelPerson()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                UserId = "3"
+            };
+            var results = await _accessChannelPersonsController.Put(request, 343432432400000000);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutAccessChannelPerson_Exception()
+        {
+            _mockAccessChannelPersonsService.Setup(x => x.UpdateAccessChannelPersonAsync(It.IsAny<AccessChannelPerson>(),
+                                                                                        It.IsAny<long>()))
+                                                .Throws(new Exception("Oops"));
+
+            var request = new AccessChannelPerson()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                UserId = "3"
+            };
+            var results = await _accessChannelPersonsController.Put(request, 343432432400000000);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/AccessTypeControllerTest.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessChannelPersons;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.AccessTypes;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class AccessTypeControllerTest
+    {
+        private AccessTypeController _accessTypeController;
+        private Mock<IAccessTypeService> _mockAccessTypeService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockAccessTypeService = new Mock<IAccessTypeService>();
+            _accessTypeController = new AccessTypeController(_mockAccessTypeService.Object);
+        }
+
+        [Test]
+        public async Task PutAccessType_OK()
+        {
+            var response = new AccessType()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                Id = "WWW"
+            };
+            _mockAccessTypeService.Setup(x => x.UpdateAccessTypeAsync(It.IsAny<AccessTypeUpdateRequest>()))
+                                                .ReturnsAsync(response);
+
+            var request = new AccessTypeUpdateRequest()
+            {
+                AccessType = new AccessType()
+                {
+                    ChannelNumber = 1,
+                    PersonNumber = 2,
+                    Id = "WWW"
+                },
+                UpdateKey = 12321312312,
+                AccessChannelPersonId = "1_2"
+
+            };
+            var results = await _accessTypeController.Put(request);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutAccessChannelPerson_Exception()
+        {
+            _mockAccessTypeService.Setup(x => x.UpdateAccessTypeAsync(It.IsAny<AccessTypeUpdateRequest>()))
+                                                .Throws(new Exception("Oops"));
+
+            var request = new AccessTypeUpdateRequest()
+            {
+                AccessType = new AccessType()
+                {
+                    ChannelNumber = 1,
+                    PersonNumber = 2,
+                    Id = "WWW"
+                },
+                UpdateKey = 12321312312,
+                AccessChannelPersonId = "1_2"
+
+            };
+            var results = await _accessTypeController.Put(request);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/AccountControllerTest.cs

@@ -0,0 +1,621 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using System.Threading.Tasks;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Account;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class AccountControllerTest
+    {
+        private AccountController _accountController;
+        private Mock<IAccountService> _mockAccountService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockAccountService = new Mock<IAccountService>();
+            _accountController = new AccountController(_mockAccountService.Object);
+        }
+
+        [Test]
+        public async Task AccountMaintenanceRequest_OK()
+        {
+            var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
+            {
+                new() {
+                AccountNumber = 123,
+                DeliveryMethod = "PRNT"
+                }
+            };
+            
+            var results = await _accountController.AccountMaintenanceRequest(accountMaintenanceRequest);
+
+            _mockAccountService.Verify(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest), Times.Once);
+
+            Assert.NotNull(results);
+            var okResult = results as OkResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task AccountMaintenanceRequest_Exception()
+        {
+            var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
+            {
+                new() {
+                    AccountNumber = 123,
+                    DeliveryMethod = "PRNT"
+                }
+            };
+            
+            _mockAccountService.Setup(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest)).Throws(new Exception("Oops")).Verifiable();
+
+            var results = await _accountController.AccountMaintenanceRequest(accountMaintenanceRequest);
+
+            _mockAccountService.Verify();
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetActivityAccountDetailsByAccountNumber_OK()
+        {
+            _mockAccountService.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<long>>()))
+                .ReturnsAsync(new List<ActivityAccountDetails>()
+                {
+                    new() { AccountNumber = 1 },
+                    new() { AccountNumber = 1 },
+                    new() { AccountNumber = 1 },
+                });
+
+           var res = await _accountController.GetActivityAccountDetailsByAccountNumber(new ActivityAccountDetailsRequest() { AccountNumbers = new List<long>(){1, 2, 3 }});
+           Assert.NotNull(res);
+           var okres = res as OkObjectResult;
+           Assert.NotNull(okres);
+           Assert.AreEqual(200, okres.StatusCode);
+        }
+        
+        
+        [Test]
+        public async Task GetActivityAccountDetailsByAccountNumber_Exception()
+        {
+            _mockAccountService.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<long>>())).ThrowsAsync(new Exception("Oops"));
+            var res = await _accountController.GetActivityAccountDetailsByAccountNumber(
+                (new ActivityAccountDetailsRequest() { AccountNumbers = new List<long>() { 1, 2, 3 } }));
+            Assert.NotNull(res);
+            var badRes = res as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);;
+        }
+
+        [Test]
+        public async Task GetOwnersByAccountNumber_OK()
+        {
+            var accountNumber = 12345;
+            var createdDate = new DateTime(1900, 1, 1);
+
+            _mockAccountService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, createdDate)).ReturnsAsync(
+                new List<AccountOwnership>() {
+                    new ()
+                    {
+                        IsPrimaryOwner = true,
+                        PersonNumber = 12345,
+                        ByOrgNbr = 45678
+                    },
+                    new ()
+                    {
+                        IsPrimaryOwner = false,
+                        PersonNumber = 09876,
+                        ByOrgNbr = 98765
+                    },
+                }).Verifiable();
+
+            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate.ToShortDateString());
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as List<AccountOwnership>;
+            Assert.NotNull(result);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetOwnersByAccountNumber_NoContent()
+        {
+            var accountNumber = 12345;
+            var createdDate = new DateTime(1900, 1, 1);
+
+            _mockAccountService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, createdDate)).ReturnsAsync((List<AccountOwnership>)null).Verifiable();
+
+            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate.ToShortDateString());
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetOwnersByAccountNumber_Error_StatusServerError()
+        {
+            var accountNumber = 12345;
+            var createdDate = new DateTime(1900, 1, 1);
+
+            _mockAccountService.Setup(x => x.GetOwnersByAccountNumber(accountNumber, createdDate)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+
+            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate.ToShortDateString());
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetOwnersByAccountNumber_Null_BadRequest()
+        {
+            var accountNumber = 12345;
+            var createdDate = "Not a date";
+
+            var results = await _accountController.GetOwnersByAccountNumber(accountNumber, createdDate);
+
+            _mockAccountService.Verify(x => x.GetOwnersByAccountNumber(It.IsAny<long>(), It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByPersonName_OK()
+        {
+            var personName = "Pete Peterson";
+
+            _mockAccountService.Setup(x => x.GetPrimaryOwnersByPersonName(personName)).ReturnsAsync(
+                new List<AccountOwnership>() {
+                    new ()
+                    {
+                        IsPrimaryOwner = true,
+                        FirstName = "Pete",
+                        LastName = "Peterson"
+                    }
+                }).Verifiable();
+
+            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as List<AccountOwnership>;
+            Assert.NotNull(result);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByPersonName_NoContent()
+        {
+            var personName = "Pete Peterson";
+
+            _mockAccountService.Setup(x => x.GetPrimaryOwnersByPersonName(personName)).ReturnsAsync((List<AccountOwnership>)null).Verifiable();
+
+            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByPersonName_Error_StatusServerError()
+        {
+            var personName = "Pete Peterson";
+
+            _mockAccountService.Setup(x => x.GetPrimaryOwnersByPersonName(personName)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+
+            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByPersonName_Null_BadRequest()
+        {
+            var personName = "";
+
+            var results = await _accountController.GetPrimaryOwnersByPersonName(personName);
+
+            _mockAccountService.Verify(x => x.GetPrimaryOwnersByPersonName(It.IsAny<string>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByOrganizationName_OK()
+        {
+            var organizationName = "The Big Company";
+
+            _mockAccountService.Setup(x => x.GetPrimaryOwnersByOrganizationName(organizationName)).ReturnsAsync(
+                new List<AccountOwnership>() {
+                    new ()
+                    {
+                        IsPrimaryOwner = true,
+                        OrganizationName = "The Big Company"
+                    }
+                }).Verifiable();
+
+            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as List<AccountOwnership>;
+            Assert.NotNull(result);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByOrganizationName_NoContent()
+        {
+            var organizationName = "The Big Company";
+
+            _mockAccountService.Setup(x => x.GetPrimaryOwnersByOrganizationName(organizationName)).ReturnsAsync((List<AccountOwnership>)null).Verifiable();
+
+            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByOrganizationName_Error_StatusServerError()
+        {
+            var organizationName = "The Big Company";
+
+            _mockAccountService.Setup(x => x.GetPrimaryOwnersByOrganizationName(organizationName)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+
+            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByOrganizationName_Null_BadRequest()
+        {
+            var organizationName = "";
+
+            var results = await _accountController.GetPrimaryOwnersByOrganizationName(organizationName);
+
+            _mockAccountService.Verify(x => x.GetPrimaryOwnersByOrganizationName(It.IsAny<string>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+
+        [Test]
+        public async Task GetAccountsForGroupMaintenance_OK()
+        {
+            _mockAccountService.Setup(x => x.GetAccountsForGroupAnalysisMaintenance()).ReturnsAsync(
+                new List<string>() {
+                        "1111111",
+                        "22222222"
+                }).Verifiable();
+
+            var results = await _accountController.GetAccountsForGroupAnalysisMaintenance();
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as List<string>;
+            Assert.NotNull(result);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetAccountsForGroupMaintenance_Error_StatusServerError()
+        {
+            _mockAccountService.Setup(x => x.GetAccountsForGroupAnalysisMaintenance()).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+
+            var results = await _accountController.GetAccountsForGroupAnalysisMaintenance();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task UpdateAccountGroupMaintenanceRequest_OK()
+        {
+            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
+            {
+                AccountNumber = 123,
+                IsGenerateAnalysisStatement = true,
+                IsPrintAnalysisStatement = true,
+                IsUseForServiceCharge = true
+            };
+
+            var results = await _accountController.PutAccountAnalysisGroup(accountAnalysisGroupMaintenanceRequest);
+
+            _mockAccountService.Verify(x => x.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest), Times.Once);
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task UpdateAccountGroupMaintenanceRequest_Exception()
+        {
+            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
+            {
+                AccountNumber = 123,
+                IsGenerateAnalysisStatement = true,
+                IsPrintAnalysisStatement = true,
+                IsUseForServiceCharge = true
+            };
+
+            _mockAccountService.Setup(x => x.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest)).Throws(new Exception("Oops")).Verifiable();
+            var results = await _accountController.PutAccountAnalysisGroup(accountAnalysisGroupMaintenanceRequest);
+            _mockAccountService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes); 
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task AccountNickNameUpdateRequest_OK()
+        {
+            var accountRequest = new AccountNickNameUpdateRequest
+            {
+                AccountNumber = 123,
+                AccountDescription = "TestOk"
+            };
+
+            var results = await _accountController.PutAccountNickNameUpdateRequest(accountRequest);
+
+            _mockAccountService.Verify(x => x.UpdateAccountNickName(accountRequest), Times.Once);
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonNumberByAccountNumber_OK()
+        {
+            long accountNumber = 1234;
+
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(accountNumber)).ReturnsAsync(
+                new Account() {
+                        AccountNumber = 1234,
+                        ReportingForPersonNumber = 5678
+                }).Verifiable();
+
+            
+            var results = await _accountController.GetAccountByAccountNumber(accountNumber);
+
+            _mockAccountService.Verify(x => x.GetAccountDetailsByAccountNumber(accountNumber), Times.Once);
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task AccountNickNameUpdateRequest_Exception()
+        {
+            var accountRequest = new AccountNickNameUpdateRequest
+            {
+                AccountNumber = 123,
+                AccountDescription = "TestError"
+            };
+
+            _mockAccountService.Setup(x => x.UpdateAccountNickName(accountRequest)).Throws(new Exception("Oops")).Verifiable();
+            var results = await _accountController.PutAccountNickNameUpdateRequest(accountRequest);
+            _mockAccountService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+    
+        [Test]
+        public async Task AccountCreditReportTypeUpdateRequest_OK()
+        {
+            var accountRequest = new AccountCreditReportTypeUpdateRequest
+            {
+                AccountNumber = 123,
+                CreditReportType = "EXCL"
+            };
+
+            var results = await _accountController.PutAccountCreditReportType(accountRequest);
+
+            _mockAccountService.Verify(x => x.UpdateAccountCreditReportType(accountRequest), Times.Once);
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task AccountCreditReportTypeUpdateRequest_Exception()
+        {
+            var accountRequest = new AccountCreditReportTypeUpdateRequest
+            {
+                AccountNumber = 123,
+                CreditReportType = "EXCL"
+            };
+
+            _mockAccountService.Setup(x => x.UpdateAccountCreditReportType(accountRequest)).Throws(new Exception("Oops")).Verifiable();
+            var results = await _accountController.PutAccountCreditReportType(accountRequest);
+            _mockAccountService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetAccountByAccountNumber_Exception()
+        {
+
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(1000L)).Throws(new Exception("Oops")).Verifiable();
+            var results = await _accountController.GetAccountByAccountNumber(1000L);
+            _mockAccountService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetAccountByAccountNumber_Ok()
+        {
+
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(1000L)).ReturnsAsync(
+                new Account()
+                {
+                    AccountNumber = 1000L,
+                    
+                }).Verifiable();
+            var results = await _accountController.GetAccountByAccountNumber(1000L);
+            _mockAccountService.Verify();
+
+            var goodResult = results as ObjectResult;
+            Assert.NotNull(goodResult);
+            Assert.AreEqual(200, goodResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetAccountByMajorMinorBranchAndStatus_Ok()
+        {
+            var request = new AccountsByMajorMinorBranchAndStatusRequest()
+            {
+                BranchCodes = new List<long>()
+                {
+                    1234,
+                    1235
+                },
+                AccountStatuses = new List<string>()
+                {
+                    "Status"
+                },
+                MajorTypes = new List<string>()
+                {
+                    "Major"
+                },
+                MinorTypes = new List<string>()
+                {
+                    "MinorOne",
+                    "MinorTwo"
+                }
+            };
+
+            _mockAccountService.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(request)).ReturnsAsync(
+                new List<AccountsByMajorMinorBranchAndStatusResponse>()
+                {
+                    new AccountsByMajorMinorBranchAndStatusResponse()
+                    {
+                        AccountNumber = 123456789,
+                        BranchCode = 1310,
+                        Name = "Test Testerson"
+                    }
+                }).Verifiable();
+
+            var results = await _accountController.GetAccountsByMajorMinorBranchAndStatus(request);
+            _mockAccountService.Verify();
+
+            var goodResult = results as ObjectResult;
+            Assert.NotNull(goodResult);
+            Assert.AreEqual(200, goodResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetAccountByMajorMinorBranchAndStatus_Exception()
+        {
+
+            _mockAccountService.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(It.IsAny<AccountsByMajorMinorBranchAndStatusRequest>())).Throws(new Exception("Oops")).Verifiable();
+            var results = await _accountController.GetAccountsByMajorMinorBranchAndStatus(new AccountsByMajorMinorBranchAndStatusRequest());
+            _mockAccountService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+		[Test]
+		public async Task AccountContractDateUpdateRequest_OK()
+		{
+            var accountRequest = new AccountContractDateUpdateRequest
+            {
+                AccountNumber = 123,
+                ContractDate = DateTime.Now
+            };
+
+			var results = await _accountController.PutAccountContractDateUpdateRequest(accountRequest);
+
+			_mockAccountService.Verify(x => x.UpdateAccountContractDate(accountRequest), Times.Once);
+			Assert.NotNull(results);
+			var okResult = results as OkObjectResult;
+			Assert.NotNull(okResult);
+			Assert.AreEqual(200, okResult.StatusCode);
+		}
+
+		[Test]
+		public async Task AccountContractDateUpdateRequest_Exception()
+		{
+			var accountRequest = new AccountContractDateUpdateRequest
+			{
+				AccountNumber = 123,
+				ContractDate = DateTime.Now
+			};
+
+			_mockAccountService.Setup(x => x.UpdateAccountContractDate(accountRequest)).Throws(new Exception("Oops")).Verifiable();
+			var results = await _accountController.PutAccountContractDateUpdateRequest(accountRequest);
+			_mockAccountService.Verify();
+
+			var badRes = results as ObjectResult;
+			Assert.NotNull(badRes);
+			Assert.AreEqual(500, badRes.StatusCode);
+		}
+	}
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/AccountUserFieldControllerTest.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class AccountUserFieldControllerTest
+    {
+        private AccountUserFieldController _accountUserFieldController;
+        private Mock<IAccountUserFieldService> _mockAccountUserFieldService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockAccountUserFieldService = new Mock<IAccountUserFieldService>();
+            _accountUserFieldController = new AccountUserFieldController(_mockAccountUserFieldService.Object);
+        }
+
+        [Test]
+        public async Task PutAccountUserFields_OK()
+        {
+            var accountUserField1 = new AccountUserField()
+            {
+                Id = "TEST1",
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+            var accountUserField2 = new AccountUserField()
+            {
+                Id = "TEST2",
+                AccountNumber = 100002,
+                UserFieldCode = "TEST2",
+                Value = "Y"
+            };
+            _mockAccountUserFieldService.Setup(x => x.UpdateAccountUserFieldsAsync(It.IsAny<List<AccountUserFieldRequest>>())).ReturnsAsync(
+            new List<AccountUserField>()
+            {
+                accountUserField1,
+                accountUserField2
+            });
+
+            var accountUserFieldUpdateRequest = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100001,
+                    UserFieldCode = "TEST1",
+                    Value = "Y"
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                    UserFieldCode = "TEST2",
+                    Value = "N"
+                }
+            };
+            var results = await _accountUserFieldController.Put(accountUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutAccountUserFields_Exception()
+        {
+            _mockAccountUserFieldService.Setup(x => x.UpdateAccountUserFieldsAsync(It.IsAny<List<AccountUserFieldRequest>>())).Throws(new Exception("Oops"));
+
+            var accountUserFieldUpdateRequest = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100001,
+                    UserFieldCode = "TEST1",
+                    Value = "Y"
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                    UserFieldCode = "TEST2",
+                    Value = "N"
+                }
+            };
+            var results = await _accountUserFieldController.Put(accountUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task PostAccountUserFields_OK()
+        {
+            var accountUserField1 = new AccountUserField()
+            {
+                Id = "TEST1",
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+            var accountUserField2 = new AccountUserField()
+            {
+                Id = "TEST2",
+                AccountNumber = 100002,
+                UserFieldCode = "TEST2",
+                Value = "Y"
+            };
+            _mockAccountUserFieldService.Setup(x => x.InsertAccountUserFieldsAsync(It.IsAny<List<AccountUserFieldRequest>>())).ReturnsAsync(
+            new List<AccountUserField>()
+            {
+                accountUserField1,
+                accountUserField2
+            });
+
+            var accountUserFieldUpdateRequest = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100001,
+                    UserFieldCode = "TEST1",
+                    Value = "Y"
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                    UserFieldCode = "TEST2",
+                    Value = "N"
+                }
+            };
+            var results = await _accountUserFieldController.Post(accountUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PostAccountUserFields_Exception()
+        {
+            _mockAccountUserFieldService.Setup(x => x.InsertAccountUserFieldsAsync(It.IsAny<List<AccountUserFieldRequest>>())).Throws(new Exception("Oops"));
+
+            var accountUserFieldUpdateRequest = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100001,
+                    UserFieldCode = "TEST1",
+                    Value = "Y"
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                    UserFieldCode = "TEST2",
+                    Value = "N"
+                }
+            };
+            var results = await _accountUserFieldController.Post(accountUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/ActivityControllerTest.cs

@@ -0,0 +1,577 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.Exceptions;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Activity;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Phones;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class ActivityControllerTest
+    {
+        private ActivityController _activityController;
+        private Mock<IActivityService> _mockActivityService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockActivityService = new Mock<IActivityService>();
+            _activityController = new ActivityController(_mockActivityService.Object);
+        }
+
+        [Test]
+        public void GetNewCheckingAccountActivities_OK()
+        {
+            _mockActivityService.Setup(x => x.GetNewCheckingAccountActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewCheckingAccountActivity>()
+                {
+                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
+                });
+
+            var results = _activityController.GetNewCheckingAccountActivities("2020-04-29T11:00:00", null);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewCheckingAccountActivities(null, 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewCheckingAccountActivities("2020-04-29T11:00:00", 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public void GetNewCheckingAccountActivities_FailedToParse()
+        {
+            _mockActivityService.Setup(x => x.GetNewCheckingAccountActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
+                .Throws(new FailedToParseException("Oops"));
+
+
+            var results = _activityController.GetNewCheckingAccountActivities(">:O", 1);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewCheckingAccountActivities_Exception()
+        {
+            _mockActivityService.Setup(x => x.GetNewCheckingAccountActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.GetNewCheckingAccountActivities("2020-04-29T11:00:00", 4);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewAtmCheckCardActivities_OK()
+        {
+            _mockActivityService.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewAtmCheckCardActivity>()
+                {
+                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
+                });
+
+            var results = _activityController.GetNewAtmCheckCardActivities("2020-04-29T11:00:00", null);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewAtmCheckCardActivities(null, 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewAtmCheckCardActivities("2020-04-29T11:00:00", 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public void GetNewAtmCheckCardActivities_FailedToParse()
+        {
+            _mockActivityService.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
+                .Throws(new FailedToParseException("Oops"));
+
+
+            var results = _activityController.GetNewAtmCheckCardActivities(">:O", 1);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewAtmCheckCardActivities_Exception()
+        {
+            _mockActivityService.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<string>(), It.IsAny<long?>(), It.IsAny<int>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.GetNewAtmCheckCardActivities("2020-04-29T11:00:00", 4);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewActivityManagerReferralActivities_OK()
+        {
+            _mockActivityService.Setup(x => x.GetNewActivityManagerIncentiveReferrals(It.IsAny<string>(), It.IsAny<long?>())).ReturnsAsync(
+                new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                });
+
+            var results = _activityController.GetNewActivityManagerReferralActivities("2020-04-29T11:00:00", null);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewActivityManagerReferralActivities(null, 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewActivityManagerReferralActivities("2020-04-29T11:00:00", 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public void GetNewActivityManagerReferralActivities_FailedToParse()
+        {
+            _mockActivityService.Setup(x => x.GetNewActivityManagerIncentiveReferrals(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new FailedToParseException("Oops"));
+
+
+            var results = _activityController.GetNewActivityManagerReferralActivities(">:O", 1);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewActivityManagerReferralActivities_Exception()
+        {
+            _mockActivityService.Setup(x => x.GetNewActivityManagerIncentiveReferrals(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.GetNewActivityManagerReferralActivities("2020-04-29T11:00:00", 4);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewMortgageAccountActivities_OK()
+        {
+            _mockActivityService.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<string>(), It.IsAny<long?>())).ReturnsAsync(
+                new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                });
+
+            var results = _activityController.GetNewMortgageAccountActivities("2020-04-29T11:00:00", null);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewMortgageAccountActivities(null, 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewMortgageAccountActivities("2020-04-29T11:00:00", 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public void GetNewMortgageAccountActivities_FailedToParse()
+        {
+            _mockActivityService.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new FailedToParseException("Oops"));
+
+
+            var results = _activityController.GetNewMortgageAccountActivities(">:O", 1);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewMortgageAccountActivities_Exception()
+        {
+            _mockActivityService.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.GetNewMortgageAccountActivities("2020-04-29T11:00:00", 4);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewVehicleSaleActivities_OK()
+        {
+            _mockActivityService.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<string>(), It.IsAny<long?>())).ReturnsAsync(
+                new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                });
+
+            var results = _activityController.GetNewVehicleSaleActivities("2020-04-29T11:00:00", null);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewVehicleSaleActivities(null, 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetNewVehicleSaleActivities("2020-04-29T11:00:00", 5);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public void GetNewVehicleSaleActivities_FailedToParse()
+        {
+            _mockActivityService.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new FailedToParseException("Oops"));
+
+
+            var results = _activityController.GetNewVehicleSaleActivities(">:O", 1);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewVehicleSaleActivities_Exception()
+        {
+            _mockActivityService.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.GetNewVehicleSaleActivities("2020-04-29T11:00:00", 4);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewDebtProtectedLoanSales_FailedToParse()
+        {
+            _mockActivityService.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new FailedToParseException("Oops"));
+
+
+            var results = _activityController.GetNewDebtProtectedLoanSaleActivities(">:O", 1);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewDebtProtectedLoanSales_Exception()
+        {
+            _mockActivityService.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<string>(), It.IsAny<long?>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.GetNewDebtProtectedLoanSaleActivities("2020-04-29T11:00:00", 4);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public void QueryActivityManagerActivity_Exception()
+        {
+            _mockActivityService.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.QueryActivityManagerActivity(new ActivityQueryRequest());
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewDebtProtectedLoanSales_OK()
+        {
+            _mockActivityService.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()))
+                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral()
+                    {
+                        ActivityId = 5
+                    },
+                    new NewActivityManagerIncentiveReferral()
+                    {
+                        ActivityId = 4
+                    },
+                });
+
+            var results = _activityController.QueryActivityManagerActivity(new ActivityQueryRequest());
+
+            Assert.NotNull(results);
+            var okRes = results as OkObjectResult;
+            Assert.NotNull(okRes);
+            Assert.AreEqual(200, okRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewEStatementDeliverySaleActivities_OK()
+        {
+            _mockActivityService.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<string>())).ReturnsAsync(
+                new List<EStatementDeliveryMethod>()
+                {
+                    new EStatementDeliveryMethod() { ActivityNumber = 1 },
+                    new EStatementDeliveryMethod() { ActivityNumber = 2 },
+                    new EStatementDeliveryMethod() { ActivityNumber = 3 }
+                });
+
+            var results = _activityController.GetEStatementDeliveryActivity("2020-04-29T11:00:00");
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetEStatementDeliveryActivity(null);
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            results = _activityController.GetEStatementDeliveryActivity("2020-04-29T11:00:00");
+
+            Assert.NotNull(results);
+            okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public void GetNewEStatementDeliverySaleActivities_FailedToParse()
+        {
+            _mockActivityService.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<string>()))
+                .Throws(new FailedToParseException("Oops"));
+
+
+            var results = _activityController.GetEStatementDeliveryActivity(">:O");
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public void GetNewEStatementDeliverySaleActivities_Exception()
+        {
+            _mockActivityService.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<string>()))
+                .Throws(new Exception("Oops"));
+
+
+            var results = _activityController.GetEStatementDeliveryActivity("2020-04-29T11:00:00");
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByPhoneNumber_OK()
+        {
+            var phoneNumber = Guid.NewGuid().ToString();
+            var personRecentActivity = new PersonRecentActivity
+            {
+                HomePhone = phoneNumber
+            };
+            var response = new PersonRecentActivityResponse
+            {
+                Success = true,
+                PersonRecentActivity = personRecentActivity
+            };
+        
+            _mockActivityService.Setup(x => x.GetPersonActivityByPhoneNumber(phoneNumber))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _activityController.GetPersonActivityByPhoneNumber(phoneNumber);
+            Assert.NotNull(result);
+            var status = result as OkObjectResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(200, status.StatusCode);
+
+            var personRecentActivityResult = status.Value as PersonRecentActivityResponse;
+            Assert.NotNull(personRecentActivityResult);
+            Assert.AreEqual(phoneNumber, personRecentActivityResult.PersonRecentActivity?.HomePhone);
+            _mockActivityService.Verify();
+        }
+
+        [Test]
+        public async Task GetPersonActivityByPhoneNumber_InternalServerError()
+        {
+            var phoneNumber = Guid.NewGuid().ToString();
+            _mockActivityService.Setup(x => x.GetPersonActivityByPhoneNumber(phoneNumber))
+                .Throws(new Exception("Test")).Verifiable();
+
+            var result = await _activityController.GetPersonActivityByPhoneNumber(phoneNumber);
+            Assert.NotNull(result);
+            var status = result as StatusCodeResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(500, status.StatusCode);
+            _mockActivityService.Verify();
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByTaxId_OK()
+        {
+            var taxId = Guid.NewGuid().ToString();
+            var personNumber = DateTime.Now.Millisecond;
+            var personRecentActivity = new PersonRecentActivity
+            {
+                PersonNumber = personNumber
+            };
+            var response = new PersonRecentActivityResponse
+            {
+                Success = true,
+                PersonRecentActivity = personRecentActivity
+            };
+        
+            _mockActivityService.Setup(x => x.GetPersonActivityByTaxId(taxId))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _activityController.GetPersonActivityByTaxId(taxId);
+            Assert.NotNull(result);
+            var status = result as OkObjectResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(200, status.StatusCode);
+
+            var personRecentActivityResult = status.Value as PersonRecentActivityResponse;
+            Assert.NotNull(personRecentActivityResult);
+            Assert.AreEqual(personNumber, personRecentActivityResult.PersonRecentActivity?.PersonNumber);
+            _mockActivityService.Verify();
+        }
+
+        [Test]
+        public async Task GetPersonActivityByTaxId_BadRequest()
+        {
+            var taxId = string.Empty;
+        
+            var result = await _activityController.GetPersonActivityByTaxId(taxId);
+            Assert.NotNull(result);
+            var status = result as BadRequestObjectResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(400, status.StatusCode);
+        }
+            
+        [Test]
+        public async Task GetPersonActivityByTaxId_InternalServerError()
+        {
+            var taxId = Guid.NewGuid().ToString();
+            _mockActivityService.Setup(x => x.GetPersonActivityByTaxId(taxId))
+                .Throws(new Exception("Test")).Verifiable();
+
+            var result = await _activityController.GetPersonActivityByTaxId(taxId);
+            Assert.NotNull(result);
+            var status = result as StatusCodeResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(500, status.StatusCode);
+            _mockActivityService.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/AgreeControllerTest.cs

@@ -0,0 +1,856 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using System.Threading.Tasks;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Agreements;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class AgreeControllerTest
+    {
+        private AgreeController _agreeController;
+        private Mock<IAgreeService> _mockAgreeService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockAgreeService = new Mock<IAgreeService>();
+            _agreeController = new AgreeController(_mockAgreeService.Object);
+        }
+
+        [Test]
+        public async Task Get_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>())).ReturnsAsync(
+                  new List<AgreeUserAccount>()
+                  {
+                      new AgreeUserAccount()
+                      {
+                         AccountNumber = 100010,
+                         AgreeNumber = 1000,
+                         UserId = "101010"
+                      },
+                      new AgreeUserAccount()
+                      {
+                         AccountNumber = 200020,
+                         AgreeNumber = 2000,
+                         UserId = "202020"
+                      }
+                  });
+
+            var accountNumbers = new List<string>()
+            {
+                "100010",
+                "200020"
+            };
+            var results = await _agreeController.GetAgreeUsersByAccounts(accountNumbers);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task Get_AccountNumbers_Null_BadRequest()
+        {
+            var results = await _agreeController.GetAgreeUsersByAccounts(null);
+
+            _mockAgreeService.Verify(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task Get_AccountNumbers_EmptyList_BadRequest()
+        {
+            var results = await _agreeController.GetAgreeUsersByAccounts(new List<string>());
+
+            _mockAgreeService.Verify(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task Get_Exception()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreeUsersByAccountNumbers(It.IsAny<List<string>>()))
+               .Throws(new Exception("Oops"));
+
+            var accountNumbers = new List<string>()
+            {
+                "100010",
+                "200020"
+            };
+            var results = await _agreeController.GetAgreeUsersByAccounts(accountNumbers);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementByUserId_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementByUserId("123")).ReturnsAsync(
+                new Agreement
+                    {
+                        AgreementNumber = 111111,
+                        PersonNumber = 222222,
+                        UserId = "101010"
+                    }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementByUserId("123");
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as Agreement;
+            Assert.NotNull(result);
+            Assert.AreEqual(111111, result.AgreementNumber);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementByUserId_NoContent()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementByUserId("123")).ReturnsAsync((Agreement)null).Verifiable();
+            
+            var results = await _agreeController.GetAgreementByUserId("123");
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementByUserId_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementByUserId(null);
+
+            _mockAgreeService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+            
+            var result2 = await _agreeController.GetAgreementByUserId("");
+
+            _mockAgreeService.Verify(x => x.GetAgreementByUserId(It.IsAny<string>()), Times.Never());
+
+            Assert.NotNull(result2);
+            var badRequest2 = result2 as BadRequestObjectResult;
+            Assert.NotNull(badRequest2);
+            Assert.AreEqual(400, badRequest2.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementByUserId_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementByUserId("123")).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementByUserId("123");
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetUserIdByPersonNumber_OK()
+        {
+            var personNumbers = new List<string> { "5436", "44889" };
+            _mockAgreeService.Setup(x => x.GetAgreeUsersByPersonNumber(123L)).ReturnsAsync(personNumbers).Verifiable();
+            
+            var results = await _agreeController.GetAgreeUsersByPersonNumber(123L);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as List<string>;
+            Assert.NotNull(result);
+            Assert.AreEqual("5436", result.FirstOrDefault());
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetUserIdByPersonNumber_NoContent()
+        {
+            var personNumbers = new List<string> {};
+            _mockAgreeService.Setup(x => x.GetAgreeUsersByPersonNumber(123L)).ReturnsAsync(personNumbers).Verifiable();
+            
+            var results = await _agreeController.GetAgreeUsersByPersonNumber(123L);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetUserIdByPersonNumber_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreeUsersByPersonNumber(0);
+
+            _mockAgreeService.Verify(x => x.GetAgreeUsersByPersonNumber(It.IsAny<long>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetUserIdByPersonNumber_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreeUsersByPersonNumber(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreeUsersByPersonNumber(123L);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetUserIdByOrganizationNumber_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreeUserByOrganizationNumber(123L)).ReturnsAsync("5436").Verifiable();
+            
+            var results = await _agreeController.GetAgreeUserByOrganizationNumber(123L);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as string;
+            Assert.NotNull(result);
+            Assert.AreEqual("5436", result);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetUserIdByOrganizationNumber_NoContent()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreeUserByOrganizationNumber(123L)).ReturnsAsync((string)null).Verifiable();
+            
+            var results = await _agreeController.GetAgreeUserByOrganizationNumber(123L);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetUserIdByOrganizationNumber_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreeUserByOrganizationNumber(0);
+
+            _mockAgreeService.Verify(x => x.GetAgreeUserByOrganizationNumber(It.IsAny<long>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetUserIdByOrganizationNumber_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreeUserByOrganizationNumber(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreeUserByOrganizationNumber(123L);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementByAgreementId_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementByAgreementId(123)).ReturnsAsync(
+                new Agreement
+                    {
+                        AgreementNumber = 111111,
+                        PersonNumber = 222222,
+                        UserId = "101010"
+                    }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementByAgreementId(123);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as Agreement;
+            Assert.NotNull(result);
+            Assert.AreEqual(111111, result.AgreementNumber);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementByAgreementId_NoContent()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementByAgreementId(123)).ReturnsAsync((Agreement)null).Verifiable();
+            
+            var results = await _agreeController.GetAgreementByAgreementId(123);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementByAgreementId_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementByAgreementId(0);
+
+            _mockAgreeService.Verify(x => x.GetAgreementByAgreementId(It.IsAny<long>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementByAgreementId_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementByAgreementId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementByAgreementId(123);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementsByAccountId_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementsByAccountId(123)).ReturnsAsync(
+                new List<Agreement>
+                {
+                    new ()
+                    {
+                        AgreementNumber = 111111,
+                        PersonNumber = 222222,
+                        UserId = "101010"
+                    },
+                    new ()
+                    {
+                        AgreementNumber = 111112,
+                        PersonNumber = 222223,
+                        UserId = "101011"
+                    }
+                }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementsByAccountId(123);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as IEnumerable<Agreement>;
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementsByAccountId_NoContent()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementsByAccountId(123)).ReturnsAsync((IEnumerable<Agreement>)null).Verifiable();
+            
+            var results = await _agreeController.GetAgreementsByAccountId(123);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementsByAccountId_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementsByAccountId(0);
+
+            _mockAgreeService.Verify(x => x.GetAgreementsByAccountId(It.IsAny<long>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementsByAccountId_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementsByAccountId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementsByAccountId(123);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+
+        [Test]
+        public async Task GetAgreementAccountByAccountId_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountByAccountId(123)).ReturnsAsync(
+                new AgreementAccount
+                {
+                    AccountNumber = 123
+                }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementAccountByAccountId(123);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as AgreementAccount;
+            Assert.NotNull(result);
+            Assert.AreEqual(123, result.AccountNumber);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountByAccountId_NoContent()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountByAccountId(123)).ReturnsAsync((AgreementAccount)null).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAccountByAccountId(123);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountByAccountId_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementAccountByAccountId(0);
+
+            _mockAgreeService.Verify(x => x.GetAgreementAccountByAccountId(It.IsAny<long>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountByAccountId_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountByAccountId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAccountByAccountId(123);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByUserId_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountsByUserId("123")).ReturnsAsync(
+                new List<AgreementAccount>
+                {
+                    new ()
+                    {
+                        AccountNumber = 123
+                    },
+                    new ()
+                    {
+                        AccountNumber = 124
+                    }
+                }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementAccountsByUserId("123");
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as IEnumerable<AgreementAccount>;
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByUserId_NoContent()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountsByUserId("123")).ReturnsAsync((IEnumerable<AgreementAccount>)null).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAccountsByUserId("123");
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByUserId_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementAccountsByUserId(null);
+
+            _mockAgreeService.Verify(x => x.GetAgreementAccountsByUserId(It.IsAny<string>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+            
+            var result2 = await _agreeController.GetAgreementAccountsByUserId("");
+
+            _mockAgreeService.Verify(x => x.GetAgreementAccountsByUserId(It.IsAny<string>()), Times.Never());
+
+            Assert.NotNull(result2);
+            var badRequest2 = result2 as BadRequestObjectResult;
+            Assert.NotNull(badRequest2);
+            Assert.AreEqual(400, badRequest2.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByUserId_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountsByUserId("123")).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAccountsByUserId("123");
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByOrganizationId_OK()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountsByOrganizationId(123)).ReturnsAsync(
+                new List<AgreementAccount>
+                {
+                    new ()
+                    {
+                        AccountNumber = 123
+                    },
+                    new ()
+                    {
+                        AccountNumber = 124
+                    }
+                }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementAccountsByOrganizationId(123);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as IEnumerable<AgreementAccount>;
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByOrganizationId_NoContent()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountsByOrganizationId(123)).ReturnsAsync((IEnumerable<AgreementAccount>)null).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAccountsByOrganizationId(123);
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByOrganizationId_empty_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementAccountsByOrganizationId(0);
+
+            _mockAgreeService.Verify(x => x.GetAgreementAccountsByOrganizationId(It.IsAny<long>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsByOrganizationId_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.GetAgreementAccountsByOrganizationId(123)).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAccountsByOrganizationId(123);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsAuditFromDateLastMaintained_OK()
+        {
+            _mockAgreeService.Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>())).ReturnsAsync(
+                new List<long>
+                {
+                   123,
+                   124
+                }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as IEnumerable<long>;
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsAuditFromDateLastMaintained_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained(null);
+
+            _mockAgreeService.Verify(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+            
+            var result2 = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained("");
+
+            _mockAgreeService.Verify(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(result2);
+            var badRequest2 = result2 as BadRequestObjectResult;
+            Assert.NotNull(badRequest2);
+            Assert.AreEqual(400, badRequest2.StatusCode);
+            
+            var resultParseError = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained("12");
+
+            _mockAgreeService.Verify(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(resultParseError);
+            var badRequestParseError = results as BadRequestObjectResult;
+            Assert.NotNull(badRequestParseError);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAccountsAuditFromDateLastMaintained_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.AuditAccountDeliveryMethodAndOwnerChangesByDateLastMaintained(It.IsAny<DateTime>())).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAccountsAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAuditFromDateLastMaintained_OK()
+        {
+            _mockAgreeService.Setup(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>())).ReturnsAsync(
+                new List<long>
+                {
+                   123,
+                   124
+                }).Verifiable();
+
+            
+            var results = await _agreeController.GetAgreementAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as IEnumerable<long>;
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetAgreementAuditFromDateLastMaintained_BadRequest()
+        {
+            var results = await _agreeController.GetAgreementAuditFromDateLastMaintained(null);
+
+            _mockAgreeService.Verify(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+            
+            var result2 = await _agreeController.GetAgreementAuditFromDateLastMaintained("");
+
+            _mockAgreeService.Verify(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(result2);
+            var badRequest2 = result2 as BadRequestObjectResult;
+            Assert.NotNull(badRequest2);
+            Assert.AreEqual(400, badRequest2.StatusCode);
+            
+            var resultParseError = await _agreeController.GetAgreementAuditFromDateLastMaintained("12");
+
+            _mockAgreeService.Verify(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(resultParseError);
+            var badRequestParseError = results as BadRequestObjectResult;
+            Assert.NotNull(badRequestParseError);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetAgreementAuditFromDateLastMaintained_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.AuditAgreementChangesByDateLastMaintained(It.IsAny<DateTime>())).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetAgreementAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetOrganizationAuditFromDateLastMaintained_OK()
+        {
+            _mockAgreeService.Setup(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>())).ReturnsAsync(
+                new List<long>
+                {
+                   123,
+                   124
+                }).Verifiable();
+
+            
+            var results = await _agreeController.GetOrganizationAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var result = okResult.Value as IEnumerable<long>;
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            _mockAgreeService.Verify();
+        }
+        
+        [Test]
+        public async Task GetOrganizationAuditFromDateLastMaintained_BadRequest()
+        {
+            var results = await _agreeController.GetOrganizationAuditFromDateLastMaintained(null);
+
+            _mockAgreeService.Verify(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(results);
+            var badRequest = results as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.AreEqual(400, badRequest.StatusCode);
+            
+            var result2 = await _agreeController.GetOrganizationAuditFromDateLastMaintained("");
+
+            _mockAgreeService.Verify(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(result2);
+            var badRequest2 = result2 as BadRequestObjectResult;
+            Assert.NotNull(badRequest2);
+            Assert.AreEqual(400, badRequest2.StatusCode);
+            
+            var resultParseError = await _agreeController.GetOrganizationAuditFromDateLastMaintained("12");
+
+            _mockAgreeService.Verify(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>()), Times.Never());
+
+            Assert.NotNull(resultParseError);
+            var badRequestParseError = results as BadRequestObjectResult;
+            Assert.NotNull(badRequestParseError);
+            Assert.AreEqual(400, badRequest.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetOrganizationAuditFromDateLastMaintained_Error_StatusServerError()
+        {
+            _mockAgreeService.Setup(x => x.AuditOrganizationChangesByDateLastMaintained(It.IsAny<DateTime>())).ThrowsAsync(new Exception("Unit Test Exception")).Verifiable();
+            
+            var results = await _agreeController.GetOrganizationAuditFromDateLastMaintained(DateTime.Now.ToString(CultureInfo.InvariantCulture));
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+            _mockAgreeService.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/ApplicationHistoryControllerTest.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.Exceptions;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using System.Threading.Tasks;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.ApplicationHistories;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class ApplicationHistoryControllerTest
+    {
+        private ApplicationHistoryController _applicationHistoryController;
+        private Mock<IApplicationHistoryService> _mockApplicationHistoryService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockApplicationHistoryService = new Mock<IApplicationHistoryService>();
+            _applicationHistoryController = new ApplicationHistoryController(_mockApplicationHistoryService.Object);
+        }
+
+        [Test]
+        public async Task GetApplicationHistory_OK()
+        {
+            _mockApplicationHistoryService.Setup(x => x.GetApplicationHistory(It.IsAny<List<string>>(), It.IsAny<string>())).ReturnsAsync(
+                                   new List<ApplicationHistory>()
+                    {
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test",
+                           ApplicationNumber = 1,
+                           QueueNumber = 10,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        },
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test2",
+                           ApplicationNumber = 2,
+                           QueueNumber = 20,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        }
+                    });
+
+            var applicationHistoryRequest = new ApplicationHistoryRequest()
+            {
+                ApplicationNumbers = new List<string>()
+                {
+                    "1",
+                    "2"
+                },
+                EffectiveDate = "1/1/2021"
+            };
+            var results = await _applicationHistoryController.GetApplicationHistory(applicationHistoryRequest);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetApplicationHistory_FailedToParse()
+        {
+            _mockApplicationHistoryService.Setup(x => x.GetApplicationHistory(It.IsAny<List<string>>(), 
+                                                                              It.IsAny<string>()))
+                .Throws(new FailedToParseException("Oops"));
+
+            var applicationHistoryRequest = new ApplicationHistoryRequest()
+            {
+                ApplicationNumbers = null,
+                EffectiveDate = null
+            };
+            var results = await _applicationHistoryController.GetApplicationHistory(applicationHistoryRequest);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetApplicationHistory_Exception()
+        {
+            _mockApplicationHistoryService.Setup(x => x.GetApplicationHistory(It.IsAny<List<string>>(),
+                                                                             It.IsAny<string>()))
+               .Throws(new Exception("Oops"));
+
+            var applicationHistoryRequest = new ApplicationHistoryRequest()
+            {
+                ApplicationNumbers = null,
+                EffectiveDate = null
+            };
+            var results = await _applicationHistoryController.GetApplicationHistory(applicationHistoryRequest);
+
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/AssociateControllerTest.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Associate;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class AssociateControllerTest
+    {
+        private AssociateController _associateController;
+        private Mock<IAssociateService> _mockAssociateService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockAssociateService = new Mock<IAssociateService>();
+            _associateController = new AssociateController(_mockAssociateService.Object);
+        }
+
+        [Test]
+        public async Task GetAssociateDetailsBySsn_OK()
+        {
+            var taxId = Guid.NewGuid().ToString();
+            var associateDetails = new AssociateDetails()
+            {
+                PersonNumber = DateTime.Now.Millisecond
+            };
+
+            _mockAssociateService.Setup(x => x.GetAssociateDetailsBySsn(taxId))
+                .ReturnsAsync(associateDetails).Verifiable();
+
+            var result = await _associateController.GetAssociateDetailsBySsn(taxId);
+            Assert.NotNull(result);
+            var status = result as OkObjectResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(200, status.StatusCode);
+
+            var associateDetailsResult = status.Value as AssociateDetails;
+            Assert.NotNull(associateDetails);
+            Assert.AreEqual(associateDetails.PersonNumber, associateDetailsResult?.PersonNumber);
+            _mockAssociateService.Verify();
+        }
+
+        [Test]
+        public async Task GetAssociateDetailsBySsn_NoContent()
+        {
+            var taxId = Guid.NewGuid().ToString();
+            AssociateDetails associateDetails = null;
+
+            _mockAssociateService.Setup(x => x.GetAssociateDetailsBySsn(taxId))
+                .ReturnsAsync(associateDetails).Verifiable();
+
+            var result = await _associateController.GetAssociateDetailsBySsn(taxId);
+            Assert.NotNull(result);
+            var status = result as NoContentResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(204, status.StatusCode);
+            _mockAssociateService.Verify();
+        }
+
+        [Test]
+        public async Task GetAssociateDetailsBySsn_BadRequest()
+        {
+            string taxId = null;
+
+            var result = await _associateController.GetAssociateDetailsBySsn(taxId);
+            Assert.NotNull(result);
+            var status = result as BadRequestObjectResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(400, status.StatusCode);
+        }
+
+        [Test]
+        public async Task GetAssociateDetailsBySsn_InternalServerError()
+        {
+            var taxId = Guid.NewGuid().ToString();
+            _mockAssociateService.Setup(x => x.GetAssociateDetailsBySsn(taxId))
+                .Throws(new Exception("Test")).Verifiable();
+
+            var result = await _associateController.GetAssociateDetailsBySsn(taxId);
+            Assert.NotNull(result);
+            var status = result as StatusCodeResult;
+            Assert.NotNull(status);
+            Assert.AreEqual(500, status.StatusCode);
+            _mockAssociateService.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/IndirectLoanControllerTest.cs

@@ -0,0 +1,163 @@
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.IndirectLoan;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class IndirectLoanControllerTest
+    {
+        private IndirectLoanController _indirectLoanController;
+        private Mock<IIndirectLoanService> _mockIndirectLoanService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockIndirectLoanService = new Mock<IIndirectLoanService>();
+            _indirectLoanController = new IndirectLoanController(_mockIndirectLoanService.Object);
+        }
+
+        [Test]
+        public async Task GetIndirectLoanByAccountNumber_OK()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetIndirectLoanByAccountNumber(It.IsAny<long>())).ReturnsAsync(new IndirectLoanDetail());
+
+            var result = await _indirectLoanController.GetIndirectLoanByAccountNumber(1234);
+
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetIndirectLoanByAccountNumber_Exception()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetIndirectLoanByAccountNumber(It.IsAny<long>()))
+                .Throws(new Exception("Oops"));
+
+            var result = await _indirectLoanController.GetIndirectLoanByAccountNumber(1234);
+
+            Assert.NotNull(result);
+            var badResult = result as StatusCodeResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetIndirectLoanByPostedDate_OK()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetIndirectLoansByPostedDate(It.IsAny<string>())).ReturnsAsync(new List<IndirectLoanDetail>());
+
+            var result = await _indirectLoanController.GetIndirectLoansByPostedDate("5/1/2021");
+
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetIndirectLoanByPostedDate_Exception()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetIndirectLoansByPostedDate(It.IsAny<string>()))
+                .Throws(new Exception("Oops"));
+
+            var result = await _indirectLoanController.GetIndirectLoansByPostedDate("5/1/2021");
+
+            Assert.NotNull(result);
+            var badResult = result as StatusCodeResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoanByPostedDate_OK()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetClosedIndirectLoansByPostedDate(It.IsAny<string>())).ReturnsAsync(new List<ClosedIndirectLoan>());
+
+            var result = await _indirectLoanController.GetClosedIndirectLoansByPostedDate("5/1/2021");
+
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoanByPostedDate_Exception()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetClosedIndirectLoansByPostedDate(It.IsAny<string>()))
+                .Throws(new Exception("Oops"));
+
+            var result = await _indirectLoanController.GetClosedIndirectLoansByPostedDate("5/1/2021");
+
+            Assert.NotNull(result);
+            var badResult = result as StatusCodeResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoanWithDetailByPostedDate_OK()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetClosedIndirectLoansWithDetailByPostedDate(It.IsAny<string>())).ReturnsAsync(new List<IndirectLoanDetail>());
+
+            var result = await _indirectLoanController.GetClosedIndirectLoansWithDetailByPostedDate("5/1/2021");
+
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoanWithDetailByPostedDate_Exception()
+        {
+            _mockIndirectLoanService.Setup(x => x.GetClosedIndirectLoansWithDetailByPostedDate(It.IsAny<string>()))
+                .Throws(new Exception("Oops"));
+
+            var result = await _indirectLoanController.GetClosedIndirectLoansWithDetailByPostedDate("5/1/2021");
+
+            Assert.NotNull(result);
+            var badResult = result as StatusCodeResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutDealerOriginalBalance_Ok()
+
+        {
+            var accountNumber = "111111111111";
+            _mockIndirectLoanService.Setup(x => x.UpdateDealerOriginalBalance(It.IsAny<string>())).ReturnsAsync(
+                                                new List<UpdateDealerOriginalBalanceResponse>() { });
+
+            var result = await _indirectLoanController.PutDealerOriginalBalance(accountNumber);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutDealerOriginalBalance_Exception()
+        {
+            var accountNumber = "111111111111";
+            _mockIndirectLoanService.Setup(x => x.UpdateDealerOriginalBalance(It.IsAny<string>()))
+               .Throws(new Exception("Oops"));
+
+            var results = await _indirectLoanController.PutDealerOriginalBalance(accountNumber);
+
+            Assert.NotNull(results);
+            var badResult = results as StatusCodeResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/IndividualControllerTest.cs

@@ -0,0 +1,90 @@
+using System;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Individuals;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class IndividualControllerTest
+    {
+        private IndividualController _individualController;
+        private Mock<IIndividualService> _mockIndividualService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockIndividualService = new Mock<IIndividualService>();
+            _individualController = new IndividualController(_mockIndividualService.Object);
+        }
+
+        [Test]
+        public void GetIndividual_OK()
+        {
+            var testIndividual = new Individual()
+            {
+                IndividualId = 1
+            };
+            _mockIndividualService.Setup(x => x.GetIndividualByUserId(It.IsAny<string>())).ReturnsAsync(testIndividual);
+
+            var result = _individualController.GetIndividual("1");
+            
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public void GetIndividual_EmptyString_BadRequest()
+        {
+            var testIndividual = new Individual()
+            {
+                IndividualId = 1
+            };
+            _mockIndividualService.Setup(x => x.GetIndividualByUserId(It.IsAny<string>())).ReturnsAsync(testIndividual);
+
+            var result = _individualController.GetIndividual("");
+
+            Assert.NotNull(result);
+            var badRes = result as BadRequestObjectResult;
+            Assert.AreEqual(400, badRes.StatusCode);
+            Assert.AreEqual("User Id must not be null or empty", badRes.Value);
+        }
+
+        [Test]
+        public void GetIndividual_StringWithSpaces_BadRequest()
+        {
+            var testIndividual = new Individual()
+            {
+                IndividualId = 1
+            };
+            _mockIndividualService.Setup(x => x.GetIndividualByUserId(It.IsAny<string>())).ReturnsAsync(testIndividual);
+
+            var result = _individualController.GetIndividual("     ");
+
+            Assert.NotNull(result);
+            var badRes = result as BadRequestObjectResult;
+            Assert.AreEqual(400, badRes.StatusCode);
+            Assert.AreEqual("User Id must not be null or empty", badRes.Value);
+        }
+
+        [Test]
+        public void GetIndividual_Exception()
+        {
+            _mockIndividualService.Setup(x => x.GetIndividualByUserId(It.IsAny<string>()))
+                .Throws(new Exception("Err"));        
+
+            var result = _individualController.GetIndividual("1");
+            
+            Assert.NotNull(result);
+            var badRes = result as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+            Assert.AreEqual("Err", badRes.Value);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/LoanControllerTest.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Loans;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Collaterals;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Properties;
+using System.Linq;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class LoanControllerTest
+    {
+        private LoanController _loanController;
+        private Mock<ILoanService> _mockLoanService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockLoanService = new Mock<ILoanService>();
+            _loanController = new LoanController(_mockLoanService.Object);
+        }
+
+        [Test]
+        public async Task GetLoanDetails_OK()
+        {
+            _mockLoanService.Setup(x => x.GetLoanDetail(123334234324)).ReturnsAsync(new LoanDetail(){ LoanId = 1}).Verifiable();
+
+            var results = await _loanController.GetLoanDetails(123334234324);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as LoanDetail;
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.LoanId);
+            _mockLoanService.Verify();
+        }
+
+        [Test]
+        public async Task GetLoanDetails_Exception()
+        {
+            _mockLoanService.Setup(x => x.GetLoanDetail(It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            var results = await _loanController.GetLoanDetails(1234555);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetLoanCollateral_OK()
+        {
+            var collateralResponse = new List<CollateralDetail>()
+            { 
+                new CollateralDetail()
+                {
+                    CollateralId = 1
+                },
+                new CollateralDetail()
+                {
+                    CollateralId = 2
+                }
+            };
+
+            _mockLoanService.Setup(x => x.GetCollateralDetails(123334234324)).ReturnsAsync(collateralResponse).Verifiable();
+
+            var results = await _loanController.GetLoanCollateral(123334234324);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var resultsValue = okResult.Value as List<CollateralDetail>;
+            Assert.NotNull(resultsValue);
+            Assert.AreEqual(2, resultsValue.Count);
+            _mockLoanService.Verify();
+        }
+
+        [Test]
+        public async Task GetLoanCollateral_Exception()
+        {
+            _mockLoanService.Setup(x => x.GetCollateralDetails(It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            var results = await _loanController.GetLoanCollateral(1234555);
+
+            Assert.NotNull(results);
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPropertyInformation_Exception()
+        {
+            _mockLoanService.Setup(x => x.GetPropertyInformation(It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            var results = await _loanController.GetPropertyInformation(1234555);
+
+            Assert.NotNull(results);
+            var result = results as ObjectResult;
+            Assert.NotNull(result);
+            Assert.AreEqual(500, result.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPropertyInformation_Ok()
+        {
+            Property property = new Property()
+            {
+                PropertyNumber = 1000
+            };
+
+            IEnumerable<Property> properties = new List<Property>() { property };
+            
+            _mockLoanService.Setup(x => x.GetPropertyInformation(1000)).ReturnsAsync(properties);
+
+            var results = await _loanController.GetPropertyInformation(1000);
+
+            Assert.NotNull(results);
+            var goodRes = results as OkObjectResult;
+            Assert.NotNull(goodRes);
+            Assert.AreEqual(200, goodRes.StatusCode);
+        }
+
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/MemberControllerTest.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Members;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Mixed;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class MemberControllerTest
+    {
+        private MemberController _memberController;
+        private Mock<IMemberService> _mockMemberService;
+        private Mock<ILoanService> _mockLoanService;
+
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockMemberService = new Mock<IMemberService>();
+            _mockLoanService = new Mock<ILoanService>();
+            _memberController = new MemberController(_mockMemberService.Object, _mockLoanService.Object);
+        }
+
+        [Test]
+        public async Task GetMemberByAccountNumber_OK()
+        {
+            _mockMemberService.Setup(x => x.GetMemberByAccountNumber(123334234324)).ReturnsAsync(new Member(){ MemberId = 1}).Verifiable();
+
+            var results = await _memberController.GetMemberByAccountNumber(123334234324);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as Member;
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.MemberId);
+            _mockLoanService.Verify();
+        }
+
+        [Test]
+        public async Task GetMemberByAccountNumber_Exception()
+        {
+            _mockMemberService.Setup(x => x.GetMemberByAccountNumber(It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            var results = await _memberController.GetMemberByAccountNumber(1234555);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonOrOrganizationNumberByMemberNumber_PersonFound()
+        {
+            long personMemberNumber = 123;
+            string personName = "John E Jacob Jr";
+
+            var personOrOrganization = new PersonOrganization()
+            {
+                PersonNumber = personMemberNumber.ToString(),
+                EntityName = personName
+            };
+            
+            _mockMemberService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<long>())).ReturnsAsync(personOrOrganization).Verifiable();
+
+            var result = await _memberController.GetPersonOrOrganizationNumberByMemberId(personMemberNumber);
+            var okResult = result as OkObjectResult;
+            var personOrOrganizationResult = okResult.Value as PersonOrganization;
+
+            Assert.NotNull(result);
+            Assert.AreEqual(personMemberNumber.ToString(), personOrOrganizationResult.PersonNumber);
+            Assert.AreEqual(personName, personOrOrganizationResult.EntityName);
+            Assert.IsNull(personOrOrganizationResult.OrganizationNumber);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonOrOrganizationNumberByMemberNumber_OrganizationFound()
+        {
+            long organizationMemberNumber = 123;
+            string organizationName = "John E Consulting LLC";
+
+            var personOrOrganization = new PersonOrganization()
+            {
+                OrganizationNumber = organizationMemberNumber.ToString(),
+                EntityName = organizationName
+            };
+
+            _mockMemberService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<long>())).ReturnsAsync(personOrOrganization).Verifiable();
+
+            var result = await _memberController.GetPersonOrOrganizationNumberByMemberId(organizationMemberNumber);
+            var okResult = result as OkObjectResult;
+            var personOrOrganizationResult = okResult.Value as PersonOrganization;
+
+            Assert.NotNull(result);
+            Assert.AreEqual(organizationMemberNumber.ToString(), personOrOrganizationResult.OrganizationNumber);
+            Assert.AreEqual(organizationName, personOrOrganizationResult.EntityName);
+            Assert.IsNull(personOrOrganizationResult.PersonNumber);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonOrOrganizationNumberByMemberNumber_NeitherFound_Exception()
+        {
+            long organizationMemberNumber = 123;
+
+            _mockMemberService.Setup(x => x.GetPersonOrOrganizationNumberByMemberId(It.IsAny<long>())).Throws(new ArgumentNullException()).Verifiable();
+
+            var result = await _memberController.GetPersonOrOrganizationNumberByMemberId(organizationMemberNumber);
+            var notFoundResult = result as StatusCodeResult;
+
+            Assert.NotNull(result);
+            Assert.NotNull(notFoundResult);
+            Assert.AreEqual(404, notFoundResult.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/OrganizationControllerTest.cs

@@ -0,0 +1,298 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Organizations;
+using LCU.Library.Internal.Exceptions;
+using Microsoft.AspNetCore.Http;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class OrganizationControllerTest
+    {
+        private OrganizationController _organizationController;
+        private Mock<IOrganizationService> _mockOrganizationService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockOrganizationService = new Mock<IOrganizationService>();
+
+            _organizationController = new OrganizationController(_mockOrganizationService.Object);
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationNumber_OK()
+        {
+            const long organizationNumber = 123334234324;
+            var testOrganizationResult = new Organization
+            {
+                Name = "Test Organization"
+            };
+            var testOrganizationsResult = new List<Organization> { testOrganizationResult };
+
+            _mockOrganizationService.Setup(x => x.GetOrganizationByOrganizationNumber(organizationNumber)).ReturnsAsync(testOrganizationsResult).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByOrganizationNumber(organizationNumber);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as List<Organization>;
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(testOrganizationResult.Name, result.FirstOrDefault()?.Name);
+            _mockOrganizationService.Verify();
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationNumber_ExceptionThrown_ServerError()
+        {
+            const long organizationNumber = 123334234324;
+           
+            _mockOrganizationService.Setup(x => x.GetOrganizationByOrganizationNumber(organizationNumber)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByOrganizationNumber(organizationNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetOrganizationByOrganizationNumber_ServiceExceptionThrown_ServerError()
+        {
+            const long organizationNumber = 123334234324;
+           
+            _mockOrganizationService.Setup(x => x.GetOrganizationByOrganizationNumber(organizationNumber)).ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByOrganizationNumber(organizationNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetMemberByAccountNumber_ServiceException_ServerErrorReturned()
+        {
+            const long organizationNumber = 123334234324;
+            _mockOrganizationService.Setup(x => x.GetOrganizationByOrganizationNumber(organizationNumber)).ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByOrganizationNumber(organizationNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetMemberByAccountNumber_Exception_ServerErrorReturned()
+        {
+            const long organizationNumber = 123334234324;
+            _mockOrganizationService.Setup(x => x.GetOrganizationByOrganizationNumber(organizationNumber)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByOrganizationNumber(organizationNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetOrganizationByMemberAgreementNumber_OK()
+        {
+            const long memberNumber = 123334234324;
+            var testOrganizationResult = new Organization
+            {
+                Name = "Test Organization"
+            };
+
+            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ReturnsAsync(testOrganizationResult).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByMemberAgreementNumber(memberNumber);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as Organization;
+            Assert.NotNull(result);
+            Assert.AreEqual(testOrganizationResult.Name, result?.Name);
+            _mockOrganizationService.Verify();
+        }
+
+        [Test]
+        public async Task GetOrganizationByMemberAgreementNumber_ServiceException_ServerErrorReturned()
+        {
+            const long memberNumber = 123334234324;
+            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByMemberAgreementNumber(memberNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetOrganizationByMemberAgreementNumber_Exception_ServerErrorReturned()
+        {
+            const long memberNumber = 123334234324;
+            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();
+
+            var results = await _organizationController.GetOrganizationByMemberAgreementNumber(memberNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationName_GetOrganizationByNameThrowsServiceException_Returns500()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            _mockOrganizationService
+                .Setup(os => os.GetOrganizationByName(organizationName))
+                .ThrowsAsync(new ServiceException(string.Empty));
+
+            var response = await _organizationController.GetOrganizationByOrganizationName(organizationName);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationName_GetOrganizationByNameThrowsNonServiceException_500()
+        {
+            var exception = new Exception();
+            var organizationName = Guid.NewGuid().ToString();
+            _mockOrganizationService
+                .Setup(os => os.GetOrganizationByName(organizationName))
+                .ThrowsAsync(exception);
+
+            var response = await _organizationController.GetOrganizationByOrganizationName(organizationName);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationName_GetOrganizationByNameSucceeds_ReturnsOkAndResult()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            var organizations = new[] { new Organization() };
+            _mockOrganizationService
+                .Setup(os => os.GetOrganizationByName(organizationName))
+                .ReturnsAsync(organizations);
+
+            var response = await _organizationController.GetOrganizationByOrganizationName(organizationName);
+
+            Assert.IsInstanceOf<OkObjectResult>(response);
+            Assert.AreSame(organizations, ((OkObjectResult)response).Value);
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationNameLike_ServiceCallReturns_ReturnsOkAndResults()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            var limit = DateTime.Now.Millisecond;
+            var organizations = new []{ new Organization{ Name = organizationName } };
+            _mockOrganizationService
+                .Setup(s => s.GetOrganizationByNameLike(organizationName, limit))
+                .ReturnsAsync(organizations);
+
+            var response = await _organizationController.GetOrganizationByOrganizationNameLike(organizationName, limit);
+
+            Assert.IsInstanceOf<OkObjectResult>(response);
+            Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
+            Assert.AreSame(organizations, ((OkObjectResult)response).Value);
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationNameLike_ServiceThrowsServiceException_Returns500()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            _mockOrganizationService
+                .Setup(s => s.GetOrganizationByNameLike(organizationName, It.IsAny<int?>()))
+                .ThrowsAsync(new ServiceException(string.Empty));
+
+            var response = await _organizationController.GetOrganizationByOrganizationNameLike(organizationName);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task GetOrganizationByOrganizationNameLike_ServiceThrowsException_Returns500()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            _mockOrganizationService
+                .Setup(s => s.GetOrganizationByNameLike(organizationName, It.IsAny<int?>()))
+                .ThrowsAsync(new Exception());
+
+            var response = await _organizationController.GetOrganizationByOrganizationNameLike(organizationName);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+        
+        [Test]
+        public async Task CountOrganizationNumbersByName_ServiceCallReturns_ReturnsOkAndResults()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            var count = DateTime.Now.Millisecond;
+            _mockOrganizationService
+                .Setup(s => s.CountOrganizationNumbersByName(organizationName))
+                .ReturnsAsync(count);
+
+            var response = await _organizationController.CountOrganizationNumbersByName(organizationName);
+
+            Assert.IsInstanceOf<OkObjectResult>(response);
+            Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
+            Assert.AreEqual(count, ((OkObjectResult)response).Value);
+        }
+
+        [Test]
+        public async Task CountOrganizationNumbersByName_ServiceThrowsServiceException_Returns500()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            _mockOrganizationService
+                .Setup(s => s.CountOrganizationNumbersByName(organizationName))
+                .ThrowsAsync(new ServiceException(string.Empty));
+
+            var response = await _organizationController.CountOrganizationNumbersByName(organizationName);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task CountOrganizationNumbersByName_ServiceThrowsException_Returns500()
+        {
+            var organizationName = Guid.NewGuid().ToString();
+            _mockOrganizationService
+                .Setup(s => s.CountOrganizationNumbersByName(organizationName))
+                .ThrowsAsync(new Exception());
+
+            var response = await _organizationController.CountOrganizationNumbersByName(organizationName);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/PersonControllerTest.cs

@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
+using LCU.Library.Internal.Exceptions;
+using Microsoft.AspNetCore.Http;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class PersonControllerTest
+    {
+        private PersonController _personController;
+        private Mock<IPersonService> _mockPersonService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockPersonService = new Mock<IPersonService>();
+            _personController = new PersonController(_mockPersonService.Object);
+        }
+
+        [Test]
+        public async Task GetPersonByPersonNumber_OK()
+        {
+            const long personNumber = 123334234324;
+            var testPersonResult = new Person
+            {
+                FirstName = "Tester"
+            };
+            var testPersonsResult = new List<Person> { testPersonResult };
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(personNumber)).ReturnsAsync(testPersonsResult).Verifiable();
+
+            var results = await _personController.GetPersonByPersonNumber(personNumber);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as List<Person>;
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(testPersonResult.FirstName, result.FirstOrDefault()?.FirstName);
+            _mockPersonService.Verify();
+        }
+
+        [Test]
+        public async Task GetPersonByPersonNumber_ServiceException_ServerErrorReturned()
+        {
+            const long personNumber = 123334234324;
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(personNumber)).ThrowsAsync(new ServiceException("Exception thrown from unit test")).Verifiable();
+
+            var results = await _personController.GetPersonByPersonNumber(personNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonByPersonNumber_Exception_ServerErrorReturned()
+        {
+            const long personNumber = 123334234324;
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(personNumber)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();
+
+            var results = await _personController.GetPersonByPersonNumber(personNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetMemberByMemberAgreeNbr_OK()
+        {
+            const long memberNumber = 123334234324;
+            var testPersonResult = new Person
+            {
+                FirstName = "Tester"
+            };
+
+            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ReturnsAsync(testPersonResult).Verifiable();
+
+            var results = await _personController.GetPersonByMemberAgreementNumber(memberNumber);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as Person;
+            Assert.NotNull(result);
+            Assert.AreEqual(testPersonResult.FirstName, result?.FirstName);
+            _mockPersonService.Verify();
+        }
+
+        [Test]
+        public async Task GetMemberByMemberAgreeNbr_ServiceException_ServerErrorReturned()
+        {
+            const long memberNumber = 123334234324;
+            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ThrowsAsync(new ServiceException("Thrown from unit test")).Verifiable();
+
+            var results = await _personController.GetPersonByMemberAgreementNumber(memberNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetMemberByMemberAgreeNbr_Exception_ServerErrorReturned()
+        {
+            const long memberNumber = 123334234324;
+            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(memberNumber)).ThrowsAsync(new Exception("Thrown from unit test")).Verifiable();
+
+            var results = await _personController.GetPersonByMemberAgreementNumber(memberNumber);
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonNameLike_RequestModelInvalid_Returns400()
+        {
+            var modelErrorKey = Guid.NewGuid().ToString();
+            var modelErrorMessage = Guid.NewGuid().ToString();
+            _personController.ModelState.AddModelError(modelErrorKey, modelErrorMessage);
+
+            var response = await _personController.GetPersonNameLike(new PersonNameRequest());
+
+            Assert.IsInstanceOf<BadRequestObjectResult>(response);
+            Assert.AreEqual(StatusCodes.Status400BadRequest, ((BadRequestObjectResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonNameLike_ServiceThrowsServiceException_Returns500()
+        {
+            var request = new PersonNameRequest();
+            var limit = DateTime.Now.Millisecond;
+            _mockPersonService
+                .Setup(s => s.GetPersonsByNameLike(request, limit))
+                .ThrowsAsync(new ServiceException(string.Empty));
+
+            var response = await _personController.GetPersonNameLike(request, limit);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonNameLike_ServiceThrowsException_Returns500()
+        {
+            var request = new PersonNameRequest();
+            var limit = DateTime.Now.Millisecond;
+            _mockPersonService
+                .Setup(s => s.GetPersonsByNameLike(request, limit))
+                .ThrowsAsync(new Exception());
+
+            var response = await _personController.GetPersonNameLike(request, limit);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonNameLike_ServiceReturnsPeople_Returns200AndPeople()
+        {
+            var request = new PersonNameRequest();
+            var limit = DateTime.Now.Millisecond;
+            var people = Enumerable.Repeat<Func<Person>>(() => new Person(), limit).Select(f => f()).ToArray();
+            _mockPersonService
+                .Setup(s => s.GetPersonsByNameLike(request, limit))
+                .ReturnsAsync(people);
+
+            var response = await _personController.GetPersonNameLike(request, limit);
+
+            Assert.IsInstanceOf<OkObjectResult>(response);
+            Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
+            Assert.AreEqual(people, ((OkObjectResult)response).Value);
+        }
+
+        [Test]
+        public async Task CountPersonNameLike_RequestModelInvalid_Returns400()
+        {
+            var modelErrorKey = Guid.NewGuid().ToString();
+            var modelErrorMessage = Guid.NewGuid().ToString();
+            _personController.ModelState.AddModelError(modelErrorKey, modelErrorMessage);
+
+            var response = await _personController.CountPersonNameLike(new PersonNameRequest());
+
+            Assert.IsInstanceOf<BadRequestObjectResult>(response);
+            Assert.AreEqual(StatusCodes.Status400BadRequest, ((BadRequestObjectResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task CountPersonNameLike_ServiceThrowsServiceException_Returns500()
+        {
+            var request = new PersonNameRequest();
+            var limit = DateTime.Now.Millisecond;
+            _mockPersonService
+                .Setup(s => s.CountPersonsByNameLike(request))
+                .ThrowsAsync(new ServiceException(string.Empty));
+
+            var response = await _personController.CountPersonNameLike(request);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task CountPersonNameLike_ServiceThrowsException_Returns500()
+        {
+            var request = new PersonNameRequest();
+            var limit = DateTime.Now.Millisecond;
+            _mockPersonService
+                .Setup(s => s.CountPersonsByNameLike(request))
+                .ThrowsAsync(new Exception());
+
+            var response = await _personController.CountPersonNameLike(request);
+
+            Assert.IsInstanceOf<StatusCodeResult>(response);
+            Assert.AreEqual(StatusCodes.Status500InternalServerError, ((StatusCodeResult)response).StatusCode);
+        }
+
+        [Test]
+        public async Task CountPersonNameLike_ServiceReturnsPeople_Returns200AndCount()
+        {
+            var request = new PersonNameRequest();
+            var count = DateTime.Now.Ticks;
+            _mockPersonService
+                .Setup(s => s.CountPersonsByNameLike(request))
+                .ReturnsAsync(count);
+
+            var response = await _personController.CountPersonNameLike(request);
+
+            Assert.IsInstanceOf<OkObjectResult>(response);
+            Assert.AreEqual(StatusCodes.Status200OK, ((OkObjectResult)response).StatusCode);
+            Assert.AreEqual(count, ((OkObjectResult)response).Value);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/PersonUserFieldControllerTest.cs

@@ -0,0 +1,289 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class PersonUserFieldControllerTest
+    {
+        private PersonUserFieldController _personUserFieldController;
+        private Mock<IPersonUserFieldService> _mockPersonUserFieldService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockPersonUserFieldService = new Mock<IPersonUserFieldService>();
+            _personUserFieldController = new PersonUserFieldController(_mockPersonUserFieldService.Object);
+        }
+
+        [Test]
+        public async Task PutPersonUserFieldsAtmCheckHolds_OK()
+        {
+            var personUserField1 = new PersonUserField()
+            {
+                Id = "TEST1",
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+
+            _mockPersonUserFieldService.Setup(x => x.UpdatePersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).ReturnsAsync(personUserField1);
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PutPersonUserFieldForAtmCheckHolds(personUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutPersonUserFieldsAtmCheckholds_Exception()
+        {
+
+            _mockPersonUserFieldService.Setup(x => x.UpdatePersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).Throws(new NullReferenceException("Oops"));
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PutPersonUserFieldForAtmCheckHolds(personUserFieldUpdateRequest);
+            _mockPersonUserFieldService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task PostPersonUserFieldsAtmCheckhold_OK()
+        {
+            var personUserField1 = new PersonUserField()
+            {
+                Id = "TEST1",
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+
+            _mockPersonUserFieldService.Setup(x => x.InsertPersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).ReturnsAsync(personUserField1);
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PostPersonUserFieldForAtmCheckHolds(personUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PostPersonUserFieldsAtmCHeckhold_Exception()
+        {
+            _mockPersonUserFieldService.Setup(x => x.InsertPersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).Throws(new NullReferenceException("Nope!"));
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PostPersonUserFieldForAtmCheckHolds(personUserFieldUpdateRequest);
+            _mockPersonUserFieldService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonUserFieldsForAtmCheckHolds_OK()
+        {
+            var personUserField1 = new PersonCheckHoldsUserField()
+            {
+                PersonNumber = 100001,
+                OldestActiveEffectiveDate = DateTime.UtcNow,
+                RecentClosedEffectiveDate = DateTime.UtcNow,
+                UserFieldExists = true,
+
+            };
+
+            var personUserField2 = new PersonCheckHoldsUserField()
+            {
+                PersonNumber = 200001,
+                OldestActiveEffectiveDate = DateTime.UtcNow,
+                RecentClosedEffectiveDate = DateTime.UtcNow,
+                UserFieldExists = false,
+            };
+
+            _mockPersonUserFieldService.Setup(x => x.GetPersonsForAtmCheckHolds(It.IsAny<DateTime>(), It.IsAny<DateTime>())).ReturnsAsync(
+                new List<PersonCheckHoldsUserField>()
+                {
+                    personUserField1,
+                    personUserField2
+                });
+
+            var results = await _personUserFieldController.GetPersonsForAtmCheckHolds(DateTime.Now, DateTime.Now, 0);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetPersonUserFieldsForAtmCheckHoldsLimit_OK()
+        {
+            var personUserField1 = new PersonCheckHoldsUserField()
+            {
+                PersonNumber = 100001,
+                OldestActiveEffectiveDate = DateTime.UtcNow,
+                RecentClosedEffectiveDate = DateTime.UtcNow,
+                UserFieldExists = true,
+
+            };
+
+            var personUserField2 = new PersonCheckHoldsUserField()
+            {
+                PersonNumber = 200001,
+                OldestActiveEffectiveDate = DateTime.UtcNow,
+                RecentClosedEffectiveDate = DateTime.UtcNow,
+                UserFieldExists = false,
+            };
+
+            _mockPersonUserFieldService.Setup(x => x.GetPersonsForAtmCheckHolds(It.IsAny<DateTime>(), It.IsAny<DateTime>())).ReturnsAsync(
+                new List<PersonCheckHoldsUserField>()
+                {
+                    personUserField1
+                });
+
+            var results = await _personUserFieldController.GetPersonsForAtmCheckHolds(DateTime.Now, DateTime.Now, 1);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutPersonUserFieldsGeneric_OK()
+        {
+            var personUserField1 = new PersonUserField()
+            {
+                Id = "TEST1",
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+
+            _mockPersonUserFieldService.Setup(x => x.UpdatePersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).ReturnsAsync(personUserField1);
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PutPersonUserField(personUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutPersonUserFieldsGeneric_Exception()
+        {
+
+            _mockPersonUserFieldService.Setup(x => x.UpdatePersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).Throws(new NullReferenceException("Oops"));
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PutPersonUserField(personUserFieldUpdateRequest);
+            _mockPersonUserFieldService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task PostPersonUserFieldsGeneric_OK()
+        {
+            var personUserField1 = new PersonUserField()
+            {
+                Id = "TEST1",
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+
+            _mockPersonUserFieldService.Setup(x => x.InsertPersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).ReturnsAsync(personUserField1);
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PostPersonUserField(personUserFieldUpdateRequest);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PostPersonUserFieldsGeneric_Exception()
+        {
+            _mockPersonUserFieldService.Setup(x => x.InsertPersonUserFieldAsync(It.IsAny<PersonUserFieldRequest>())).Throws(new NullReferenceException("Nope!"));
+
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var results = await _personUserFieldController.PostPersonUserField(personUserFieldUpdateRequest);
+            _mockPersonUserFieldService.Verify();
+
+            var badRes = results as ObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/PropertyUserFieldControllerTest.cs

@@ -0,0 +1,145 @@
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Properties;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class PropertyUserFieldControllerTest
+    {
+        private PropertyUserFieldController _propertyUserFieldController;
+        private Mock<IPropertyUserFieldService> _mockPropertyUserFieldService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockPropertyUserFieldService = new Mock<IPropertyUserFieldService>();
+            _propertyUserFieldController = new PropertyUserFieldController(_mockPropertyUserFieldService.Object);
+        }
+     
+        [Test]
+        public async Task GetPropertyUserField_ExceptionAsync()
+        {
+            _mockPropertyUserFieldService.Setup(x => x.GetPropertyUserFieldsAsync(1000)).Throws(new Exception("Unit Test Failed"));
+
+            var propertyUserField = new PropertyUserField()
+            {
+                Id = "TEST",
+                PropertyNumber = 1000,
+                UserFieldCode = "TEST",
+                Value = "TEST"
+            };
+
+            var results = await _propertyUserFieldController.GetPropertyUserField(1000);
+
+            Assert.NotNull(results);
+            var badResult = results as ObjectResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PostPropertyUserField_OkAsync()
+        {
+            var propertyUserField = new PropertyUserField()
+            {
+                Id = "TEST",
+                PropertyNumber = 1000,
+                UserFieldCode = "TEST",
+                Value = "TEST"
+            };
+
+            BasicResponse basicResponse = new BasicResponse()
+            {
+                Success = true,
+            };
+
+            _mockPropertyUserFieldService.Setup(x => x.InsertPropertyUserFieldAsync(It.IsAny<PropertyUserField>())).ReturnsAsync(basicResponse);
+
+            var results = await _propertyUserFieldController.PostPropertyUserField(propertyUserField);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PostPropertyUserField_ExceptionAsync()
+        {
+            _mockPropertyUserFieldService.Setup(x => x.InsertPropertyUserFieldAsync(It.IsAny<PropertyUserField>())).Throws(new Exception("Unit Test Failed"));
+
+            var propertyUserField = new PropertyUserField()
+            {
+                Id = "TEST",
+                PropertyNumber = 1000,
+                UserFieldCode = "TEST",
+                Value = "TEST"
+            };
+
+            var results = await _propertyUserFieldController.PostPropertyUserField(propertyUserField);
+
+            Assert.NotNull(results);
+            var badResult = results as ObjectResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutPropertyUserField_OkAsync()
+        {
+            var propertyUserField = new PropertyUserField()
+            {
+                Id = "TEST",
+                PropertyNumber = 1000,
+                UserFieldCode = "TEST",
+                Value = "TEST"
+            };
+
+            BasicResponse basicResponse = new BasicResponse()
+            {
+                Success = true,
+            };
+
+            _mockPropertyUserFieldService.Setup(x => x.UpdatePropertyUserFieldAsync(It.IsAny<PropertyUserField>())).ReturnsAsync(basicResponse);
+
+            var results = await _propertyUserFieldController.PutPropertyUserField(propertyUserField);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task PutPropertyUserField_ExceptionAsync()
+        {
+            _mockPropertyUserFieldService.Setup(x => x.UpdatePropertyUserFieldAsync(It.IsAny<PropertyUserField>())).Throws(new Exception("Unit Test Failed"));
+
+            var propertyUserField = new PropertyUserField()
+            {
+                Id = "TEST",
+                PropertyNumber = 1000,
+                UserFieldCode = "TEST",
+                Value = "TEST"
+            };
+
+            var results = await _propertyUserFieldController.PutPropertyUserField(propertyUserField);
+
+            Assert.NotNull(results);
+            var badResult = results as ObjectResult;
+            Assert.NotNull(badResult);
+            Assert.AreEqual(500, badResult.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/TaxControllerTest.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using System.Threading.Tasks;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class TaxControllerTest
+    {
+        private TaxController _taxController;
+        private Mock<ITaxService> _mockTaxService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockTaxService = new Mock<ITaxService>();
+            _taxController = new TaxController(_mockTaxService.Object);
+        }
+
+        [Test]
+        public async Task GetPersonsTaxIdData_OK()
+        {
+            var personTaxIdDataResponse = new List<PersonTaxIdDataResponse>
+            {
+                new() {
+                    FirstName = "Greg",
+                    MiddleInitial = "H",
+                    LastName = "Stevens",
+                    Suffix = "Jr.",
+                    NameFull = "Greg H. Stevens Jr.",
+                    PersonNumber = 123
+                }
+            };
+
+            _mockTaxService.Setup(service => service.GetPersonsTaxIdData("123")).ReturnsAsync(personTaxIdDataResponse).Verifiable();
+            var results = await _taxController.GetPersonsTaxIdData("123");
+            
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var dataResponse = okResult.Value as IEnumerable<PersonTaxIdDataResponse>;
+            Assert.NotNull(dataResponse);
+            Assert.AreEqual(1, dataResponse.Count());
+            var firstResponse = dataResponse.First();
+            Assert.AreEqual("Greg",firstResponse.FirstName);
+            Assert.AreEqual("H", firstResponse.MiddleInitial);
+            Assert.AreEqual("Stevens", firstResponse.LastName);
+            Assert.AreEqual("Jr.", firstResponse.Suffix);
+            Assert.AreEqual("Greg H. Stevens Jr.", firstResponse.NameFull);
+            Assert.AreEqual(123, firstResponse.PersonNumber);
+            _mockTaxService.Verify();
+        }
+        
+        [Test]
+        public async Task GetPersonsTaxIdData_EmptyString_BadRequest()
+        {
+            
+            var results = await _taxController.GetPersonsTaxIdData("");
+            
+            Assert.NotNull(results);
+            var okResult = results as BadRequestObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(400, okResult.StatusCode);
+            
+            _mockTaxService.Verify(service => service.GetPersonsTaxIdData(It.IsAny<string>()), Times.Never);
+        }
+        
+        [Test]
+        public async Task GetPersonsTaxIdData_ErrorThrown_ServerError()
+        {
+            _mockTaxService.Setup(service => service.GetPersonsTaxIdData("123")).ThrowsAsync(new Exception("Thrown from unit test."));
+            var results = await _taxController.GetPersonsTaxIdData("123");
+            
+            Assert.NotNull(results);
+            var okResult = results as StatusCodeResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(500, okResult.StatusCode);
+            _mockTaxService.Verify();
+        }
+        
+        [Test]
+        public async Task GetOrganizationsTaxIdData_OK()
+        {
+            var organizationsTaxIdDataResponse = new List<OrganizationTaxIdDataResponse>
+            {
+                new() {
+                    Name = "Electric Company",
+                    OrganizationNumber = 123
+                }
+            };
+
+            _mockTaxService.Setup(service => service.GetOrganizationsTaxIdData("123")).ReturnsAsync(organizationsTaxIdDataResponse).Verifiable();
+            var results = await _taxController.GetOrganizationsTaxIdData("123");
+            
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+            
+            var dataResponse = okResult.Value as IEnumerable<OrganizationTaxIdDataResponse>;
+            Assert.NotNull(dataResponse);
+            Assert.AreEqual(1, dataResponse.Count());
+            var firstResponse = dataResponse.First();
+            Assert.AreEqual("Electric Company",firstResponse.Name);
+            Assert.AreEqual(123, firstResponse.OrganizationNumber);
+            _mockTaxService.Verify();
+        }
+        
+        [Test]
+        public async Task GetOrganizationsTaxIdData_EmptyString_BadRequest()
+        {
+            
+            var results = await _taxController.GetOrganizationsTaxIdData("");
+            
+            Assert.NotNull(results);
+            var okResult = results as BadRequestObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(400, okResult.StatusCode);
+            
+            _mockTaxService.Verify(service => service.GetOrganizationsTaxIdData(It.IsAny<string>()), Times.Never);
+        }
+        
+        [Test]
+        public async Task GetOrganizationsTaxIdData_ErrorThrown_ServerError()
+        {
+            _mockTaxService.Setup(service => service.GetOrganizationsTaxIdData("123")).ThrowsAsync(new Exception("Thrown from unit test."));
+            var results = await _taxController.GetOrganizationsTaxIdData("123");
+            
+            Assert.NotNull(results);
+            var okResult = results as StatusCodeResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(500, okResult.StatusCode);
+            _mockTaxService.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Controllers/TransactionControllerTest.cs

@@ -0,0 +1,202 @@
+using LCU.Api.Internal.CoreApiWrapper.Configuration;
+using LCU.Api.Internal.CoreApiWrapper.Controllers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Transaction;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Controllers
+{
+    public class TransactionControllerTest
+    {
+        private TransactionController _transactionController;
+        private Mock<ITransactionService> _mockTransactionService;
+        private CoreApiWrapperConfig _coreApiWrapperConfig;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockTransactionService = new Mock<ITransactionService>();
+            _coreApiWrapperConfig = new CoreApiWrapperConfig
+            {
+                FeatureFlags = new FeatureFlags
+                {
+                    DisableCoreDBWrite = false
+                }
+            };
+            _transactionController = new TransactionController(_mockTransactionService.Object, _coreApiWrapperConfig);
+        }
+
+        [Test]
+        public async Task PostMonetaryTransactions_OK()
+        {
+            _mockTransactionService.Setup(x => x.AddMonetaryTransactionsAsync(It.IsAny<List<GroupedMonetaryTransactionRequest>>())).ReturnsAsync(
+                                                new List<MonetaryTransactionResponse>() { });
+
+            var groupRequest = new GroupedMonetaryTransactionRequest()
+            {
+                MonetaryTransactionRequests = new List<MonetaryTransactionRequest>() {
+                new MonetaryTransactionRequest()
+                {
+                        AccountNumber = 19617805142,
+                        TransactionAmount = -1.27,
+                        ApprovalPersonNumber = 5225,
+                        RequestNumber = "1",
+                        OverrideCashBoxNumber = 800,
+                        TransactionTypeCode = "DRIR",
+                        Description = "",
+                        BalanceTypes = new List<BalanceType1> {
+                            new BalanceType1() {
+                                BalanceCategoryCode = "UPFR",
+                                BalanceTypeCode = "DLR",
+                                BalanceTypeAmount = -1.27
+                            }
+                        },
+                        Funds = new List<Fund> {
+                            new Fund() {
+                                ClearingCategoryCode = "IMED",
+                                FundAmount = -1.27,
+                                FundTypeCode = "EL",
+                                FundTypeDetailCode = "INTR",
+                                NumberOfItems = 1
+                            }
+                        }
+                    }
+                }
+            };
+
+            var response = new MonetaryTransactionResponse()
+            {
+                WasSuccessful = false
+            };
+
+            var listResponse = new List<MonetaryTransactionResponse> { response };
+            var listGroupRequest = new List<GroupedMonetaryTransactionRequest> { groupRequest };
+
+            var result = await _transactionController.PostMonetaryTransactions(listGroupRequest);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+        }
+
+        [Test]
+        public async Task GetTransactionHistory_OK()
+        {
+            _mockTransactionService.Setup(x => x.GetTransactionHistory(123334234324, 
+                                                                       Convert.ToDateTime("12/25/2020"), 
+                                                                       Convert.ToDateTime("2/2/2021"),
+                                                                       null)).ReturnsAsync(
+                new List<TransactionHistory>
+                {
+                  new TransactionHistory()
+                  {
+                      AccountNumber = 123334234324,
+                      ActivityDateTime = Convert.ToDateTime("1/1/2021")
+                  },
+                  new TransactionHistory()
+                  {
+                      AccountNumber = 123334234324,
+                      ActivityDateTime = Convert.ToDateTime("1/2/2021")
+                  }
+                }).Verifiable();
+
+            var results = await _transactionController.GetTransactionHistory(123334234324, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as IEnumerable<TransactionHistory>;
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            _mockTransactionService.Verify();
+        }
+
+        [Test]
+        public async Task GetTransactionHistory_Null_NotFoundException()
+        {
+            _mockTransactionService.Setup(x => x.GetTransactionHistory(It.IsAny<long>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>())).ReturnsAsync((IEnumerable<TransactionHistory>)null);
+
+            var results = await _transactionController.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));
+
+            Assert.NotNull(results);
+            var notFoundRes = results as NotFoundResult;
+            Assert.NotNull(notFoundRes);
+            Assert.AreEqual(404, notFoundRes.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetTransactionHistory_EmptyList_NoContentException()
+        {
+            _mockTransactionService.Setup(x => x.GetTransactionHistory(It.IsAny<long>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>())).ReturnsAsync(new List<TransactionHistory>());
+
+            var results = await _transactionController.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));
+
+            Assert.NotNull(results);
+            var noContentResult = results as NoContentResult;
+            Assert.NotNull(noContentResult);
+            Assert.AreEqual(204, noContentResult.StatusCode);
+        }
+        
+        [Test]
+        public async Task GetTransactionHistory_Exception()
+        {
+            _mockTransactionService.Setup(x => x.GetTransactionHistory(It.IsAny<long>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>()))
+               .Throws(new Exception("Oops"));
+
+            var results = await _transactionController.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"));
+
+            Assert.NotNull(results);
+            var badRes = results as StatusCodeResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(500, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetTransactionsByDateSpan_OK()
+        {
+            _mockTransactionService.Setup(x => x.GetTransactionsByDateSpan(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string[]>())).ReturnsAsync(new List<TransactionAlertInfo>() { new TransactionAlertInfo() });
+
+            var results = await _transactionController.GetTransactionsByDateSpan(DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow, new string[1]);
+
+            Assert.NotNull(results);
+            var okResult = results as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.AreEqual(200, okResult.StatusCode);
+
+            var result = okResult.Value as IEnumerable<TransactionAlertInfo>;
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count());
+        }
+
+        [Test]
+        public async Task GetTransactionsByDateSpan_Exception_DateOrder()
+        {
+            var results = await _transactionController.GetTransactionsByDateSpan(DateTime.UtcNow, DateTime.UtcNow.AddMinutes(-1));
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+
+        [Test]
+        public async Task GetTransactionsByDateSpan_Exception_DateMinimum()
+        {
+            var results = await _transactionController.GetTransactionsByDateSpan(DateTime.MinValue, DateTime.UtcNow);
+
+            Assert.NotNull(results);
+            var badRes = results as BadRequestObjectResult;
+            Assert.NotNull(badRes);
+            Assert.AreEqual(400, badRes.StatusCode);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/CoreApiUtilities/CoreRequestTest.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using Moq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.CoreApiUtilities
+{
+    public class CoreRequestTest
+    {
+        private readonly CoreRequest _coreRequest;
+        private readonly Mock<IHttpClientFactory> _mockClientFactory;
+        private readonly Mock<ICoreServiceConnection> _mockCoreServiceConnection;
+
+        public CoreRequestTest()
+        {
+            _mockClientFactory = new Mock<IHttpClientFactory>();
+            _mockCoreServiceConnection = new Mock<ICoreServiceConnection>();
+            var coreConfiguration = new CoreConfiguration()
+            {
+                CoreApiConfiguration = new CoreApiConfiguration()
+            };
+
+            _coreRequest = new CoreRequest(_mockClientFactory.Object,
+                                           _mockCoreServiceConnection.Object,
+                                           coreConfiguration);
+        }
+
+        [Test]
+        public void CreateHttpRequestMessage_NoBodyOrContent_CorrectUrl()
+        {
+            var testEndPoint = "endpoint/test";
+
+            var coreConfiguration = new CoreConfiguration()
+            {
+                CoreApiConfiguration = new CoreApiConfiguration()
+                {
+                    HostUrl = "https://CoreTEST.com",
+                    HostPort = "1111",
+                    ApiChannelId = "TEST-afjksd9-0sakjf-klsdja-fpsjad"
+                }
+            };
+
+            var coreRequest = new CoreRequest(_mockClientFactory.Object,
+                                              _mockCoreServiceConnection.Object,
+                                              coreConfiguration);
+
+            _mockCoreServiceConnection.Setup(x => x.GetAccessToken()).Returns("TESTAafjp07087jfjas0d908qj324");
+
+            var result = coreRequest.CreateHttpRequestMessage(testEndPoint, HttpMethod.Post);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("//CoreTEST.com:1111endpoint/test", result.RequestUri.AbsolutePath);
+            Assert.AreEqual("TESTAafjp07087jfjas0d908qj324", result.Headers.Authorization.Scheme);
+            Assert.IsNull(result.Content);
+        }
+
+        [Test]
+        public void CreateHttpRequestMessage_BodyIsJson()
+        {
+            var testCompare = new Dictionary<string, string>();
+            testCompare.Add("FirstName", "Test");
+            var jsonTestCompare = JsonConvert.SerializeObject(testCompare);
+
+            var testEndPoint = "endpoint/test";
+
+            var coreConfiguration = new CoreConfiguration()
+            {
+                CoreApiConfiguration = new CoreApiConfiguration()
+                {
+                    HostUrl = "https://CoreTEST.com",
+                    HostPort = "1111"
+                }
+            };
+
+            var coreRequest = new CoreRequest(_mockClientFactory.Object,
+                                          _mockCoreServiceConnection.Object,
+                                          coreConfiguration);
+
+            _mockCoreServiceConnection.Setup(x => x.GetAccessToken()).Returns("TESTAafjp07087jfjas0d908qj324");
+
+            var result = coreRequest.CreateHttpRequestMessage(testEndPoint, HttpMethod.Post, jsonTestCompare);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("//CoreTEST.com:1111endpoint/test", result.RequestUri.AbsolutePath);
+            Assert.AreEqual("TESTAafjp07087jfjas0d908qj324", result.Headers.Authorization.Scheme);
+            Assert.NotNull(result.Content);
+        }       
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/AccountDaoTest.cs

@@ -0,0 +1,438 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
+using LCU.Library.Internal.ApiSecurity.Models;
+using LCU.Library.Internal.LcuHttpClient.HttpRequest;
+using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class AccountDaoTest
+    {
+        private IAccountDao _accountDao;
+        private CoreConfiguration _coreConfiguration;
+        private ApiSecurityConfiguration _apiSecurityConfiguration;
+        private Mock<ICoreRequest> _mockCoreRequest;
+        private Mock<ICoreDbExecution> _mockCoreDbExecution;
+        private Mock<IPostRequest> _mockPostRequest;
+        private Mock<IPutRequest> _mockPutRequest;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _mockCoreRequest = new Mock<ICoreRequest>();
+            _mockPostRequest = new Mock<IPostRequest>();
+            _mockPutRequest = new Mock<IPutRequest>();
+
+            _coreConfiguration = new CoreConfiguration()
+            {
+                CoreSoapApiConfiguration = new CoreSoapApiConfiguration()
+                {
+                    CoreSoapApiWrapperHost = "test.lcu-internal.com",
+                    CoreSoapEndpointConfiguration = new CoreSoapEndpointConfiguration()
+                    {
+                        PutAccountAnalysisGroupMaintenanceRequest = "TEST/Account/AccountAnalysisGroupMaintenanceRequest"
+                    }
+                }
+            };
+
+            _apiSecurityConfiguration = new ApiSecurityConfiguration()
+            {
+                InternalApiKeySet = new Dictionary<string, string>()
+                {
+                    ["CoreSoapApiWrapper"] = "TEST"
+                }
+            };
+
+            _accountDao = new AccountDao(_mockCoreRequest.Object,
+                                         _coreConfiguration,
+                                         _apiSecurityConfiguration,
+                                         _mockCoreDbExecution.Object,
+                                         _mockPostRequest.Object,
+                                         _mockPutRequest.Object);
+        }
+
+        [Test]
+        public async Task GetActivityAccountDetailsByAccountNumbers_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<ActivityAccountDetails, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<ActivityAccountDetails>()
+                {
+                    new() {AccountNumber = 1},
+                    new() {AccountNumber = 2},
+                    new() {AccountNumber = 3}
+                }).Verifiable();
+
+            var results = await _accountDao.GetActivityAccountDetailsByAccountNumbers(new List<string>() { "1", "2", "3" });
+            Assert.NotNull(results);
+            Assert.AreEqual(3,results.Count);
+
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<ActivityAccountDetails, object>(It.Is<string>(str => str.Contains("ActivityAccountDetailsByAccountNbr") && str.Contains(":accountNumbers")),
+                    It.IsAny<It.IsAnyType>()));
+        }
+        
+        [Test]
+        public async Task GetActivityAccountDetailsByAccountNumbers_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<ActivityAccountDetails, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accountDao.GetActivityAccountDetailsByAccountNumbers(new List<string>() { "1", "2", "3" }));
+          
+            
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<ActivityAccountDetails, object>(It.Is<string>(str => str.Contains("ActivityAccountDetailsByAccountNbr") && str.Contains(":accountNumbers")),
+                    It.IsAny<It.IsAnyType>()));
+        }
+
+        [Test]
+        public async Task FindOwnersByAccountNumber_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<AccountOwnership> { new AccountOwnership() { FirstName = "Tim" } }).Verifiable();
+
+            var result = await _accountDao.FindOwnersByAccountNumber(12345, new DateTime());
+
+            Assert.NotNull(result);
+            var firstResult = result.First();
+            Assert.AreEqual(firstResult.FirstName, "Tim");
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public void FindOwnersByAccountNumber_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Error thrown from unit test"));
+
+            Assert.ThrowsAsync<Exception>(async () => await _accountDao.FindOwnersByAccountNumber(12345, new DateTime()));
+
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public async Task FindOwnersByPersonName_OK()
+        {
+            var firstName = "Tim";
+            var role = "OWN";
+
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<AccountOwnership> { new AccountOwnership() { FirstName = firstName, Role = role } }).Verifiable();
+
+            var result = await _accountDao.FindPrimaryOwnersByPersonName(firstName);
+
+            Assert.NotNull(result);
+            var firstResult = result.First();
+            Assert.AreEqual(firstResult.FirstName, firstName);
+            Assert.AreEqual(firstResult.Role, role);
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public void FindOwnersByPersonName_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Error thrown from unit test"));
+
+            Assert.ThrowsAsync<Exception>(async () => await _accountDao.FindPrimaryOwnersByPersonName("Tim"));
+
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public async Task FindOwnersByOrganizationName_OK()
+        {
+            var organizationName = "The Big Company";
+
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<AccountOwnership> { new AccountOwnership() { OrganizationName = organizationName } }).Verifiable();
+
+            var result = await _accountDao.FindPrimaryOwnersByOrganizationName(organizationName);
+
+            Assert.NotNull(result);
+            var firstResult = result.First();
+            Assert.AreEqual(firstResult.OrganizationName, organizationName);
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public void FindOwnersByOrganizationName_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AccountOwnership, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Error thrown from unit test"));
+
+            Assert.ThrowsAsync<Exception>(async () => await _accountDao.FindPrimaryOwnersByOrganizationName("The Big Company"));
+
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public async Task FindAccountsForGroupAnalysisUpdate_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<string>(It.IsAny<string>()))
+                .ReturnsAsync(new List<string> { { "11111111" }, { "22222222" } }).Verifiable();
+
+           var result = await _accountDao.FindAccountsToUpdateAccountAnalysis();
+
+            Assert.NotNull(result);
+            Assert.AreEqual(result.First(), "11111111");
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public async Task FindAccountsForGroupAnalysisUpdate_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<string, object>(null, null))
+                .ThrowsAsync(new Exception("Error thrown from unit test"));
+            _mockCoreDbExecution.Verify();
+            var result = await _accountDao.FindAccountsToUpdateAccountAnalysis();
+
+            Assert.IsEmpty(result);
+        }
+
+        [Test]
+        public async Task UpdateAccountsForGroupAnalysisUpdate_OK()
+        {
+            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
+            {
+                AccountNumber = 123,
+                IsGenerateAnalysisStatement = true,
+                IsPrintAnalysisStatement = true,
+                IsUseForServiceCharge = true
+            };
+
+            var basicResponse = new BasicResponse()
+            {
+                Success = true
+            };
+
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountAnalysisGroupMaintenanceRequest);
+            _mockPutRequest.Setup(x => x.Async<AccountAnalysisGroupMaintenanceRequest, BasicResponse>(endpoint,
+                                                                                                      It.IsAny<AccountAnalysisGroupMaintenanceRequest>(),
+                                                                                                      It.IsAny<Dictionary<string, string>>(),
+                                                                                                      It.IsAny<int>(),
+                                                                                                      It.IsAny<int>()))
+                .ReturnsAsync(basicResponse).Verifiable();
+
+            var result = await _accountDao.UpdateAccountAnalysis(accountAnalysisGroupMaintenanceRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(result.Success, true);
+        }
+
+        [Test]
+        public async Task UpdateAccountsForGroupAnalysisUpdate_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<string, object>(null, null))
+                .ThrowsAsync(new Exception("Error thrown from unit test"));
+            _mockCoreDbExecution.Verify();
+            var result = await _accountDao.FindAccountsToUpdateAccountAnalysis();
+
+            Assert.IsEmpty(result);
+        }
+
+        [Test]
+        public async Task UpdateAccountNickName_OK()
+        {
+            var accountRequest = new AccountNickNameUpdateRequest()
+            {
+                AccountNumber = 123,
+                AccountDescription = "TestOk"
+            };
+
+            var basicResponse = new BasicResponse()
+            {
+                Success = true
+            };
+
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountNickNameUpdateRequest);
+            _mockPutRequest.Setup(x => x.Async<AccountNickNameUpdateRequest, BasicResponse>(endpoint,
+                                                                                            It.IsAny<AccountNickNameUpdateRequest>(),
+                                                                                            It.IsAny<Dictionary<string, string>>(),
+                                                                                            It.IsAny<int>(),
+                                                                                            It.IsAny<int>()))
+                .ReturnsAsync(basicResponse).Verifiable();
+
+            var result = await _accountDao.UpdateAccountNickName(accountRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(result.Success, true);
+        }
+
+        [Test]
+        public async Task UpdateAccountNickName_Exception()
+        {
+            var accountRequest = new AccountNickNameUpdateRequest()
+            {
+                AccountNumber = 0,
+                AccountDescription = "TestError"
+            };
+            var result = await _accountDao.UpdateAccountNickName(accountRequest);
+
+            Assert.IsNull(result);
+        }
+        [Test]
+        public async Task UpdateAccountCreditReportType_OK()
+        {
+            var accountRequest = new AccountCreditReportTypeUpdateRequest()
+            {
+                AccountNumber = 123,
+                CreditReportType = "EXCL"
+            };
+
+            var basicResponse = new BasicResponse()
+            {
+                Success = true
+            };
+
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                           _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountCreditReportTypeUpdateRequest);
+            _mockPutRequest.Setup(x => x.Async<AccountCreditReportTypeUpdateRequest, BasicResponse>(endpoint,
+                                                                                                    It.IsAny<AccountCreditReportTypeUpdateRequest>(),
+                                                                                                    It.IsAny<Dictionary<string, string>>(),
+                                                                                                    It.IsAny<int>(),
+                                                                                                    It.IsAny<int>()))
+                .ReturnsAsync(basicResponse).Verifiable();
+
+            var result = await _accountDao.UpdateAccountCreditReportType(accountRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(result.Success, true);
+        }
+
+        [Test]
+        public async Task UpdateAccountCreditReportType_Exception()
+        {
+            var accountRequest = new AccountCreditReportTypeUpdateRequest()
+            {
+                AccountNumber = 0,
+                CreditReportType = "EXCL"
+            };
+            var result = await _accountDao.UpdateAccountCreditReportType(accountRequest);
+
+            Assert.IsNull(result);
+        }
+
+        [Test]
+        public async Task GetAccountsByMajorMinorBranchAndStatus_OK()
+        {
+            var request = new AccountsByMajorMinorBranchAndStatusRequest()
+            {
+                BranchCodes = new List<long>()
+                {
+                    1234,
+                    1235
+                },
+                AccountStatuses = new List<string>()
+                {
+                    "Status"
+                },
+                MajorTypes = new List<string>()
+                {
+                    "Major"
+                },
+                MinorTypes = new List<string>()
+                {
+                    "MinorOne",
+                    "MinorTwo"
+                }
+            };
+
+            var response = new List<AccountsByMajorMinorBranchAndStatusResponse>()
+            {
+                new AccountsByMajorMinorBranchAndStatusResponse()
+                {
+                    AccountNumber = 1234,
+                    BranchCode = 987654321,
+                    Name = "Test Name"
+                },
+                new AccountsByMajorMinorBranchAndStatusResponse()
+                {
+                    AccountNumber = 5678,
+                    BranchCode = 987654321,
+                    Name = "Test Name Two"
+                }
+            };
+
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AccountsByMajorMinorBranchAndStatusResponse, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _accountDao.GetAccountsByMajorMinorBranchAndStatus(request);
+
+            Assert.NotNull(result);
+            var firstResult = result.First();
+            Assert.AreEqual(firstResult.AccountNumber, 1234);
+            Assert.AreEqual(firstResult.Name, "Test Name");
+            _mockCoreDbExecution.Verify();
+        }
+
+		[Test]
+		public async Task UpdateAccountContractDate_OK()
+		{
+			var accountRequest = new AccountContractDateUpdateRequest
+			{
+				AccountNumber = 123,
+				ContractDate = DateTime.Now
+			};
+
+			var basicResponse = new BasicResponse()
+			{
+				Success = true
+			};
+
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                           _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountContractDateUpdateRequest);
+            _mockPutRequest.Setup(x => x.Async<AccountContractDateUpdateRequest, BasicResponse>(endpoint,
+                                                                                                It.IsAny<AccountContractDateUpdateRequest>(),
+                                                                                                It.IsAny<Dictionary<string, string>>(),
+                                                                                                It.IsAny<int>(),
+                                                                                                It.IsAny<int>()))
+                .ReturnsAsync(basicResponse).Verifiable();
+
+            var result = await _accountDao.UpdateAccountContractDate(accountRequest);
+
+			Assert.NotNull(result);
+			Assert.AreEqual(result.Success, true);
+		}
+
+		[Test]
+		public async Task UpdateAccountContractDate_Exception()
+		{
+			var accountRequest = new AccountContractDateUpdateRequest
+			{
+				AccountNumber = 123,
+				ContractDate = DateTime.Now
+			};
+			var result = await _accountDao.UpdateAccountContractDate(accountRequest);
+
+			Assert.IsNull(result);
+		}
+	}
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/ActivityDaoTest.cs

@@ -0,0 +1,652 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Activity;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Phones;
+using Moq;
+using NUnit.Framework;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class ActivityDaoTest
+    {
+        private ActivityDao _activityDao;
+        private Mock<ICoreDbExecution> _mockCoreDbExecution;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _activityDao = new ActivityDao(_mockCoreDbExecution.Object);
+        }
+
+        [Test]
+        public async Task GetNewCheckingActivities_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewCheckingAccountActivity>()
+                {
+                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewCheckingActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode()
+                            .Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00", limitAmount = "100" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewCheckingActivities_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewCheckingActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewCheckingActivitiesNewerThanDate_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewCheckingAccountActivity>()
+                {
+                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewCheckingActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
+                            .GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewCheckingActivitiesNewerThanDate()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewCheckingActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
+                            .GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewCheckingActivitiesAfterActivityNbr_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewCheckingAccountActivity>()
+                {
+                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewCheckingActivitiesAfterActivityNbr(1, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewCheckingActivitiesAfterActivityNbr_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewCheckingAccountActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewCheckingActivitiesAfterActivityNbr(1, 100));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewCheckingAccountActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewAtmCheckCardActivity>()
+                {
+                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewAtmCheckCardActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode()
+                            .Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00", limitAmount = "100" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewAtmCheckCardActivities(DateTime.Parse("2020-04-02T11:00:00"), 1, 100));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivitiesNewerThanDate_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewAtmCheckCardActivity>()
+                {
+                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewAtmCheckCardActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
+                            .GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivitiesNewerThanDate()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewAtmCheckCardActivitiesNewerThanDate(DateTime.Parse("2020-04-02T11:00:00"), 100));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = (string)null, limitAmount = "100" }
+                            .GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivitiesAfterActivityNbr_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewAtmCheckCardActivity>()
+                {
+                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewAtmCheckCardActivitiesAfterActivityNbr(1, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivitiesAfterActivityNbr_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewAtmCheckCardActivitiesAfterActivityNbr(1, 100));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewAtmCheckCardActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = (string)null, afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerReferrals_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewActivityManagerReferrals(DateTime.Parse("2020-04-02T11:00:00"), 1);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { afterActivityId = "1", newerThanOriginationDate = "2020-04-02 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerReferrals_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewActivityManagerReferrals(DateTime.Parse("2020-04-02T11:00:00"), 1));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanOriginationDate = "2020-04-02 11:00:00", afterActivityId = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerReferralsNewerThan_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewActivityManagerReferralsNewerThan(DateTime.Parse("2020-04-02T11:00:00"));
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanOriginationDate = "2020-04-02 11:00:00", afterActivityId = (string)null }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerReferralsNewerThan_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewActivityManagerReferralsNewerThan(DateTime.Parse("2020-04-02T11:00:00")));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanOriginationDate = "2020-04-02 11:00:00", afterActivityId = (string)null }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerReferralsAfterActivityId_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewActivityManagerReferralsAfterActivityId(1);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanOriginationDate = (string)null, afterActivityId = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerReferralsAfterActivityId_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewActivityManagerReferralsAfterActivityId(1));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":newerThanOriginationDate")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanOriginationDate = (string)null, afterActivityId = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewMortgageSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewMortgageSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewVehicleSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewVehicleSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewEDeliverySaleActivities_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<EStatementDeliveryMethod, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<EStatementDeliveryMethod>()
+                {
+                    new EStatementDeliveryMethod() { ActivityNumber = 1 },
+                    new EStatementDeliveryMethod() { ActivityNumber = 2 },
+                    new EStatementDeliveryMethod() { ActivityNumber = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetEStatementDeliveryActivity(DateTime.Parse("2020-04-02T11:00:00"));
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+          
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<EStatementDeliveryMethod, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewEDeliverySaleActivities_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<EStatementDeliveryMethod, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Exception thrown"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetEStatementDeliveryActivity(null));
+
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<EStatementDeliveryMethod, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.GetNewDebtProtectedLoanSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { afterActivityNbr = "1", newerThanDateTime = "2020-04-02 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewLoanSaleActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetNewDebtProtectedLoanSaleActivities(DateTime.Parse("2020-04-02T11:00:00"), 1));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewLoanSaleActivity, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2020-04-02 11:00:00", afterActivityNbr = "1" }.GetHashCode()))), Times.Never);
+        }
+
+        [Test]
+        public async Task QueryActivityManagerActivity_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new() { ActivityId = 1 },
+                    new() { ActivityId = 2 },
+                    new() { ActivityId = 3 }
+                }).Verifiable();
+
+            var results = await _activityDao.QueryActivityManagerActivity(new ActivityQueryRequest()
+            {
+                ActivityIds = new List<long>() { 1, 2, 3 }
+            });
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            //Parameters are passed in using Anonymous Object, Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.Is<string>(str => str.Contains(":activityIds")), It.IsAny<object>()));
+        }
+
+        [Test]
+        public async Task QueryActivityManagerActivity_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<NewActivityManagerIncentiveReferral, object>(It.IsAny<string>(),
+                    It.IsAny<object>()))
+                .ThrowsAsync(new Exception());
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.QueryActivityManagerActivity(new ActivityQueryRequest()
+                {
+                    ActivityIds = new List<long>() { 1, 2, 3 }
+                }));
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByPhoneNumber_OK()
+        {
+            var phoneNumber = Guid.NewGuid().ToString();
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<PersonRecentActivity>()
+                {
+                    new() { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
+                }).Verifiable();
+
+            var result = await _activityDao.GetPersonActivityByPhoneNumber(phoneNumber);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(phoneNumber, result.FirstOrDefault()?.HomePhone);
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public void GetPersonActivityByPhoneNumber_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(),
+                    It.IsAny<object>()))
+                .ThrowsAsync(new Exception());
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetPersonActivityByPhoneNumber(It.IsAny<string>()));
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByPersonNumber_OK()
+        {
+            var personNumber = DateTime.Now.Millisecond;
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<PersonRecentActivity>
+                {
+                    new() { PersonNumber = personNumber }
+                }).Verifiable();
+
+            var result = await _activityDao.GetPersonActivityByPersonNumber(personNumber.ToString());
+
+            Assert.NotNull(result);
+            Assert.AreEqual(personNumber, result.PersonNumber);
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public void GetPersonActivityByPersonNumber_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<PersonRecentActivity, object>(It.IsAny<string>(),
+                    It.IsAny<object>()))
+                .ThrowsAsync(new Exception());
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityDao.GetPersonActivityByPersonNumber(It.IsAny<string>()));
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/AgreeDaoTest.cs

@@ -0,0 +1,127 @@
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class AgreeDaoTest
+    {
+        private AgreeDao _agreeDao;
+        private Mock<ICoreDbExecution> _mockCoreDbExecution;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _agreeDao = new AgreeDao(_mockCoreDbExecution.Object);
+        }
+
+        [Test]
+        public async Task FindAgreeUsersByAccountNumbers_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreeUserAccount, object>(It.IsAny<string>(),
+                    It.IsAny<Dictionary<string, object>>()))
+                .ReturnsAsync(new List<AgreeUserAccount>()
+                {
+                    new()
+                    {
+                        AccountNumber = 20001,
+                        AgreeNumber = 2000,
+                        UserId = "12000"
+                    }
+                }).Verifiable();
+
+            var testAccountNumbers = new List<string>() { "20001" };
+            var results = await _agreeDao.FindAgreeUsersByAccountNumbers(testAccountNumbers);
+
+            Assert.NotNull(results);
+            var firstResult = results.FirstOrDefault();
+            Assert.AreEqual(20001, firstResult.AccountNumber);
+            Assert.AreEqual(2000, firstResult.AgreeNumber);
+            Assert.AreEqual("12000", firstResult.UserId);
+
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<AgreeUserAccount, Dictionary<string, object>>(
+                    It.Is<string>(str => str.Contains(":param0")),
+                    It.IsAny<Dictionary<string, object>>()));
+        }
+
+        [Test]
+        public void FindByUserId_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreeUserAccount, object>(It.IsAny<string>(),
+                    It.IsAny<Dictionary<string, object>>()))
+                .ThrowsAsync(new Exception("Ah oh Error"));
+
+
+            var testAccountNumbers = new List<string>() { "20001" };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _agreeDao.FindAgreeUsersByAccountNumbers(testAccountNumbers));
+
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<AgreeUserAccount, Dictionary<string, object>>(
+                    It.Is<string>(str => str.Contains(":param0")),
+                    It.IsAny<Dictionary<string, object>>()));
+        }
+
+        [Test]
+        public async Task FindAgreeUserByPersonNumber_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<string, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<string> { "5436" }).Verifiable();
+
+            var result = await _agreeDao.FindAgreeUserByPersonNumber(12355L);
+            
+            Assert.NotNull(result);
+            Assert.AreEqual("5436", result.FirstOrDefault());
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public void FindAgreeUserByPersonNumber_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<string, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Error thrown from unit test"));
+
+            Assert.ThrowsAsync<Exception>(async () => await _agreeDao.FindAgreeUserByPersonNumber(123L));
+
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public async Task FindAgreeUserByOrganizationNumber_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<string, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<string> { "5436" }).Verifiable();
+
+            var result = await _agreeDao.FindAgreeUserByOrganizationNumber(12355L);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("5436", result);
+            _mockCoreDbExecution.Verify();
+        }
+
+        [Test]
+        public void FindAgreeUserByOrganizationNumber_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<string, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Error thrown from unit test"));
+
+            Assert.ThrowsAsync<Exception>(async () => await _agreeDao.FindAgreeUserByOrganizationNumber(123L));
+
+            _mockCoreDbExecution.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/AgreePersonDaoTest.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+using LCU.Library.Internal.ApiSecurity.Models;
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
+using LCU.Library.Internal.LcuHttpClient.HttpRequest;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class AgreePersonDaoTest
+    {
+        private AgreePersonDao _agreePersonDao;
+        private Mock<ICoreDbExecution> _mockCoreDbExecution;
+        private ApiSecurityConfiguration _apiSecurityConfiguration;
+        private Mock<IPutRequest> _mockPutRequest;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _mockPutRequest = new Mock<IPutRequest>();
+
+            var coreConfiguration = new CoreConfiguration()
+            {
+                CoreSoapApiConfiguration = new CoreSoapApiConfiguration()
+                {
+                    CoreSoapApiWrapperHost = "test.lcu-internal.com",
+                    CoreSoapEndpointConfiguration = new CoreSoapEndpointConfiguration()
+                    {
+                        PutPersonAgreementsDetailTypes = "api/Test/core/PutThing"
+                    }
+                }
+            };
+
+            _apiSecurityConfiguration = new ApiSecurityConfiguration()
+            {
+                InternalApiKeySet = new Dictionary<string, string>()
+                {
+                    ["CoreSoapApiWrapper"] = "TEST"
+                }
+            };
+
+            _agreePersonDao = new AgreePersonDao(_mockCoreDbExecution.Object,
+                                                 coreConfiguration,
+                                                 _apiSecurityConfiguration,
+                                                 _mockPutRequest.Object);
+        }
+
+        [Test]
+        public async Task FindByUserId_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreePerson, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<AgreePerson>()
+                {
+                    new AgreePerson() 
+                    { 
+                        AgreeNumber = 100,
+                        PersonNumber = 10,
+                        UserId = "1"
+                    }
+                }).Verifiable();
+
+            var result = await _agreePersonDao.FindByUserId("1");
+
+            Assert.NotNull(result);
+            Assert.AreEqual(100, result.AgreeNumber);
+            Assert.AreEqual(10, result.PersonNumber);
+            Assert.AreEqual("1", result.UserId);
+            //Parameters are passed in using Anonymous Object, 
+            // Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<AgreePerson, object>(It.Is<string>(str => str.Contains(":userId")),
+                    It.Is<object>(obj => obj.GetHashCode().Equals(new { userId = "1"}.GetHashCode()))));
+        }
+
+        [Test]
+        public void FindByUserId_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreePerson, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Ah oh Error"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _agreePersonDao.FindByUserId("1"));
+
+            //Parameters are passed in using Anonymous Object,
+            // Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<AgreePerson, object>(It.Is<string>(str => str.Contains(":userId")),
+                    It.Is<object>(obj => obj.GetHashCode().Equals(new { userId = "1"}.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task FindAgreePersonsWithHyphenatedUserId_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreePerson>(It.IsAny<string>()))
+                .ReturnsAsync(new List<AgreePerson>()
+                {
+                    new AgreePerson()
+                    {
+                        AgreeNumber = 100,
+                        PersonNumber = 10,
+                        UserId = "1-1"
+                    }
+                }).Verifiable();
+
+            var result = await _agreePersonDao.FindAgreePersonsWithHyphenatedUserId();
+
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count());
+            var singleResult = result.FirstOrDefault();
+            Assert.NotNull(singleResult);
+            Assert.AreEqual(100, singleResult.AgreeNumber);
+            Assert.AreEqual(10, singleResult.PersonNumber);
+            Assert.AreEqual("1-1", singleResult.UserId);
+        }
+
+        [Test]
+        public void FindAgreePersonsWithHyphenatedUserId_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreePerson>(It.IsAny<string>()))
+                .ThrowsAsync(new Exception("Ah oh Error"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _agreePersonDao.FindAgreePersonsWithHyphenatedUserId());
+        }
+
+        [Test]
+        public async Task FindActiveCustodialVruCardAgreementAgreePersons_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreePerson>(It.IsAny<string>()))
+                .ReturnsAsync(new List<AgreePerson>()
+                {
+                    new AgreePerson()
+                    {
+                        AgreeNumber = 100,
+                        PersonNumber = 10,
+                        UserId = "11"
+                    }
+                }).Verifiable();
+
+            var result = await _agreePersonDao.FindActiveCustodialVruCardAgreementAgreePersons();
+
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count());
+            var singleResult = result.FirstOrDefault();
+            Assert.NotNull(singleResult);
+            Assert.AreEqual(100, singleResult.AgreeNumber);
+            Assert.AreEqual(10, singleResult.PersonNumber);
+            Assert.AreEqual("11", singleResult.UserId);
+        }
+
+        [Test]
+        public void FindActiveCustodialVruCardAgreementAgreePersons_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<AgreePerson>(It.IsAny<string>()))
+                .ThrowsAsync(new Exception("Ah oh Error"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _agreePersonDao.FindActiveCustodialVruCardAgreementAgreePersons());
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/ApplicationHistoryDaoTest.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using System.Linq;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.ApplicationHistories;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class ApplicationHistoryDaoTest
+    {
+        private ApplicationHistoryDao _applicationHistoryDao;
+        private Mock<ICoreDbExecution> _mockCoreDbExecution;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _applicationHistoryDao = new ApplicationHistoryDao(_mockCoreDbExecution.Object);
+        }
+
+        [Test]
+        public async Task FindApplicationHistory_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<ApplicationHistory, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<ApplicationHistory>()
+                {
+                    new ApplicationHistory()
+                    {
+                       ApplicationName = "Test",
+                       ApplicationNumber = 1,
+                       QueueNumber = 10,
+                       StopDateTime = Convert.ToDateTime("1/1/2021"),
+                       EffectiveDate = Convert.ToDateTime("1/1/2021")
+                    },
+                    new ApplicationHistory()
+                    {
+                       ApplicationName = "Test2",
+                       ApplicationNumber = 2,
+                       QueueNumber = 20,
+                       StopDateTime = Convert.ToDateTime("1/1/2021"),
+                       EffectiveDate = Convert.ToDateTime("1/1/2021")
+                    }
+                }).Verifiable();
+
+            var applicationTestNumbers = new List<string>()
+            {
+                "1",
+                "2"
+            };
+            var effectiveDate = Convert.ToDateTime("1/2/2021");
+            var results = await _applicationHistoryDao.FindApplicationHistory(applicationTestNumbers, effectiveDate);
+
+            var resultsList = results.ToList();
+            Assert.NotNull(results);
+            Assert.AreEqual(2, resultsList.Count);
+            Assert.True(resultsList.Any(x => x.ApplicationName == "Test"));
+            Assert.True(resultsList.Any(x => x.ApplicationName == "Test"));
+            Assert.True(resultsList.Any(x => x.ApplicationNumber == 1));
+            Assert.True(resultsList.Any(x => x.ApplicationNumber == 2));
+            Assert.True(resultsList.Any(x => x.QueueNumber == 10));
+            Assert.True(resultsList.Any(x => x.QueueNumber == 20));
+            Assert.True(resultsList.Any(x => x.StopDateTime == Convert.ToDateTime("1/1/2021")));
+            Assert.True(resultsList.Any(x => x.EffectiveDate == Convert.ToDateTime("1/1/2021")));
+            Assert.AreEqual(2, resultsList.Where(r => r.StopDateTime == Convert.ToDateTime("1/1/2021")).ToList().Count);
+
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<ApplicationHistory, object>(
+                    It.Is<string>(str => str.Contains(":param0") && str.Contains(":param1") &&
+                                         str.Contains(":EffectiveDate")),
+                    It.IsAny<object>()));
+        }
+
+        [Test]
+        public void FindApplicationHistory_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<ApplicationHistory, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Ah oh Error"));
+
+            var applicationTestNumbers = new List<string>()
+            {
+                "1",
+                "2"
+            };
+            var effectiveDate = Convert.ToDateTime("1/2/2021");
+
+            Assert.ThrowsAsync<Exception>(async () =>
+               await _applicationHistoryDao.FindApplicationHistory(applicationTestNumbers, effectiveDate));
+
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<ApplicationHistory, object>(
+                    It.Is<string>(str => str.Contains(":param0") && str.Contains(":param1") &&
+                                         str.Contains(":EffectiveDate")),
+                    It.IsAny<object>()));
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/IndirectLoanDaoTest.cs

@@ -0,0 +1,275 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+using LCU.Library.Internal.ApiSecurity.Models;
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.IndirectLoan;
+using LCU.Library.Internal.LcuHttpClient.HttpRequest;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class IndirectLoanDaoTest
+    {
+        private IndirectLoanDao _indirectLoanDao;
+        private Mock<ICoreDbExecution> _mockCoreDbExecution;
+        private CoreConfiguration _coreConfiguration;
+        private ApiSecurityConfiguration _apiSecurityConfiguration;
+        private Mock<IPutRequest> _mockPutRequest;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockPutRequest = new Mock<IPutRequest>();
+
+            _coreConfiguration = new CoreConfiguration()
+            {
+                CoreSoapApiConfiguration = new CoreSoapApiConfiguration()
+                {
+                    CoreSoapEndpointConfiguration = new CoreSoapEndpointConfiguration()
+                    {
+                        PutDealerOriginalBalance = "TEST/IndirectLoan/PutDealerOriginalBalance"
+                    }
+                }
+            };
+
+            _apiSecurityConfiguration = new ApiSecurityConfiguration()
+            {
+                InternalApiKeySet = new Dictionary<string, string>()
+                {
+                    ["CoreSoapApiWrapper"] = "TEST"
+                }
+            };
+
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _indirectLoanDao = new IndirectLoanDao(_mockCoreDbExecution.Object,
+                                                   _coreConfiguration,
+                                                   _apiSecurityConfiguration,
+                                                   _mockPutRequest.Object);
+        }
+
+        [Test]
+        public async Task GetIndirectLoanByAccountNumber_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<IndirectLoanDetail, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<IndirectLoanDetail>()
+                {
+                    new IndirectLoanDetail() {LoanNumber = "1234"}
+                }).Verifiable();
+
+            var results = await _indirectLoanDao.FindByAccountNumber(1234);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(1, results.Count());
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<IndirectLoanDetail, object>(It.Is<string>(str => str.Contains(":AcctNbr")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { AcctNbr = 1234 }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetIndirectLoanByAccountNumber_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<IndirectLoanDetail, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _indirectLoanDao.FindByAccountNumber(1234));
+
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<IndirectLoanDetail, object>(It.Is<string>(str => str.Contains(":AcctNbr")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { AcctNbr = 1234 }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetIndirectLoansByPostedDate_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<IndirectLoanDetail, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<IndirectLoanDetail>()
+                {
+                    new IndirectLoanDetail { LoanNumber = "1" },
+                    new IndirectLoanDetail { LoanNumber = "2" },
+                    new IndirectLoanDetail { LoanNumber = "3" }
+                }).Verifiable();
+
+            var results = await _indirectLoanDao.FindByPostedDate(DateTime.Parse("2021-05-01T11:00:00"));
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count());
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<IndirectLoanDetail, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2021-05-01 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetIndirectLoansByPostedDate_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<IndirectLoanDetail, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _indirectLoanDao.FindByPostedDate(DateTime.Parse("2021-05-01T11:00:00")));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<IndirectLoanDetail, object>(It.Is<string>(str => str.Contains(":newerThanDateTime")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2021-05-01 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoansByPostedDate_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<ClosedIndirectLoan, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<ClosedIndirectLoan>()
+                {
+                    new ClosedIndirectLoan { LoanNumber = "1" },
+                    new ClosedIndirectLoan { LoanNumber = "2" },
+                    new ClosedIndirectLoan { LoanNumber = "3" }
+                }).Verifiable();
+
+            var results = await _indirectLoanDao.FindClosedByPostedDate(DateTime.Parse("2021-05-01T11:00:00"));
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count());
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<ClosedIndirectLoan, object>(It.Is<string>(str => str.Contains(":newerThanDateTime") && str.Contains("CLS")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2021-05-01 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoansByPostedDate_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<ClosedIndirectLoan, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _indirectLoanDao.FindClosedByPostedDate(DateTime.Parse("2021-05-01T11:00:00")));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<ClosedIndirectLoan, object>(It.Is<string>(str => str.Contains(":newerThanDateTime") && str.Contains("CLS")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2021-05-01 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoansWithDetailByPostedDate_OK()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<IndirectLoanDetail, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ReturnsAsync(new List<IndirectLoanDetail>()
+                {
+                    new IndirectLoanDetail { LoanNumber = "1" },
+                    new IndirectLoanDetail { LoanNumber = "2" },
+                    new IndirectLoanDetail { LoanNumber = "3" }
+                }).Verifiable();
+
+            var results = await _indirectLoanDao.FindClosedWithDetailByPostedDate(DateTime.Parse("2021-05-01T11:00:00"));
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count());
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<IndirectLoanDetail, object>(It.Is<string>(str => str.Contains(":newerThanDateTime") && str.Contains("CLS")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2021-05-01 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task GetClosedIndirectLoansWithDetailByPostedDate_Exception()
+        {
+            _mockCoreDbExecution
+                .Setup(x => x.ExecuteQuery<IndirectLoanDetail, object>(It.IsAny<string>(), It.IsAny<object>()))
+                .ThrowsAsync(new Exception("Yikes"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _indirectLoanDao.FindClosedWithDetailByPostedDate(DateTime.Parse("2021-05-01T11:00:00")));
+
+            //Parameters are passed in using Anonymous Object,Verify they are expected object using HashCode. Obj.Equals has issues with Anonymous Objects.
+            _mockCoreDbExecution.Verify(x =>
+                x.ExecuteQuery<IndirectLoanDetail, object>(It.Is<string>(str => str.Contains(":newerThanDateTime") && str.Contains("CLS")),
+                    It.Is<object>(obj =>
+                        obj.GetHashCode().Equals(new { newerThanDateTime = "2021-05-01 11:00:00" }.GetHashCode()))));
+        }
+
+        [Test]
+        public async Task UpdateDealerOriginalBalance_Ok()
+        {
+            var accountNumber = "111111111111";
+            var response = new UpdateDealerOriginalBalanceResponse();
+            var responseList = new List<UpdateDealerOriginalBalanceResponse> { response }; //no errors in response
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutDealerOriginalBalance + $"?accountNumber={accountNumber}");
+            _mockPutRequest.Setup(x => x.Async<string, List<UpdateDealerOriginalBalanceResponse>>(endpoint,
+                                                                                                  null,
+                                                                                                  It.IsAny<Dictionary<string, string>>(),
+                                                                                                  It.IsAny<int>(),
+                                                                                                  It.IsAny<int>()))
+                .ReturnsAsync(responseList).Verifiable();
+
+            var results = await _indirectLoanDao.UpdateDealerOriginalBalance(accountNumber);
+            Assert.IsNotNull(results);
+            Assert.AreEqual("", results.ToList().Where(x => x.AccountNumber == "111111111111"));
+            _mockPutRequest.Verify();
+        }
+
+        [Test]
+        public async Task UpdateDealerOriginalBalance_Ok_WithErrors()
+        {
+            var accountNumber ="111111111111";
+            var response = new UpdateDealerOriginalBalanceResponse()
+            {
+                AccountNumber = "111111111111",
+                ErrorMessage = "Error: This account is not valid for update."
+            };
+
+            var responseList = new List<UpdateDealerOriginalBalanceResponse> { response }; //error for second account
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutDealerOriginalBalance + $"?accountNumber={accountNumber}");
+            _mockPutRequest.Setup(x => x.Async<string, List<UpdateDealerOriginalBalanceResponse>>(endpoint,
+                                                                                                  null,
+                                                                                                  It.IsAny<Dictionary<string, string>>(),
+                                                                                                  It.IsAny<int>(),
+                                                                                                  It.IsAny<int>()))
+                .ReturnsAsync(responseList).Verifiable();
+
+            var results = await _indirectLoanDao.UpdateDealerOriginalBalance(accountNumber);
+            Assert.IsNotNull(results);
+            Assert.AreEqual(1, results.Count());
+            Assert.AreEqual("111111111111", results.ToList().Where(x => x.AccountNumber == "111111111111").FirstOrDefault().AccountNumber);
+            _mockPutRequest.Verify();
+        }
+
+        [Test]
+        public void UpdateDealerOriginalBalance_Exception()
+        {
+            var accountNumber = "111111111111";
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutDealerOriginalBalance + $"?accountNumber={accountNumber}");
+            _mockPutRequest.Setup(x => x.Async<string, List<UpdateDealerOriginalBalanceResponse>>(endpoint,
+                                                                                                  null,
+                                                                                                  It.IsAny<Dictionary<string, string>>(),
+                                                                                                  It.IsAny<int>(),
+                                                                                                  It.IsAny<int>()))
+                .Throws(new Exception("Error thrown in unit test.")).Verifiable();
+
+            Assert.ThrowsAsync<Exception>(async () => await _indirectLoanDao.UpdateDealerOriginalBalance(accountNumber));
+            _mockPutRequest.Verify();
+        }
+
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/OrganizationDaoTest.cs

@@ -0,0 +1,143 @@
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
+using LCU.Library.Internal.CoreApiWrapperModel.Constants;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Organizations;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
+using Moq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class OrganizationDaoTest
+    {
+        private readonly OrganizationDao _organizationDao;
+        private readonly Mock<ICoreRequest> _mockCoreRequest;
+        private readonly Mock<ICoreDbExecution> _coreDb;
+
+        public OrganizationDaoTest()
+        {
+            _mockCoreRequest = new Mock<ICoreRequest>();
+            _coreDb = new Mock<ICoreDbExecution>();
+
+            var coreConfiguration = new CoreConfiguration
+            {
+                CoreApiConfiguration = new CoreApiConfiguration
+                {
+                    CoreEndPointConfiguration = new CoreEndPointConfiguration
+                    {
+                        PersonsQueryName = "Test"
+                    }
+                }
+            };
+
+            _organizationDao = new OrganizationDao
+            (
+                _mockCoreRequest.Object,
+                coreConfiguration,
+                _coreDb.Object
+            );
+        }
+
+        [Test]
+        public async Task FindOrganizationByMemberAgreeNbr()
+        {
+            // Arrange
+            var listOfIncludes = new List<string>
+            {
+                RequestIncludeConstants.AllAddresses
+            };
+            var coreRequestParameters = new CoreRequestParameters(listOfIncludes);
+            var organizationRequest = new MemberNbrRequest
+            {
+                MemberNbr = 100,
+            };
+
+            var testPostalAddress = new PostalAddress
+            {
+                AddressUseCode = AddressConstants.PrimaryUseCode,
+                AddressNumber = 11,
+                AddressLine1 = "Test Street",
+                AddressLine2 = "",
+                AddressLine3 = "",
+                CityName = "City Test",
+                PostalCode = "53183",
+                ZipPlus = "3123",
+                CountrySubdivisionCode = "WI"
+            };
+            var testPostalAddressList = new List<PostalAddress> { testPostalAddress };
+            var testOrganization = new Organization
+            {
+                MemberAgreementNumber = 111111111,
+                Name = "Test Organization Name",
+                OrganizationNumber = 123,
+                PostalAddressList = testPostalAddressList
+            };
+
+            var header = new CoreMessageHeader();
+            CoreApiMessage<Organization> organizationApiMessage =
+                new CoreApiMessage<Organization>(header, testOrganization);
+
+            var organizationJson = JsonConvert.SerializeObject(testOrganization);
+
+            _mockCoreRequest.Setup(x => x.PostRequestObject<CoreApiMessage<Organization>>(It.IsAny<string>(),
+                It.IsAny<Dictionary<string, string>>(),
+                It.IsAny<string>())).ReturnsAsync(organizationApiMessage);
+
+            // Act
+            var results = _organizationDao.FindOrganizationByMemberAgreeNbr(coreRequestParameters, organizationRequest);
+
+            // Assert
+            Assert.NotNull(results);
+        }
+
+        [Test]
+        public async Task FindOrganizationNumbersByNameSearch_AllCases_ExecutesOrganizationNumberByNameLikeQueryWithNameAndLimitParameters()
+        {
+            var query = QueryUtilities.GetQuery("Organization/OrganizationNumberByNameLikeQuery");
+            var name = Guid.NewGuid().ToString().ToUpperInvariant();
+            var limit = DateTime.Now.Millisecond;
+            var resultSeries = new Random(DateTime.Now.Millisecond);
+            var results = new long[]{ resultSeries.Next(), resultSeries.Next(), resultSeries.Next() };
+            _coreDb
+                .Setup(c => c.ExecuteQuery<long, dynamic>(query, It.Is<object>(q => q.GetPropertyValue<string>("organizationName") == name.ToLowerInvariant() && q.GetPropertyValue<int>("limit") == limit)))
+                .Returns(Task.FromResult<IEnumerable<long>>(results));
+
+            var organizationNumbers = await _organizationDao.FindOrganizationNumbersByNameSearch(name, limit);
+
+            Assert.AreSame(results, organizationNumbers);
+        }
+        
+        [Test]
+        public async Task CountOrganizationNumbersByName_AllCases_ExecutesOrganizationByNameLikeCountWithNameParameter()
+        {
+            var query = QueryUtilities.GetQuery("Organization/OrganizationByNameLikeCount");
+            var name = Guid.NewGuid().ToString().ToUpperInvariant();
+            var count = DateTime.Now.Millisecond;
+            var results = new long[]{ count };
+            _coreDb
+                .Setup(c => c.ExecuteQuery<long, dynamic>(query, It.Is<object>(q => q.GetPropertyValue<string>("organizationName") == name.ToLowerInvariant())))
+                .Returns(Task.FromResult<IEnumerable<long>>(results));
+
+            var organizationCount = await _organizationDao.CountOrganizationNumbersByName(name);
+
+            Assert.AreEqual(count, organizationCount);
+        }
+    }
+}
+
+public static class ObjectPropertyExtension
+{
+    public static T GetPropertyValue<T>(this object obj, string propertyName)
+    {
+        return (T) obj.GetType().GetProperty(propertyName).GetValue(obj, null);
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/PersonDaoTest.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Moq;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class PersonDaoTest
+    {
+        private readonly PersonDao _personDao;
+        private readonly Mock<ICoreRequest> _mockCoreRequest;
+        private readonly Mock<ICoreDbExecution> _mockCoreDbExecution;
+
+        public PersonDaoTest()
+        {
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _mockCoreRequest = new Mock<ICoreRequest>();
+
+            var coreConfiguration = new CoreConfiguration
+            {
+                CoreApiConfiguration = new CoreApiConfiguration
+                {
+                    CoreEndPointConfiguration = new CoreEndPointConfiguration
+                    {
+                        PersonsQueryName = "Test"                        
+                    }
+                }
+            };
+
+            _personDao = new PersonDao(_mockCoreRequest.Object,
+                                       _mockCoreDbExecution.Object,
+                                       coreConfiguration);
+        }
+
+        [Test]
+        public async Task FindPersons_Returns_Null()
+        {
+            var coreRequestParameters = new CoreRequestParameters();
+            var personRequest = new PersonNameRequest();
+            CoreApiMessage<IEnumerable<Person>> personsJsonResponse = null;
+
+            _mockCoreRequest.Setup(x => x.PostRequestObject<CoreApiMessage<IEnumerable<Person>>>(It.IsAny<string>(), 
+                                                                             It.IsAny<Dictionary<string,string>>(), 
+                                                                             It.IsAny<string>())).ReturnsAsync(personsJsonResponse);
+            var result = await _personDao.FindByPersonsName(coreRequestParameters, personRequest);
+
+            Assert.IsNull(result);
+        }
+        
+        [Test]
+        public async Task GetPersonNumbersByNameLike_AllCases_ExecutesPersonNumberByNameLikeQueryWithNameAndLimitParameters()
+        {
+            var query = QueryUtilities.GetQuery("Person/PersonNumberByNameLikeQuery");
+            var firstName = Guid.NewGuid().ToString().ToUpperInvariant();
+            var middleName = Guid.NewGuid().ToString().ToUpperInvariant();
+            var lastName = Guid.NewGuid().ToString().ToUpperInvariant();
+            var limit = DateTime.Now.Millisecond;
+            var resultSeries = new Random(DateTime.Now.Millisecond);
+            var results = new long[]{ resultSeries.Next(), resultSeries.Next(), resultSeries.Next() };
+            _mockCoreDbExecution
+                .Setup(c => c.ExecuteQuery<long, dynamic>(query, It.Is<object>(q => q.GetPropertyValue<string>("firstName") == firstName.ToLowerInvariant() && q.GetPropertyValue<string>("middleName") == middleName.ToLowerInvariant() && q.GetPropertyValue<string>("lastName") == lastName.ToLowerInvariant() && q.GetPropertyValue<int>("limit") == limit)))
+                .Returns(Task.FromResult<IEnumerable<long>>(results));
+
+            var organizationNumbers = await _personDao.GetPersonNumbersByNameLike(firstName, middleName, lastName, limit);
+
+            Assert.AreSame(results, organizationNumbers);
+        }
+        
+        [Test]
+        public async Task CountPersonsByNameLike_AllCases_ExecutesPersonByNameLikeCountWithNameParameters()
+        {
+            var query = QueryUtilities.GetQuery("Person/PersonByNameLikeCount");
+            var firstName = Guid.NewGuid().ToString().ToUpperInvariant();
+            var middleName = Guid.NewGuid().ToString().ToUpperInvariant();
+            var lastName = Guid.NewGuid().ToString().ToUpperInvariant();
+            var count = DateTime.Now.Millisecond;
+            var results = new long[]{ count };
+            _mockCoreDbExecution
+                .Setup(c => c.ExecuteQuery<long, dynamic>(query, It.Is<object>(q => q.GetPropertyValue<string>("firstName") == firstName.ToLowerInvariant() && q.GetPropertyValue<string>("middleName") == middleName.ToLowerInvariant() && q.GetPropertyValue<string>("lastName") == lastName.ToLowerInvariant())))
+                .Returns(Task.FromResult<IEnumerable<long>>(results));
+
+            var organizationCount = await _personDao.CountPersonsByNameLike(firstName, middleName, lastName);
+
+            Assert.AreEqual(count, organizationCount);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/TaxDaoTest.cs

@@ -0,0 +1,96 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class TaxDaoTest
+    {
+        private TaxDao _taxDao;
+        private Mock<ICoreRequest> _mockCoreRequest;
+        private CoreConfiguration _coreConfiguration;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockCoreRequest = new Mock<ICoreRequest>();
+
+            _coreConfiguration = new CoreConfiguration
+            {
+                CoreApiConfiguration = new CoreApiConfiguration
+                {
+                    CoreEndPointConfiguration = new CoreEndPointConfiguration
+                    {
+                        GetOrganizationsDataByTaxId = "test/Organization/Query/TaxId",
+                        GetPersonsDataByTaxId = "test/Person/Query/TaxId"
+                    }
+                }
+            };
+
+            _taxDao = new TaxDao(_mockCoreRequest.Object, _coreConfiguration);
+        }
+
+        [Test]
+        public async Task GetPersonTaxIdData_Returns_Success()
+        {
+            var header = new CoreMessageHeader
+            {
+                UpdateKey = null,
+                MessageId = null
+            };
+            
+            var body = new List<PersonTaxIdDataResponse>{
+            new()
+            {
+                FirstName = "Greg",
+                MiddleInitial = "H",
+                LastName = "Stevens",
+                Suffix = "Jr.",
+                NameFull = "Greg H. Stevens Jr.",
+                PersonNumber = 123
+            }
+            };
+            var personTaxIdDataResponse = new CoreApiMessage<IEnumerable<PersonTaxIdDataResponse>>(header, body);
+            
+            _mockCoreRequest.Setup(x => x.PostRequestObject<CoreApiMessage<IEnumerable<PersonTaxIdDataResponse>>>(It.Is<string>(url => url.Equals("test/Person/Query/TaxId")), It.IsAny<Dictionary<string, string>>() ,It.Is<string>(x => x.Contains("123")))).ReturnsAsync(personTaxIdDataResponse).Verifiable();
+            
+            var results = await _taxDao.GetPersonTaxIdData(new CoreRequestParameters(), "123");
+            Assert.IsNotNull(results);
+            Assert.AreEqual(1, results.Count());
+            _mockCoreRequest.Verify();
+        }
+        
+        [Test]
+        public async Task GetOrganizationTaxIdData_Returns_Success()
+        {
+            var header = new CoreMessageHeader
+            {
+                UpdateKey = null,
+                MessageId = null
+            };
+            
+            var body = new List<OrganizationTaxIdDataResponse>{
+                new()
+                {
+                    Name = "Organization",
+                    OrganizationNumber = 123
+                }
+            };
+            var personTaxIdDataResponse = new CoreApiMessage<IEnumerable<OrganizationTaxIdDataResponse>>(header, body);
+            
+            _mockCoreRequest.Setup(x => x.PostRequestObject<CoreApiMessage<IEnumerable<OrganizationTaxIdDataResponse>>>(It.Is<string>(url => url.Equals("test/Organization/Query/TaxId")), It.IsAny<Dictionary<string, string>>() ,It.Is<string>(url => url.Contains("123")))).ReturnsAsync(personTaxIdDataResponse).Verifiable();
+            
+            var results = await _taxDao.GetOrganizationTaxIdData(new CoreRequestParameters(), "123");
+            Assert.IsNotNull(results);
+            Assert.AreEqual(1, results.Count());
+            _mockCoreRequest.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/DataAccess/TransactionDaoTest.cs

@@ -0,0 +1,233 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+using LCU.Library.Internal.ApiSecurity.Models;
+using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Transaction;
+using LCU.Library.Internal.LcuHttpClient.HttpRequest;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.DataAccess
+{
+    public class TransactionDaoTest
+    {
+        private TransactionDao _transactionDao;
+        private Mock<ICoreRequest> _mockCoreRequest;
+        private CoreConfiguration _coreConfiguration;
+        private ApiSecurityConfiguration _apiSecurityConfiguration;
+        private Mock<ICoreDbExecution> _mockCoreDbExecution;
+        private Mock<IPostRequest> _mockPostRequest;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockCoreRequest = new Mock<ICoreRequest>();
+            _mockCoreDbExecution = new Mock<ICoreDbExecution>();
+            _mockPostRequest = new Mock<IPostRequest>();
+
+            _coreConfiguration = new CoreConfiguration()
+            {
+                CoreSoapApiConfiguration = new CoreSoapApiConfiguration()
+                {
+                    CoreSoapEndpointConfiguration = new CoreSoapEndpointConfiguration()
+                    {
+                        PostMonetaryTransactions = "TEST/MonetaryTransaction/PostMonetaryTransactions"
+                    }
+                },
+                CoreApiConfiguration = new CoreApiConfiguration()
+                {
+                    CoreEndPointConfiguration = new CoreEndPointConfiguration()
+                    {
+                        AccountsTransactionHistoryQueryAccountNumber = "test/AccountsTransactionHistoryQueryAccountNumber"
+                    }
+                }
+            };
+
+            _apiSecurityConfiguration = new ApiSecurityConfiguration()
+            {
+                InternalApiKeySet = new Dictionary<string, string>()
+                { 
+                    ["CoreSoapApiWrapper"] = "TEST"
+                }
+            };
+
+            _transactionDao = new TransactionDao(_mockCoreRequest.Object,
+                                                 _coreConfiguration,
+                                                 _apiSecurityConfiguration,
+                                                 _mockCoreDbExecution.Object,
+                                                 _mockPostRequest.Object);
+        }
+
+        [Test]
+        public async Task AddMonetaryTransactions_Returns_Two()
+        {
+            var response = new List<MonetaryTransactionResponse>()
+            {
+                new()
+                {
+                    WasSuccessful = true
+                },
+                new()
+                {
+                    WasSuccessful = true
+                }
+            };
+
+            _mockPostRequest.Setup(x => x.Async<List<GroupedMonetaryTransactionRequest>, List<MonetaryTransactionResponse>>(It.IsAny<Uri>(),
+                                                                                                                            It.IsAny<List<GroupedMonetaryTransactionRequest>>(),
+                                                                                                                            It.IsAny<Dictionary<string, string>>(),
+                                                                                                                            It.IsAny<int>(),
+                                                                                                                            It.IsAny<int>()))
+                .ReturnsAsync(response).Verifiable();
+
+            var groupRequest = new GroupedMonetaryTransactionRequest()
+            {
+                ParentRequestNumber = "1",
+                MonetaryTransactionRequests =
+                [
+                    new MonetaryTransactionRequest()
+                    {
+                        AccountNumber = 19617805142,
+                        ApprovalPersonNumber = 5225,
+                        RequestNumber = "1",
+                        OverrideCashBoxNumber = 800,
+                        TransactionTypeCode = "DEXP",
+                        Description = "",
+                        BalanceTypes =
+                        [
+                            new BalanceType1()
+                            {
+                                BalanceCategoryCode = "UPFR",
+                                BalanceTypeCode = "DLR",
+                                BalanceTypeAmount = 1.27
+                            }
+                        ],
+                        FundBalanceTypes =
+                        [
+                            new FundBalanceType()
+                            {
+                                 FundBalanceAmount = 1.27,
+                                 FundTypeCode = "EL",
+                                 FundTypeDetailCode = "IMED"
+                            }
+                        ],
+                        Funds =
+                        [
+                            new Fund()
+                            {
+                                ClearingCategoryCode = "IMED",
+                                FundAmount = 1.27,
+                                FundTypeCode = "EL",
+                                FundTypeDetailCode = "INTR",
+                                NumberOfItems = 1
+                            }
+                        ]
+                    },
+                    new MonetaryTransactionRequest()
+                    {
+                        AccountNumber = 19617805142,
+                        TransactionAmount = -1.27,
+                        ApprovalPersonNumber = 5225,
+                        RequestNumber = "2",
+                        ParentRequestNumber = "1",
+                        OverrideCashBoxNumber = 800,
+                        TransactionTypeCode = "DRIR",
+                        Description = "",
+                        BalanceTypes =
+                        [
+                             new()
+                             {
+                                 BalanceCategoryCode = "UPFR",
+                                 BalanceTypeCode = "DLR",
+                                 BalanceTypeAmount = -1.27
+                             }
+                        ],
+                        Funds =
+                        [
+                            new Fund()
+                            {
+                                ClearingCategoryCode = "IMED",
+                                FundAmount = -1.27,
+                                FundTypeCode = "EL",
+                                FundTypeDetailCode = "INTR",
+                                NumberOfItems = 1
+                            }
+                        ]
+                    }
+                ]
+            };
+            var listGroupRequest = new List<GroupedMonetaryTransactionRequest> { groupRequest };
+
+            var results = await _transactionDao.AddMonetaryTransactions(listGroupRequest);
+            Assert.IsNotNull(results);
+            Assert.AreEqual(2, results.Count);
+            _mockPostRequest.Verify();
+        }
+
+        [Test]
+        public void AddMonetaryTransactions_Exception()
+        {     
+            var listGroupRequest = new List<GroupedMonetaryTransactionRequest> { new() };
+            var endpoint = HttpUtilities.BuildHttpsUri(_coreConfiguration.CoreSoapApiConfiguration.CoreSoapApiWrapperHost,
+                                                       _coreConfiguration.CoreSoapApiConfiguration.CoreSoapEndpointConfiguration.PostMonetaryTransactions);
+
+            _mockPostRequest.Setup(x => x.Async<List<GroupedMonetaryTransactionRequest>, List<MonetaryTransactionResponse>>(endpoint,
+                                                                                                                            It.IsAny<List<GroupedMonetaryTransactionRequest>>(),
+                                                                                                                            It.IsAny<Dictionary<string, string>>(),
+                                                                                                                            It.IsAny<int>(),
+                                                                                                                            It.IsAny<int>()))
+                .Throws(new Exception("Error thrown in unit test.")).Verifiable();
+
+            Assert.ThrowsAsync<Exception>(async () => await _transactionDao.AddMonetaryTransactions(listGroupRequest));
+            _mockPostRequest.Verify();
+        }
+
+        [Test]
+        public async Task FindTransactionHistoryById_Return_Two()
+        {
+            var messageBody = new List<TransactionHistory>()
+            {
+               new TransactionHistory()
+               {
+                    AccountNumber = 1234555,
+                    ActivityDateTime = Convert.ToDateTime("1/1/2021")
+               },
+               new TransactionHistory()
+               {
+                    AccountNumber = 1234555,
+                    ActivityDateTime = Convert.ToDateTime("1/2/2021")
+               }
+            };
+
+            var messageHeader = new CoreMessageHeader() { };
+            var returnValue = new CoreApiMessage<IEnumerable<TransactionHistory>>(messageHeader, messageBody);
+
+            _mockCoreRequest
+                .Setup(x => x.PostRequestObject<CoreApiMessage<IEnumerable<TransactionHistory>>>(It.IsAny<string>(),
+                                                                                                 It.IsAny<Dictionary<string, string>>(),
+                                                                                                 It.IsAny<string>()))
+                .ReturnsAsync(returnValue).Verifiable();
+
+
+            var coreRequestParameters = new CoreRequestParameters() { };
+            var transactionHistoryRequest = new TransactionHistoryRequest() { };
+
+            var results = await _transactionDao.FindTransactionHistoryById(coreRequestParameters, transactionHistoryRequest, "dfasdfasdp-adfsdafafd-asfsadf");
+
+            var resultsList = results.ToList();
+            Assert.NotNull(results);
+            Assert.AreEqual(2, resultsList.Count);
+            Assert.True(resultsList.Any(x => x.AccountNumber == 1234555));
+
+            _mockCoreRequest.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/LCU.Api.Internal.CoreApiWrapperTest.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+
+    <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.19.4" />
+    <PackageReference Include="Moq" Version="4.20.69" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LCU.Api.Internal.CoreApiWrapper\LCU.Api.Internal.CoreApiWrapper.csproj" />
+    <ProjectReference Include="..\LCU.Library.Internal.CoreApiWrapperLib\LCU.Library.Internal.CoreApiWrapperLib.csproj" />
+    <ProjectReference Include="..\LCU.Library.Internal.CoreApiWrapperModel\LCU.Library.Internal.CoreApiWrapperModel.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Queries\TEST_Query.sql">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Models/CoreRequestParametersTest.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Utilities
+{
+    public class CoreRequestParametersTest
+    {
+        [Test]
+        public void CreateCoreRequestParameters_BasicCreation_NullIncludes()
+        {
+            var result = new CoreRequestParameters();
+            Assert.NotNull(result);
+            Assert.AreEqual(null, result.Include);
+        }
+
+        [Test]
+        public void CreateCoreRequestParameters_EmptyList_NullIncludes()
+        {
+            var emptyList = new List<string>();
+            var result = new CoreRequestParameters(emptyList);
+            Assert.NotNull(result);
+            Assert.AreEqual("", result.Include);
+        }
+
+        [Test]
+        public void CreateCoreRequestParameters_Returns_CommaDelimitedString()
+        {
+            var testStringList = new List<string>()
+            {
+                "Testing1",
+                "Testing2"
+            };
+            var result = new CoreRequestParameters(testStringList);
+            Assert.NotNull(result);
+            Assert.AreEqual("Testing1,Testing2", result.Include);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Queries/TEST_Query.sql

@@ -0,0 +1,3 @@
+select TEST
+from TEST
+where TEST like TEST

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/AccessChannelPersonsServiceTest.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+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.AccessChannelPersons;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class AccessChannelPersonsServiceTest
+    {
+        private readonly AccessChannelPersonsService _accessChannelPersonsService;
+        private readonly Mock<IAccessChannelPersonsDao> _mockAccessChannelPersonsDao;
+
+        public AccessChannelPersonsServiceTest()
+        {
+            _mockAccessChannelPersonsDao = new Mock<IAccessChannelPersonsDao>();
+            _accessChannelPersonsService = new AccessChannelPersonsService(_mockAccessChannelPersonsDao.Object);
+        }
+
+        [Test]
+        public void GetAccessChannelPersonCoreApiResponseAsync_ExceptionThrown()
+        {
+            _mockAccessChannelPersonsDao.Setup(x => x.FindAccessChannelPersonsByPerson(It.IsAny<CoreRequestParameters>(),
+                                                                                       It.IsAny<AccessChannelPersonsByPersonRequest>()))
+                                            .Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accessChannelPersonsService.GetAccessChannelPersonCoreApiResponseAsync(new AccessChannelPersonsByPersonRequest()));
+        }
+
+        [Test]
+        public async Task GetAccessChannelPersonCoreApiResponseAsync_UserFieldsReturned()
+        {
+            var accessChannelPersons = new List<AccessChannelPerson>()
+            {
+                new AccessChannelPerson()
+                {
+                    ChannelNumber = 1,
+                    PersonNumber = 2,
+                    UserId = "3"
+                },
+                new AccessChannelPerson()
+                {
+                    ChannelNumber = 4,
+                    PersonNumber = 5,
+                    UserId = "6"
+                }
+            };
+            var coreMessageheader = new CoreMessageHeader();
+            var coreApiResponse = new CoreApiMessage<IEnumerable<AccessChannelPerson>>(coreMessageheader, accessChannelPersons);
+            _mockAccessChannelPersonsDao.Setup(x => x.FindAccessChannelPersonsByPerson(It.IsAny<CoreRequestParameters>(),
+                                                                                       It.IsAny<AccessChannelPersonsByPersonRequest>()))
+                                            .ReturnsAsync(coreApiResponse);
+
+
+            var accessChannelPersonsByPersonRequest = new AccessChannelPersonsByPersonRequest();
+
+            var result = await _accessChannelPersonsService.GetAccessChannelPersonCoreApiResponseAsync(accessChannelPersonsByPersonRequest);
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.MessageBody.Count());
+        }
+
+        [Test]
+        public void UpdateAccountChannelPersonAsync_ExceptionThrown()
+        {
+            _mockAccessChannelPersonsDao.Setup(x => x.UpdateAccessChannelPerson(It.IsAny<CoreApiMessage<AccessChannelPerson>>()))
+                                            .Throws(new Exception("Oops"));
+
+            var request = new AccessChannelPerson()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                UserId = "3"
+            };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accessChannelPersonsService.UpdateAccessChannelPersonAsync(request, 10002312312));
+        }
+
+        [Test]
+        public void UpdateAccountChannelPersonAsync_NullResult_ExceptionThrown()
+        {
+            AccessChannelPerson response = null;
+            _mockAccessChannelPersonsDao.Setup(x => x.UpdateAccessChannelPerson(It.IsAny<CoreApiMessage<AccessChannelPerson>>()))            
+                                            .ReturnsAsync(response);
+
+            var request = new AccessChannelPerson()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                UserId = "3"
+            };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accessChannelPersonsService.UpdateAccessChannelPersonAsync(request, 10002312312));
+        }
+
+        [Test]
+        public async Task UpdateAccountChannelPersonAsync_UpdatedUserFieldsReturned()
+        {
+            var response = new AccessChannelPerson()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                UserId = "3"
+            };
+            _mockAccessChannelPersonsDao.Setup(x => x.UpdateAccessChannelPerson(It.IsAny<CoreApiMessage<AccessChannelPerson>>()))
+                                            .ReturnsAsync(response);
+
+            var request = new AccessChannelPerson()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                UserId = "3"
+            };
+            var result = await _accessChannelPersonsService.UpdateAccessChannelPersonAsync(request, 10002312312);
+            Assert.NotNull(result);
+            Assert.AreEqual(response, result);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/AccessTypeServiceTest.cs

@@ -0,0 +1,98 @@
+using System;
+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.AccessTypes;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class AccessTypeServiceTest
+    {
+        private readonly AccessTypeService _accessTypeService;
+        private readonly Mock<IAccessTypeDao> _mockAccessTypeDao;
+
+        public AccessTypeServiceTest()
+        {
+            _mockAccessTypeDao = new Mock<IAccessTypeDao>();
+            _accessTypeService = new AccessTypeService(_mockAccessTypeDao.Object);
+        }
+
+        [Test]
+        public void UpdateAccountTypeAsync_ExceptionThrown()
+        {
+            _mockAccessTypeDao.Setup(x => x.UpdateAccessType(It.IsAny<CoreApiMessage<AccessType>>(), It.IsAny<string>()))
+                                            .Throws(new Exception("Oops"));
+
+            var accessType = new AccessType()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                Id = "WWW"
+            };
+            var request = new AccessTypeUpdateRequest()
+            {
+                AccessType = accessType,
+                AccessChannelPersonId = "1_2",
+                UpdateKey = 123213131
+            };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accessTypeService.UpdateAccessTypeAsync(request));
+        }
+
+        [Test]
+        public void UpdateAccountUserFieldAsync_NullResult_ExceptionThrown()
+        {
+            AccessType response = null;
+            _mockAccessTypeDao.Setup(x => x.UpdateAccessType(It.IsAny<CoreApiMessage<AccessType>>(), It.IsAny<string>()))
+                                            .ReturnsAsync(response);
+
+            var accessType = new AccessType()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                Id = "WWW"
+            };
+            var request = new AccessTypeUpdateRequest() 
+            { 
+                AccessType = accessType,
+                AccessChannelPersonId = "1_2",
+                UpdateKey = 123213131
+            };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accessTypeService.UpdateAccessTypeAsync(request));
+        }
+
+        [Test]
+        public async Task UpdateAccountUserFieldAsync_UpdatedUserFieldsReturned()
+        {
+            var response = new AccessType()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                Id = "WWW"
+            };
+            _mockAccessTypeDao.Setup(x => x.UpdateAccessType(It.IsAny<CoreApiMessage<AccessType>>(), It.IsAny<string>()))
+                                            .ReturnsAsync(response);
+
+            var accessType = new AccessType()
+            {
+                ChannelNumber = 1,
+                PersonNumber = 2,
+                Id = "WWW"
+            };
+            var request = new AccessTypeUpdateRequest()
+            {
+                AccessType = accessType,
+                AccessChannelPersonId = "1_2",
+                UpdateKey = 123213131
+            };
+            var result = await _accessTypeService.UpdateAccessTypeAsync(request);
+            Assert.NotNull(result);
+            Assert.AreEqual(response, result);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/AccountServiceTest.cs

@@ -0,0 +1,743 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Moq;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperLib.Exceptions;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreSoapResponses;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class AccountServiceTest
+    {
+        private readonly AccountService _accountService;
+        private readonly Mock<IAccountDao> _mockAccountDao;
+
+        public AccountServiceTest()
+        {
+            _mockAccountDao = new Mock<IAccountDao>();
+            _accountService = new AccountService(_mockAccountDao.Object);
+        }
+
+        [Test]
+        public async Task GetAccountDetailsByAccountNumber_Returns_AccountDetails()
+        {
+            var testAccount = new Account()
+            {
+                Id = "fasd;fljqer8-3418-3824-8dsfjas;djf",
+                ContractDate = "1/1/2021"
+            };
+            _mockAccountDao.Setup(x => x.FindByAcctNbr(It.IsAny<CoreRequestParameters>(), It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccount);
+            var testAccountNumber = 1000143;
+            var result = await _accountService.GetAccountDetailsByAccountNumber(testAccountNumber);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("fasd;fljqer8-3418-3824-8dsfjas;djf", result.Id);
+            Assert.AreEqual("1/1/2021", result.ContractDate);
+        }
+
+        [Test]
+        public async Task PutAccountMaintenanceRequest_UpdateSuccessful()
+        {
+            var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
+            {
+                new() {
+                    AccountNumber = 123,
+                    DeliveryMethod = "PRNT"
+                }
+            };
+
+            await _accountService.PutAccountMaintenanceRequest(accountMaintenanceRequest);
+            _mockAccountDao.Verify(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest), Times.Once);
+        }
+
+        [Test]
+        public void PutAccountMaintenanceRequest_ExceptionThrown()
+        {
+            var accountMaintenanceRequest = new List<AccountMaintenanceRequest>
+            {
+                new() {
+                    AccountNumber = 123,
+                    DeliveryMethod = "PRNT"
+                }
+            };
+
+            _mockAccountDao.Setup(x => x.PutAccountMaintenanceRequest(accountMaintenanceRequest)).ThrowsAsync(new AccountMaintenanceRequestException("Test exception"));
+
+            Assert.ThrowsAsync<AccountMaintenanceRequestException>(async () => await _accountService.PutAccountMaintenanceRequest(accountMaintenanceRequest));
+        }
+
+        [Test]
+        public async Task GetActivityAccountDetailsByAccountNumbers_OK()
+        {
+            _mockAccountDao.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<string>>()))
+                .ReturnsAsync(new List<ActivityAccountDetails>()
+                {
+                    new ActivityAccountDetails()
+                    {
+                        AccountNumber = 12345,
+                        MinorAccountType = "DV01",
+                        CurrentAccountStatus = "ACT"
+                    },
+                    new ActivityAccountDetails()
+                    {
+                        AccountNumber = 6789,
+                        MinorAccountType = "DV01",
+                        CurrentAccountStatus = "ACT"
+                    }
+                });
+
+            var results =
+                await _accountService.GetActivityAccountDetailsByAccountNumbers(new List<long>() { 12345, 6789 });
+            Assert.NotNull(results);
+            Assert.AreEqual(2, results.Count);
+            _mockAccountDao.Verify(x =>
+                x.GetActivityAccountDetailsByAccountNumbers(It.Is<List<string>>(x =>
+                    x.Contains("12345") && x.Contains("6789"))));
+        }
+
+        [Test]
+        public async Task GetActivityAccountDetailsByAccountNumbers_NoSearch_OK()
+        {
+            _mockAccountDao.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<string>>()))
+                .ReturnsAsync(new List<ActivityAccountDetails>()
+                {
+                    new()
+                    {
+                        AccountNumber = 12345,
+                        MinorAccountType = "DV01",
+                        CurrentAccountStatus = "ACT"
+                    },
+                    new()
+                    {
+                        AccountNumber = 6789,
+                        MinorAccountType = "DV01",
+                        CurrentAccountStatus = "ACT"
+                    }
+                });
+
+            var results = await _accountService.GetActivityAccountDetailsByAccountNumbers(new List<long>() { });
+            Assert.NotNull(results);
+            Assert.AreEqual(0, results.Count);
+        }
+
+        [Test]
+        public async Task GetActivityAccountDetailsByAccountNumbers_Exception_OK()
+        {
+            _mockAccountDao.Setup(x => x.GetActivityAccountDetailsByAccountNumbers(It.IsAny<List<string>>()))
+                .ThrowsAsync(new Exception("Boo"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accountService.GetActivityAccountDetailsByAccountNumbers(new List<long>() { 1, 2, 3 }));
+            _mockAccountDao.Verify(x =>
+                x.GetActivityAccountDetailsByAccountNumbers(It.Is<List<string>>(x =>
+                    x.Contains("1") && x.Contains("2") && x.Contains("3"))));
+        }
+
+        [Test]
+        public async Task GetOwnersByAccountNumber_OK()
+        {
+            var returnedAccountNumbers = new List<AccountOwnership>
+            {
+                new AccountOwnership
+                {
+                    FirstName = "Pete",
+                    LastName = "Peterson",
+                    PersonNumber = 12345,
+                    IsPrimaryOwner = true
+                },
+                new AccountOwnership
+                {
+                    FirstName = "Bill",
+                    LastName = "Billson",
+                    PersonNumber = 98765,
+                }
+            };
+
+            _mockAccountDao
+                .Setup(x => x.FindOwnersByAccountNumber(It.IsAny<long>(), It.IsAny<DateTime>()))
+                .ReturnsAsync(returnedAccountNumbers).Verifiable();
+
+            var result = await _accountService.GetOwnersByAccountNumber(12345, DateTime.Now);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.First().PersonNumber, 12345);
+            Assert.AreEqual(result.First().IsPrimaryOwner, true);
+            Assert.AreEqual(result.Last().PersonNumber, 98765);
+            Assert.AreEqual(result.Last().IsPrimaryOwner, false);
+            Assert.AreEqual(result.Count(), 2);
+
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void GetOwnersByAccountNumber_Exception()
+        {
+            _mockAccountDao.Setup(x => x.FindOwnersByAccountNumber(It.IsAny<long>(), It.IsAny<DateTime>()))
+                .Throws(new Exception("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<Exception>(async () => await _accountService.GetOwnersByAccountNumber(12345, DateTime.Now));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByPersonName_OK()
+        {
+            var personName = "Peterson";
+
+            var returnedAccountNumbers = new List<AccountOwnership>
+            {
+                new AccountOwnership
+                {
+                    FirstName = "Pete",
+                    LastName = "Peterson",
+                    PersonNumber = 12345,
+                    IsPrimaryOwner = true
+                },
+                new AccountOwnership
+                {
+                    FirstName = "Paul",
+                    LastName = "Peterson",
+                    PersonNumber = 98765,
+                }
+            };
+
+            _mockAccountDao
+                .Setup(x => x.FindPrimaryOwnersByPersonName(It.IsAny<string>()))
+                .ReturnsAsync(returnedAccountNumbers).Verifiable();
+
+            var result = await _accountService.GetPrimaryOwnersByPersonName(personName);
+            Assert.NotNull(result);
+
+            var firstNameConcat = returnedAccountNumbers.First().FirstName + " " + returnedAccountNumbers.First().LastName;
+            var secondNameConcat = returnedAccountNumbers.Last().FirstName + " " + returnedAccountNumbers.Last().LastName;
+            Assert.IsTrue(firstNameConcat.Contains(personName));
+            Assert.IsTrue(secondNameConcat.Contains(personName));
+            Assert.AreEqual(result.First().IsPrimaryOwner, true);
+            Assert.AreEqual(result.Last().PersonNumber, 98765);
+            Assert.AreEqual(result.Last().IsPrimaryOwner, false);
+            Assert.AreEqual(result.Count(), 2);
+
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void GetPrimaryOwnersByPersonName_Exception()
+        {
+            var personName = "Pete Peterson";
+
+            _mockAccountDao.Setup(x => x.FindPrimaryOwnersByPersonName(It.IsAny<string>()))
+                .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetPrimaryOwnersByPersonName(personName));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task GetPrimaryOwnersByOrganizationName_OK()
+        {
+            var organizationName = "The Big Company";
+
+            var returnedAccountNumbers = new List<AccountOwnership>
+            {
+                new AccountOwnership
+                {
+                    OrganizationName = organizationName,
+                    ByOrgNbr = 12345,
+                    IsPrimaryOwner = true
+                }
+            };
+
+            _mockAccountDao
+                .Setup(x => x.FindPrimaryOwnersByOrganizationName(It.IsAny<string>()))
+                .ReturnsAsync(returnedAccountNumbers).Verifiable();
+
+            var result = await _accountService.GetPrimaryOwnersByOrganizationName(organizationName);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.First().OrganizationName, organizationName);
+            Assert.AreEqual(result.First().IsPrimaryOwner, true);
+
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void GetPrimaryOwnersByOrganizationName_Exception()
+        {
+            var organizationName = "The Big Company";
+
+            _mockAccountDao.Setup(x => x.FindPrimaryOwnersByOrganizationName(It.IsAny<string>()))
+                .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetPrimaryOwnersByOrganizationName(organizationName));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task GetAccountsForAccoutGroupMaintenance_OK()
+        {
+
+            IEnumerable<string> returnedAccountNumbers = new List<string>
+            {
+                "22",
+                "44"
+            };
+
+            _mockAccountDao.Setup(x => x.FindAccountsToUpdateAccountAnalysis())
+                .ReturnsAsync(returnedAccountNumbers).Verifiable();
+
+            IEnumerable<string> result = await _accountService.GetAccountsForGroupAnalysisMaintenance();
+            Assert.NotNull(result);
+            Assert.IsTrue(result.ToList().Count > 1);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void GetAccountsForAccoutGroupMaintenance_Exception()
+        {
+            _mockAccountDao.Setup(x => x.FindAccountsToUpdateAccountAnalysis())
+                .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetAccountsForGroupAnalysisMaintenance());
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task UpdateAccountsForAccoutGroupMaintenance_OK()
+        {
+            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
+            {
+                AccountNumber = 123,
+                IsGenerateAnalysisStatement = true,
+                IsPrintAnalysisStatement = true,
+                IsUseForServiceCharge = true
+            };
+
+            var returnedAccountNumbers = new List<string>
+            {
+                "22",
+                "44"
+            };
+
+            var response = new BasicResponse()
+            {
+                Success = true
+            };
+
+            _mockAccountDao
+                .Setup(x => x.UpdateAccountAnalysis(accountAnalysisGroupMaintenanceRequest))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _accountService.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.Success, true);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void UpdateAccountsForAccoutGroupMaintenance_Exception()
+        {
+            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest()
+            {
+                AccountNumber = 123,
+                IsGenerateAnalysisStatement = true,
+                IsPrintAnalysisStatement = true,
+                IsUseForServiceCharge = true
+            };
+            _mockAccountDao.Setup(x => x.UpdateAccountAnalysis(accountAnalysisGroupMaintenanceRequest))
+                .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountAnalysisMaintenance(accountAnalysisGroupMaintenanceRequest));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task PostAccountsForPerson_OK()
+        {
+            var request = new CreatePersonAccountRequest()
+            {
+                PersonNumber = 1,
+                FirstName = "Test",
+                LastName = "Test"
+            };
+
+            var returnedAccountNumbers = new List<long>
+            {
+                22
+            };
+
+            var response = new CreatedAccountResponse()
+            {
+                AccountNumber = returnedAccountNumbers[0],
+                BasicResponse = new BasicResponse() { Success = true }
+            };
+
+            _mockAccountDao
+                .Setup(x => x.AddPersonAccount(request))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _accountService.AddPersonAccount(request);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.BasicResponse.Success, true);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void PostAccountsForPerson_Exception()
+        {
+            var request = new CreatePersonAccountRequest()
+            {
+                PersonNumber = 1,
+                FirstName = "Test",
+                LastName = "Test"
+            };
+
+            var returnedAccountNumbers = new List<long>
+            {
+                22
+            };
+
+            var response = new CreatedAccountResponse()
+            {
+                AccountNumber = returnedAccountNumbers[0],
+                BasicResponse = new BasicResponse() { Success = true }
+            };
+
+            _mockAccountDao
+                .Setup(x => x.AddPersonAccount(request))
+            .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.AddPersonAccount(request));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task PostAccountsForOrganization_OK()
+        {
+            var request = new CreateOrganizationAccountRequest()
+            {
+                OrganizationNumber = 1
+            };
+
+            var returnedAccountNumbers = new List<long>
+            {
+                22
+            };
+
+            var response = new CreatedAccountResponse()
+            {
+                AccountNumber = returnedAccountNumbers[0],
+                BasicResponse = new BasicResponse() { Success = true }
+            };
+
+            _mockAccountDao
+                .Setup(x => x.AddOrganizationAccount(request))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _accountService.AddOrganizationAccount(request);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.BasicResponse.Success, true);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void PostAccountsForOrganization_Exception()
+        {
+            var request = new CreateOrganizationAccountRequest()
+            {
+                OrganizationNumber = 1
+            };
+
+            var returnedAccountNumbers = new List<long>
+            {
+                22
+            };
+
+            var response = new CreatedAccountResponse()
+            {
+                AccountNumber = returnedAccountNumbers[0],
+                BasicResponse = new BasicResponse() { Success = true }
+            };
+
+            _mockAccountDao
+                .Setup(x => x.AddOrganizationAccount(request))
+            .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.AddOrganizationAccount(request));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task AddControlPersonOrgMaintenance_OK()
+        {
+            var request = new OrganizationMaintenanceRequest()
+            {
+                ControllingPersonNumber = 1,
+                OrganizationNumber = 12
+            };
+
+            var returnedAccountNumbers = new List<long>
+            {
+                22
+            };
+
+            var response = new BasicResponse()
+            {
+                Success = true
+            };
+
+            _mockAccountDao
+                .Setup(x => x.PutOrganizationMaintenanceRequest(request))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _accountService.PutOrganizationMaintenanceRequest(request);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.Success, true);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void AddControlPersonOrgMaintenance_Exception()
+        {
+            var request = new OrganizationMaintenanceRequest()
+            {
+                ControllingPersonNumber = 1,
+                OrganizationNumber = 12
+            };
+
+            var returnedAccountNumbers = new List<long>
+            {
+                22
+            };
+
+            var response = new BasicResponse()
+            {
+                Success = true
+            };
+
+            _mockAccountDao
+                .Setup(x => x.PutOrganizationMaintenanceRequest(request))
+            .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.PutOrganizationMaintenanceRequest(request));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task AccountNickNameUpdateRequest_OK()
+        {
+            var accountRequest = new AccountNickNameUpdateRequest()
+            {
+                AccountNumber = 123,
+                AccountDescription = "TestOK"
+            };
+
+            var response = new BasicResponse()
+            {
+                Success = true
+            };
+
+            _mockAccountDao
+                .Setup(x => x.UpdateAccountNickName(accountRequest))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _accountService.UpdateAccountNickName(accountRequest);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.Success, true);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void AccountNickNameUpdateRequest_Exception()
+        {
+            var accountRequest = new AccountNickNameUpdateRequest()
+            {
+                AccountNumber = 123,
+                AccountDescription = "TestException"
+            };
+
+            _mockAccountDao.Setup(x => x.UpdateAccountNickName(accountRequest))
+                .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountNickName(accountRequest));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task AccountCreditReportTypeUpdateRequest_OK()
+        {
+            var accountRequest = new AccountCreditReportTypeUpdateRequest()
+            {
+                AccountNumber = 123,
+                CreditReportType = "EXCL"
+            };
+
+            var response = new BasicResponse()
+            {
+                Success = true
+            };
+
+            _mockAccountDao
+                .Setup(x => x.UpdateAccountCreditReportType(accountRequest))
+                .ReturnsAsync(response).Verifiable();
+
+            var result = await _accountService.UpdateAccountCreditReportType(accountRequest);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.Success, true);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public void AccountCreditReportTypeUpdateRequest_Exception()
+        {
+            var accountRequest = new AccountCreditReportTypeUpdateRequest()
+            {
+                AccountNumber = 123,
+                CreditReportType = "EXCL"
+            };
+
+            _mockAccountDao.Setup(x => x.UpdateAccountCreditReportType(accountRequest))
+                .Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountCreditReportType(accountRequest));
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task GetAccountsByMajorMinorBranchAndStatus_Ok()
+        {
+            var request = new AccountsByMajorMinorBranchAndStatusRequest()
+            {
+                BranchCodes = new List<long>()
+                {
+                    1234,
+                    1235
+                },
+                AccountStatuses = new List<string>()
+                {
+                    "Status"
+                },
+                MajorTypes = new List<string>()
+                {
+                    "Major"
+                },
+                MinorTypes = new List<string>()
+                {
+                    "MinorOne",
+                    "MinorTwo"
+                }
+            };
+
+            var response = new List<AccountsByMajorMinorBranchAndStatusResponse>()
+            {
+                new AccountsByMajorMinorBranchAndStatusResponse()
+                {
+                    AccountNumber = 1234,
+                    BranchCode = 987654321,
+                    Name = "Test Name"
+                },
+                new AccountsByMajorMinorBranchAndStatusResponse()
+                {
+                    AccountNumber = 5678,
+                    BranchCode = 987654321,
+                    Name = "Test Name Two"
+                }
+            };
+
+            _mockAccountDao.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(request)).ReturnsAsync(response).Verifiable();
+
+            var result = await _accountService.GetAccountsByMajorMinorBranchAndStatus(request);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(result.Count(), 2);
+            Assert.AreEqual(result.FirstOrDefault().AccountNumber, 1234);
+            _mockAccountDao.Verify();
+        }
+
+        [Test]
+        public async Task GetAccountsByMajorMinorBranchAndStatus_Exception()
+        {
+            var request = new AccountsByMajorMinorBranchAndStatusRequest()
+            {
+                BranchCodes = new List<long>()
+                {
+                    1234,
+                    1235
+                },
+                AccountStatuses = new List<string>()
+                {
+                    "Status"
+                },
+                MajorTypes = new List<string>()
+                {
+                    "Major"
+                },
+                MinorTypes = new List<string>()
+                {
+                    "MinorOne",
+                    "MinorTwo"
+                }
+            };
+
+            _mockAccountDao.Setup(x => x.GetAccountsByMajorMinorBranchAndStatus(request)).Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _accountService.GetAccountsByMajorMinorBranchAndStatus(request));
+            _mockAccountDao.Verify();
+        }
+
+		[Test]
+		public async Task AccountContractDateUpdateRequest_OK()
+		{
+			var accountRequest = new AccountContractDateUpdateRequest
+			{
+				AccountNumber = 123,
+				ContractDate = DateTime.Now
+			};
+
+			var response = new BasicResponse()
+			{
+				Success = true
+			};
+
+			_mockAccountDao
+				.Setup(x => x.UpdateAccountContractDate(accountRequest))
+				.ReturnsAsync(response).Verifiable();
+
+			var result = await _accountService.UpdateAccountContractDate(accountRequest);
+			Assert.NotNull(result);
+
+			Assert.AreEqual(result.Success, true);
+			_mockAccountDao.Verify();
+		}
+
+		[Test]
+		public void AccountContractDateUpdateRequest_Exception()
+		{
+			var accountRequest = new AccountContractDateUpdateRequest
+			{
+				AccountNumber = 123,
+				ContractDate = DateTime.Now
+			};
+
+			_mockAccountDao.Setup(x => x.UpdateAccountContractDate(accountRequest))
+				.Throws(new ServiceException("Exception from unit test")).Verifiable();
+
+			Assert.ThrowsAsync<ServiceException>(async () => await _accountService.UpdateAccountContractDate(accountRequest));
+			_mockAccountDao.Verify();
+		}
+	}
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/AccountUserFieldServiceTest.cs

@@ -0,0 +1,419 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+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.Accounts;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class AccountUserFieldServiceTest
+    {
+        private readonly AccountUserFieldService _accountUserFieldService;
+        private readonly Mock<IAccountService> _mockAccountService;
+        private readonly Mock<IAccountUserFieldDao> _mockAccountUserFieldDao;
+
+        public AccountUserFieldServiceTest()
+        {
+            _mockAccountService = new Mock<IAccountService>();
+            _mockAccountUserFieldDao = new Mock<IAccountUserFieldDao>();
+            _accountUserFieldService = new AccountUserFieldService(_mockAccountService.Object,_mockAccountUserFieldDao.Object);
+        }
+
+        [Test]
+        public void GetAccountUserFieldCoreApiResponseAsync_ExceptionThrown()
+        {
+            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accountUserFieldService.GetAccountUserFieldCoreApiResponseAsync("testaccountiddsafasfsadfsdfsdafsd"));
+        }
+
+        [Test]
+        public async Task GetAccountUserFieldCoreApiResponseAsync_UserFieldsReturned()
+        {
+            var accountUserFields = new List<AccountUserField>()
+            {
+                new AccountUserField()
+                {
+                  AccountNumber = 100001,
+                   UserFieldCode = "TEST1",
+                   Value = "Y"
+
+                },
+                new AccountUserField()
+                {
+                   AccountNumber = 100002,
+                   UserFieldCode = "TEST2",
+                   Value = "N"
+                }
+            };
+            var coreMessageheader = new CoreMessageHeader();
+            var accountUserFieldCoreApiResponse = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageheader, accountUserFields);
+            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(accountUserFieldCoreApiResponse);
+
+
+            var result = await _accountUserFieldService.GetAccountUserFieldCoreApiResponseAsync("testaccountidasfasdfsdfsadfsdfsdf");
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.MessageBody.Count());
+        }
+
+        [Test]
+        public void UpdateAccountUserFieldAsync_ExceptionThrown()
+        {
+            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(), It.IsAny<string>(), It.IsAny<string>())).Throws(new Exception("Oops"));
+
+            var accountUserUpdateRequest = new AccountUserFieldRequest()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accountUserFieldService.UpdateAccountUserFieldAsync(accountUserUpdateRequest, 10002312312, "testaccountidfdafdfasfdsf", "TEST1"));
+        }
+
+        [Test]
+        public async Task UpdateAccountUserFieldAsync_UpdatedUserFieldsReturned()
+        {
+            var updatedAccountUserField = new AccountUserField()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y",
+                LastMaintained = Convert.ToDateTime("9/1/2001")
+            };
+            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
+                                                                It.IsAny<string>(),
+                                                                It.IsAny<string>())).ReturnsAsync(updatedAccountUserField);
+
+            var accountUserUpdateRequest = new AccountUserFieldRequest()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var result = await _accountUserFieldService.UpdateAccountUserFieldAsync(accountUserUpdateRequest, 10002312312, "testaccountidfdafdfasfdsf", "TEST1");
+            Assert.NotNull(result);
+            Assert.AreEqual(updatedAccountUserField, result);
+        }
+
+        [Test]
+        public void InsertAccountUserFieldAsync_ExceptionThrown()
+        {
+            _mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(), It.IsAny<string>())).Throws(new Exception("Oops"));
+
+            var accountUserUpdateRequest = new AccountUserFieldRequest()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _accountUserFieldService.InsertAccountUserFieldAsync(accountUserUpdateRequest, "testaccountidfdafdfasfdsf"));
+        }
+
+        [Test]
+        public async Task InsertAccountUserFieldAsync_InsertUserFieldsReturned()
+        {
+            var createdAccountUserField = new AccountUserField()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y",
+                LastMaintained = Convert.ToDateTime("9/1/2001")
+            };
+            _mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
+                                                                It.IsAny<string>())).ReturnsAsync(createdAccountUserField);
+
+            var accountUserUpdateRequest = new AccountUserFieldRequest()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var result = await _accountUserFieldService.InsertAccountUserFieldAsync(accountUserUpdateRequest, "testaccountidfdafdfasfdsf");
+            Assert.NotNull(result);
+            Assert.AreEqual(createdAccountUserField, result);
+        }
+
+        [Test]
+        public void UpdateAccountUserFieldsAsync_AccountNull_NullExceptionThrown()
+        {
+            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                   AccountNumber = 100001,
+                   UserFieldCode = "TEST1",
+                   Value = "Y"
+
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                   UserFieldCode = "TEST2",
+                   Value = "N"
+                }
+            };
+            Account testAccount = null;
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
+
+            Assert.ThrowsAsync<NullReferenceException>(async () =>
+                 await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
+        }
+
+        [Test]
+        public void UpdateAccountUserFieldsAsync_ExistingUserFieldNull_NullExceptionThrown()
+        {
+            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                   AccountNumber = 100001,
+                   UserFieldCode = "TEST1",
+                   Value = "Y"
+
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                   UserFieldCode = "TEST2",
+                   Value = "N"
+                }
+            };
+            Account testAccount = new Account()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
+
+            IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>();
+            CoreMessageHeader coreMessageHeader = new CoreMessageHeader();
+            CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
+            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
+                                                       It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);
+
+            Assert.ThrowsAsync<NullReferenceException>(async () =>
+                 await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
+        }
+
+        [Test]
+        public void UpdateAccountUserFieldsAsync_UpdateUserFieldNull_NullExceptionThrown()
+        {
+            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                   AccountNumber = 100001,
+                   UserFieldCode = "TEST1",
+                   Value = "Y"
+
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                   UserFieldCode = "TEST2",
+                   Value = "N"
+                }
+            };
+            Account testAccount = new Account()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
+
+            IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>()
+            {
+                new AccountUserField()
+                {
+                    Id = "TEST1",
+                    AccountNumber = 100001,
+                    UserFieldCode = "TEST1",
+                    Value = "N"
+                },
+                new AccountUserField()
+                {
+                    Id = "TEST2",
+                    AccountNumber = 100002,
+                    UserFieldCode = "TEST2",
+                    Value = "Y"
+                }
+            };
+            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
+            CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
+            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
+                                                       It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);
+
+            AccountUserField updatedAccountUserField = null;
+            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
+                                                                It.IsAny<string>(),
+                                                                It.IsAny<string>())).ReturnsAsync(updatedAccountUserField);
+
+            Assert.ThrowsAsync<NullReferenceException>(async () =>
+                 await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests));
+        }
+
+        [Test]
+        public async Task UpdateAccountUserFieldsAsync_ListofUpdateduserfields()
+        {
+            var request1 = new AccountUserFieldRequest()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+
+            };
+            var request2 = new AccountUserFieldRequest()
+            {
+                AccountNumber = 100002,
+                UserFieldCode = "TEST2",
+                Value = "N"
+            };
+
+            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
+            {
+                request1,
+                request2
+            };
+
+            Account testAccount = new Account()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
+
+
+            var accountUserField1 = new AccountUserField()
+            {
+                Id = "TEST1",
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+            var accountUserField2 = new AccountUserField()
+            {
+                Id = "TEST2",
+                AccountNumber = 100002,
+                UserFieldCode = "TEST2",
+                Value = "Y"
+            };
+
+            IEnumerable<AccountUserField> accountUserFields = new List<AccountUserField>()
+            {
+                accountUserField1,
+                accountUserField2
+            };
+            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
+            CoreApiMessage<IEnumerable<AccountUserField>> coreApiMessageAccountUserFields = new CoreApiMessage<IEnumerable<AccountUserField>>(coreMessageHeader, accountUserFields);
+            _mockAccountUserFieldDao.Setup(x => x.FindAccountUserFieldCoreApiResponseByAccountId(It.IsAny<CoreRequestParameters>(),
+                                                       It.IsAny<string>())).ReturnsAsync(coreApiMessageAccountUserFields);
+
+            AccountUserField updatedAccountUserField1 = new AccountUserField()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
+                                                                It.IsAny<string>(),
+                                                                accountUserField1.Id)).ReturnsAsync(updatedAccountUserField1);
+
+            AccountUserField updatedAccountUserField2 = new AccountUserField()
+            {
+                AccountNumber = 100002,
+                UserFieldCode = "TEST2",
+                Value = "N"
+            };
+            _mockAccountUserFieldDao.Setup(x => x.UpdateAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
+                                                                It.IsAny<string>(),
+                                                                accountUserField2.Id)).ReturnsAsync(updatedAccountUserField2);
+
+            var result = await _accountUserFieldService.UpdateAccountUserFieldsAsync(accountUserFieldUpdateRequests);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            var result1 = result.FirstOrDefault(r => r.UserFieldCode == "TEST1");
+            Assert.NotNull(result1);
+            Assert.AreEqual("Y", result1.Value);
+            Assert.AreEqual(100001, result1.AccountNumber);
+
+            var result2 = result.FirstOrDefault(r => r.UserFieldCode == "TEST2");
+            Assert.NotNull(result2);
+            Assert.AreEqual("N", result2.Value);
+            Assert.AreEqual(100002, result2.AccountNumber);
+        }
+
+        [Test]
+        public void InsertAccountUserFieldsAsync_AccountNull_NullExceptionThrown()
+        {
+            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
+            {
+                new AccountUserFieldRequest()
+                {
+                   AccountNumber = 100001,
+                   UserFieldCode = "TEST1",
+                   Value = "Y"
+
+                },
+                new AccountUserFieldRequest()
+                {
+                    AccountNumber = 100002,
+                   UserFieldCode = "TEST2",
+                   Value = "N"
+                }
+            };
+            Account testAccount = null;
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
+
+            Assert.ThrowsAsync<NullReferenceException>(async () =>
+                 await _accountUserFieldService.InsertAccountUserFieldsAsync(accountUserFieldUpdateRequests));
+        }
+
+        [Test]
+        public async Task InsertAccountUserFieldsAsync_ListofInsertedUserfields()
+        {
+
+            var testAccount = new Account()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetailsByAccountNumber(It.IsAny<long>())).ReturnsAsync(testAccount);
+
+            var messageHeader = new CoreMessageHeader() { };
+            var accountUserFieldRequest1 = new AccountUserFieldRequest()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var coreApiMessage = new CoreApiMessage<AccountUserFieldRequest>(messageHeader, accountUserFieldRequest1);
+            var createdAccountUserField1 = new AccountUserField()
+            {
+                AccountNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            _mockAccountUserFieldDao.Setup(x => x.InsertAccountUserField(It.IsAny<CoreApiMessage<AccountUserFieldRequest>>(),
+                                                                testAccount.Id)).ReturnsAsync(createdAccountUserField1);          
+
+            var accountUserFieldUpdateRequests = new List<AccountUserFieldRequest>()
+            {
+                accountUserFieldRequest1
+            };
+            var result = await _accountUserFieldService.InsertAccountUserFieldsAsync(accountUserFieldUpdateRequests);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count());
+            var result1 = result.FirstOrDefault(r => r.UserFieldCode == "TEST1");
+            Assert.NotNull(result1);
+            Assert.AreEqual("Y", result1.Value);
+            Assert.AreEqual(100001, result1.AccountNumber);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/ActivityServiceTest.cs

@@ -0,0 +1,909 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Activity;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Tax;
+using LCU.Library.Internal.CoreApiWrapperModel.LcuModels.Activity;
+using LCU.Library.Internal.Exceptions;
+using Moq;
+using NUnit.Framework;
+using FailedToParseException = LCU.Library.Internal.CoreApiWrapperLib.Exceptions.FailedToParseException;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class ActivityServiceTest
+    {
+        private ActivityService _activityService;
+        private Mock<ITaxService> _mockTaxService;
+        private Mock<IActivityDao> _mockActivityDao;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockActivityDao = new Mock<IActivityDao>();
+            _mockTaxService = new Mock<ITaxService>();
+            _activityService = new ActivityService(_mockActivityDao.Object, _mockTaxService.Object);
+
+            _mockActivityDao.Setup(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewCheckingAccountActivity>()
+                {
+                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewCheckingAccountActivity>()
+                {
+                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+
+            _mockActivityDao.Setup(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewCheckingAccountActivity>()
+                {
+                    new NewCheckingAccountActivity() { ActivityNbr = 1 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 2 },
+                    new NewCheckingAccountActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewAtmCheckCardActivity>()
+                {
+                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewAtmCheckCardActivity>()
+                {
+                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+
+            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>())).ReturnsAsync(
+                new List<NewAtmCheckCardActivity>()
+                {
+                    new NewAtmCheckCardActivity() { ActivityNbr = 1 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 2 },
+                    new NewAtmCheckCardActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>())).ReturnsAsync(
+                new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ReturnsAsync(
+                new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>())).ReturnsAsync(
+                new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                }).Verifiable();
+
+
+            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>())).ReturnsAsync(
+                new List<NewActivityManagerIncentiveReferral>()
+                {
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 1 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 2 },
+                    new NewActivityManagerIncentiveReferral() { ActivityId = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
+                new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
+                new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime?>(), It.IsAny<long?>())).ReturnsAsync(
+                new List<NewLoanSaleActivity>()
+                {
+                    new NewLoanSaleActivity() { ActivityNbr = 1 },
+                    new NewLoanSaleActivity() { ActivityNbr = 2 },
+                    new NewLoanSaleActivity() { ActivityNbr = 3 }
+                }).Verifiable();
+
+            _mockActivityDao.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime?>())).ReturnsAsync(
+             new List<EStatementDeliveryMethod>()
+             {
+                    new EStatementDeliveryMethod() { ActivityNumber = 1 },
+                    new EStatementDeliveryMethod() { ActivityNumber = 2 },
+                    new EStatementDeliveryMethod() { ActivityNumber = 3 }
+             }).Verifiable();
+        }
+
+        [Test]
+        public async Task GetNewCheckingAccountActivities_Both_Ok()
+        {
+            var results = await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", 5, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewCheckingActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5), 100));
+
+            _mockActivityDao.Verify(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Once);
+            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewCheckingAccountActivities_No_ActvNbr_Ok()
+        {
+            var results = await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", null, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewCheckingActivitiesNewerThanDate(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0), 100));
+
+            _mockActivityDao.Verify(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewCheckingAccountActivities_No_Date_Ok()
+        {
+            var results = await _activityService.GetNewCheckingAccountActivities(null, 5, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewCheckingActivitiesAfterActivityNbr(It.Is<long>(nbr => nbr == 5), 100));
+        }
+
+        [Test]
+        public async Task GetNewCheckingAccountActivities_No_Params_Exception()
+        {
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewCheckingAccountActivities(null, null, 100));
+        }
+
+        [Test]
+        public async Task GetNewCheckingAccountActivities_FailedToParse_BadDateTime()
+        {
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewCheckingAccountActivities("DateTimes are a Devs Best Friend", 1, 100));
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewCheckingAccountActivities("DateTimes are a Devs Best Friend", null, 100));
+        }
+
+        [Test]
+        public async Task GetNewCheckingAccountActivities_Exception()
+        {
+            _mockActivityDao.Setup(x => x.GetNewCheckingActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewCheckingAccountActivities("2020-04-15T11:00:00", 10, 100));
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_Both_Ok()
+        {
+            var results = await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", 5, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewAtmCheckCardActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5), 100));
+
+            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Once);
+            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_No_ActvNbr_Ok()
+        {
+            var results = await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", null, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewAtmCheckCardActivitiesNewerThanDate(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0), 100));
+
+            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.IsAny<long>(), It.IsAny<int>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesNewerThanDate(It.IsAny<DateTime>(), It.IsAny<int>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_No_Date_Ok()
+        {
+            var results = await _activityService.GetNewAtmCheckCardActivities(null, 5, 100);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewAtmCheckCardActivitiesAfterActivityNbr(It.Is<long>(nbr => nbr == 5), 100));
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_No_Params_Exception()
+        {
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewAtmCheckCardActivities(null, null, 100));
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_FailedToParse_BadDateTime()
+        {
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewAtmCheckCardActivities("DateTimes are a Devs Best Friend", 1, 100));
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewAtmCheckCardActivities("DateTimes are a Devs Best Friend", null, 100));
+        }
+
+        [Test]
+        public async Task GetNewAtmCheckCardActivities_Exception()
+        {
+            _mockActivityDao.Setup(x => x.GetNewAtmCheckCardActivities(It.IsAny<DateTime>(), It.IsAny<long>(), It.IsAny<int>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewAtmCheckCardActivities("2020-04-15T11:00:00", 10, 100));
+        }
+
+        [Test]
+        public async Task GetNewEDeliveryStatementSaleActivities_Ok()
+        {
+            var results = await _activityService.GetEStatementDeliveryActivity("2020-04-15T11:00:00");
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNumber == 1));
+            Assert.True(results.Any(x => x.ActivityNumber == 2));
+            Assert.True(results.Any(x => x.ActivityNumber == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetEStatementDeliveryActivity(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0)
+                    ));
+
+            _mockActivityDao.Verify(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewEDeliveryStatementSaleActivities_Exception()
+        {
+            _mockActivityDao.Setup(x => x.GetEStatementDeliveryActivity(It.IsAny<DateTime>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetEStatementDeliveryActivity("2020-04-15T11:00:00"));
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerIncentiveReferrals_Both_Ok()
+        {
+            var results = await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityId == 1));
+            Assert.True(results.Any(x => x.ActivityId == 2));
+            Assert.True(results.Any(x => x.ActivityId == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewActivityManagerReferrals(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5)));
+
+            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
+            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>()), Times.Never);
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerIncentiveReferrals_No_ActvNbr_Ok()
+        {
+            var results = await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", null);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityId == 1));
+            Assert.True(results.Any(x => x.ActivityId == 2));
+            Assert.True(results.Any(x => x.ActivityId == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewActivityManagerReferralsNewerThan(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0)));
+
+            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsAfterActivityId(It.IsAny<long>()), Times.Never);
+            _mockActivityDao.Verify(x => x.GetNewActivityManagerReferralsNewerThan(It.IsAny<DateTime>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerIncentiveReferrals_No_Date_Ok()
+        {
+            var results = await _activityService.GetNewActivityManagerIncentiveReferrals(null, 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityId == 1));
+            Assert.True(results.Any(x => x.ActivityId == 2));
+            Assert.True(results.Any(x => x.ActivityId == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewActivityManagerReferralsAfterActivityId(
+                    It.Is<long>(nbr => nbr == 5)));
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerIncentiveReferrals_No_Params_Exception()
+        {
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewActivityManagerIncentiveReferrals(null, null));
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerIncentiveReferrals_FailedToParse_BadDateTime()
+        {
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewActivityManagerIncentiveReferrals("DateTimes are a Devs Best Friend", 1));
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewActivityManagerIncentiveReferrals("DateTimes are a Devs Best Friend", null));
+        }
+
+        [Test]
+        public async Task GetNewActivityManagerIncentiveReferrals_Exception()
+        {
+            _mockActivityDao.Setup(x => x.GetNewActivityManagerReferrals(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewActivityManagerIncentiveReferrals("2020-04-15T11:00:00", 10));
+        }
+
+        [Test]
+        public async Task GetNewMortgageSalesActivities_Ok()
+        {
+            var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewMortgageSaleActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5)));
+
+            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_No_ActvNbr_Ok()
+        {
+            var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", null);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_No_Date_Ok()
+        {
+            var results = await _activityService.GetNewMortgageSaleActivities(null, 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_No_Params_Exception()
+        {
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewMortgageSaleActivities(null, null));
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_FailedToParse_BadDateTime()
+        {
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewMortgageSaleActivities("DateTimes are a Devs Best Friend", 1));
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewMortgageSaleActivities("DateTimes are a Devs Best Friend", null));
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_Exception()
+        {
+            _mockActivityDao.Setup(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 10));
+        }
+
+        [Test]
+        public async Task GetNewMortgageSaleActivities_Both_Ok()
+        {
+            var results = await _activityService.GetNewMortgageSaleActivities("2020-04-15T11:00:00", 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewMortgageSaleActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5)));
+
+            _mockActivityDao.Verify(x => x.GetNewMortgageSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_Ok()
+        {
+            var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewVehicleSaleActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5)));
+
+            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_No_ActvNbr_Ok()
+        {
+            var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", null);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_No_Date_Ok()
+        {
+            var results = await _activityService.GetNewVehicleSaleActivities(null, 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_No_Params_Exception()
+        {
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewVehicleSaleActivities(null, null));
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_FailedToParse_BadDateTime()
+        {
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewVehicleSaleActivities("DateTimes are a Devs Best Friend", 1));
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewVehicleSaleActivities("DateTimes are a Devs Best Friend", null));
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_Exception()
+        {
+            _mockActivityDao.Setup(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 10));
+        }
+
+        [Test]
+        public async Task GetNewVehicleSaleActivities_Both_Ok()
+        {
+            var results = await _activityService.GetNewVehicleSaleActivities("2020-04-15T11:00:00", 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewVehicleSaleActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5)));
+
+            _mockActivityDao.Verify(x => x.GetNewVehicleSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_Ok()
+        {
+            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewDebtProtectedLoanSaleActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5)));
+
+            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_No_ActvNbr_Ok()
+        {
+            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", null);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.Is<long?>(x => x == null)), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_No_Date_Ok()
+        {
+            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities(null, 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.Is<DateTime?>(x => x.HasValue == false), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_No_Params_Exception()
+        {
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewDebtProtectedLoanSaleActivities(null, null));
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_FailedToParse_BadDateTime()
+        {
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewDebtProtectedLoanSaleActivities("DateTimes are a Devs Best Friend", 1));
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _activityService.GetNewDebtProtectedLoanSaleActivities("DateTimes are a Devs Best Friend", null));
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_Exception()
+        {
+            _mockActivityDao.Setup(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>())).Throws(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 10));
+        }
+
+        [Test]
+        public async Task GetNewDebtProtectedLoanSaleActivities_Both_Ok()
+        {
+            var results = await _activityService.GetNewDebtProtectedLoanSaleActivities("2020-04-15T11:00:00", 5);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityNbr == 1));
+            Assert.True(results.Any(x => x.ActivityNbr == 2));
+            Assert.True(results.Any(x => x.ActivityNbr == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.GetNewDebtProtectedLoanSaleActivities(
+                    It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("2020-04-15T11:00:00")) == 0),
+                    It.Is<long>(actvnbr => actvnbr == 5)));
+
+            _mockActivityDao.Verify(x => x.GetNewDebtProtectedLoanSaleActivities(It.IsAny<DateTime>(), It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public async Task QueryActivityManagerActivity_Ok()
+        {
+            var results = await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
+            {
+                ActivityIds = new List<long>() { 1, 2, 3 }
+            });
+
+            Assert.NotNull(results);
+            Assert.AreEqual(3, results.Count);
+            Assert.True(results.Any(x => x.ActivityId == 1));
+            Assert.True(results.Any(x => x.ActivityId == 2));
+            Assert.True(results.Any(x => x.ActivityId == 3));
+
+            _mockActivityDao.Verify(x =>
+                x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()));
+        }
+
+        [Test]
+        public async Task QueryActivityManagerActivity_Exception()
+        {
+            _mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ThrowsAsync(new Exception("Oops"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
+                {
+                    ActivityIds = new List<long>() { 1, 2, 3, 4, 5, 6, 7 }
+                }));
+
+            _mockActivityDao.Verify(x =>
+                x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()));
+        }
+
+        [Test]
+        public async Task QueryActivityManagerActivity_DontHitCoreWhenEmpty()
+        {
+            _mockActivityDao.Setup(x => x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>())).ThrowsAsync(new Exception("Oops"));
+
+
+            var result = await _activityService.QueryActivityManagerActivity(new ActivityQueryRequest()
+            {
+                ActivityIds = new List<long>()
+            });
+
+            Assert.NotNull(result);
+
+            _mockActivityDao.Verify(x =>
+                x.QueryActivityManagerActivity(It.IsAny<ActivityQueryRequest>()), Times.Never());
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByPhoneNumber_OK()
+        {
+            var phoneNumber = Guid.NewGuid().ToString();
+            _mockActivityDao
+                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
+                .ReturnsAsync(new List<PersonRecentActivity>
+                {
+                    new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
+                }).Verifiable();
+
+            var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);
+
+            Assert.NotNull(result);
+            Assert.IsTrue(result.Success);
+            Assert.AreEqual(phoneNumber, result.PersonRecentActivity?.HomePhone);
+            _mockActivityDao.Verify(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()), Times.Once);
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByPhoneNumber_MultipleReturn()
+        {
+            var phoneNumber = Guid.NewGuid().ToString();
+            _mockActivityDao
+                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
+                .ReturnsAsync(new List<PersonRecentActivity>
+                {
+                    new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber },
+                    new () { PersonNumber = DateTime.Now.Millisecond, HomePhone = phoneNumber }
+                }).Verifiable();
+
+            var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);
+
+            Assert.NotNull(result);
+            Assert.IsFalse(result.Success);
+            Assert.IsNotNull(result.Message);
+            Assert.IsNull(result.PersonRecentActivity);
+            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
+        }
+                
+        [Test]
+        public async Task GetPersonActivityByPhoneNumber_NoContent()
+        {
+            var phoneNumber = Guid.NewGuid().ToString();
+            _mockActivityDao
+                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
+                .ReturnsAsync(new List<PersonRecentActivity>()).Verifiable();
+
+            var result = await _activityService.GetPersonActivityByPhoneNumber(phoneNumber);
+
+            Assert.NotNull(result);
+            Assert.IsFalse(result.Success);
+            Assert.IsNotNull(result.Message);
+            Assert.IsNull(result.PersonRecentActivity);
+            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetPersonActivityByPhoneNumber_Exception()
+        {
+            _mockActivityDao
+                .Setup(x => x.GetPersonActivityByPhoneNumber(It.IsAny<string>()))
+                .ThrowsAsync(new Exception());
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _activityService.GetPersonActivityByPhoneNumber(It.IsAny<string>()));
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByTaxId_OK()
+        {
+            var personNumber = DateTime.Now.Millisecond;
+            var taxId = Guid.NewGuid().ToString();
+            var persons = new List<PersonTaxIdDataResponse>
+            {
+                new()
+                {
+                    PersonNumber = personNumber
+                }
+            };
+            _mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
+                .ReturnsAsync(persons).Verifiable();
+            _mockActivityDao
+                .Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
+                .ReturnsAsync(new PersonRecentActivity
+                {
+                    PersonNumber = personNumber
+                }).Verifiable();
+
+            var result = await _activityService.GetPersonActivityByTaxId(taxId);
+
+            Assert.NotNull(result);
+            Assert.IsTrue(result.Success);
+            Assert.NotNull(result.PersonRecentActivity);
+            Assert.AreEqual(personNumber, result.PersonRecentActivity?.PersonNumber);
+            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Once);
+            _mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByTaxId_MultipleReturn()
+        {
+            var personNumber = DateTime.Now.Millisecond;
+            var taxId = Guid.NewGuid().ToString();
+            var persons = new List<PersonTaxIdDataResponse>
+            {
+                new() { PersonNumber = personNumber },
+                new() { PersonNumber = personNumber }
+            };
+            _mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
+                .ReturnsAsync(persons).Verifiable();
+            _mockActivityDao
+                .Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
+                .ReturnsAsync(new PersonRecentActivity
+                {
+                    PersonNumber = personNumber
+                }).Verifiable();
+
+            var result = await _activityService.GetPersonActivityByTaxId(taxId);
+
+            Assert.NotNull(result);
+            Assert.IsFalse(result.Success);
+            Assert.IsNotNull(result.Message);
+            Assert.IsNull(result.PersonRecentActivity);
+            _mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
+            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
+        }
+        
+        [Test]
+        public async Task GetPersonActivityByTaxId_NoContent()
+        {
+            var personNumber = DateTime.Now.Millisecond;
+            var taxId = Guid.NewGuid().ToString();
+            var persons = new List<PersonTaxIdDataResponse>();
+            _mockTaxService.Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
+                .ReturnsAsync(persons).Verifiable();
+            _mockActivityDao
+                .Setup(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()))
+                .ReturnsAsync(new PersonRecentActivity
+                {
+                    PersonNumber = personNumber
+                }).Verifiable();
+
+            var result = await _activityService.GetPersonActivityByTaxId(taxId);
+
+            Assert.NotNull(result);
+            Assert.IsFalse(result.Success);
+            Assert.IsNotNull(result.Message);
+            Assert.IsNull(result.PersonRecentActivity);
+            _mockTaxService.Verify(x => x.GetPersonsTaxIdData(It.IsAny<string>()), Times.Once);
+            _mockActivityDao.Verify(x => x.GetPersonActivityByPersonNumber(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetPersonActivityByTaxId_Exception()
+        {
+            _mockTaxService
+                .Setup(x => x.GetPersonsTaxIdData(It.IsAny<string>()))
+                .ThrowsAsync(new Exception());
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _activityService.GetPersonActivityByTaxId(It.IsAny<string>()));
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/AddressServiceTest.cs

@@ -0,0 +1,177 @@
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
+using LCU.Library.Internal.Exceptions;
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class AddressServiceTest
+    {
+        private AddressService _addressService;
+        private Mock<IAddressDao> _mockAddressDao;
+        private PersonAddrLine _updatedPersonAddrLineOneAddressLine = new PersonAddrLine()
+        {
+            PersonNumber = 111,
+            AddressNumber = 222,
+            AddressUseCode = "PRI",
+            AddressLine1 = "1 Imaginary Street",
+            AddressLineTypeCode1 = "ST",
+            CityName = "Milwaukee",
+            PostalCode = "53220",
+            CountrySubdivisionCode = "WI",
+            CountryCode = "USA",
+        };
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockAddressDao = new Mock<IAddressDao>();
+            _addressService = new AddressService(_mockAddressDao.Object);
+            
+        }
+
+        [Test]
+        public async Task UpdateAddrLine_ok()
+        {
+            _mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).ReturnsAsync(
+            _updatedPersonAddrLineOneAddressLine).Verifiable();
+
+            var personpostal = new PersonPostalAddress()
+            {
+                PersonNumber = 111,
+                AddressNumber = 222
+            };
+
+            var header = new CoreMessageHeader()
+            {
+                UpdateKey = 123456
+            };
+
+            var personList = new List<PersonPostalAddress>()
+            {
+                personpostal
+            }
+            .AsReadOnly();
+
+            var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
+
+            _mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
+                response);
+
+            var personAddrLine = _updatedPersonAddrLineOneAddressLine;
+
+            var result = await _addressService.UpdatePersonAddrLine(personAddrLine);
+
+            _mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
+            _mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Once);
+            Assert.AreEqual(_updatedPersonAddrLineOneAddressLine, result);
+        }
+
+        [Test]
+        public async Task UpdateAddrLine_Fail_WrongPersonId()
+        {
+            _mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).ReturnsAsync(
+            _updatedPersonAddrLineOneAddressLine).Verifiable();
+
+            var personpostal = new PersonPostalAddress()
+            {
+                PersonNumber = 999,
+                AddressNumber = 888
+            };
+
+            var header = new CoreMessageHeader()
+            {
+                UpdateKey = 123456
+            };
+
+            var personList = new List<PersonPostalAddress>()
+            {
+                personpostal
+            }
+            .AsReadOnly();
+
+            var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
+
+            _mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
+                response);
+
+            var personAddrLine = _updatedPersonAddrLineOneAddressLine;
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _addressService.UpdatePersonAddrLine(personAddrLine));
+
+            _mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
+            _mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Never);
+        }
+
+        [Test]
+        public async Task UpdateAddrLine_Fail_NullPerson()
+        {
+            _mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).ReturnsAsync(
+            _updatedPersonAddrLineOneAddressLine).Verifiable();
+
+            var header = new CoreMessageHeader()
+            {
+                UpdateKey = 123456
+            };
+
+            var personList = new List<PersonPostalAddress>().AsReadOnly();
+
+            var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
+
+            _mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
+                response);
+
+            var personAddrLine = _updatedPersonAddrLineOneAddressLine;
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _addressService.UpdatePersonAddrLine(personAddrLine));
+
+            _mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
+            _mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Never);
+        }
+
+        [Test]
+        public async Task UpdateAddrLine_Fail_NullResponse()
+        {
+            _mockAddressDao.Setup(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>())).Returns(
+            Task.FromResult((PersonAddrLine)null)).Verifiable();
+
+            var personpostal = new PersonPostalAddress()
+            {
+                PersonNumber = 111,
+                AddressNumber = 222
+            };
+
+            var header = new CoreMessageHeader()
+            {
+                UpdateKey = 123456
+            };
+
+            var personList = new List<PersonPostalAddress>()
+            {
+                personpostal
+            }
+            .AsReadOnly();
+
+            var response = new CoreApiMessage<IReadOnlyCollection<PersonPostalAddress>>(header, personList);
+
+            _mockAddressDao.Setup(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>())).ReturnsAsync(
+                response);
+
+            var personAddrLine = _updatedPersonAddrLineOneAddressLine;
+
+
+            Assert.ThrowsAsync<ServiceException>(async () => await _addressService.UpdatePersonAddrLine(personAddrLine));
+
+            _mockAddressDao.Verify(x => x.FindByPersonNumber(It.IsAny<CoreRequestParameters>(), It.IsAny<string>()), Times.Once);
+            _mockAddressDao.Verify(x => x.UpdatePersonAddrLine(It.IsAny<CoreApiMessage<PersonAddrLine>>()), Times.Once);
+        }
+    }
+}

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

@@ -0,0 +1,190 @@
+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));
+        }
+    }
+}

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

@@ -0,0 +1,547 @@
+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();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/ApplicationHistoryServiceTest.cs

@@ -0,0 +1,149 @@
+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.CoreApiWrapperLib.Exceptions;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.ApplicationHistories;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class ApplicationHistoryServiceTest
+    {
+        private ApplicationHistoryService _applicationHistoryService;
+        private Mock<IApplicationHistoryDao> _mockApplicationHistoryDao;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockApplicationHistoryDao = new Mock<IApplicationHistoryDao>();
+            _applicationHistoryService = new ApplicationHistoryService(_mockApplicationHistoryDao.Object);
+        }
+
+        [Test]
+        public async Task GetApplicationHistory_OK()
+        {
+            _mockApplicationHistoryDao
+                .Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(), It.IsAny<DateTime>()))
+                .ReturnsAsync(
+                    new List<ApplicationHistory>()
+                    {
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test",
+                           ApplicationNumber = 1,
+                           QueueNumber = 10,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        },
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test2",
+                           ApplicationNumber = 2,
+                           QueueNumber = 20,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        }
+                    })
+                .Verifiable();
+
+            var applicationTestNumbers = new List<string>()
+            {
+                "1",
+                "2"
+            };
+            var results = await _applicationHistoryService.GetApplicationHistory(applicationTestNumbers,  "1/2/2021");
+
+            var resultsList = results.ToList();
+            Assert.NotNull(results);
+            Assert.AreEqual(2, resultsList.Count);
+            Assert.True(resultsList.Any(x => x.ApplicationName == "Test"));
+            Assert.True(resultsList.Any(x => x.ApplicationName == "Test"));
+            Assert.True(resultsList.Any(x => x.ApplicationNumber == 1));
+            Assert.True(resultsList.Any(x => x.ApplicationNumber == 2));
+            Assert.True(resultsList.Any(x => x.QueueNumber == 10));
+            Assert.True(resultsList.Any(x => x.QueueNumber == 20));
+            Assert.True(resultsList.Any(x => x.StopDateTime == Convert.ToDateTime("1/1/2021")));
+            Assert.AreEqual(2, resultsList.Where(r => r.StopDateTime == Convert.ToDateTime("1/1/2021")).ToList().Count);
+
+            _mockApplicationHistoryDao.Verify(x =>
+                x.FindApplicationHistory( It.Is<List<string>>( ls => ls.Count == 2 && ls.Contains("1") && ls.Contains("2")),
+                                          It.Is<DateTime>(dt => dt.CompareTo(DateTime.Parse("1/2/2021")) == 0)));
+        }
+
+        [Test]
+        public void GetApplicationHistory_FailedToParse_Null()
+        {
+            _mockApplicationHistoryDao
+                 .Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(), It.IsAny<DateTime>()))
+                 .ReturnsAsync(
+                     new List<ApplicationHistory>()
+                     {
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test",
+                           ApplicationNumber = 1,
+                           QueueNumber = 10,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        },
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test2",
+                           ApplicationNumber = 2,
+                           QueueNumber = 20,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        }
+                     })
+                 .Verifiable();
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _applicationHistoryService.GetApplicationHistory(null, null));
+        }
+
+        [Test]
+        public void GetApplicationHistory_FailedToParse_BadDateTime()
+        {
+            _mockApplicationHistoryDao
+                 .Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(),  It.IsAny<DateTime>()))
+                 .ReturnsAsync(
+                     new List<ApplicationHistory>()
+                     {
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test",
+                           ApplicationNumber = 1,
+                           QueueNumber = 10,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        },
+                        new ApplicationHistory()
+                        {
+                           ApplicationName = "Test2",
+                           ApplicationNumber = 2,
+                           QueueNumber = 20,
+                           StopDateTime = Convert.ToDateTime("1/1/2021")
+                        }
+                     })
+                 .Verifiable();
+
+            Assert.ThrowsAsync<FailedToParseException>(async () =>
+                await _applicationHistoryService.GetApplicationHistory(null,  ":-)"));
+        }
+
+        [Test]
+        public void GetApplicationHistory_Exception()
+        {
+            _mockApplicationHistoryDao
+                .Setup(x => x.FindApplicationHistory(It.IsAny<List<string>>(), 
+                                                     It.IsAny<DateTime>())).Throws(new Exception("Ohh nooo"));
+
+            var applicationTestNumbers = new List<string>()
+            {
+                "1",
+                "2"
+            };
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _applicationHistoryService.GetApplicationHistory(applicationTestNumbers, "1/2/2021"));
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/AssociateServiceTest.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Moq;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Associate;
+using LCU.Library.Internal.Exceptions;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class AssociateServiceTest
+    {
+        private readonly AssociateService _associateService;
+        private readonly Mock<IAssociateDao> _mockAssociateDao;
+
+        public AssociateServiceTest()
+        {
+            _mockAssociateDao = new Mock<IAssociateDao>();
+            _associateService = new AssociateService(_mockAssociateDao.Object);
+        }
+
+        [Test]
+        public void GetAssociateDetailsBySsn_Exception_Returns_Null()
+        {
+            var taxId = Guid.NewGuid().ToString();
+
+            _mockAssociateDao.Setup(x => x.GetAssociateDetailsBySsn(It.IsAny<string>())).Throws(new Exception());
+
+            Assert.ThrowsAsync<ServiceException>(() => _associateService.GetAssociateDetailsBySsn(taxId));
+        }
+
+        [Test]
+        public async Task GetAssociateDetailsBySsn_Returns_PersonAssociateDetails()
+        {
+            var taxId = Guid.NewGuid().ToString();
+
+            var associateDetails = new AssociateDetails
+            {
+                PersonNumber = DateTime.Now.Millisecond
+            };
+
+            _mockAssociateDao.Setup(x => x.GetAssociateDetailsBySsn(It.IsAny<string>())).ReturnsAsync(associateDetails).Verifiable();
+
+            var result = await _associateService.GetAssociateDetailsBySsn(taxId);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(associateDetails.PersonNumber, result.PersonNumber);
+            _mockAssociateDao.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/BranchServiceTest.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using AutoMapper;
+using Moq;
+using LCU.Api.Internal.CoreApiWrapper.Mappers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Branches;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class BranchServiceTest
+    {
+        private readonly BranchService _branchService;
+        private readonly IMapper _mapper;
+        private readonly Mock<IBranchDao> _mockBranchDao;
+
+        public BranchServiceTest()
+        {
+
+            if (_mapper == null)
+            {
+                var mappingConfig = new MapperConfiguration(mc =>
+                {
+                    mc.AddProfile(new BranchMapper());
+                });
+                IMapper mapper = mappingConfig.CreateMapper();
+                _mapper = mapper;
+            }
+
+            _mockBranchDao = new Mock<IBranchDao>();
+            _branchService = new BranchService(_mapper, _mockBranchDao.Object);
+        }
+
+        [Test]
+        public async Task GetBranches_Returns_FilledOutBranches()
+        {
+            var testBranch = new List<Branch>() 
+            {
+                new Branch()
+                {
+                    BranchNumber = 1,
+                    BranchName = "Test Branch One"
+                },
+                new Branch()
+                {
+                    BranchNumber = 2,
+                    BranchName = "Test Branch Two"
+                }
+            };
+            _mockBranchDao.Setup(x => x.FindBranches(It.IsAny<CoreRequestParameters>())).ReturnsAsync(testBranch);
+
+            var result = await _branchService.GetBranches();
+
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count());
+            Assert.AreEqual(1, result.FirstOrDefault().BranchId);
+            Assert.AreEqual("Test Branch One", result.FirstOrDefault().BranchName);
+        }
+
+        [Test]
+        public void GetBranches_Exception()
+        {
+            _mockBranchDao.Setup(x => x.FindBranches(It.IsAny<CoreRequestParameters>())).Throws(new Exception());
+           
+            Assert.ThrowsAsync<Exception>(() => _branchService.GetBranches());
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/IndividualServiceTest.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using AutoMapper;
+using Moq;
+using System.Threading.Tasks;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Api.Internal.CoreApiWrapper.Mappers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.Constants;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.EmailAddress;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Phones;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class IndividualServiceTest
+    {
+        private readonly IndividualService _individualService;        
+        private readonly IMapper _mapper;
+        private readonly Mock<IPersonService> _mockPersonService;
+        private readonly Mock<IAgreePersonService> _mockAgreePersonService;
+
+        public IndividualServiceTest()
+        {
+            if (_mapper == null)
+            {
+                var mappingConfig = new MapperConfiguration(mc =>
+                {
+                    mc.AddProfile(new IndividualMapper());
+                    mc.AddProfile(new AddressMapper());
+                    mc.AddProfile(new PhoneMapper());
+                });
+                IMapper mapper = mappingConfig.CreateMapper();
+                _mapper = mapper;
+            }
+            _mockPersonService = new Mock<IPersonService>();
+            _mockAgreePersonService = new Mock<IAgreePersonService>();
+
+            _individualService = new IndividualService(_mapper, 
+                                                       _mockPersonService.Object,
+                                                       _mockAgreePersonService.Object);
+        }
+
+        [Test]
+        public async Task GetIndividual_Returns_FilledOutIndividual()
+        {
+            var agreePerson = new AgreePerson() 
+            { 
+               AgreeNumber = 100,
+               PersonNumber = 10,
+               UserId = "1"
+            };
+            _mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).ReturnsAsync(agreePerson);
+
+            var testPostalAddress = new PostalAddress()
+            {
+                AddressUseCode = AddressConstants.PrimaryUseCode,
+                AddressNumber = 11
+            };
+            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
+
+            var email1 = new Email()
+            {
+                EmailAddress = "[email protected]"
+            };
+            var email2 = new Email()
+            {
+                EmailAddress = "[email protected]"
+            };
+            var testEmailAddressList = new List<Email>() { email1, email2 }; 
+
+            var phone1 = new Phone()
+            {
+                IsPreferred = true,
+                AreaCode = "262",
+                Exchange = "789",
+                PhoneNumber = "3321"
+            };
+            var phone2 = new Phone()
+            {
+                IsPreferred = false,
+                AreaCode = "626",
+                Exchange = "987",
+                PhoneNumber = "1123"
+            };
+            var testPhoneList = new List<Phone>() { phone1, phone2 };
+            
+            var testPersonResult = new Person()
+            {
+                PersonNumber = 10,
+                FirstName = "Tester",
+                MiddleName = "Person",
+                MiddleInitial = "P",
+                LastName = "Guy",
+                Suffix = "Jr",
+                TaxId = "1231232132",
+                BirthDate = "1/1/2021",
+                PostalAddressList = testPostalAddressList,
+                IsEmployee = true,
+                EmailAddressList = testEmailAddressList,
+                Phones = testPhoneList
+            };
+            var testPersonsResult = new List<Person>();
+            testPersonsResult.Add(testPersonResult);
+            _mockPersonService.Setup(x => x.GetPersonsBySearch(It.IsAny<CoreRequestParameters>(), 
+                                                               It.IsAny<PersonSearchRequest>())).ReturnsAsync(testPersonsResult);
+
+            var result = await _individualService.GetIndividualByUserId("1111");
+
+            Assert.NotNull(result);
+            Assert.AreEqual(10, result.IndividualId);
+            Assert.AreEqual("Tester", result.FirstName);
+            Assert.AreEqual("P", result.MiddleName);
+            Assert.AreEqual("Guy", result.LastName);
+            Assert.AreEqual("Jr", result.NameSuffix);
+            Assert.AreEqual("1231232132", result.TaxId);
+            Assert.AreEqual(Convert.ToDateTime("1/1/2021"), result.BirthDate);
+            Assert.AreEqual(11, result.PrimaryAddressId);
+            Assert.IsTrue(result.IsEmployee);
+            Assert.AreEqual(1, result.Address.Count);
+            Assert.AreEqual("[email protected]", result.Email1);
+            Assert.AreEqual(2, result.Phone.Count);
+        }
+
+        [Test]
+        public void GetPersonsByMemberAgreementNbr_Exception_InGetByUserId()
+        {         
+            _mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).Throws(new Exception());            
+            var testId = "1";
+            Assert.ThrowsAsync<Exception>(() => _individualService.GetIndividualByUserId(testId));
+        }
+
+        [Test]
+        public void GetPersonsByMemberAgreementNbr_Exception_InGetPersonBySearch()
+        {
+            var agreePerson = new AgreePerson()
+            {
+                AgreeNumber = 100,
+                PersonNumber = 10,
+                UserId = "1"
+            };
+            _mockAgreePersonService.Setup(x => x.GetByUserId(It.IsAny<string>())).ReturnsAsync(agreePerson);            
+            _mockPersonService.Setup(x => x.GetPersonsBySearch(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<PersonSearchRequest>())).Throws(new Exception());
+
+            var testId = "1";
+            Assert.ThrowsAsync<Exception>(() => _individualService.GetIndividualByUserId(testId));
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/LoanServiceTest.cs

@@ -0,0 +1,274 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using AutoMapper;
+using Moq;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Api.Internal.CoreApiWrapper.Mappers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.Constants;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Loans;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Properties;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class LoanServiceTest
+    {
+        private readonly LoanService _loanService;
+        private readonly IMapper _mapper;
+        private readonly Mock<IAccountService> _mockAccountService;
+        private readonly Mock<IPropertyService> _mockPropertyService;
+        private readonly Mock<IAccountHistoryService> _mockAccountHistoryService;
+
+        public LoanServiceTest()
+        {
+
+            if (_mapper == null)
+            {
+                var mappingConfig = new MapperConfiguration(mc =>
+                {
+                    mc.AddProfile(new LoanDetailMapper());
+                    mc.AddProfile(new CollateralDetailMapper());
+                    mc.AddProfile(new OtherCollateralMapper());
+                    mc.AddProfile(new VehicleMapper());
+                });
+                IMapper mapper = mappingConfig.CreateMapper();
+                _mapper = mapper;
+            }
+
+            _mockAccountService = new Mock<IAccountService>();
+            _mockPropertyService = new Mock<IPropertyService>();
+            _mockAccountHistoryService = new Mock<IAccountHistoryService>();
+            _loanService = new LoanService(_mapper, _mockAccountService.Object, _mockPropertyService.Object, _mockAccountHistoryService.Object);
+        }
+
+        [Test]
+        public async Task GetLoanDetail_Returns_FilledOutAccount_WrittenOffStatus()
+        {
+            var testAccountRolesInfos = new List<AccountRolesInfo>()
+            {
+                new AccountRolesInfo()
+                {
+                    AccountRoleDescription = AccountRoleConstants.LoanOfficer
+                },
+                new AccountRolesInfo()
+                {
+                    PersonNumber = 1,
+                    RoleName = "Tester One"
+                },
+                new AccountRolesInfo()
+                {
+                    PersonNumber = 2,
+                    RoleName = "Tester Two"
+                }
+            };
+
+            var testLoanInfo = new LoanInfo()
+            {
+                NextDueDate = Convert.ToDateTime("1/1/2021"),
+                CurrentDueDate = Convert.ToDateTime("1/1/2020")
+            };
+
+            var account = new Account()
+            {
+                MemberAgreementNumber = 100,
+                AccountNumber = 1000143,
+                ReportingForPersonNumber = 1,
+                CurrentAccountStatusDescription = AccountStatusConstants.CoreChargeOffAccount,
+                CurrentAccountStatusDateTime = Convert.ToDateTime("1/1/2021"),
+                Balance = 100.10M,
+                AccountRolesInfo = testAccountRolesInfos,
+                LoanInfo = testLoanInfo
+
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).ReturnsAsync(account);
+
+            _mockAccountHistoryService.Setup(x => x.GetChargeoffDateTimesByAccountNumber(It.IsAny<string>())).ReturnsAsync(new List<DateTime>() { Convert.ToDateTime("1/1/2021") });
+
+            var testLoanId = 1000143;
+            var result = await _loanService.GetLoanDetail(testLoanId);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.IndividualId.Length);
+            Assert.AreEqual(1, result.IndividualId[0]);
+            Assert.AreEqual(2, result.Borrowers.Count);
+            Assert.AreEqual(AccountRoleConstants.Borrower, result.Borrowers.FirstOrDefault().Type);
+            Assert.AreEqual(1, result.Borrowers.FirstOrDefault().IndividualId);
+            Assert.AreEqual("Tester One", result.Borrowers.FirstOrDefault().Name);
+            Assert.AreEqual(AccountStatusConstants.WrittenOffStatus, result.Status);
+            Assert.AreEqual(Convert.ToDateTime("1/1/2021"), result.WrittenOffDate);
+            Assert.AreEqual(Convert.ToDateTime("1/1/2020"), result.NextDueDate);
+        }
+
+        [Test]
+        public async Task GetLoanDetail_Returns_FilledOutAccount_OpenStatus()
+        {
+            var testAccountRolesInfos = new List<AccountRolesInfo>()
+            {
+                new AccountRolesInfo()
+                {
+                    AccountRoleDescription = AccountRoleConstants.LoanOfficer
+                },
+                new AccountRolesInfo()
+                {
+                    PersonNumber = 1,
+                    RoleName = "Tester One"
+                },
+                new AccountRolesInfo()
+                {
+                    PersonNumber = 2,
+                    RoleName = "Tester Two"
+                }
+            };
+
+            var testLoanInfo = new LoanInfo()
+            {
+                NextDueDate = Convert.ToDateTime("1/1/2021"),
+                CurrentDueDate = Convert.ToDateTime("1/1/2020")
+            };
+
+            var account = new Account()
+            {
+                MemberAgreementNumber = 100,
+                AccountNumber = 1000143,
+                ReportingForPersonNumber = 1,
+                CurrentAccountStatusDescription = AccountStatusConstants.CoreActiveAccount,
+                Balance = 100.10M,
+                AccountRolesInfo = testAccountRolesInfos,
+                LoanInfo = testLoanInfo
+
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).ReturnsAsync(account);
+            
+            var testLoanId = 1000143;
+            var result = await _loanService.GetLoanDetail(testLoanId);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.IndividualId.Length);
+            Assert.AreEqual(1, result.IndividualId[0]);
+            Assert.AreEqual(2, result.Borrowers.Count);
+            Assert.AreEqual(AccountRoleConstants.Borrower, result.Borrowers.FirstOrDefault().Type);
+            Assert.AreEqual(1, result.Borrowers.FirstOrDefault().IndividualId);
+            Assert.AreEqual("Tester One", result.Borrowers.FirstOrDefault().Name);
+            Assert.AreEqual(AccountStatusConstants.OpenStatus, result.Status);
+            Assert.AreEqual(DateTime.MinValue, result.WrittenOffDate);
+            Assert.AreEqual(Convert.ToDateTime("1/1/2020"), result.NextDueDate);
+        }
+
+        [Test]
+        public void GetLoanDetail_Exception()
+        {
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).Throws(new Exception());
+
+            var testLoanId = 1000143;
+            Assert.ThrowsAsync<Exception>(async () => await _loanService.GetLoanDetail(testLoanId));
+        }
+
+        [Test]
+        public async Task GetCollateralDetails_Returns_CollateralDetails_OneVehicle_OneNoneVehicle()
+        {
+            var testProperty1 = new Property()
+            {
+                TypeCode= "AUTU",
+                Value = 100,
+                Make ="Test Make",
+                Model = "Test Model",
+                PropertyNumber = 1,
+                PropertyId = "dfjadf12083213"
+            };
+            var testProperty2 = new Property()
+            {
+                TypeCode = "TEST",
+                Value = 1000,
+                PropertyId = "2"
+            };
+            List<Property> testProperties = new List<Property>() { testProperty1, testProperty2 };
+            _mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).ReturnsAsync(testProperties);
+
+            var testLoanId = 1000143;
+            var results = await _loanService.GetCollateralDetails(testLoanId);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(2, results.Count());
+            var resultVehicle = results.FirstOrDefault(p => p.Vehicle !=  null);
+            Assert.NotNull(resultVehicle);
+            Assert.AreEqual("Test Make", resultVehicle.Vehicle.Make);
+            Assert.AreEqual("Test Model", resultVehicle.Vehicle.Model);
+            Assert.AreEqual("dfjadf12083213", resultVehicle.Vehicle.VIN);
+            Assert.AreEqual(1, resultVehicle.CollateralId);
+        }
+
+        [Test]
+        public async Task GetCollateralDetails_Returns_CollateralDetails_AllNoneVehicle()
+        {
+            var testProperty1 = new Property()
+            {
+                TypeCode = "TEST 1",
+                Value = 10001.99,
+                PropertyId = "1"
+            };
+            var testProperty2 = new Property()
+            {
+                TypeCode = "TEST 2",
+                Value = 10002.01,
+                PropertyId = "2"
+            };
+            List<Property> testProperties = new List<Property>() { testProperty1, testProperty2 };
+            _mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).ReturnsAsync(testProperties);
+
+            var testLoanId = 1000143;
+            var results = await _loanService.GetCollateralDetails(testLoanId);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(2, results.Count());
+            var resultVehicle = results.FirstOrDefault(p => p.Vehicle != null);
+            Assert.Null(resultVehicle);
+        }
+
+        [Test]
+        public void GetCollateralDetails_Exception()
+        {
+            _mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).Throws(new Exception());
+
+            var testLoanId = 1000143;
+            Assert.ThrowsAsync<Exception>(async () => await _loanService.GetCollateralDetails( testLoanId));
+        }
+
+        [Test]
+        public async Task GetPropertyInformation_OkAsync()
+        {
+            var testProperty1 = new Property()
+            {
+                PropertyNumber = 1000
+            };
+            var testProperty2 = new Property()
+            {
+                PropertyNumber = 1001
+            };
+            List<Property> testProperties = new List<Property>() { testProperty1, testProperty2 };
+            _mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).ReturnsAsync(testProperties);
+
+            var testLoanId = 1000143;
+            var results = await _loanService.GetPropertyInformation(testLoanId);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(2, results.Count());
+        }
+
+        [Test]
+        public void GetPropertyInformation_Exception()
+        {
+            _mockPropertyService.Setup(x => x.GetAccountProperties(It.IsAny<long>())).Throws(new Exception());
+
+            var testaccountId = 1000;
+            Assert.ThrowsAsync<Exception>(async () => await _loanService.GetPropertyInformation(testaccountId));
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/MemberServiceTest.cs

@@ -0,0 +1,408 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using AutoMapper;
+using Moq;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Api.Internal.CoreApiWrapper.Mappers;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperModel.Constants;
+using LCU.Library.Internal.CoreApiWrapperModel.Enums;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.PostalAddresses;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Identifications;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Phones;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.MemberAgreements;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Organizations;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Mixed;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class MemberServiceTest
+    {
+        private readonly MemberService _memberService;
+        private readonly IMapper _mapper;
+        private readonly Mock<IPersonService> _mockPersonService;
+        private readonly Mock<IAccountService>  _mockAccountService;
+        private readonly Mock<IOrganizationService> _mockOrganizationService;
+
+        public MemberServiceTest()
+        {
+            if (_mapper == null)
+            {
+                var mappingConfig = new MapperConfiguration(mc =>
+                {
+                    mc.AddProfile(new MemberOwnerMapper());
+                    mc.AddProfile(new MemberMapper());
+                    mc.AddProfile(new AddressMapper());
+                });
+                IMapper mapper = mappingConfig.CreateMapper();
+                _mapper = mapper;
+            }
+            _mockPersonService = new Mock<IPersonService>();
+            _mockAccountService = new Mock<IAccountService>();
+            _mockOrganizationService = new Mock<IOrganizationService>();
+
+            _memberService = new MemberService(_mapper,
+                                               _mockPersonService.Object,
+                                               _mockAccountService.Object,
+                                               _mockOrganizationService.Object);
+        }
+
+        [Test]
+        public async Task GetMember_Returns_FilledOutMember()
+        {
+            var testPostalAddress = new PostalAddress()
+            {
+                AddressUseCode = AddressConstants.PrimaryUseCode,
+                AddressNumber = 11,
+                AddressLine1 = "Test Street",
+                AddressLine2 = "",
+                AddressLine3 = "",
+                CityName = "City Test",
+                PostalCode = "53183",
+                ZipPlus = "3123",
+                CountrySubdivisionCode = "WI"
+            };
+            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
+
+            var testId = 100;
+            var testPersonResult = new Person()
+            {
+                PersonNumber = 1,
+                FirstName = "Tester",
+                MiddleName = "Person",
+                LastName = "Guy",
+                NameFull = "Tester Person Guy",
+                Suffix = "",
+                TaxId = "1231232132",
+                BirthDate = "1/1/2021",
+                MemberNumber = 111111111,
+                PostalAddressList = testPostalAddressList
+            };
+
+            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
+                                                                           It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);
+
+            var result = await _memberService.GetMemberDetails(testId);
+
+            Assert.NotNull(result); 
+            Assert.AreEqual("Tester Person Guy", result.MemberName);
+            Assert.AreEqual(111111111, result.MemberId);
+            Assert.AreEqual("Test Street", result.Address.Line1);
+            Assert.AreEqual("WI", result.Address.State);
+            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(111111111), Times.Never());
+        }
+
+        [Test]
+        public void GetMemberDetails_Return_Exception()
+        {
+            var testId = 100;
+            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
+                                                            It.IsAny<MemberNbrRequest>())).Throws(new Exception());
+
+            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberDetails(testId));
+        }
+
+        [Test]
+        public async Task GetMemberByAccountNumber_Person_Returns_FilledOutMember()
+        {
+            var testAccountResult = new Account()
+            {
+                MemberAgreementNumber = 111111111,
+                ReportingForPersonNumber = 1
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                              It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);            
+
+            var testPostalAddress = new PostalAddress()
+            {
+                AddressUseCode = AddressConstants.PrimaryUseCode,
+                AddressNumber = 11,
+                AddressLine1 = "Test Street",
+                AddressLine2 = "",
+                AddressLine3 = "",
+                CityName = "City Test",
+                PostalCode = "53183",
+                ZipPlus = "3123",
+                CountrySubdivisionCode = "WI"
+            };
+            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
+
+            var testId = 100;
+            var testPersonResult = new Person()
+            {
+                PersonNumber = 1,
+                FirstName = "Tester",
+                MiddleName = "Person",
+                LastName = "Guy",
+                NameFull = "Tester Person Guy",
+                Suffix = "",
+                TaxId = "1231232132",
+                BirthDate = "1/1/2021",
+                MemberNumber = 111111111,
+                PostalAddressList = testPostalAddressList
+            };
+
+            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
+                                                                           It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);
+
+            var result = await _memberService.GetMemberByAccountNumber(testId);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("Tester Person Guy", result.MemberName);
+            Assert.AreEqual(111111111, result.MemberId);
+            Assert.AreEqual("Test Street", result.Address.Line1);
+            Assert.AreEqual("WI", result.Address.State);
+        }
+
+        [Test]
+        public void GetMemberDetailsByAccountNumber_Return_Exception_OnGetAccountDetails()
+        {
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                              It.IsAny<AcctNbrRequest>())).Throws(new Exception());
+            var testId = 100;
+            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberByAccountNumber(testId));
+        }
+
+
+        [Test]
+        public void GetMemberDetailsByAccountNumber_Return_Exception_OnGetPersonsByMemberAgreementNbr()
+        {
+            var testAccountResult = new Account()
+            {
+                MemberAgreementNumber = 111111111
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                              It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);
+            var testId = 100;
+            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
+                                                            It.IsAny<MemberNbrRequest>())).Throws(new Exception());
+
+            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberByAccountNumber(testId));
+        }
+
+        [Test]
+        public async Task GetMemberOwner_Returns_FilledOutMemberOwner()
+        {
+            var testPostalAddress = new PostalAddress()
+            {
+                AddressUseCode = AddressConstants.PrimaryUseCode,
+                AddressNumber = 11,
+                AddressLine1 = "Test Street",
+                AddressLine2 = "",
+                AddressLine3 = "",
+                CityName = "City Test",
+                PostalCode = "53183",
+                ZipPlus = "3123",
+                CountrySubdivisionCode = "WI"
+            };
+            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
+
+            var identification = new Identification()
+            {
+                TypeCode = ((int)IdentificationTypeEnum.UnexpiredDriversLicense).ToString(),
+                CountryCode = AddressConstants.CountryUSA,
+                StateCode = "WI",
+                IdNumber = "A3243208fj213aupasdf"
+            };
+            var identificationList = new List<Identification>() { identification };
+
+
+            var phone1 = new Phone()
+            {
+                IsPreferred = true,
+                AreaCode = "262",
+                Exchange = "789",
+                PhoneNumber = "3321"
+            };
+            var testMemberAgreement = new MemberAgreement()
+            {
+                PrimaryPersonNumber = 1
+            };
+
+            var testId = 100;
+            var testPersonResult = new Person()
+            {
+                PersonNumber = 1,
+                FirstName = "Tester",
+                MiddleName = "Person",
+                LastName = "Guy",
+                NameFull = "Tester Person Guy",
+                Suffix = "",
+                TaxId = "1231232132",
+                BirthDate = "1/1/2021",
+                PostalAddressList = testPostalAddressList,
+                IsEmployee = true,
+                MemberAgreement = testMemberAgreement,
+                Identifications = identificationList
+            };
+
+            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
+                                                                           It.IsAny<MemberNbrRequest>())).ReturnsAsync(testPersonResult);
+
+            var results = await _memberService.GetMemberOwner(testId);
+
+            Assert.NotNull(results);
+            Assert.AreEqual(1, results.ToList().Count);
+            var result = results.FirstOrDefault();
+
+            Assert.AreEqual(1, result.IndividualId);
+            Assert.AreEqual("Tester Person Guy", result.Name);
+            Assert.AreEqual("1231232132", result.TaxId);
+            Assert.AreEqual("1/1/2021", result.BirthDate);
+            Assert.AreEqual("Primary", result.Type);
+            Assert.AreEqual("Test Street, City Test, WI 53183-3123", result.Address);
+            Assert.AreEqual("WI A3243208fj213aupasdf", result.DriverLicense);
+        }
+
+        [Test]
+        public void GetMemberOwner_Return_Exception()
+        {
+            var testId = 100;
+            _mockPersonService.Setup(x => x.GetPersonsByMemberAgreementNbr(It.IsAny<CoreRequestParameters>(),
+                                                            It.IsAny<MemberNbrRequest>())).Throws(new Exception());
+
+            Assert.ThrowsAsync<Exception>(() => _memberService.GetMemberOwner(testId));
+        }
+
+        [Test]
+        public async Task GetMemberByAccountNumber_Organization_Returns_FilledOutMember()
+        {
+            // Arrange
+            var testAccountResult = new Account()
+            {
+                MemberAgreementNumber = 111111111,
+                ReportingForOrganizationNumber = 1
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                              It.IsAny<AcctNbrRequest>())).ReturnsAsync(testAccountResult);
+
+            var testPostalAddress = new PostalAddress()
+            {
+                AddressUseCode = AddressConstants.PrimaryUseCode,
+                AddressNumber = 11,
+                AddressLine1 = "Test Street",
+                AddressLine2 = "",
+                AddressLine3 = "",
+                CityName = "City Test",
+                PostalCode = "53183",
+                ZipPlus = "3123",
+                CountrySubdivisionCode = "WI"
+            };
+            var testPostalAddressList = new List<PostalAddress>() { testPostalAddress };
+            var testOrganization = new Organization
+            {
+                MemberAgreementNumber = 111111111,
+                Name = "Test Organization Name",
+                OrganizationNumber = 123,
+                PostalAddressList = testPostalAddressList
+            };
+
+            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(testOrganization);
+
+            // Act
+            var result = await _memberService.GetMemberByAccountNumber(1);
+
+            // ASsert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(result.MemberId, 111111111);
+            Assert.AreEqual(result.MemberName, "Test Organization Name");
+            Assert.AreEqual(result.PrimaryIndividualId, 123);
+            Assert.AreEqual("Test Street", result.Address.Line1);
+            Assert.AreEqual("WI", result.Address.State);
+            _mockPersonService.Verify(x => x.GetPersonsByMemberAgreementNbr(new CoreRequestParameters(), new MemberNbrRequest()), Times.Never());
+        }
+
+        [Test]
+        public async Task GetPersonOrOrganizationNumberByMemberId_PersonFound()
+        {
+            // Arrange
+            _mockOrganizationService.Invocations.Clear();
+
+            long personMemberNumber = 123;
+            var personName = "John E Jacob Jr";
+
+            var person = new Person()
+            {
+                PersonNumber = (int)personMemberNumber,
+                FirstMiddleInitialLastSuffix = personName
+            };
+
+            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(person).Verifiable();
+
+            // Act
+            var result = await _memberService.GetPersonOrOrganizationNumberByMemberId(personMemberNumber);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(result.PersonNumber, personMemberNumber.ToString());
+            Assert.AreEqual(result.EntityName, personName);
+            Assert.IsNull(result.OrganizationNumber);
+            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Never);
+        }
+
+        [Test]
+        public async Task GetPersonOrOrganizationNumberByMemberId_OrganizationFound()
+        {
+            // Arrange
+            _mockPersonService.Invocations.Clear();
+            _mockOrganizationService.Invocations.Clear();
+
+            long organizationMemberNumber = 123;
+            var organizationName = "John E Consulting LLC";
+
+            var organization = new Organization()
+            {
+                OrganizationNumber = organizationMemberNumber,
+                Name = organizationName
+            };
+
+            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ThrowsAsync(new Exception());
+            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(organization).Verifiable();
+
+            // Act
+            var result = await _memberService.GetPersonOrOrganizationNumberByMemberId(organizationMemberNumber);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(result.OrganizationNumber, organizationMemberNumber.ToString());
+            Assert.AreEqual(result.EntityName, organizationName);
+            Assert.IsNull(result.PersonNumber);
+            _mockPersonService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
+            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
+        }
+
+        [Test]
+        public void GetPersonOrOrganizationNumberByMemberId_NeitherFound_Exception()
+        {
+            // Arrange
+            _mockPersonService.Invocations.Clear();
+            _mockOrganizationService.Invocations.Clear();
+
+            var person = new Person()
+            {
+                PersonNumber = 0
+            };
+
+            var organization = new Organization()
+            {
+                OrganizationNumber = 0
+            };
+
+            _mockPersonService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(person).Verifiable();
+            _mockOrganizationService.Setup(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>())).ReturnsAsync(organization).Verifiable();
+
+            // Act
+
+            // Assert
+            Assert.ThrowsAsync<ArgumentNullException>(async () => await _memberService.GetPersonOrOrganizationNumberByMemberId(0));
+            _mockPersonService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
+            _mockOrganizationService.Verify(x => x.GetMemberByMemberAgreeNbr(It.IsAny<long>()), Times.Once);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/OrganizationServiceTest.cs

@@ -0,0 +1,228 @@
+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()
+            };
+        }
+    }
+}

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

@@ -0,0 +1,269 @@
+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()
+            };
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/PersonUserFieldServiceTest.cs

@@ -0,0 +1,402 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+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 PersonUserFieldServiceTest
+    {
+        private readonly PersonUserFieldService _personUserFieldService;
+        private readonly Mock<IPersonService> _mockPersonService;
+        private readonly Mock<IPersonUserFieldDao> _mockPersonUserFieldDao;
+
+        public PersonUserFieldServiceTest()
+        {
+            _mockPersonService = new Mock<IPersonService>();
+            _mockPersonUserFieldDao = new Mock<IPersonUserFieldDao>();
+            _personUserFieldService = new PersonUserFieldService(_mockPersonService.Object, _mockPersonUserFieldDao.Object);
+        }
+
+        [Test]
+        public void GetPersonUserFieldCoreApiResponseAsync_ExceptionThrown()
+        {
+            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).Throws(new ServiceException("Nope"));
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _personUserFieldService.GetPersonUserFieldCoreApiResponseAsync(00000000));
+        }
+
+        [Test]
+        public async Task GetPersonUserFieldCoreApiResponseAsync_UserFieldsReturned()
+        {
+            var personUserFields = new List<PersonUserField>()
+            {
+                new PersonUserField()
+                {
+                   PersonNumber = 100001,
+                   UserFieldCode = "TEST1",
+                   Value = "Y"
+
+                },
+                new PersonUserField()
+                {
+                   PersonNumber = 200001,
+                   UserFieldCode = "TEST2",
+                   Value = "N"
+                }
+            };
+            var coreMessageheader = new CoreMessageHeader();
+            var personUserFieldCoreApiResponse = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageheader, personUserFields);
+            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).ReturnsAsync(personUserFieldCoreApiResponse);
+
+
+            var result = await _personUserFieldService.GetPersonUserFieldCoreApiResponseAsync(100001);
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.MessageBody.Count());
+        }
+
+        [Test]
+        public void UpdatePersonUserFieldAsync_ExceptionThrown()
+        {
+            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(), It.IsAny<int>(), It.IsAny<string>())).Throws(new ServiceException("Nope"));
+
+            var personUserUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _personUserFieldService.UpdatePersonUserFieldAsync(personUserUpdateRequest));
+        }
+
+        [Test]
+        public async Task UpdatePersonUserFieldAsync_UpdatedUserFieldsReturned()
+        {
+            var testPerson = new Person()
+            {
+                PersonNumber = 100001
+            };
+
+            var updatedPersonUserField = new PersonUserField()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y",
+                LastMaintained = Convert.ToDateTime("9/1/2001")
+            };
+
+            var listexistingPersonUserField = new List<PersonUserField>()
+            {
+                new PersonUserField()
+                {
+                    PersonNumber = 100001,
+                    Id = updatedPersonUserField.Id,
+                    UserFieldCode = "TEST1",
+                    Value = "N",
+                    LastMaintained = Convert.ToDateTime("8/1/2001")
+                }
+            };
+            var coreMessageheader = new CoreMessageHeader();
+            var coreApiResponse = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageheader, listexistingPersonUserField);
+            
+            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),It.IsAny<int>())).ReturnsAsync(coreApiResponse);
+
+            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
+                                                                It.IsAny<int>(),
+                                                                It.IsAny<string>())).ReturnsAsync(updatedPersonUserField);
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(new List<Person>() { testPerson });
+
+            var personUserUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var result = await _personUserFieldService.UpdatePersonUserFieldAsync(personUserUpdateRequest);
+            Assert.NotNull(result);
+            Assert.AreEqual(updatedPersonUserField, result);
+        }
+
+        [Test]
+        public void InsertPersonUserFieldAsync_ExceptionThrown()
+        {
+            _mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(), It.IsAny<int>())).Throws(new ServiceException("Oops"));
+
+            var personUserUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _personUserFieldService.InsertPersonUserFieldAsync(personUserUpdateRequest));
+        }
+
+        [Test]
+        public async Task InsertPersonUserFieldAsync_InsertUserFieldsReturned()
+        {
+            var person = new Person()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+
+            var personList = new List<Person> { person };
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
+
+            var createdPersonUserField = new PersonUserField()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y",
+                LastMaintained = Convert.ToDateTime("9/1/2001")
+            };
+            _mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
+                                                                It.IsAny<int>())).ReturnsAsync(createdPersonUserField);
+
+            var personUserUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var result = await _personUserFieldService.InsertPersonUserFieldAsync(personUserUpdateRequest);
+            Assert.NotNull(result);
+            Assert.AreEqual(createdPersonUserField, result);
+        }
+
+        [Test]
+        public void UpdatePersonUserFieldsAsync_NullPerson_ExceptionThrown()
+        {
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+
+            };
+
+            var personList = new List<Person>();
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                 await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
+        }
+
+        [Test]
+        public void UpdatePersonUserFieldsAsync_ExistingUserFieldNull_NullExceptionThrown()
+        {
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+
+            };
+
+            var person = new Person()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+
+            var personList = new List<Person> { person };
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
+
+            IEnumerable<PersonUserField> PersonUserFields = new List<PersonUserField>();
+            CoreMessageHeader coreMessageHeader = new CoreMessageHeader();
+            CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, PersonUserFields);
+            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
+                                                       It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                 await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
+        }
+
+        [Test]
+        public void UpdatePersonUserFieldsAsync_UpdateUserFieldNull_NullExceptionThrown()
+        {
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+
+            };
+
+            var personList = new List<Person>();
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
+
+            IEnumerable<PersonUserField> PersonUserFields = new List<PersonUserField>()
+            {
+                new PersonUserField()
+                {
+                    Id = "TEST1",
+                    PersonNumber = 100001,
+                    UserFieldCode = "TEST1",
+                    Value = "N"
+                },
+                new PersonUserField()
+                {
+                    Id = "TEST2",
+                    PersonNumber = 100002,
+                    UserFieldCode = "TEST2",
+                    Value = "Y"
+                }
+            };
+            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
+            CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, PersonUserFields);
+            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
+                                                       It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);
+
+            PersonUserField updatedPersonUserField = null;
+            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
+                                                                It.IsAny<int>(),
+                                                                It.IsAny<string>())).ReturnsAsync(updatedPersonUserField);
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                 await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest));
+        }
+
+        [Test]
+        public async Task UpdatePersonUserFieldsAsync_UpdatedUserField()
+        {
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+
+            };
+
+            var person = new Person()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+
+            var personList = new List<Person> { person };
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
+
+
+            var personUserField1 = new PersonUserField()
+            {
+                Id = "TEST1",
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "N"
+            };
+            var personUserField2 = new PersonUserField()
+            {
+                Id = "TEST2",
+                PersonNumber = 100002,
+                UserFieldCode = "TEST2",
+                Value = "Y"
+            };
+
+            IEnumerable<PersonUserField> personUserFields = new List<PersonUserField>()
+            {
+                personUserField1,
+                personUserField2
+            };
+            CoreMessageHeader coreMessageHeader = new CoreMessageHeader(1122000321);
+            CoreApiMessage<IEnumerable<PersonUserField>> coreApiMessagePersonUserFields = new CoreApiMessage<IEnumerable<PersonUserField>>(coreMessageHeader, personUserFields);
+            _mockPersonUserFieldDao.Setup(x => x.FindPersonUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(),
+                                                       It.IsAny<int>())).ReturnsAsync(coreApiMessagePersonUserFields);
+
+            PersonUserField updatedPersonUserField1 = new PersonUserField()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
+                                                                It.IsAny<int>(),
+                                                                personUserField1.Id)).ReturnsAsync(updatedPersonUserField1);
+
+            PersonUserField updatedPersonUserField2 = new PersonUserField()
+            {
+                PersonNumber = 100002,
+                UserFieldCode = "TEST2",
+                Value = "N"
+            };
+            _mockPersonUserFieldDao.Setup(x => x.UpdatePersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
+                                                                It.IsAny<int>(),
+                                                                personUserField2.Id)).ReturnsAsync(updatedPersonUserField2);
+
+            var result = await _personUserFieldService.UpdatePersonUserFieldAsync(personUserFieldUpdateRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("Y", result.Value);
+            Assert.AreEqual(100001, result.PersonNumber);
+        }
+
+        [Test]
+        public void InsertPersonUserFieldsAsync_NullPerson_ExceptionThrown()
+        {
+            var personUserFieldUpdateRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+
+            var personList = new List<Person>();
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                 await _personUserFieldService.InsertPersonUserFieldAsync(personUserFieldUpdateRequest));
+        }
+
+        [Test]
+        public async Task InsertPersonUserFieldsAsync_InsertedUserField()
+        {
+
+            var person = new Person()
+            {
+                Id = "TEST-adsfasdfas[]djfas"
+            };
+
+            var personList = new List<Person> { person };
+
+            _mockPersonService.Setup(x => x.GetPersonByPersonNumber(It.IsAny<long>())).ReturnsAsync(personList);
+
+            var messageHeader = new CoreMessageHeader() { };
+            var personUserFieldRequest = new PersonUserFieldRequest()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var coreApiMessage = new CoreApiMessage<PersonUserFieldRequest>(messageHeader, personUserFieldRequest);
+            var createdPersonUserField1 = new PersonUserField()
+            {
+                PersonNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            _mockPersonUserFieldDao.Setup(x => x.InsertPersonUserField(It.IsAny<CoreApiMessage<PersonUserFieldRequest>>(),
+                                                                personUserFieldRequest.PersonNumber)).ReturnsAsync(createdPersonUserField1);
+
+
+            var result = await _personUserFieldService.InsertPersonUserFieldAsync(personUserFieldRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("Y", result.Value);
+            Assert.AreEqual(100001, result.PersonNumber);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/PropertyUserFieldServiceTest.cs

@@ -0,0 +1,157 @@
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Properties;
+using LCU.Library.Internal.Exceptions;
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class PropertyUserFieldServiceTest
+    {
+        private readonly PropertyUserFieldService _propertyUserFieldService;
+        private readonly Mock<IPropertyService> _mockPropertyService;
+        private readonly Mock<IPropertyUserFieldDao> _mockPropertyUserFieldDao;
+
+        public PropertyUserFieldServiceTest()
+        {
+            _mockPropertyService = new Mock<IPropertyService>();
+            _mockPropertyUserFieldDao = new Mock<IPropertyUserFieldDao>();
+            _propertyUserFieldService = new PropertyUserFieldService(_mockPropertyService.Object, _mockPropertyUserFieldDao.Object);
+        }
+
+        [Test]
+        public void GetPropertyUserFieldCoreApiResponseAsync_ExceptionThrown()
+        {
+            _mockPropertyUserFieldDao.Setup(x => x.FindPropertyUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).Throws(new ServiceException("Nope"));
+
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _propertyUserFieldService.GetPropertyUserFieldsAsync(0));
+        }
+
+        [Test]
+        public void UpdatePropertyUserFieldAsync_ExceptionThrown()
+        {
+            _mockPropertyUserFieldDao.Setup(x => x.UpdatePropertyUserField(It.IsAny<UserFieldRequest>())).Throws(new ServiceException("Unit Test Failed"));
+
+            var propertyUserUpdateRequest = new PropertyUserField()
+            {
+                PropertyNumber = 100001,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _propertyUserFieldService.UpdatePropertyUserFieldAsync(propertyUserUpdateRequest));
+        }
+
+        [Test]
+        public async Task UpdatePropertyUserFieldAsync_Ok()
+        {
+            var testProperty = new Property()
+            {
+                PropertyNumber = 1000
+            };
+
+            var updatedPropertyUserField = new PropertyUserField()
+            {
+                PropertyNumber = 1000L,
+                UserFieldCode = "TEST1",
+                Value = "Y",
+                LastMaintained = Convert.ToDateTime("9/1/2001")
+            };
+
+            var listExistingPropertyUserField = new List<PropertyUserField>()
+            {
+                new PropertyUserField()
+                {
+                    PropertyNumber = 1000L,
+                    Id = updatedPropertyUserField.Id,
+                    UserFieldCode = "TEST1",
+                    Value = "N",
+                    LastMaintained = Convert.ToDateTime("8/1/2001")
+                }
+            };
+            var coreMessageheader = new CoreMessageHeader();
+            var coreApiResponse = new CoreApiMessage<IEnumerable<PropertyUserField>>(coreMessageheader, listExistingPropertyUserField);
+
+            BasicResponse response = new BasicResponse()
+            {
+                Success = true
+            };
+
+            _mockPropertyUserFieldDao.Setup(x => x.FindPropertyUserFieldCoreApiResponseByPersonId(It.IsAny<CoreRequestParameters>(), It.IsAny<int>())).ReturnsAsync(coreApiResponse);
+
+            _mockPropertyUserFieldDao.Setup(x => x.UpdatePropertyUserField(It.IsAny<UserFieldRequest>())).ReturnsAsync(response);
+
+            _mockPropertyService.Setup(x => x.GetProperty(It.IsAny<int>())).ReturnsAsync(testProperty);
+
+            var propertyUserUpdateRequest = new PropertyUserField()
+            {
+                PropertyNumber = 1000L,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var result = await _propertyUserFieldService.UpdatePropertyUserFieldAsync(propertyUserUpdateRequest);
+            Assert.NotNull(result);
+            Assert.AreEqual(response.Success, result.Success);
+        }
+
+        [Test]
+        public void InsertPersonUserFieldAsync_ExceptionThrown()
+        {
+            _mockPropertyUserFieldDao.Setup(x => x.InsertPropertyUserField(It.IsAny<UserFieldRequest>())).Throws(new ServiceException("Oops"));
+
+            var propertyUserUpdateRequest = new PropertyUserField()
+            {
+                PropertyNumber = 1000,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            Assert.ThrowsAsync<ServiceException>(async () =>
+                await _propertyUserFieldService.InsertPropertyUserFieldAsync(propertyUserUpdateRequest));
+        }
+
+        [Test]
+        public async Task InsertPropertyUserFieldAsync_InsertUserFieldsReturned()
+        {
+            var property = new Property()
+            {
+                PropertyNumber = 1000
+            };
+
+            _mockPropertyService.Setup(x => x.GetProperty(1000)).ReturnsAsync(property);
+
+            var createdPropertyUserField = new PropertyUserField()
+            {
+                PropertyNumber = 1000L,
+                UserFieldCode = "TEST1",
+                Value = "Y",
+                LastMaintained = Convert.ToDateTime("9/1/2001")
+            };
+            BasicResponse response = new BasicResponse()
+            {
+                Success = true,
+            };
+            _mockPropertyUserFieldDao.Setup(x => x.InsertPropertyUserField(It.IsAny<UserFieldRequest>())).ReturnsAsync(response);
+
+            var personUserUpdateRequest = new PropertyUserField()
+            {
+                PropertyNumber = 1000,
+                UserFieldCode = "TEST1",
+                Value = "Y"
+            };
+            var result = await _propertyUserFieldService.InsertPropertyUserFieldAsync(personUserUpdateRequest);
+            Assert.NotNull(result);
+            Assert.AreEqual(response.Success, result.Success);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/TaxServiceTest.cs

@@ -0,0 +1,76 @@
+using System.Linq;
+using System.Collections.Generic;
+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.Tax;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class TaxServiceTest
+    {
+        private readonly TaxService _taxService;
+        private readonly Mock<ITaxDao> _mockTaxDao;
+
+        public TaxServiceTest()
+        {
+            _mockTaxDao = new Mock<ITaxDao>();
+            _taxService = new TaxService(_mockTaxDao.Object);
+        }       
+
+        [Test]
+        public async Task GetPersonsTaxIdData_Returns_PersonTaxIdData()
+        {
+            var personTaxIdDataResponse = new List<PersonTaxIdDataResponse>
+            {
+                new() {
+                    FirstName = "Greg",
+                    MiddleInitial = "H",
+                    LastName = "Stevens",
+                    Suffix = "Jr.",
+                    NameFull = "Greg H. Stevens Jr.",
+                    PersonNumber = 123
+                }
+            };
+            
+            _mockTaxDao.Setup(x => x.GetPersonTaxIdData(It.IsAny<CoreRequestParameters>(), It.Is<string>(x => x == "123"))).ReturnsAsync(personTaxIdDataResponse).Verifiable();
+            var result = await _taxService.GetPersonsTaxIdData("123");
+
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count());
+            var firstResponse = result.First();
+            Assert.AreEqual("Greg",firstResponse.FirstName);
+            Assert.AreEqual("H", firstResponse.MiddleInitial);
+            Assert.AreEqual("Stevens", firstResponse.LastName);
+            Assert.AreEqual("Jr.", firstResponse.Suffix);
+            Assert.AreEqual("Greg H. Stevens Jr.", firstResponse.NameFull);
+            Assert.AreEqual(123, firstResponse.PersonNumber);
+            _mockTaxDao.Verify();
+        }
+        
+        [Test]
+        public async Task GetOrganizationsTaxIdData_Returns_OrganizationTaxIdData()
+        {
+            var organizationsTaxIdDataResponse = new List<OrganizationTaxIdDataResponse>
+            {
+                new() {
+                    Name = "Electric Company",
+                    OrganizationNumber = 123
+                }
+            };
+            
+            _mockTaxDao.Setup(x => x.GetOrganizationTaxIdData(It.IsAny<CoreRequestParameters>(), It.Is<string>(x => x == "123"))).ReturnsAsync(organizationsTaxIdDataResponse).Verifiable();
+            var result = await _taxService.GetOrganizationsTaxIdData("123");
+
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count());
+            var firstResponse = result.First();
+            Assert.AreEqual("Electric Company",firstResponse.Name);
+            Assert.AreEqual(123, firstResponse.OrganizationNumber);
+            _mockTaxDao.Verify();
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Service/TransactionServiceTest.cs

@@ -0,0 +1,202 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Castle.Core.Internal;
+using Moq;
+using NUnit.Framework;
+using LCU.Api.Internal.CoreApiWrapper.Services;
+using LCU.Library.Internal.CoreApiWrapperLib.DataAccess;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Transaction;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Service
+{
+    public class TransactionServiceTest
+    {
+        private TransactionService _transactionService;
+        private Mock<ITransactionDao> _mockTransactionDao;
+        private Mock<IAccountService> _mockAccountService;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _mockTransactionDao = new Mock<ITransactionDao>();
+            _mockAccountService = new Mock<IAccountService>();
+            _transactionService = new TransactionService(_mockTransactionDao.Object, _mockAccountService.Object);
+        }
+
+        [Test]
+        public async Task GetTransactionHistory_Return_Two()
+        {
+            var setupAccountNumber = 8675309143;
+            
+            var accountResponse = new Account()
+            {
+                Id="fasdfsda;fjsdipfu0-231231"
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).ReturnsAsync(accountResponse).Verifiable();
+
+            _mockTransactionDao
+                .Setup(x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()))
+                .ReturnsAsync(
+                    new List<TransactionHistory>()
+                    {
+                       new TransactionHistory()
+                       {
+                            AccountNumber = setupAccountNumber,
+                            ActivityDateTime = Convert.ToDateTime("1/1/2021"),
+                            AllowCustomerView = true,
+                            Amount = 220,
+                            BalanceAccountNumber = 2,
+                            BalanceTypeDescription = "Note Interest (Excess)",
+                            CurrTransactionStatusCode = "C",
+                            DueDate = null,
+                            EffectiveDate = "2021-10-14",
+                            ExternalTransactionDescription = null,
+                            Id = "22",
+                            IsDisputedTransaction = false,
+                            OnlineCheckTraceNumber = 0,
+                            PostingDate = "2021-10-15",
+                            RunningBalance = (decimal?)3529.53,
+                            TimeUniqueNumber = 86570239,
+                            TransactionNumber = 22,
+                            TransactionReference = $"{setupAccountNumber} - 22",
+                            TransactionStatusDescription = "Completed",
+                            TransactionTypeCode = "SPMT",
+                            TransactionTypeDescription = "Regular Payment   LandmarkCU      TRANSFER  12345",
+                            Uid = "abcd77299_sABCDMD]MYo5crdZyPN3s2QAHx[CHxgigabcdeYuALuVGL9Jklm_22"
+                       },
+                       new TransactionHistory()
+                       {
+                            AccountNumber = setupAccountNumber,
+                            ActivityDateTime = Convert.ToDateTime("1/2/2021"),
+                            AllowCustomerView = true,
+                            Amount = 30,
+                            BalanceAccountNumber = 2,
+                            BalanceTypeDescription = "Note Interest (Excess)",
+                            CurrTransactionStatusCode = "C",
+                            DueDate = null,
+                            EffectiveDate = "2021-10-14",
+                            ExternalTransactionDescription = null,
+                            Id = "23",
+                            IsDisputedTransaction = false,
+                            OnlineCheckTraceNumber = 0,
+                            PostingDate = "2021-10-15",
+                            RunningBalance = (decimal?)3559.53,
+                            TimeUniqueNumber = 86570239,
+                            TransactionNumber = 23,
+                            TransactionReference = $"{setupAccountNumber} - 23",
+                            TransactionStatusDescription = "Completed",
+                            TransactionTypeCode = "SPMT",
+                            TransactionTypeDescription = "Regular Payment   LandmarkCU      TRANSFER  12346",
+                            Uid = "abcd77299_sABCDMD]MYo5crdZyPN3s2QAHx[CHxgigabcdeYuALuVGL9Jklm_23"
+                       }
+                    })
+                .Verifiable();            
+
+            var results = await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null);
+
+            var resultsList = results.ToList();
+            Assert.NotNull(results);
+            Assert.AreEqual(2, resultsList.Count);
+            Assert.True(resultsList.Any(x => x.AccountNumber == setupAccountNumber));
+
+            _mockAccountService.Verify();
+            _mockTransactionDao.Verify();
+        }
+
+        [Test]
+        public async Task GetTransactionHistory_NullTransactions_EmptyList()
+        {
+            var setupAccountNumber = 8675309143;
+            
+            var accountResponse = new Account()
+            {
+                Id="fasdfsda;fjsdipfu0-231231"
+            };
+            
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).ReturnsAsync(accountResponse).Verifiable();
+
+            _mockTransactionDao
+                .Setup(x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()))
+                .ReturnsAsync((IEnumerable<TransactionHistory>)null)
+                .Verifiable();            
+
+            var results = await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null);
+            Assert.NotNull(results);
+            var resultsList = results.ToList();
+            Assert.IsEmpty(resultsList);
+
+            _mockAccountService.Verify();
+            _mockTransactionDao.Verify();
+        }
+        
+        [Test]
+        public async Task GetTransactionHistory_NoAccount_ReturnNull()
+        {
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).ReturnsAsync((Account)null).Verifiable();
+            
+            var results = await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null);
+
+            Assert.Null(results);
+            
+            _mockAccountService.Verify();
+            _mockTransactionDao.Verify( x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()), Times.Never);
+        }
+        
+        [Test]
+        public void GetTransactionHistory_TransactionDao_Exception()
+        {
+            var accountResponse = new Account()
+            {
+                Id = "fasdfsda;fjsdipfu0-231231"
+            };
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).ReturnsAsync(accountResponse).Verifiable();
+            _mockTransactionDao.Setup(x => x.FindTransactionHistoryById(It.IsAny<CoreRequestParameters>(), It.IsAny<TransactionHistoryRequest>(), It.IsAny<string>()))
+                .Throws(new Exception("Ohh nooo"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null));
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public void GetTransactionHistory_AccountService_Exception()
+        {
+            _mockAccountService.Setup(x => x.GetAccountDetails(It.IsAny<CoreRequestParameters>(),
+                                                               It.IsAny<AcctNbrRequest>())).Throws(new Exception("Ohh nooo"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _transactionService.GetTransactionHistory(1234555, Convert.ToDateTime("12/25/2020"), Convert.ToDateTime("2/2/2021"), null));
+            _mockAccountService.Verify();
+        }
+
+        [Test]
+        public async Task GetTransactionsByDateSpan_OK()
+        {
+            _mockTransactionDao.Setup(x => x.GetTransactionsByDateSpan(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(new List<TransactionAlertInfo>() { new TransactionAlertInfo() });
+
+            var results = await _transactionService.GetTransactionsByDateSpan(DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow, new string[1]);
+
+            Assert.NotNull(results);
+            var resultsList = results.ToList();
+            Assert.AreEqual(1, resultsList.Count);
+        }
+
+        [Test]
+        public async Task GetTransactionsByDateSpan_Exception()
+        {
+            _mockTransactionDao.Setup(x => x.GetTransactionsByDateSpan(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<string>())).ThrowsAsync(new Exception("Exception!"));
+
+            Assert.ThrowsAsync<Exception>(async () =>
+                await _transactionService.GetTransactionsByDateSpan(DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow, new string[1]));
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Utilities/HttpUtilitiesTest.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
+using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Utilities
+{
+    public class HttpUtilitiesTest
+    {
+        [Test]
+        public void BuildJsonBody_Returns_FullUri()
+        {
+            var testHost = "test.com";
+            var testEndpoint = "test/endpoint";         
+
+            var result = HttpUtilities.BuildHttpsUri(testHost, testEndpoint);
+
+            var testCompare = new Uri($"https://{testHost}{testEndpoint}");
+
+            Assert.NotNull(result);
+            Assert.AreEqual(testCompare, result);
+        }
+
+        [Test]
+        public void BuildJsonBody_Returns_UriWithouEndpoint()
+        {
+            var testHost = "test.com";
+            var testEndpoint = "";
+
+            var result = HttpUtilities.BuildHttpsUri(testHost, testEndpoint);
+
+            var testCompare = new Uri($"https://{testHost}");
+
+            Assert.NotNull(result);
+            Assert.AreEqual(testCompare, result);
+        }
+
+        [Test]
+        public void BuildEndPointWithParams_Returns_EndpointWith_TwoParams()
+        {
+            var testEndpoint = "test/endpoint";
+            var paramDictionary = new Dictionary<string, string>();
+            paramDictionary.Add("testparam1", "test1");
+            paramDictionary.Add("testparam2", "test2");
+
+            var result = HttpUtilities.BuildEndPointWithParams(testEndpoint, paramDictionary);
+
+            var testCompare = $"{testEndpoint}?testparam1=test1&testparam2=test2";
+
+            Assert.NotNull(result);
+            Assert.AreEqual(testCompare, result);
+        }
+
+        [Test]
+        public void BuildEndPointWithParams_Returns_EndpointWith_NoParams()
+        {
+            var testEndpoint = "test/endpoint";
+            var paramDictionary = new Dictionary<string, string>();
+
+            var result = HttpUtilities.BuildEndPointWithParams(testEndpoint, paramDictionary);
+
+            var testCompare = $"{testEndpoint}";
+
+            Assert.NotNull(result);
+            Assert.AreEqual(testCompare, result);
+        }
+
+        [Test]
+        public void ReplaceRootParameter_Returns_RootParamReplaced()
+        {
+            var testEndpoint = "test/{Test}/endpoint";
+            var testPlaceholder = "{Test}";
+            var testValue = "dasdwerwqer-1321dsaffew423";
+
+            var result = HttpUtilities.ReplaceRootParameter(testEndpoint, testPlaceholder, testValue);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("test/dasdwerwqer-1321dsaffew423/endpoint", result);
+        }
+
+        [Test]
+        public void ReplaceRootParameter_RootParamPlaceHolder_DoesNotExist_Return_EndPoint()
+        {
+            var testEndpoint = "test/endpoint";
+            var testPlaceholder = "{Test}";
+            var testValue = "dasdwerwqer-1321dsaffew423";
+
+            var result = HttpUtilities.ReplaceRootParameter(testEndpoint, testPlaceholder, testValue);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("test/endpoint", result);
+        }
+
+        [Test]
+        public void BuildDictionaryOfValues_Returns_OneProperty_InDictionary()
+        {
+            var personRequest = new PersonNameRequest()
+            {
+                FirstName = "Test"
+            };
+
+            var testCompare = new Dictionary<string, string>();
+            testCompare.Add("FirstName", "Test");
+
+            var result = HttpUtilities.BuildDictionaryOfNonNullValues(personRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(1, result.Count);
+            Assert.AreEqual(testCompare, result);
+        }
+
+        [Test]
+        public void BuildDictionaryOfValues_Returns_TwoProperty_InDictionary()
+        {
+            var personRequest = new PersonNameRequest()
+            {
+                FirstName = "Test",
+                LastName = "Test Last"
+            };
+
+            var testCompare = new Dictionary<string, string>();
+            testCompare.Add("FirstName", "Test");
+            testCompare.Add("LastName", "Test Last");
+
+            var result = HttpUtilities.BuildDictionaryOfNonNullValues(personRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(2, result.Count);
+            Assert.AreEqual(testCompare, result);
+        }
+
+        [Test]
+        public void BuildDictionaryOfValues_Returns_EmptyDictionary()
+        {
+            var personRequest = new PersonNameRequest();
+
+            var result = HttpUtilities.BuildDictionaryOfNonNullValues(personRequest);
+
+            Assert.NotNull(result);
+            Assert.Zero(result.Count);
+        }
+
+        [Test]
+        public void BuildJsonBody_Returns_OneProperty_JsonWithout_NullFields()
+        {
+            var personRequest = new PersonNameRequest()
+            {
+                FirstName = "Test"
+            };
+
+            var testCompare = new Dictionary<string, string>();
+            testCompare.Add("FirstName", "Test");
+            var jsonTestCompare = JsonConvert.SerializeObject(testCompare);
+
+            var result = HttpUtilities.BuildJsonOfNonNullProperties(personRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(jsonTestCompare, result);
+        }
+
+        [Test]
+        public void BuildJsonBody_Returns_OneProperty_JJsonWithout_NullFields()
+        {
+            var personRequest = new PersonNameRequest()
+            {
+                FirstName = "Test",
+                LastName = "Test Last"
+            };
+
+            var testCompare = new Dictionary<string, string>();
+            testCompare.Add("FirstName", "Test");
+            testCompare.Add("LastName", "Test Last");
+            var jsonTestCompare = JsonConvert.SerializeObject(testCompare);
+
+            var result = HttpUtilities.BuildJsonOfNonNullProperties(personRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual(jsonTestCompare, result);
+        }
+
+        [Test]
+        public void BuildJsonBody_Returns_EmptyString()
+        {
+            var personRequest = new PersonNameRequest();
+
+            var result = HttpUtilities.BuildJsonOfNonNullProperties(personRequest);
+
+            Assert.NotNull(result);
+            Assert.AreEqual("", result);
+        }
+    }
+}

LCU.Api.Internal.CoreApiWrapper/LCU.Api.Internal.CoreApiWrapperTest/Utilities/QueryUtilitiesTest.cs

@@ -0,0 +1,65 @@
+using NUnit.Framework;
+using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
+using System.Collections.Generic;
+
+namespace LCU.Api.Internal.CoreApiWrapperTest.Utilities
+{
+    public class QueryUtilitiesTest
+    {
+        public void GetQuery_Returns_QueryReturned()
+        {
+            var testEndpoint = "TEST_Query";
+
+            var result = QueryUtilities.GetQuery(testEndpoint);
+
+            var testCompare = "select TEST\r\nfrom TEST\r\nwhere TEST like TEST";
+
+            Assert.NotNull(result);
+            Assert.AreEqual(testCompare, result);
+        }
+
+        [Test]
+        public void GetQuery_Returns_EmptyReturned()
+        {
+            var testEndpoint = "TEST_Query_NOPE";
+
+            var result = QueryUtilities.GetQuery(testEndpoint);
+
+            Assert.IsEmpty(result);
+        }
+
+        [Test]
+        public void BuildParameterListString_Returns_StringOfParameterCommaDelimited()
+        {
+            var testValues = new List<string>() 
+            { 
+                "Test1",
+                "Test2",
+                "Test3"
+            };
+
+            var result = QueryUtilities.BuildParameterListString(testValues);
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(":param0,:param1,:param2" ,result);
+        }
+
+        [Test]
+        public void BuildDictionaryParameter_Returns_DictionaryWithThreeParams()
+        {
+            var testValues = new List<string>()
+            {
+                "Test1",
+                "Test2",
+                "Test3"
+            };
+
+            var result = QueryUtilities.BuildDictionaryParameter(testValues);
+
+            Assert.IsNotNull(result);
+            Assert.IsNotNull(result["param0"]);
+            Assert.IsNotNull(result["param1"]);
+            Assert.IsNotNull(result["param2"]);
+        }
+    }
+}