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);
+        }
+    }
+}