Adding

2026-04-20 14:47:24 -05:00
parent 89057eceea
commit 8b3ea92501
485 changed files with 71042 additions and 0 deletions
@@ -0,0 +1,120 @@
+using System.Collections.Generic;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Models.Filters;
+using LCU.API.Collections.RepoApi.Models.Requests;
+using LCU.API.Collections.RepoApi.Models.Responses;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using LCU.Shared.Collections.RepoApiLib.Models.Results;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class AuctionAssignmentControllerTest
+    {
+        private readonly AuctionAssignmentController controller;
+        private readonly Mock<IAuctionAssignmentService> mockAuctionAssignmentServiceService;
+        private readonly Mock<IFloorPricingService> mockloorPricingService;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public AuctionAssignmentControllerTest()
+        {
+            mockAuctionAssignmentServiceService = new Mock<IAuctionAssignmentService>();
+            mockloorPricingService = new Mock<IFloorPricingService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new AuctionAssignmentController(
+                mockAuctionAssignmentServiceService.Object,
+                mockloorPricingService.Object,
+                mockHttpContextAccessor.Object
+            );
+        }
+
+        [Fact]
+        public async void Get_OK()
+        {
+            mockAuctionAssignmentServiceService.Setup(service => service.ListByFilterAsync(It.IsAny<AuctionAssignmentFilter>())).ReturnsAsync(
+                new PagedResult<AuctionAssignment>()
+                {
+                    Total = 1,
+                    Items = new List<AuctionAssignment>()
+                    {
+                        new AuctionAssignment()
+                    }
+                });
+
+            var filter = new AuctionAssignmentFilter();
+            var result = await controller.Get(filter);
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as PagedResponse<AuctionAssignment>;
+            Assert.NotNull(okValue);
+            Assert.Equal(1, okValue.TotalItems);
+            mockAuctionAssignmentServiceService.Verify(x => x.ListByFilterAsync(It.IsAny<AuctionAssignmentFilter>()), Times.Once);
+        }
+
+        [Fact]
+        public async void Post_OK()
+        {
+            mockAuctionAssignmentServiceService.Setup(service => service.SaveAsync(It.IsAny<AuctionAssignmentPostRequest>())).ReturnsAsync(
+                new AuctionAssignmentPostRequest()
+                {
+                    AuctionAssignment = new AuctionAssignment()
+                    {
+                        CollateralVIN = "abcde",
+                    }
+                });
+
+            //var controller = new AuctionAssignmentController(mockService.Object, mockAutoIms.Object);
+            var result = await controller.Post(new AuctionAssignmentPostRequest()
+            {
+                Collaterals = new List<Collateral>
+                {
+                    new Collateral()
+                }
+            });
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as AuctionAssignmentPostRequest;
+            Assert.NotNull(okValue);
+            Assert.Equal("abcde", okValue.AuctionAssignment.CollateralVIN);
+            mockAuctionAssignmentServiceService.Verify(x => x.SaveAsync(It.IsAny<AuctionAssignmentPostRequest>()), Times.Once);
+        }
+
+        [Fact]
+        public async void Bad_GetById_Fails()
+        {
+            var result = await controller.GetById(0);
+            Assert.NotNull(result);
+
+            var badRequest = result as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.Equal(400, badRequest.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_IdMismatch_Fails()
+        {
+            var auctionAssignmentToPut = new AuctionAssignment()
+            {
+                ID = 2
+            };
+            var result = await controller.Put(1, auctionAssignmentToPut);
+            Assert.NotNull(result);
+
+            var badRequest = result as BadRequestObjectResult;
+            Assert.NotNull(badRequest);
+            Assert.Equal(400, badRequest.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,105 @@
+using System.Collections.Generic;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class AuctionHouseControllerTest
+    {
+        private readonly Mock<IAuctionHouseService> mockAuctionHouseService;
+        private readonly AuctionHouseController controller;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public AuctionHouseControllerTest()
+        {
+            mockAuctionHouseService = new Mock<IAuctionHouseService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new AuctionHouseController(mockAuctionHouseService.Object,
+                mockHttpContextAccessor.Object);
+        }
+
+        [Fact]
+        public async void Get_OK()
+        {
+            // arrange
+            mockAuctionHouseService.Setup(service => service.ListAllAsync()).ReturnsAsync(new List<AuctionHouse>()
+            {
+                new AuctionHouse()
+                {
+                    Name = "Auction House A"
+                }
+            });
+
+            // act
+            var result = await controller.Get();
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<AuctionHouse>;
+            Assert.NotNull(okValue);
+
+            var enumerator = okValue.GetEnumerator();
+            enumerator.MoveNext();
+            Assert.NotNull(enumerator.Current);
+            Assert.Equal("Auction House A", enumerator.Current.Name);
+        }
+
+        [Fact]
+        public async void Post_OK()
+        {
+            // arrange
+            mockAuctionHouseService.Setup(service => service.SaveAsync(It.IsAny<AuctionHouse>())).ReturnsAsync(
+                new AuctionHouse()
+                {
+                    Name = "Auction House A"
+                });
+
+            // act
+            var result = await controller.Post(new AuctionHouse()
+            {
+                Name = "Auction House A"
+            });
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as AuctionHouse;
+            Assert.NotNull(okValue);
+            Assert.Equal("Auction House A", okValue.Name);
+        }
+
+        [Fact]
+        public async void Put_Bad_Request()
+        {
+            // arrange
+            mockAuctionHouseService.Setup(service => service.UpdateAsync(It.IsAny<AuctionHouse>()))
+                .ReturnsAsync(new AuctionHouse());
+
+            // act
+            var result = await controller.Put("ID1", new AuctionHouse()
+            {
+                AuctionID = "ID2"
+            });
+
+
+            // assert
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,114 @@
+using System.Collections.Generic;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Models.Filters;
+using LCU.API.Collections.RepoApi.Models.Responses;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using LCU.Shared.Collections.RepoApiLib.Models.Results;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class AuditRecordControllerTest
+    {
+        private readonly Mock<IAuditRecordService> mockAuditRecordService;
+        private readonly AuditRecordController controller;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public AuditRecordControllerTest()
+        {
+            mockAuditRecordService = new Mock<IAuditRecordService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new AuditRecordController(mockAuditRecordService.Object,
+                mockHttpContextAccessor.Object);
+        }
+
+        // Get tests
+        [Fact]
+        public async void Get_OK()
+        {
+            mockAuditRecordService.Setup(service => service.ListAll(It.IsAny<PageFilter>())).ReturnsAsync(
+                new PagedResult<AuditRecord>()
+                {
+                    Total = 1,
+                    Items = new List<AuditRecord>()
+                    {
+                        new AuditRecord()
+                        {
+                            Action = "action",
+                            ClassName = "Something",
+                            Description = "changed something field 1",
+                            PerformedBy = "Developer",
+                            KeyRepresentation = "111"
+                        }
+                    }
+                });
+
+            // arrange
+            var filter = new PageFilter();
+
+            // act
+            var result = await controller.Get(filter);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as PagedResponse<AuditRecord>;
+            Assert.NotNull(okValue);
+            Assert.Equal(1, okValue.TotalItems);
+        }
+
+        // Post tests
+        [Fact]
+        public async void Post_OK()
+        {
+            // arrange
+            var postAudit = new AuditRecord()
+            {
+                Action = "action",
+                ClassName = "Something",
+                Description = "changed something field 1",
+                PerformedBy = "Developer",
+                KeyRepresentation = "111"
+            };
+
+            // act
+            var result = await controller.Post(postAudit);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Bad_Request()
+        {
+            // arrange
+            var postAudit = new AuditRecord()
+            {
+                Action = "action",
+                ClassName = "Something",
+                Description = "changed something field 1",
+                KeyRepresentation = "111"
+            };
+            controller.ModelState.AddModelError("PerformedBy", "The performed by field is required.");
+
+            // act
+            var result = await controller.Post(postAudit);
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            // assert
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+using System.Linq;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class CollateralControllerTest
+    {
+        private readonly Mock<ICollateralService> mockCollateralService;
+        private readonly CollateralController controller;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public CollateralControllerTest()
+        {
+            mockCollateralService = new Mock<ICollateralService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new CollateralController(mockCollateralService.Object,
+                mockHttpContextAccessor.Object);
+        }
+
+        // Get tests
+        [Fact]
+        public async void Get_OK()
+        {
+            // arrange
+            var collateral = new List<Collateral>
+            {
+                new Collateral()
+                {
+                    CollateralId = 1234567,
+                    RepoId = 2345678
+                }
+            };
+            mockCollateralService.Setup(x => x.ListAll()).ReturnsAsync(collateral);
+
+            // act
+            var result = await controller.Get();
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<Collateral>;
+            Assert.NotNull(okValue);
+            Assert.True(collateral.SequenceEqual(okValue));
+        }
+
+        [Fact]
+        public async void GetById_OK()
+        {
+            // arrange
+            var repos = new List<Collateral>
+            {
+                new Collateral()
+                {
+                    CollateralId = 1234567,
+                    RepoId = 2345678
+                }
+            };
+            mockCollateralService.Setup(x => x.Get(It.IsAny<int>())).ReturnsAsync(repos.First());
+
+            // act
+            var result = await controller.GetById(1234567);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as Collateral;
+            Assert.NotNull(okValue);
+            Assert.Equal(2345678, okValue.RepoId);
+        }
+
+        // Post tests
+        [Fact]
+        public async void Post_OK()
+        {
+            // arrange
+            var postCollateral = new Collateral()
+            {
+                CollateralId = 1234567,
+                RepoId = 2345678
+            };
+
+            // act
+            var result = await controller.Post(postCollateral);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Bad_Request()
+        {
+            // arrange
+            var postCollateral = new Collateral()
+            {
+                CollateralId = 1234567,
+            };
+            controller.ModelState.AddModelError("Message", "The message field is required.");
+
+            // act
+            var result = await controller.Post(postCollateral);
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            // assert
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,252 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Exceptions;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class EventAlertControllerTest
+    {
+        private readonly EventAlertController controller;
+        private readonly Mock<IEventAlertService> mockEventAlertService;
+        private readonly Mock<IRepoAccountService> mockRepoService;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public EventAlertControllerTest()
+        {
+            mockEventAlertService = new Mock<IEventAlertService>();
+            mockRepoService = new Mock<IRepoAccountService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new EventAlertController(mockEventAlertService.Object,
+                mockRepoService.Object, mockHttpContextAccessor.Object);
+        }
+
+        // Get tests
+        [Fact]
+        public async void Get_OK()
+        {
+            // arrange
+            var alerts = new List<EventAlert>
+            {
+                new EventAlert()
+                {
+                    AccountNo = "1234567-98",
+                    Message = "Status is O4R"
+                }
+            };
+            mockEventAlertService.Setup(x => x.ListAll()).ReturnsAsync(alerts);
+
+            // act
+            var result = await controller.Get();
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<EventAlert>;
+            Assert.NotNull(okValue);
+            Assert.True(alerts.SequenceEqual(okValue));
+        }
+
+        [Fact]
+        public async void Get_UnreadOnly_OK()
+        {
+            // arrange
+            var expected = new EventAlert()
+            {
+                AccountNo = "1234567-99",
+                Message = "Status is O4R"
+            };
+            mockEventAlertService.Setup(x => x.ListUnread()).ReturnsAsync(new List<EventAlert> {expected});
+
+            // act
+            var result = await controller.Get(unreadOnly: true);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<EventAlert>;
+            Assert.NotNull(okValue);
+            Assert.Single(okValue);
+            Assert.Equal(expected, okValue.First());
+        }
+
+        [Fact]
+        public async void Get_ActionNeeded_OK()
+        {
+            // arrange
+            var expected = new EventAlert()
+            {
+                AccountNo = "1234567-90",
+                Message = "Status is O4R"
+            };
+            mockEventAlertService.Setup(x => x.ListActionNeeded()).ReturnsAsync(new List<EventAlert> {expected});
+
+            // act
+            var result = await controller.Get(actionNeeded: true);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<EventAlert>;
+            Assert.NotNull(okValue);
+            Assert.Single(okValue);
+            Assert.Equal(expected, okValue.First());
+        }
+
+        [Fact]
+        public async void Get_WithinDateRange_OK()
+        {
+            // arrange
+            var startDate = DateTime.Now.AddSeconds(-5);
+            var endDate = DateTime.Now.AddSeconds(5);
+            var expected = new EventAlert()
+            {
+                DateAdded = DateTime.Now,
+                AccountNo = "1234567-99",
+                Message = "Status is O4R"
+            };
+            mockEventAlertService.Setup(x => x.ListWithinDateRange(startDate, endDate))
+                .ReturnsAsync(new List<EventAlert> {expected});
+
+            // act
+            var result = await controller.GetWithinDateRange(startDate, endDate);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<EventAlert>;
+            Assert.NotNull(okValue);
+            Assert.Single(okValue);
+            Assert.Equal(expected, okValue.First());
+        }
+
+        // Post tests
+        [Fact]
+        public async void Post_OK()
+        {
+            // arrange
+            var postAlert = new EventAlert()
+            {
+                AccountNo = "1234567-98",
+                Message = "Status is O4R"
+            };
+
+            // act
+            var result = await controller.Post(postAlert);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_By_Auction_ID_OK()
+        {
+            // arrange
+            mockRepoService.Setup(x => x.FindByAuctionAssignmentId(5)).ReturnsAsync(new RepoAccount()
+            {
+                RepoId = 10,
+                AccountNo = "12345"
+            });
+
+            var postAlert = new EventAlert()
+            {
+                AccountNo = "1234567-98",
+                Message = "Status is O4R"
+            };
+
+            // act
+            var result = await controller.CreateByAuctionAssignmentId(5, postAlert);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+            mockRepoService.Verify(x => x.FindByAuctionAssignmentId(5), Times.Once);
+        }
+
+        [Fact]
+        public async void Post_Bad_Request()
+        {
+            // arrange
+            var postAlert = new EventAlert()
+            {
+                AccountNo = "1234567-98",
+            };
+            controller.ModelState.AddModelError("Message", "The message field is required.");
+
+            // act
+            var result = await controller.Post(postAlert);
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            // assert
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_By_AuctionAssignment_Bad_Request()
+        {
+            // arrange
+            mockEventAlertService.Setup(x => x.SaveAsync(It.IsAny<EventAlert>())).Verifiable();
+            mockRepoService.Setup(x => x.FindByAuctionAssignmentId(5)).Returns(Task.FromResult<RepoAccount>(null));
+            var postAlert = new EventAlert()
+            {
+                AccountNo = "1234567-98",
+            };
+
+            // act
+            var result = await controller.CreateByAuctionAssignmentId(5, postAlert);
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            // assert
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+            mockRepoService.Verify(x => x.FindByAuctionAssignmentId(5), Times.Once);
+            mockEventAlertService.Verify(x => x.SaveAsync(It.IsAny<EventAlert>()), Times.Never);
+        }
+
+        [Fact]
+        public async void Duplicate_Add_Bad_Request()
+        {
+            // arrange
+            mockEventAlertService.Setup(x => x.SaveAsync(It.IsAny<EventAlert>())).ThrowsAsync(
+                new DuplicateResourceException("EventAlert"));
+
+            // act
+            var result = await controller.Post(new EventAlert());
+            Assert.NotNull(result);
+            var requestResult = result as ObjectResult;
+
+            // assert
+            Assert.NotNull(requestResult);
+            Assert.Equal(StatusCodes.Status409Conflict, requestResult.StatusCode);
+            Assert.Equal("A Duplicate Event Alert already exists.", requestResult.Value);
+        }
+    }
+}
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Models.Responses;
+using LCU.API.Collections.RepoApi.Services;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class FactoidControllerTest
+    {
+        private readonly FactoidController controller;
+        private readonly Mock<IFactoidService> mockFactoidService;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public FactoidControllerTest()
+        {
+            mockFactoidService = new Mock<IFactoidService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new FactoidController(mockHttpContextAccessor.Object,
+                mockFactoidService.Object);
+        }
+
+        [Fact]
+        public async void Get_All_Factoids_OK()
+        {
+            // act
+            var result = await controller.GetAllFactoids();
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var factoidResponses = okResult.Value as IReadOnlyCollection<FactoidResponse>;
+            Assert.Equal(10, factoidResponses.Count);
+        }
+
+        [Fact]
+        public async void Get_Factoid_O4R_OK()
+        {
+            // act
+            var result = await controller.GetAllAccountsO4R();
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using LCU.Shared.Collections.RepoApiLib.Models.Producer;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Xunit;
+using  Moq;
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class ProcessingReceiptControllerTest
+    {
+        List<ProcessingReceipt> list = new List<ProcessingReceipt>()
+        {
+            new ProcessingReceipt("123456-888")
+            {
+                Message = "x",
+                Outcome = RepoProcessingResult.Error,
+                Processed = DateTime.Now,
+                AccountId = "321",
+                CaseId = "",
+                QueuedBy = "Testing"
+            },
+            new ProcessingReceipt("123456-888")
+            {
+                Message = "y",
+                Outcome = RepoProcessingResult.Created,
+                Processed = DateTime.Now,
+                AccountId = "",
+                CaseId = "",
+                QueuedBy = "Testing"
+            }
+        };
+        private readonly Mock<IProcessingReceiptService> _mockReceiptService;
+        private readonly ProcessingReceiptController _controller;
+
+        public ProcessingReceiptControllerTest()
+        {
+            _mockReceiptService = new Mock<IProcessingReceiptService>();
+            var mockHttpContextAccessor = new Mock<HttpContextAccessor>();
+            _controller = new ProcessingReceiptController(_mockReceiptService.Object, mockHttpContextAccessor.Object);
+        }
+
+        [Fact]
+        public async void GetByAccountNo_OK()
+        {
+            _mockReceiptService.Setup(service => service.GetReceiptsByAccountNoAsync(It.IsAny<string>()))
+                .ReturnsAsync(list);
+
+            var results = await _controller.GetByAccountNo("123456-888");
+            var okresults = results as OkObjectResult;
+            Assert.NotNull(okresults);
+            Assert.Equal(200, okresults.StatusCode);
+        }
+
+        [Fact]
+        public async void GetByAccountNo_NotFound()
+        {
+            _mockReceiptService.Setup(service => service.GetReceiptsByAccountNoAsync(It.IsAny<string>()))
+                .ReturnsAsync(new List<ProcessingReceipt>{});
+
+            var results = await _controller.GetByAccountNo("123456-888");
+            var objectResult = results as ObjectResult;
+            Assert.NotNull(objectResult);
+            Assert.IsType<NotFoundObjectResult>(objectResult);
+        }
+        
+        [Fact]
+        public async void GetByAccountNo_ServerException()
+        {
+            _mockReceiptService.Setup(service => service.GetReceiptsByAccountNoAsync(It.IsAny<string>())).ThrowsAsync(new Exception("oops"));
+
+            var results = await _controller.GetByAccountNo("123456-888");
+            var objectResult = results as StatusCodeResult;
+            Assert.NotNull(objectResult);
+            Assert.Equal(500, objectResult.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,96 @@
+using System;
+using System.Security.Claims;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.HostedServices;
+using LCU.API.Collections.RepoApi.Models.Requests;
+using LCU.Shared.Collections.RepoApiLib.Models.Producer;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class QueueControllerTest
+    {
+        private readonly Mock<IRepoQueueProducerService> _mockService;
+        private readonly Mock<IHttpContextAccessor> _mockHttpContextAccessor;
+
+        public QueueControllerTest()
+        {
+            _mockService = new Mock<IRepoQueueProducerService>();
+            _mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+        }
+
+        [Fact]
+        public void PutSingleAccountOnQueue_OK()
+        {
+            //setup
+            _mockService.Setup(x => x.SendRequestToQueue(It.IsAny<ProcessingItem>()));
+            QueueController controller = new QueueController(_mockService.Object, _mockHttpContextAccessor.Object);
+            
+            var context = new DefaultHttpContext();
+            context.User = new ClaimsPrincipal();
+            _mockHttpContextAccessor.Setup(_ => _.HttpContext).Returns(context);
+
+            var request = new AccountQueueRequest()
+            {
+                AccountNo = "12345-123"
+            };
+
+            //act
+            var res = controller.PutSingleAccountOnQueue(request);
+
+            Assert.IsType<OkResult>(res);
+            _mockService.Verify(x => x.SendRequestToQueue(It.IsAny<ProcessingItem>()), Times.Once);
+        }
+
+        [Fact]
+        public void PutSingleAccountOnQueue_Exception()
+        {
+            //setup
+            _mockService.Setup(x => x.SendRequestToQueue(It.IsAny<ProcessingItem>())).Throws(new Exception("oops"));
+            QueueController controller = new QueueController(_mockService.Object, _mockHttpContextAccessor.Object);
+            var context = new DefaultHttpContext();
+            context.User = new ClaimsPrincipal();
+            _mockHttpContextAccessor.Setup(_ => _.HttpContext).Returns(context);
+
+            var request = new AccountQueueRequest()
+            {
+                AccountNo = "12345-123"
+            };
+
+            //act
+            var res = controller.PutSingleAccountOnQueue(request);
+            var badres = res as ObjectResult;
+
+            //asert
+            Assert.Equal(500, badres.StatusCode);
+            _mockService.Verify(x => x.SendRequestToQueue(It.IsAny<ProcessingItem>()), Times.Once);
+        }
+
+        [Fact]
+        public void PutSingleAccountOnQueue_BadFormat1()
+        {
+            //setup
+            _mockService.Setup(x => x.SendRequestToQueue(It.IsAny<ProcessingItem>()));
+            QueueController controller = new QueueController(_mockService.Object, _mockHttpContextAccessor.Object);
+            var context = new DefaultHttpContext();
+            context.User = new ClaimsPrincipal();
+            _mockHttpContextAccessor.Setup(_ => _.HttpContext).Returns(context);
+            controller.ModelState.AddModelError("Message", "Some field is required.");
+            var request = new AccountQueueRequest()
+            {
+                AccountNo = "12345"
+            };
+
+            //act
+            var res = controller.PutSingleAccountOnQueue(request);
+            var badres = res as ObjectResult;
+
+            //asert
+            Assert.Equal(400, badres.StatusCode);
+            _mockService.Verify(x => x.SendRequestToQueue(It.IsAny<ProcessingItem>()), Times.Never);
+        }
+    }
+}
@@ -0,0 +1,172 @@
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Exceptions;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class RefundStatusControllerTest
+    {
+        private RefundStatusController _refundStatusController;
+        private Mock<IRefundStatusService> _refundStatusService;
+        private Mock<IHttpContextAccessor> _httpAccessor;
+
+        public RefundStatusControllerTest()
+        {
+            _refundStatusService = new Mock<IRefundStatusService>();
+            _httpAccessor = new Mock<IHttpContextAccessor>();
+            _refundStatusController = new RefundStatusController(
+                _refundStatusService.Object,
+                _httpAccessor.Object);
+        }
+
+        [Fact]
+        public async void GetById_Ok()
+        {
+            // Arrange
+            _refundStatusService.Setup(service => service.GetAsync(It.IsAny<int>())).ReturnsAsync(
+                new RefundStatus());
+
+            // Act
+            var result = await _refundStatusController.GetById(123);
+
+            // Assert
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+
+            var okValue = okResult.Value;
+            Assert.NotNull(okValue);
+
+            var refundStatus = okValue as RefundStatus;
+            Assert.NotNull(refundStatus);
+        }
+
+        [Fact]
+        public async void GetById_Returns_Bad_Request_Invalid_ID_Equal_to_Zero()
+        {
+            // Act
+            var result = await _refundStatusController.GetById(0);
+
+            // Assert
+            Assert.NotNull(result);
+
+            var badResult = result as BadRequestObjectResult;
+            Assert.NotNull(badResult);
+        }
+
+        [Fact]
+        public async void GetById_Returns_NotFound_On_NFE()
+        {
+            // Arrange
+            _refundStatusService.Setup(service => service.GetAsync(It.IsAny<int>())).ThrowsAsync(
+                new NotFoundException("Refund Status Not Found Test"));
+
+            // Act
+            var result = await _refundStatusController.GetById(123);
+
+            // Assert
+            Assert.NotNull(result);
+
+            var badResult = result as NotFoundObjectResult;
+            Assert.NotNull(badResult);
+
+            var badResultValue = badResult.Value;
+            Assert.NotNull(badResultValue);
+
+            var badResultMessage = badResultValue as string;
+            Assert.NotNull(badResultMessage);
+            Assert.Equal("Refund Status Not Found Test", badResultMessage);
+        }
+
+        [Fact]
+        public async void Post_Ok()
+        {
+            // Arrange
+            _refundStatusService.Setup(service => service.SaveAsync(It.IsAny<RefundStatus>())).ReturnsAsync(
+                new RefundStatus());
+
+            // Act
+            var result = await _refundStatusController.Post(new RefundStatus() {RepoId = 123});
+
+            // Assert
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+
+            var okValue = okResult.Value;
+            Assert.NotNull(okValue);
+
+            var refundStatus = okValue as RefundStatus;
+            Assert.NotNull(refundStatus);
+        }
+
+        [Fact]
+        public async void Post_Returns_Bad_Request_Invalid_ID_Equal_to_Zero()
+        {
+            // Act
+            var result = await _refundStatusController.Post(new RefundStatus() {RepoId = 0});
+
+            // Assert
+            Assert.NotNull(result);
+
+            var badResult = result as BadRequestObjectResult;
+            Assert.NotNull(badResult);
+        }
+
+        [Fact]
+        public async void Put_Ok()
+        {
+            // Arrange
+            _refundStatusService.Setup(service => service.UpdateAsync(It.IsAny<RefundStatus>())).ReturnsAsync(
+                new RefundStatus());
+
+            // Act
+            var result = await _refundStatusController.Put(123, new RefundStatus() {RepoId = 123});
+
+            // Assert
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+
+            var okValue = okResult.Value;
+            Assert.NotNull(okValue);
+
+            var refundStatus = okValue as RefundStatus;
+            Assert.NotNull(refundStatus);
+        }
+
+        [Fact]
+        public async void Put_Returns_Bad_Request_Invalid_ID_Equal_to_Zero()
+        {
+            // Act
+            var result = await _refundStatusController.Put(0, new RefundStatus() {RepoId = 0});
+
+            // Assert
+            Assert.NotNull(result);
+
+            var badResult = result as BadRequestObjectResult;
+            Assert.NotNull(badResult);
+        }
+
+        [Fact]
+        public async void Put_Returns_Bad_Request_Invalid_ID_Mismatch()
+        {
+            // Act
+            var result = await _refundStatusController.Put(123, new RefundStatus() {RepoId = 1234});
+
+            // Assert
+            Assert.NotNull(result);
+
+            var badResult = result as BadRequestObjectResult;
+            Assert.NotNull(badResult);
+        }
+    }
+}
@@ -0,0 +1,359 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Models.Filters;
+using LCU.API.Collections.RepoApi.Models.Requests;
+using LCU.API.Collections.RepoApi.Models.Responses;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Exceptions;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using LCU.Shared.Collections.RepoApiLib.Models.Results;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class RepoAccountControllerTest
+    {
+        private Mock<IRepoAccountService> mockService;
+        private Mock<IRepoStatusChangeService> mockStatusService;
+        private Mock<IRepoLetterService> mockLetterService;
+        private RepoAccountController controller;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public RepoAccountControllerTest()
+        {
+            mockService = new Mock<IRepoAccountService>();
+            mockStatusService = new Mock<IRepoStatusChangeService>();
+            mockLetterService = new Mock<IRepoLetterService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new RepoAccountController(mockService.Object, mockLetterService.Object,
+                mockStatusService.Object, mockHttpContextAccessor.Object);
+        }
+
+        [Fact]
+        public async void Get_OK()
+        {
+            mockService.Setup(service => service.ListAll(It.IsAny<PageFilter>(), It.IsAny<RepoAccountPostFilter>()))
+                .ReturnsAsync(
+                    new PagedResult<RepoAccount>()
+                    {
+                        Total = 1,
+                        Items = new List<RepoAccount>
+                        {
+                            new RepoAccount()
+                            {
+                                RepoId = 5,
+                                AccountNo = "1234567-98"
+                            }
+                        }
+                    });
+
+            // arrange
+            var filter = new PageFilter();
+
+            // act
+            var result = await controller.Get(filter);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as PagedResponse<RepoAccount>;
+            Assert.NotNull(okValue);
+            Assert.Equal(1, okValue.TotalItems);
+        }
+
+        [Fact]
+        public async void Get_Repo_Account_Status_Changes_OK()
+        {
+            // arrange
+            var statusChanges = new List<RepoStatusChange>
+            {
+                new RepoStatusChange()
+                {
+                    Id = 1,
+                    RepoId = 5,
+                    StatusFrom = "None",
+                    StatusTo = "O4R",
+                    ChangedBy = "System",
+                    ChangedDate = DateTime.Now
+                }
+            };
+            mockStatusService.Setup(x => x.ListByAccount(It.IsAny<int>())).ReturnsAsync(statusChanges);
+
+            // act
+            var result = await controller.GetStatusChangesByRepoId(5);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<RepoStatusChange>;
+            Assert.NotNull(okValue);
+            Assert.True(statusChanges.SequenceEqual(okValue));
+        }
+
+        [Fact]
+        public async void Get_Repo_Account_Letters_OK()
+        {
+            // arrange
+            var letters = new List<RepoLetter>
+            {
+                new RepoLetter
+                {
+                    NoticeType = "Type",
+                    DateSent = DateTime.Now,
+                    DateExpired = DateTime.Now.AddDays(15),
+                    DaysToRedeem = 15
+                }
+            };
+            mockLetterService.Setup(x => x.ListByAccountIdAsync(It.IsAny<int>())).ReturnsAsync(letters);
+
+            // act
+            var result = await controller.GetLettersByRepoId(5);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<RepoLetter>;
+            Assert.NotNull(okValue);
+            Assert.True(letters.SequenceEqual(okValue));
+        }
+
+
+        [Fact]
+        public async void GetByAccountNo_OK()
+        {
+            // arrange
+            var repos = new List<RepoAccount>
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Today
+                },
+                new RepoAccount()
+                {
+                    RepoId = 6,
+                    AccountNo = "1234567-98",
+                    DateClosed = DateTime.Today
+                }
+            };
+            mockService.Setup(x => x.GetByAccountNo(It.IsAny<string>())).ReturnsAsync(repos);
+
+            // act
+            var result = await controller.GetByAccountNo("55555-123");
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IReadOnlyCollection<RepoAccount>;
+            Assert.NotNull(okValue);
+            Assert.Equal(5, okValue.First().RepoId);
+        }
+
+        [Fact]
+        public async void GetById_OK()
+        {
+            // arrange
+            var repos = new List<RepoAccount>
+            {
+                new RepoAccount()
+                {
+                    RepoId = 5,
+                    AccountNo = "1234567-98"
+                }
+            };
+            mockService.Setup(x => x.Get(It.IsAny<int>())).ReturnsAsync(repos.First());
+
+            // act
+            var result = await controller.GetById(5);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as RepoAccount;
+            Assert.NotNull(okValue);
+            Assert.Equal(5, okValue.RepoId);
+        }
+
+        // Post tests
+        [Fact]
+        public async void Post_OK()
+        {
+            // arrange
+            var postAlert = new RepoAccount()
+            {
+                AccountNo = "1234567-98",
+                Borrowers = new List<Borrower>()
+                {
+                    new Borrower()
+                    {
+                        RepoId = 0,
+                        IndividualId = "123456",
+                        OwnershipType = 6,
+                        IndividualName = "John Doe"
+                    }
+                },
+                Collaterals = new List<Collateral>
+                {
+                    new Collateral()
+                    {
+                        CollateralId = 1234567,
+                        RepoId = 2345678
+                    }
+                }
+            };
+
+            // act
+            var result = await controller.Post(postAlert);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Bad_Request()
+        {
+            // arrange
+            var postAlert = new RepoAccount()
+            {
+                AccountNo = "1234567-98",
+            };
+            controller.ModelState.AddModelError("Message", "The message field is required.");
+
+            // act
+            var result = await controller.Post(postAlert);
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            // assert
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Search_Ok()
+        {
+            // arrange
+            var searchPhrase = "abcd123";
+            mockService.Setup(service => service.SearchRepoAccounts(It.IsAny<string>(), It.IsAny<int>())).ReturnsAsync(
+                new List<RepoAccount>()
+                {
+                    new RepoAccount(),
+                    new RepoAccount(),
+                    new RepoAccount()
+                });
+
+            // act
+            var result = await controller.SearchRepoAccounts(searchPhrase);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+
+            var okResultValue = okResult.Value as IReadOnlyCollection<RepoAccount>;
+            Assert.NotNull(okResultValue);
+            Assert.Equal(3, okResultValue.Count());
+        }
+
+        [Fact]
+        public async void Search_Empty_Bad_Request()
+        {
+            // arrange
+            var searchPhrase = "";
+
+            // act
+            var result = await controller.SearchRepoAccounts(searchPhrase);
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            // assert
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+            Assert.Equal("Search Phrase Cannot Be Empty", badRequestResult.Value);
+        }
+
+        [Fact]
+        public async void Search_Low_Characters_Bad_Request()
+        {
+            // arrange
+            var searchPhrase = "12";
+
+            // act
+            var result = await controller.SearchRepoAccounts(searchPhrase);
+            Assert.NotNull(result);
+            var badRequestResult = result as BadRequestObjectResult;
+
+            // assert
+            Assert.NotNull(badRequestResult);
+            Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
+            Assert.Equal("Search Phrase Must Be At Least Three (3) Characters Long", badRequestResult.Value);
+        }
+
+        [Fact]
+        public async void Search_Max_Results_Bad_Request()
+        {
+            // arrange
+            var searchPhrase = "143";
+            mockService.Setup(service => service.SearchRepoAccounts(It.IsAny<string>(), It.IsAny<int>()))
+                .ThrowsAsync(new MaxItemException(1492));
+
+            // act
+            var result = await controller.SearchRepoAccounts(searchPhrase);
+            Assert.NotNull(result);
+            var payloadTooLargeResult = result as ObjectResult;
+
+            // assert
+            Assert.NotNull(payloadTooLargeResult);
+            Assert.Equal(StatusCodes.Status413PayloadTooLarge, payloadTooLargeResult.StatusCode);
+            Assert.Equal("Too Many Search Results. (Max: 100) (Found: 1492)", payloadTooLargeResult.Value);
+        }
+
+        [Fact]
+        public async void DeleteAccountByID_Exception()
+        {
+            //arrange
+            mockService.Setup(service => service.DeleteAsync(It.IsAny<int>())).ThrowsAsync(new Exception("oops"));
+
+            var result = await controller.DeleteAccountById(5);
+            var badres = result as StatusCodeResult;
+            Assert.NotNull(result);
+            Assert.Equal(500, badres.StatusCode);
+        }
+
+        [Fact]
+        public async void DeleteAccountByID_Ok()
+        {
+            //arrange
+            mockService.Setup(service => service.DeleteAsync(It.IsAny<int>())).ReturnsAsync(new RepoAccount() { });
+
+            var result = await controller.DeleteAccountById(5);
+            var okres = result as OkObjectResult;
+            Assert.NotNull(result);
+            Assert.Equal(200, okres.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class RepoCompanyControllerTest
+    {
+        private Mock<IRepoCompanyService> mockService;
+        private RepoCompanyController controller;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public RepoCompanyControllerTest()
+        {
+            mockService = new Mock<IRepoCompanyService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller =
+                new RepoCompanyController(mockService.Object, mockHttpContextAccessor.Object);
+        }
+
+        [Fact]
+        public async void Get_OK()
+        {
+            var repoCompanyList = getMockCompanyList();
+
+            mockService.Setup(service => service.ListAll()).ReturnsAsync(repoCompanyList);
+
+            var result = await controller.Get();
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<RepoCompany>;
+            Assert.NotNull(okValue);
+
+            var repoEnum = okValue.GetEnumerator();
+
+            repoEnum.MoveNext();
+            var firstValue = repoEnum.Current;
+            Assert.Equal(repoCompanyList[0], firstValue);
+        }
+
+        [Fact]
+        public async void Post_Ok()
+        {
+            var repoCompanyList = getMockCompanyList();
+
+            mockService.Setup(service => service.Save(It.IsAny<RepoCompany>())).ReturnsAsync(repoCompanyList[0]);
+
+            var result = await controller.Post(repoCompanyList[0]);
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as RepoCompany;
+            Assert.Equal(repoCompanyList[0], okValue);
+        }
+
+        private IList<RepoCompany> getMockCompanyList()
+        {
+            return new List<RepoCompany>
+            {
+                getMockCompany()
+            };
+        }
+
+        private RepoCompany getMockCompany()
+        {
+            return new RepoCompany() {ID = 1, Email = "[email protected]", Name = "A Inc."};
+        }
+    }
+}
@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Exceptions;
+using LCU.API.Collections.RepoApi.Models.Responses;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class RepoCompanySelectionControllerTest
+    {
+        private RepoCompanySelectionController _controller;
+        private Mock<IRepoCompanySelectionService> _mockService;
+        private Mock<IHttpContextAccessor> _mockHttpContextAccessor;
+
+        public RepoCompanySelectionControllerTest()
+        {
+            _mockService = new Mock<IRepoCompanySelectionService>();
+            _mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            _controller = new RepoCompanySelectionController(
+                _mockService.Object,
+                _mockHttpContextAccessor.Object);
+        }
+
+        [Fact]
+        public async void Get_Ok()
+        {
+            // Arrange
+            _mockService.Setup(service => service.ListAllAsync()).ReturnsAsync(new List<RepoCompanySelection>()
+            {
+                new RepoCompanySelection(),
+                new RepoCompanySelection()
+            });
+
+            // Act
+            var result = await _controller.Get();
+
+            // Assert
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.NotNull(okResult.Value);
+
+            var repoCompanySelectionList = okResult.Value as IEnumerable<RepoCompanySelection>;
+            Assert.NotNull(repoCompanySelectionList);
+            Assert.Equal(2, repoCompanySelectionList.Count());
+        }
+
+        [Fact]
+        public async void Get_ById_Ok()
+        {
+            // Arrange
+            _mockService.Setup(service => service.GetAsync(It.IsAny<int>())).ReturnsAsync(new RepoCompanySelection()
+            {
+                RepoCompanyId = 5
+            });
+
+            // Act
+            var result = await _controller.Get(42);
+
+            // Assert
+            Assert.NotNull(result);
+
+            var okResult = result as OkObjectResult;
+            Assert.NotNull(okResult);
+            Assert.NotNull(okResult.Value);
+
+            var repoCompanySelection = okResult.Value as RepoCompanySelection;
+            Assert.NotNull(repoCompanySelection);
+            Assert.Equal(5, repoCompanySelection.RepoCompanyId);
+        }
+
+        [Fact]
+        public async void Get_ById_Invalid_ID()
+        {
+            // Act
+            var result = await _controller.Get(0);
+
+            // Assert
+            Assert.NotNull(result);
+
+            var badRequestResult = result as BadRequestObjectResult;
+            Assert.NotNull(badRequestResult);
+            Assert.Equal("Invalid ID", badRequestResult.Value);
+        }
+
+        [Fact]
+        public async void Get_ById_Not_Found()
+        {
+            // Arrange
+            _mockService.Setup(service => service.GetAsync(It.IsAny<int>()))
+                .ThrowsAsync(new NotFoundException("Not Found in Get"));
+
+            // Act
+            var result = await _controller.Get(1);
+
+            // Assert
+            Assert.NotNull(result);
+
+            var notFoundRequest = result as NotFoundObjectResult;
+            Assert.NotNull(notFoundRequest);
+            Assert.Equal("Not Found in Get", notFoundRequest.Value);
+        }
+    }
+}
@@ -0,0 +1,81 @@
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Models.Requests;
+using LCU.API.Collections.RepoApi.Services.Reporting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class ReportingControllerTest
+    {
+        private readonly ReportingController controller;
+        private readonly Mock<ILandmarkReportingService> mockLandmarkReportingService;
+        private readonly Mock<IAuctionReportingService> mockAuctionReportingService;
+        private readonly Mock<IRepoCompanyReportingService> mockRepoCompanyReportingService;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public ReportingControllerTest()
+        {
+            mockLandmarkReportingService = new Mock<ILandmarkReportingService>();
+            mockAuctionReportingService = new Mock<IAuctionReportingService>();
+            mockRepoCompanyReportingService = new Mock<IRepoCompanyReportingService>();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new ReportingController(
+                mockHttpContextAccessor.Object,
+                mockLandmarkReportingService.Object,
+                mockAuctionReportingService.Object,
+                mockRepoCompanyReportingService.Object);
+        }
+
+        [Fact]
+        public async void Get_Gross_Amount_OK()
+        {
+            // arrange
+            var request = new ReportingRequest();
+           
+            // act
+            var result = await controller.GetAuctionAssignedBalance(request);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Get_Active_Account_OK()
+        {
+            // arrange
+            var request = new ReportingRequest();
+           
+            // act
+            var result = await controller.GetIsActiveAccount(request);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Get_Closed_Account_OK()
+        {
+            // arrange
+            var request = new ReportingRequest();
+           
+            // act
+            var result = await controller.GetIsClosedAccount(request);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+    }
+}
@@ -0,0 +1,370 @@
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models.Settings;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class SettingsControllerTest
+    {
+        private readonly Mock<ISettingsService> mockSettingsService;
+        private readonly Settings settings;
+        private readonly SettingsController controller;
+        private readonly Mock<IHttpContextAccessor> mockHttpContextAccessor;
+
+        public SettingsControllerTest()
+        {
+            mockSettingsService = new Mock<ISettingsService>();
+            settings = new Settings();
+            mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            controller = new SettingsController(mockSettingsService.Object,
+                mockHttpContextAccessor.Object);
+        }
+
+        // Get tests
+        [Fact]
+        public async void Get_OK()
+        {
+            // arrange
+            mockSettingsService.Setup(x => x.ListAllSettingsAsync()).ReturnsAsync(settings);
+
+            // act
+            var result = await controller.Get();
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as Settings;
+            Assert.NotNull(okValue);
+            Assert.Equal(settings, okValue);
+        }
+
+        // Put tests
+        [Fact]
+        public async void Put_Account_Type_OK()
+        {
+            // arrange
+            var putAccountType = new AccountType();
+
+            // act
+            var result = await controller.PutAccountType(putAccountType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_Allowed_Status_Change_OK()
+        {
+            // arrange
+            var putAllowedStatusChange = new AllowedStatusChange();
+
+            // act
+            var result = await controller.PutAllowedStatusChange(putAllowedStatusChange);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_Body_Style_OK()
+        {
+            // arrange
+            var putBodyStyle = new BodyStyle();
+
+            // act
+            var result = await controller.PutBodyStyle(putBodyStyle);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_Cleaning_Level_OK()
+        {
+            // arrange
+            var putCleaningLevel = new CleaningLevel();
+
+            // act
+            var result = await controller.PutCleaningLevel(putCleaningLevel);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_CollateralType_OK()
+        {
+            // arrange
+            var putCollateralType = new CollateralType();
+
+            // act
+            var result = await controller.PutCollateralType(putCollateralType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_CollateralTypeToVehicleType_OK()
+        {
+            // arrange
+            var putCollateralToVehicle = new CollateralTypeToVehicleType();
+
+            // act
+            var result = await controller.PutCollateralTypeToVehicleType(putCollateralToVehicle);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_Hold_Status_OK()
+        {
+            // arrange
+            var putHoldStatus = new HoldStatus();
+
+            // act
+            var result = await controller.PutHoldStatus(putHoldStatus);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_Loan_Category_OK()
+        {
+            // arrange
+            var putLoanCategory = new LoanCategory();
+
+            // act
+            var result = await controller.PutLoanCategory(putLoanCategory);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_Location_Type_OK()
+        {
+            // arrange
+            var putLocationType = new LocationType();
+
+            // act
+            var result = await controller.PutLocationType(putLocationType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Put_Vehicle_Type_OK()
+        {
+            // arrange
+            var putVehicleType = new VehicleType();
+
+            // act
+            var result = await controller.PutVehicleType(putVehicleType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        // Post tests
+        [Fact]
+        public async void Post_Account_Type_OK()
+        {
+            // arrange
+            var postAccountType = new AccountType();
+
+            // act
+            var result = await controller.PostAccountType(postAccountType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Allowed_Status_Change_OK()
+        {
+            // arrange
+            var postStatusChange = new AllowedStatusChange();
+
+            // act
+            var result = await controller.PostAllowedStatusChange(postStatusChange);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Body_Style_OK()
+        {
+            // arrange
+            var postBodyStyle = new BodyStyle();
+
+            // act
+            var result = await controller.PostBodyStyle(postBodyStyle);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Cleaning_Level_OK()
+        {
+            // arrange
+            var postCleaningLevel = new CleaningLevel();
+
+            // act
+            var result = await controller.PostCleaningLevel(postCleaningLevel);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Collateral_Type_OK()
+        {
+            // arrange
+            var postCollateralType = new CollateralType();
+
+            // act
+            var result = await controller.PostCollateralType(postCollateralType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Collateral_Type_To_Vehicle_Type_OK()
+        {
+            // arrange
+            var postCollateralTypeToVehicleType = new CollateralTypeToVehicleType();
+
+            // act
+            var result = await controller.PostCollateralTypeToVehicleType(postCollateralTypeToVehicleType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Hold_Status_OK()
+        {
+            // arrange
+            var postHoldStatus = new HoldStatus();
+
+            // act
+            var result = await controller.PostHoldStatus(postHoldStatus);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Loan_Category_OK()
+        {
+            // arrange
+            var postLoanCategory = new LoanCategory();
+
+            // act
+            var result = await controller.PostLoanCategory(postLoanCategory);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Location_Type_OK()
+        {
+            // arrange
+            var postLocationType = new LocationType();
+
+            // act
+            var result = await controller.PostLocationType(postLocationType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+
+        [Fact]
+        public async void Post_Vehicle_Type_OK()
+        {
+            // arrange
+            var postVehicleType = new VehicleType();
+
+            // act
+            var result = await controller.PostVehicleType(postVehicleType);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Linq;
+using LCU.API.Collections.RepoApi.Controllers;
+using LCU.API.Collections.RepoApi.Services;
+using LCU.Shared.Collections.RepoApiLib.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace LCU.API.Collections.RepoApiTests.Controllers
+{
+    public class VehicleFloorPricingParametersControllerTest
+    {
+        // Get tests
+        [Fact]
+        public async void Get_OK()
+        {
+            var mockService = new Mock<IVehicleFloorPricingParametersService>();
+            var mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            var parameters = new List<VehicleFloorPricingParameters>
+            {
+                new VehicleFloorPricingParameters()
+                {
+                    Id = 1,
+                    LowCondition = 0.0m,
+                    HighCondition = 1.5m,
+                    NADAFirstValue = "Low Value",
+                    NADASecondValue = "Low Value",
+                    MMRAdjustedValue = "Regional Value",
+                    PercentageOf = 95.00m
+                }
+            };
+            mockService.Setup(x => x.ListAll()).ReturnsAsync(parameters);
+
+            // arrange
+            var controller = new VehicleFloorPricingParametersController(mockService.Object,
+                mockHttpContextAccessor.Object);
+
+            // act
+            var result = await controller.Get();
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as IEnumerable<VehicleFloorPricingParameters>;
+            Assert.NotNull(okValue);
+            Assert.True(parameters.SequenceEqual(okValue));
+        }
+
+        [Fact]
+        public async void GetById_OK()
+        {
+            var mockService = new Mock<IVehicleFloorPricingParametersService>();
+            var mockHttpContextAccessor = new Mock<IHttpContextAccessor>();
+            var repos = new List<VehicleFloorPricingParameters>
+            {
+                new VehicleFloorPricingParameters()
+                {
+                    Id = 1,
+                    LowCondition = 0.0m,
+                    HighCondition = 1.5m,
+                    NADAFirstValue = "Low Value",
+                    NADASecondValue = "Low Value",
+                    MMRAdjustedValue = "Regional Value",
+                    PercentageOf = 95.00m
+                }
+            };
+            mockService.Setup(x => x.Get(It.IsAny<int>())).ReturnsAsync(repos.First());
+
+            // arrange
+            var controller = new VehicleFloorPricingParametersController(mockService.Object,
+                mockHttpContextAccessor.Object);
+
+            // act
+            var result = await controller.GetById(1234567);
+            Assert.NotNull(result);
+            var okResult = result as OkObjectResult;
+
+            // assert
+            Assert.NotNull(okResult);
+            Assert.Equal(200, okResult.StatusCode);
+
+            var okValue = okResult.Value as VehicleFloorPricingParameters;
+            Assert.NotNull(okValue);
+            Assert.Equal(1, okValue.Id);
+        }
+    }
+}