Adding

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ControllerTests/RateControllerTest.cs

@@ -0,0 +1,716 @@
+using Microsoft.AspNetCore.Mvc;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.API.Internal.LoanRate.Controllers;
+using LCU.API.Internal.LoanRate.Services;
+namespace LCU.API.Internal.LoanRateTests.ControllerTests;
+
+public class RateControllerTest
+{
+    private readonly Mock<IRateService> _mockRateService;
+    private readonly RateController _controller;
+
+    public RateControllerTest()
+    {
+        _mockRateService = new Mock<IRateService>();
+        _controller = new RateController(_mockRateService.Object);
+    }
+
+    [Fact]
+    public async void Rate_Get_OK()
+    {
+        var rateId = 1;
+        var rates = new List<Rate>
+        {
+            new()
+            {
+                RateId = rateId
+            }
+        };
+
+        _mockRateService.Setup(x => x.GetAsync()).ReturnsAsync(rates).Verifiable();
+
+        var result = await _controller.Get();
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var RateResult = status.Value as List<Rate>;
+        Assert.NotNull(RateResult);
+        Assert.Single(RateResult);
+        Assert.Equal(rateId, RateResult.First().RateId);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Get_NoContent()
+    {
+        var rates = new List<Rate>();
+
+        _mockRateService.Setup(x => x.GetAsync()).ReturnsAsync(rates).Verifiable();
+
+        var result = await _controller.Get();
+        Assert.NotNull(result);
+
+        Assert.IsType<NoContentResult>(result);
+        var status = result as NoContentResult;
+        Assert.NotNull(status);
+        Assert.Equal(204, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Get_InternalServerError()
+    {
+        _mockRateService.Setup(x => x.GetAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Get();
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetById_OK()
+    {
+        var rateId = 1;
+        var rate = new Rate
+        {
+            RateId = rateId
+        };
+
+        _mockRateService.Setup(x => x.GetByIdAsync(rateId))
+            .ReturnsAsync(rate).Verifiable();
+
+        var result = await _controller.GetById(rateId);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var RateResult = status.Value as Rate;
+        Assert.NotNull(RateResult);
+        Assert.Equal(rateId, RateResult.RateId);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetById_NoContent()
+    {
+        var rateId = 1;
+        Rate? rate = null;
+
+        _mockRateService.Setup(x => x.GetByIdAsync(rateId))
+            .ReturnsAsync(rate).Verifiable();
+
+        var result = await _controller.GetById(rateId);
+        Assert.NotNull(result);
+
+        Assert.IsType<NoContentResult>(result);
+        var status = result as NoContentResult;
+        Assert.NotNull(status);
+        Assert.Equal(204, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetById_BadRequest()
+    {
+        var rateId = 0;
+
+        var result = await _controller.GetById(rateId);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_GetById_InternalServerError()
+    {
+        var rateId = 1;
+        _mockRateService.Setup(x => x.GetByIdAsync(rateId))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.GetById(rateId);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetListById_OK()
+    {
+        var rateIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        var rates = new List<Rate>
+        {
+            new() { RateId = rateIds[0] },
+            new() { RateId = rateIds[1] },
+            new() { RateId = rateIds[2] }
+        };
+
+        _mockRateService.Setup(x => x.GetRangeByIdAsync(rateIds))
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = await _controller.GetListById(rateIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var rateResult = status.Value as List<Rate>;
+        Assert.NotNull(rateResult);
+        Assert.Equal(rateIds[0], rateResult[0].RateId);
+        Assert.Equal(rateIds[1], rateResult[1].RateId);
+        Assert.Equal(rateIds[2], rateResult[2].RateId);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetListById_NoContent()
+    {
+        var rateIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        List<Rate>? rates = null;
+
+        _mockRateService.Setup(x => x.GetRangeByIdAsync(rateIds))
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = await _controller.GetListById(rateIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<NoContentResult>(result);
+        var status = result as NoContentResult;
+        Assert.NotNull(status);
+        Assert.Equal(204, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetListById_BadRequest()
+    {
+        List<int>? rateIds = null;
+
+        var result = await _controller.GetListById(rateIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_GetListById_InternalServerError()
+    {
+        var rateIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        _mockRateService.Setup(x => x.GetRangeByIdAsync(rateIds))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.GetListById(rateIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Post_CreatedAtAction()
+    {
+        var rateId = 1;
+        var Value = Guid.NewGuid().ToString();
+        var rate = new Rate
+        {
+            Value = 5.59M
+        };
+        var rateReturned = new Rate
+        {
+            RateId = rateId,
+            Value = 5.59M
+        };
+
+        _mockRateService.Setup(x => x.SaveAsync(rate))
+            .ReturnsAsync(rateReturned).Verifiable();
+
+        var result = await _controller.Post(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<CreatedAtActionResult>(result);
+        var status = result as CreatedAtActionResult;
+        Assert.NotNull(status);
+        Assert.Equal(201, status.StatusCode);
+
+        var resultValue = status.Value as Rate;
+        Assert.NotNull(result);
+        Assert.NotNull(resultValue);
+        Assert.Equal(rateReturned.RateId, resultValue.RateId);
+        Assert.Equal(rateReturned.Value, resultValue.Value);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Post_BadRequest()
+    {
+        Rate? rate = null;
+
+        var result = await _controller.Post(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_Post_InternalServerError()
+    {
+        var rate = new Rate
+        {
+            RateId = 1
+        };
+        _mockRateService.Setup(x => x.SaveAsync(rate))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Post(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_SaveRange_Ok()
+    {
+        var rates = new List<Rate>
+        {
+            new() { Value = 5.60M },
+            new() { Value = 5.59M },
+            new() { Value = 5.61M }
+        };
+
+        _mockRateService.Setup(x => x.SaveRangeAsync(rates));
+
+        var result = await _controller.SaveRange(rates);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkResult>(result);
+        var status = result as OkResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_SaveRange_BadRequest()
+    {
+        List<Rate>? rates = null;
+
+        var result = await _controller.SaveRange(rates);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_SaveRange_InternalServerError()
+    {
+        var rates = new List<Rate>
+        {
+            new() { Value = 5.60M },
+            new() { Value = 5.59M },
+            new() { Value = 5.61M }
+        };
+        _mockRateService.Setup(x => x.SaveRangeAsync(rates))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.SaveRange(rates);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Put_OK()
+    {
+        var rateId = 1;
+        var value = 5.60M;
+        var rate = new Rate
+        {
+            RateId = rateId,
+            Value = value
+        };
+        var rateReturned = new Rate
+        {
+            RateId = rateId,
+            Value = value
+        };
+
+        _mockRateService.Setup(x => x.UpdateAsync(rate))
+            .ReturnsAsync(rateReturned).Verifiable();
+
+        var result = await _controller.Put(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var rateResult = status.Value as Rate;
+        Assert.NotNull(rateResult);
+        Assert.Equal(rate.Value, rateResult.Value);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Put_Status406NotAcceptable()
+    {
+        var rate = new Rate
+        {
+            RateId = 1
+        };
+
+        var result = await _controller.Put(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(406, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_Put_BadRequest_NoIds()
+    {
+        var rate = new Rate
+        {
+            Value = 5.59M
+        };
+
+        var result = await _controller.Put(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+        _mockRateService.Verify(x => x.GetAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void Rate_Put_BadRequest()
+    {
+        Rate? rate = null;
+
+        var result = await _controller.Put(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_Put_InternalServerError()
+    {
+        var rate = new Rate
+        {
+            RateId = 1
+        };
+        _mockRateService.Setup(x => x.UpdateAsync(rate))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Put(rate);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_UpdateRange_OK()
+    {
+        var values = new List<decimal>
+        {
+            5.60M,
+            5.61M,
+            5.62M
+        };
+        var rates = new List<Rate>
+        {
+            new() 
+            { 
+                RateId = 1,
+                Value = values[0] 
+            },
+            new() 
+            {
+                RateId = 2,
+                Value = values[1] 
+            },
+            new() 
+            {
+                RateId = 3,
+                Value = values[2] 
+            }
+        };
+
+        var ratesReturned = new List<Rate>
+        {
+            new()
+            {
+                RateId = 1,
+                Value = values[0]
+            },
+            new()
+            {
+                RateId = 2,
+                Value = values[1]
+            },
+            new()
+            {
+                RateId = 3,
+                Value = values[2]
+            }
+        };
+
+        _mockRateService.Setup(x => x.UpdateRangeAsync(rates))
+            .ReturnsAsync(ratesReturned).Verifiable();
+
+        var result = await _controller.UpdateRange(rates);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var rateResult = status.Value as List<Rate>;
+        Assert.NotNull(rateResult);
+        Assert.Equal(rates[0].Value, rateResult[0].Value);
+        Assert.Equal(rates[1].Value, rateResult[1].Value);
+        Assert.Equal(rates[2].Value, rateResult[2].Value);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_UpdateRange_BadRequest_NoIds()
+    {
+        var rates = new List<Rate>
+        {
+            new ()
+            {
+                Value = 5.60M
+            },
+            new ()
+            {
+                Value = 5.61M
+            }
+        };
+
+        var result = await _controller.UpdateRange(rates);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+        _mockRateService.Verify(x => x.GetAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void Rate_UpdateRange_BadRequest()
+    {
+        List<Rate>? rates = null;
+
+        var result = await _controller.UpdateRange(rates);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_UpdateRange_InternalServcerError()
+    {
+        var rates = new List<Rate>
+        {
+            new ()
+            {
+                RateId = 1,
+                Value = 5.60M
+            },
+            new ()
+            {
+                RateId = 2,
+                Value = 5.61M
+            }
+        };
+        _mockRateService.Setup(x => x.UpdateRangeAsync(rates))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.UpdateRange(rates);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Delete_OK()
+    {
+        var rateId = 1;
+
+        _mockRateService.Setup(x => x.DeleteAsync(rateId)).Verifiable();
+
+        var result = await _controller.Delete(rateId);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkResult>(result);
+        var status = result as OkResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_Delete_BadRequest()
+    {
+        var rateId = 0;
+
+        var result = await _controller.Delete(rateId);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_Delete_InternalServerError()
+    {
+        var rateId = 1;
+        _mockRateService.Setup(x => x.DeleteAsync(rateId))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Delete(rateId);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_DeleteRange_OK()
+    {
+        var rateIds = new List<int>
+        {
+            1,
+            1,
+            1
+        };
+
+        _mockRateService.Setup(x => x.DeleteRangeAsync(rateIds)).Verifiable();
+
+        var result = await _controller.DeleteRange(rateIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkResult>(result);
+        var status = result as OkResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateService.Verify();
+    }
+
+    [Fact]
+    public async void Rate_DeleteRange_BadRequest()
+    {
+        var rateIds = new List<int>();
+
+        var result = await _controller.DeleteRange(rateIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void Rate_DeleteRange_InternalServerError()
+    {
+        var rateIds = new List<int>
+        {
+            1
+        };
+        _mockRateService.Setup(x => x.DeleteRangeAsync(rateIds))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.DeleteRange(rateIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateService.Verify();
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ControllerTests/RateEvaluationControllerTest.cs

@@ -0,0 +1,765 @@
+using Microsoft.AspNetCore.Mvc;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.API.Internal.LoanRate.Controllers;
+namespace LCU.API.Internal.LoanRateTests.ControllerTests;
+
+public class RateEvaluationControllerTest
+{
+    private readonly Mock<IRateEvaluationService> _mockRateEvaluationService;
+    private readonly RateEvaluationController _controller;
+
+    public RateEvaluationControllerTest()
+    {
+        _mockRateEvaluationService = new Mock<IRateEvaluationService>();
+        _controller = new RateEvaluationController(_mockRateEvaluationService.Object);
+    }
+
+    [Fact]
+    public async void RateEvaluation_Get_OK()
+    {
+        var rateEvaluationId = 1;
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new()
+            {
+                RateEvaluationId = rateEvaluationId
+            }
+        };
+
+        _mockRateEvaluationService.Setup(x => x.GetAsync()).ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = await _controller.Get();
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var RateEvaluationResult = status.Value as List<RateEvaluation>;
+        Assert.NotNull(RateEvaluationResult);
+        Assert.Single(RateEvaluationResult);
+        Assert.Equal(rateEvaluationId, RateEvaluationResult.First().RateEvaluationId);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Get_NoContent()
+    {
+        var rateEvaluations = new List<RateEvaluation>();
+
+        _mockRateEvaluationService.Setup(x => x.GetAsync()).ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = await _controller.Get();
+        Assert.NotNull(result);
+
+        Assert.IsType<NoContentResult>(result);
+        var status = result as NoContentResult;
+        Assert.NotNull(status);
+        Assert.Equal(204, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Get_InternalServerError()
+    {
+        _mockRateEvaluationService.Setup(x => x.GetAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Get();
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetById_OK()
+    {
+        var rateEvaluationId = 1;
+        var rateEvaluation = new RateEvaluation
+        {
+            RateEvaluationId = rateEvaluationId
+        };
+
+        _mockRateEvaluationService.Setup(x => x.GetByIdAsync(rateEvaluationId))
+            .ReturnsAsync(rateEvaluation).Verifiable();
+
+        var result = await _controller.GetById(rateEvaluationId);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var rateEvaluationResult = status.Value as RateEvaluation;
+        Assert.NotNull(rateEvaluationResult);
+        Assert.Equal(rateEvaluationId, rateEvaluationResult.RateEvaluationId);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetById_NoContent()
+    {
+        var rateEvaluationId = 1;
+        RateEvaluation? rateEvaluation = null;
+
+        _mockRateEvaluationService.Setup(x => x.GetByIdAsync(rateEvaluationId))
+            .ReturnsAsync(rateEvaluation).Verifiable();
+
+        var result = await _controller.GetById(rateEvaluationId);
+        Assert.NotNull(result);
+
+        Assert.IsType<NoContentResult>(result);
+        var status = result as NoContentResult;
+        Assert.NotNull(status);
+        Assert.Equal(204, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetById_BadRequest()
+    {
+        var rateEvaluationId = 0;
+
+        var result = await _controller.GetById(rateEvaluationId);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetById_InternalServerError()
+    {
+        var rateEvaluationId = 1;
+        _mockRateEvaluationService.Setup(x => x.GetByIdAsync(rateEvaluationId))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.GetById(rateEvaluationId);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetListById_OK()
+    {
+        var rateEvaluationIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new() { RateEvaluationId = rateEvaluationIds[0] },
+            new() { RateEvaluationId = rateEvaluationIds[1] },
+            new() { RateEvaluationId = rateEvaluationIds[2] }
+        };
+
+        _mockRateEvaluationService.Setup(x => x.GetRangeByIdAsync(rateEvaluationIds))
+            .ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = await _controller.GetListById(rateEvaluationIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var rateEvaluationResult = status.Value as List<RateEvaluation>;
+        Assert.NotNull(rateEvaluationResult);
+        Assert.Equal(rateEvaluationIds[0], rateEvaluationResult[0].RateEvaluationId);
+        Assert.Equal(rateEvaluationIds[1], rateEvaluationResult[1].RateEvaluationId);
+        Assert.Equal(rateEvaluationIds[2], rateEvaluationResult[2].RateEvaluationId);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetListById_NoContent()
+    {
+        var rateEvaluationIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        List<RateEvaluation>? rateEvaluations = null;
+
+        _mockRateEvaluationService.Setup(x => x.GetRangeByIdAsync(rateEvaluationIds))
+            .ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = await _controller.GetListById(rateEvaluationIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<NoContentResult>(result);
+        var status = result as NoContentResult;
+        Assert.NotNull(status);
+        Assert.Equal(204, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetListById_BadRequest()
+    {
+        List<int>? rateEvaluationIds = null;
+
+        var result = await _controller.GetListById(rateEvaluationIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetListById_InternalServerError()
+    {
+        var rateEvaluationIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        _mockRateEvaluationService.Setup(x => x.GetRangeByIdAsync(rateEvaluationIds))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.GetListById(rateEvaluationIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Post_CreatedAtAction()
+    {
+        var rateEvaluationId = 1;
+        var Value = Guid.NewGuid().ToString();
+        var rateEvaluation = new RateEvaluation
+        {
+            EvaluationDetailId = 1
+        };
+        var rateEvaluationReturned = new RateEvaluation
+        {
+            RateEvaluationId = rateEvaluationId,
+            EvaluationDetailId = 1
+        };
+
+        _mockRateEvaluationService.Setup(x => x.SaveAsync(rateEvaluation))
+            .ReturnsAsync(rateEvaluationReturned).Verifiable();
+
+        var result = await _controller.Post(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<CreatedAtActionResult>(result);
+        var status = result as CreatedAtActionResult;
+        Assert.NotNull(status);
+        Assert.Equal(201, status.StatusCode);
+
+        var resultValue = status.Value as RateEvaluation;
+        Assert.NotNull(result);
+        Assert.NotNull(resultValue);
+        Assert.Equal(rateEvaluationReturned.RateEvaluationId, resultValue.RateEvaluationId);
+        Assert.Equal(rateEvaluationReturned.EvaluationDetailId, resultValue.EvaluationDetailId);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Post_BadRequest()
+    {
+        RateEvaluation? rateEvaluation = null;
+
+        var result = await _controller.Post(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_Post_InternalServerError()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            EvaluationDetailId = 1
+        };
+        _mockRateEvaluationService.Setup(x => x.SaveAsync(rateEvaluation))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Post(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_SaveRange_Ok()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new() { EvaluationDetailId = 1 },
+            new() { EvaluationDetailId = 2 },
+            new() { EvaluationDetailId = 3 }
+        };
+
+        _mockRateEvaluationService.Setup(x => x.SaveRangeAsync(rateEvaluations));
+
+        var result = await _controller.SaveRange(rateEvaluations);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkResult>(result);
+        var status = result as OkResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_SaveRange_BadRequest()
+    {
+        List<RateEvaluation>? rateEvaluations = null;
+
+        var result = await _controller.SaveRange(rateEvaluations);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_SaveRange_InternalServerError()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new() { EvaluationDetailId = 1 },
+            new() { EvaluationDetailId = 2 },
+            new() { EvaluationDetailId = 3 }
+        };
+        _mockRateEvaluationService.Setup(x => x.SaveRangeAsync(rateEvaluations))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.SaveRange(rateEvaluations);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Put_OK()
+    {
+        var rateEvaluationId = 1;
+        var rateEvaluation = new RateEvaluation
+        {
+            RateEvaluationId = rateEvaluationId,
+            EvaluationDetailId = 1
+        };
+        var RateEvaluationReturned = new RateEvaluation
+        {
+            RateEvaluationId = rateEvaluationId,
+            EvaluationDetailId = 1
+        };
+
+        _mockRateEvaluationService.Setup(x => x.UpdateAsync(rateEvaluation))
+            .ReturnsAsync(RateEvaluationReturned).Verifiable();
+
+        var result = await _controller.Put(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var rateEvaluationResult = status.Value as RateEvaluation;
+        Assert.NotNull(rateEvaluationResult);
+        Assert.Equal(rateEvaluation.EvaluationDetailId, rateEvaluationResult.EvaluationDetailId);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Put_Status406NotAcceptable()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            RateEvaluationId = 1
+        };
+
+        var result = await _controller.Put(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(406, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_Put_BadRequest_NoIds()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            EvaluationDetailId = 1
+        };
+
+        var result = await _controller.Put(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+        _mockRateEvaluationService.Verify(x => x.GetAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void RateEvaluation_Put_BadRequest()
+    {
+        RateEvaluation? rateEvaluation = null;
+
+        var result = await _controller.Put(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_Put_InternalServerError()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            RateEvaluationId = 1
+        };
+        _mockRateEvaluationService.Setup(x => x.UpdateAsync(rateEvaluation))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Put(rateEvaluation);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_UpdateRange_OK()
+    {
+        var evaluationDetailIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new() 
+            { 
+                RateEvaluationId = 1,
+                EvaluationDetailId = evaluationDetailIds[0] 
+            },
+            new() 
+            {
+                RateEvaluationId = 2,
+                EvaluationDetailId = evaluationDetailIds[1] 
+            },
+            new() 
+            {
+                RateEvaluationId = 3,
+                EvaluationDetailId = evaluationDetailIds[2] 
+            }
+        };
+
+        var rateEvaluationsReturned = new List<RateEvaluation>
+        {
+            new()
+            {
+                RateEvaluationId = 1,
+                EvaluationDetailId = evaluationDetailIds[0]
+            },
+            new()
+            {
+                RateEvaluationId = 2,
+                EvaluationDetailId = evaluationDetailIds[1]
+            },
+            new()
+            {
+                RateEvaluationId = 3,
+                EvaluationDetailId = evaluationDetailIds[2]
+            }
+        };
+
+        _mockRateEvaluationService.Setup(x => x.UpdateRangeAsync(rateEvaluations))
+            .ReturnsAsync(rateEvaluationsReturned).Verifiable();
+
+        var result = await _controller.UpdateRange(rateEvaluations);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+
+        var rateEvaluationResult = status.Value as List<RateEvaluation>;
+        Assert.NotNull(rateEvaluationResult);
+        Assert.Equal(rateEvaluations[0].EvaluationDetailId, rateEvaluationResult[0].EvaluationDetailId);
+        Assert.Equal(rateEvaluations[1].EvaluationDetailId, rateEvaluationResult[1].EvaluationDetailId);
+        Assert.Equal(rateEvaluations[2].EvaluationDetailId, rateEvaluationResult[2].EvaluationDetailId);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_UpdateRange_BadRequest_NoIds()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new ()
+            {
+                EvaluationDetailId = 1
+            },
+            new ()
+            {
+                EvaluationDetailId = 2
+            }
+        };
+
+        var result = await _controller.UpdateRange(rateEvaluations);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+        _mockRateEvaluationService.Verify(x => x.GetAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void RateEvaluation_UpdateRange_BadRequest()
+    {
+        List<RateEvaluation>? rateEvaluations = null;
+
+        var result = await _controller.UpdateRange(rateEvaluations);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_UpdateRange_InternalServcerError()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new ()
+            {
+                RateEvaluationId = 1,
+                EvaluationDetailId = 1
+            },
+            new ()
+            {
+                RateEvaluationId = 2,
+                EvaluationDetailId = 2
+            }
+        };
+        _mockRateEvaluationService.Setup(x => x.UpdateRangeAsync(rateEvaluations))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.UpdateRange(rateEvaluations);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Delete_OK()
+    {
+        var rateEvaluationId = 1;
+
+        _mockRateEvaluationService.Setup(x => x.DeleteAsync(rateEvaluationId)).Verifiable();
+
+        var result = await _controller.Delete(rateEvaluationId);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkResult>(result);
+        var status = result as OkResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_Delete_BadRequest()
+    {
+        var rateEvaluationId = 0;
+
+        var result = await _controller.Delete(rateEvaluationId);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_Delete_InternalServerError()
+    {
+        var rateEvaluationId = 1;
+        _mockRateEvaluationService.Setup(x => x.DeleteAsync(rateEvaluationId))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.Delete(rateEvaluationId);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_DeleteRange_OK()
+    {
+        var rateEvaluationIds = new List<int>
+        {
+            1,
+            1,
+            1
+        };
+
+        _mockRateEvaluationService.Setup(x => x.DeleteRangeAsync(rateEvaluationIds)).Verifiable();
+
+        var result = await _controller.DeleteRange(rateEvaluationIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkResult>(result);
+        var status = result as OkResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_DeleteRange_BadRequest()
+    {
+        var rateEvaluationIds = new List<int>();
+
+        var result = await _controller.DeleteRange(rateEvaluationIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_DeleteRange_InternalServerError()
+    {
+        var rateEvaluationIds = new List<int>
+        {
+            1
+        };
+        _mockRateEvaluationService.Setup(x => x.DeleteRangeAsync(rateEvaluationIds))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.DeleteRange(rateEvaluationIds);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+    
+    [Fact]
+    public async void RateEvaluation_CountByEvaluationDetailId_OK()
+    {
+        var evaluationDetailId = DateTime.Now.Millisecond;
+        var count = DateTime.Now.Minute;
+
+        _mockRateEvaluationService.Setup(x => x.CountByEvaluationDetailIdAsync(evaluationDetailId)).ReturnsAsync(count).Verifiable();
+
+        var result = await _controller.CountByEvaluationDetailId(evaluationDetailId);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        Assert.Equal(count, status.Value);
+        _mockRateEvaluationService.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_CountByEvaluationDetailId_BadRequest()
+    {
+        var evaluationDetailId = 0;
+
+        var result = await _controller.CountByEvaluationDetailId(evaluationDetailId);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateEvaluation_CountByEvaluationDetailId_InternalServerError()
+    {
+        var evaluationDetailId = DateTime.Now.Millisecond;
+        _mockRateEvaluationService.Setup(x => x.CountByEvaluationDetailIdAsync(evaluationDetailId))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.CountByEvaluationDetailId(evaluationDetailId);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateEvaluationService.Verify();
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ControllerTests/RateUploadInfoControllerTest.cs

@@ -0,0 +1,232 @@
+using System.Linq.Dynamic.Core;
+using LCU.API.Internal.LoanRate.Controllers;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Tests;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Utilities;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.Library.Internal.LoanRateModels.Requests;
+using LCU.Library.Internal.LoanRateModels.Responses;
+using Microsoft.AspNetCore.Mvc;
+
+namespace LCU.API.Internal.LoanRateTests.ControllerTests;
+
+public class RateUploadInfoControllerTest : CrudControllerTest<RateUploadInfo>
+{
+    private readonly Mock<IRateUploadInfoService> _mockRateUploadInfoService = new();
+    private readonly RateUploadInfoController _controller;
+
+    public RateUploadInfoControllerTest()
+    {
+        _controller = new RateUploadInfoController(_mockRateUploadInfoService.Object);
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetLatest_OK()
+    {
+        var rateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue()
+        };
+        
+        _mockRateUploadInfoService.Setup(x => x.GetLatestAsync()).ReturnsAsync(rateUploadInfo).Verifiable();
+
+        var result = await _controller.GetLatest();
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetLatest_NoContent()
+    {
+        RateUploadInfo? rateUploadInfo = null;
+        
+        _mockRateUploadInfoService.Setup(x => x.GetLatestAsync()).ReturnsAsync(rateUploadInfo).Verifiable();
+
+        var result = await _controller.GetLatest();
+        Assert.NotNull(result);
+
+        Assert.IsType<NoContentResult>(result);
+        var status = result as NoContentResult;
+        Assert.NotNull(status);
+        Assert.Equal(204, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetLatest_InternalServerError()
+    {
+        _mockRateUploadInfoService.Setup(x => x.GetLatestAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.GetLatest();
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetFilteredRateUploadInfo_OK()
+    {
+        var request = new RateUploadInfoFilter
+        {
+            EffectiveDate = (DateTime)typeof(DateTime).GetRandomValue()
+        };
+        
+        var response = new RateUploadInfoFilterResult
+        {
+            Items = new List<RateUploadInfo>
+            {
+                new() { RateUploadInfoId = (int)typeof(int).GetRandomValue() },
+                new() { RateUploadInfoId = (int)typeof(int).GetRandomValue() },
+                new() { RateUploadInfoId = (int)typeof(int).GetRandomValue() }
+            }
+        };
+        
+        _mockRateUploadInfoService.Setup(x => x.GetFilteredRateUploadInfo(request)).ReturnsAsync(response).Verifiable();
+
+        var result = await _controller.GetFilteredRateUploadInfo(request);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetFilteredRateUploadInfo_InternalServerError()
+    {
+        var request = new RateUploadInfoFilter
+        {
+            EffectiveDate = (DateTime)typeof(DateTime).GetRandomValue()
+        };
+        
+        _mockRateUploadInfoService.Setup(x => x.GetFilteredRateUploadInfo(request))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.GetFilteredRateUploadInfo(request);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+
+    [Fact]
+    public async void RateUploadInfo_ComplexDelete_OK()
+    {
+        var rateUploadInfoId = (int)typeof(int).GetRandomValue();
+
+        _mockRateUploadInfoService.Setup(x => x.ComplexDelete(rateUploadInfoId)).Verifiable();
+
+        var result = await _controller.ComplexDelete(rateUploadInfoId);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkResult>(result);
+        var status = result as OkResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+
+    [Fact]
+    public async void RateUploadInfo_ComplexDelete_BadRequest()
+    {
+        var rateUploadInfoId = 0;
+
+        var result = await _controller.ComplexDelete(rateUploadInfoId);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateUploadInfo_ComplexDelete_InternalServerError()
+    {
+        var rateUploadInfoId = (int)typeof(int).GetRandomValue();
+
+        _mockRateUploadInfoService.Setup(x => x.ComplexDelete(rateUploadInfoId))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.ComplexDelete(rateUploadInfoId);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_ComplexSave_OK()
+    {
+        var rateUploadInfoRequest = new RateUploadInfoRequest
+        {
+            EffectiveDate = (DateTime)typeof(DateTime).GetRandomValue(),
+            FileName = (string)typeof(string).GetRandomValue()
+        };
+
+        _mockRateUploadInfoService.Setup(x => x.ComplexSave(rateUploadInfoRequest)).Verifiable();
+
+        var result = await _controller.ComplexSave(rateUploadInfoRequest);
+        Assert.NotNull(result);
+
+        Assert.IsType<OkObjectResult>(result);
+        var status = result as OkObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(200, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+
+    [Fact]
+    public async void RateUploadInfo_ComplexSave_BadRequest()
+    {
+        RateUploadInfoRequest? rateUploadInfoRequest = null;
+
+        var result = await _controller.ComplexSave(rateUploadInfoRequest);
+        Assert.NotNull(result);
+
+        Assert.IsType<BadRequestObjectResult>(result);
+        var status = result as BadRequestObjectResult;
+        Assert.NotNull(status);
+        Assert.Equal(400, status.StatusCode);
+    }
+
+    [Fact]
+    public async void RateUploadInfo_ComplexSave_InternalServerError()
+    {
+        var rateUploadInfoRequest = new RateUploadInfoRequest
+        {
+            EffectiveDate = (DateTime)typeof(DateTime).GetRandomValue(),
+            FileName = (string)typeof(string).GetRandomValue()
+        };
+
+        _mockRateUploadInfoService.Setup(x => x.ComplexSave(rateUploadInfoRequest))
+            .Throws(new Exception("Test")).Verifiable();
+
+        var result = await _controller.ComplexSave(rateUploadInfoRequest);
+        Assert.NotNull(result);
+
+        Assert.IsType<StatusCodeResult>(result);
+        var status = result as StatusCodeResult;
+        Assert.NotNull(status);
+        Assert.Equal(500, status.StatusCode);
+        _mockRateUploadInfoService.Verify();
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ControllerTests/StatusControllerTest.cs

@@ -0,0 +1,42 @@
+using Microsoft.AspNetCore.Mvc;
+using LCU.Library.Internal.StatusModels.Models;
+using LCU.API.Internal.LoanRate.Controllers;
+using LCU.API.Internal.LoanRate.Services;
+namespace LCU.API.Internal.LoanRateTests.ControllerTests;
+
+public class StatusControllerTest
+{
+    private readonly StatusController controller;
+    private readonly Mock<IStatusService> _mockStatusService;
+
+    public StatusControllerTest()
+    {
+        _mockStatusService = new Mock<IStatusService>();
+        controller = new StatusController(_mockStatusService.Object);
+    }
+
+    [Fact]
+    public void CreateStatus_Ok()
+    {
+        // Arrange
+        var status = new EnvironmentView()
+        {
+            Application = "Test.Application.Name",
+            CurrentDate = DateTime.Now,
+            BuildVersion = "1.1.1",
+            BuildDate = DateTime.Now.AddDays(-1),
+            Environment = "TestEnvironment"
+        };
+
+        _mockStatusService.Setup(service => service.GetEnviromentView()).Returns(status);
+
+        // Act
+        var result = controller.Get();
+
+        // Assert
+        Assert.NotNull(result);
+        var okResult = result as OkObjectResult;
+        Assert.NotNull(okResult);
+        Assert.Equal(200, okResult.StatusCode);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/LCU.API.Internal.LoanRateTests.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="LCU.Library.Internal.LcuClassPatterns.CrudTests" Version="1.0.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Core" Version="2.2.5" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Moq" Version="4.18.4" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.2.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LCU.API.Internal.LoanRate\LCU.API.Internal.LoanRate.csproj" />
+  </ItemGroup>
+
+</Project>

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/ComplexEvaluationDetailServiceTest.cs

@@ -0,0 +1,191 @@
+using LCU.API.Internal.LoanRate.Services;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LcuEvaluation.Services;
+using LCU.Library.Internal.LcuEvaluationModels.Entities;
+using LCU.Library.Internal.LcuEvaluationModels.Requests;
+using LCU.Library.Internal.LoanRateModels.Entities;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests;
+
+public class ComplexEvaluationDetailServiceTest
+{
+    private readonly Mock<IRateEvaluationService> _mockRateEvaluationService;
+    private readonly Mock<IEvaluationDetailService> _mockEvaluationDetailService;
+    private readonly IComplexEvaluationDetailService _service;
+
+    public ComplexEvaluationDetailServiceTest()
+    {
+        _mockRateEvaluationService = new Mock<IRateEvaluationService>();
+        _mockEvaluationDetailService = new Mock<IEvaluationDetailService>();
+        _service = new ComplexEvaluationDetailService(_mockRateEvaluationService.Object,
+                                                      _mockEvaluationDetailService.Object);
+    }
+
+    [Fact]
+    public async void ComplexEvaluationDetail_UpdateComplexAsync_Success()
+    {
+        var evaluationDetail = new EvaluationDetail
+        {
+            EvaluationDetailId = DateTime.Now.Millisecond,
+            Description = Guid.NewGuid().ToString()
+        };
+        
+        var newEvaluationDetail = new EvaluationDetail
+        {
+            EvaluationDetailId = DateTime.Now.Millisecond,
+            Description = Guid.NewGuid().ToString()
+        };
+        
+        _mockEvaluationDetailService.Setup(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()))
+                                                                        .ReturnsAsync(newEvaluationDetail).Verifiable();
+
+        var result = await _service.UpdateComplexAsync(evaluationDetail);
+        Assert.NotNull(result);
+        Assert.Equal(result.Description, newEvaluationDetail.Description);
+        _mockEvaluationDetailService.Verify(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()), Times.Once);
+    }
+
+    [Fact]
+    public async void ComplexEvaluationDetail_UpdateComplexAsync_Success_NotFound()
+    {
+        EvaluationDetail? evaluationDetail = null;
+
+        _mockEvaluationDetailService.Setup(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()))
+                                                                .ReturnsAsync(evaluationDetail).Verifiable();
+
+        var result = await _service.UpdateComplexAsync(evaluationDetail);
+        Assert.Null(result);
+        _mockEvaluationDetailService.Verify(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()), Times.Once);
+    }
+
+    [Fact]
+    public void ComplexEvaluationDetail_UpdateComplexAsync_Failure_Exception()
+    {
+        var evaluationDetail = new EvaluationDetail();
+        _mockEvaluationDetailService.Setup(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.UpdateComplexAsync(evaluationDetail));
+        _mockEvaluationDetailService.Verify(x => x.UpdateComplexAsync(It.IsAny<EvaluationDetail>()), Times.Once);
+    }
+
+    [Fact]
+    public async void ComplexEvaluationDetail_SaveComplexAsync_Success_NewEvaluationDetail()
+    {
+        var evaluationDetail = new EvaluationDetail
+        {
+            Description = Guid.NewGuid().ToString()
+        };
+
+        var request = new EvaluationDetailRequest
+        {
+            EvaluationDetail = evaluationDetail
+        }; 
+        
+        var newEvaluationDetail = new EvaluationDetail
+        {
+            EvaluationDetailId = DateTime.Now.Millisecond + 1,
+            Description = evaluationDetail.Description
+        };
+
+        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
+                                                                        .ReturnsAsync(newEvaluationDetail).Verifiable();
+
+        var result = await _service.SaveComplexAsync(request);
+        Assert.NotNull(result);
+        Assert.Equal(request.EvaluationDetail.Description, newEvaluationDetail.Description);
+        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
+    }
+
+    [Fact]
+    public async void ComplexEvaluationDetail_SaveComplexAsync_Success_ExistingEvaluationDetail()
+    {
+        var evaluationDetail = new EvaluationDetail
+        {
+            EvaluationDetailId = DateTime.Now.Millisecond,
+            Description = Guid.NewGuid().ToString()
+        };
+
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new()
+            {
+                EvaluationDetailId = evaluationDetail.EvaluationDetailId,
+                RateId = DateTime.Now.Millisecond + 5
+            }
+        };
+
+        var request = new EvaluationDetailRequest
+        {
+            PreviousVersionEvaluationDetailId = evaluationDetail.EvaluationDetailId,
+            EvaluationDetail = evaluationDetail
+        }; 
+        
+        var newEvaluationDetail = new EvaluationDetail
+        {
+            EvaluationDetailId = DateTime.Now.Millisecond + 1,
+            Description = evaluationDetail.Description
+        };
+
+        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
+            .ReturnsAsync(newEvaluationDetail).Verifiable();
+        _mockRateEvaluationService.Setup(x => x.GetRangeByEvaluationDetailIdAsync(It.IsAny<int>()))
+            .ReturnsAsync(rateEvaluations).Verifiable();
+        _mockRateEvaluationService.Setup(x => x.SaveRangeAsync(rateEvaluations)).Verifiable();
+
+        var result = await _service.SaveComplexAsync(request);
+        Assert.NotNull(result);
+        Assert.Equal(request.EvaluationDetail.Description, newEvaluationDetail.Description);
+        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
+        _mockRateEvaluationService.Verify(x => x.GetRangeByEvaluationDetailIdAsync(It.IsAny<int>()), Times.Once);
+        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateEvaluation>>()), Times.Once);
+    }
+    
+    [Fact]
+    public async void ComplexEvaluationDetail_SaveComplexAsync_Success_NotFound()
+    {
+        var request = new EvaluationDetailRequest();
+        EvaluationDetail? evaluationDetail = null;
+
+        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
+                                                                .ReturnsAsync(evaluationDetail).Verifiable();
+
+        var result = await _service.SaveComplexAsync(request);
+        Assert.Null(result);
+        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
+    }
+
+    [Fact]
+    public void ComplexEvaluationDetail_SaveComplexAsync_Failure_Exception()
+    {
+        var request = new EvaluationDetailRequest();
+        _mockEvaluationDetailService.Setup(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.SaveComplexAsync(request));
+        _mockEvaluationDetailService.Verify(x => x.SaveComplexAsync(It.IsAny<EvaluationDetailRequest>()), Times.Once);
+    }
+    
+    [Fact]
+    public async void ComplexEvaluationDetail_DeleteComplexAsync_Success()
+    {
+        var evaluationDetailId = DateTime.Now.Millisecond;
+        
+        _mockEvaluationDetailService.Setup(x => x.DeleteComplexAsync(It.IsAny<int>())).Verifiable();
+        _mockRateEvaluationService.Setup(x => x.DeleteRangeByEvaluationDetailIdAsync(It.IsAny<int>())).Verifiable();
+
+        await _service.DeleteComplexAsync(evaluationDetailId);
+        _mockEvaluationDetailService.Verify(x => x.DeleteComplexAsync(It.IsAny<int>()), Times.Once);
+        _mockRateEvaluationService.Verify(x => x.DeleteRangeByEvaluationDetailIdAsync(It.IsAny<int>()), Times.Once);
+    }
+    
+    [Fact]
+    public void ComplexEvaluationDetail_DeleteComplexAsync_Failure_Exception()
+    {
+        _mockEvaluationDetailService.Setup(x => x.DeleteComplexAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteComplexAsync(It.IsAny<int>()));
+        _mockEvaluationDetailService.Verify(x => x.DeleteComplexAsync(It.IsAny<int>()), Times.Once);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/LoadTestRunInfoServiceTest.cs

@@ -0,0 +1,586 @@
+using LCU.API.Internal.LoanRate.Services;
+using LCU.API.Internal.LoanRateLoadTestingLib.Repositories;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LCUFilterModels.Pagination;
+using LCU.Library.Internal.LoanRateModels.Entities.LoadTestingEntities;
+using LCU.Library.Internal.LoanRateModels.Enums;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests;
+
+public class LoadTestRunInfoServiceTest
+{
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    private readonly Mock<ILoadTestRunInfoRepository> _mockLoadTestRunInfoRepository;
+    private readonly ILoadTestRunInfoService _loadTestRunInfoService;
+
+    public LoadTestRunInfoServiceTest()
+    {
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        _mockLoadTestRunInfoRepository = new Mock<ILoadTestRunInfoRepository>();
+        _loadTestRunInfoService = new LoadTestRunInfoService(_mockUnitOfWork.Object, 
+                                                             _mockLoadTestRunInfoRepository.Object);
+    }
+    
+    [Fact]
+    public async void LoadTestRunInfo_GetAsync_Success()
+    {
+        var loadTestRunInfos = new List<LoadTestRunInfo>
+        {
+            new() { LoadTestRunInfoId = 1 },
+            new() { LoadTestRunInfoId = 2 },
+            new() { LoadTestRunInfoId = 3 }
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindAsync())
+            .ReturnsAsync(loadTestRunInfos).Verifiable();
+
+        var result = (await _loadTestRunInfoService.GetAsync()).ToList();
+        Assert.NotNull(result);
+        Assert.Equal(loadTestRunInfos.First().LoadTestRunInfoId, result.First().LoadTestRunInfoId);
+        Assert.Equal(loadTestRunInfos.Count, result.Count);
+        _mockLoadTestRunInfoRepository.Verify();
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_GetAsync_Success_NotFound()
+    {
+        List<LoadTestRunInfo>? loadTestRunInfos = null;
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindAsync())
+            .ReturnsAsync(loadTestRunInfos).Verifiable();
+
+        var result = await _loadTestRunInfoService.GetAsync();
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockLoadTestRunInfoRepository.Verify();
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_GetAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _loadTestRunInfoService.GetAsync());
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_GetByIdAsync_Success()
+    {
+        var loadTestRunInfoId = 1;
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            LoadTestRunInfoId = loadTestRunInfoId
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfoId))
+            .ReturnsAsync(loadTestRunInfo).Verifiable();
+
+        var result = await _loadTestRunInfoService.GetByIdAsync(loadTestRunInfoId);
+        Assert.NotNull(result);
+        Assert.Equal(loadTestRunInfo.LoadTestRunInfoId, result.LoadTestRunInfoId);
+        _mockLoadTestRunInfoRepository.Verify();
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_GetByIdAsync_Success_NotFound()
+    {
+        var loadTestRunInfoId = 1;
+        LoadTestRunInfo? loadTestRunInfo = null;
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfoId))
+            .ReturnsAsync(loadTestRunInfo).Verifiable();
+
+        var result = await _loadTestRunInfoService.GetByIdAsync(loadTestRunInfoId);
+        Assert.Null(result);
+        _mockLoadTestRunInfoRepository.Verify();
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_GetByIdAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+                            await _loadTestRunInfoService.GetByIdAsync(It.IsAny<int>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_GetRangeByIdAsync_Success()
+    {
+        var loadTestRunInfos = new List<LoadTestRunInfo>
+        {
+            new() { LoadTestRunInfoId = 1 },
+            new() { LoadTestRunInfoId = 2 },
+            new() { LoadTestRunInfoId = 3 }
+        };
+        var ids = loadTestRunInfos.Select(x => x.LoadTestRunInfoId).ToList();
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindRangeByIdAsync(ids))
+            .ReturnsAsync(loadTestRunInfos).Verifiable();
+
+        var results = (await _loadTestRunInfoService.GetRangeByIdAsync(ids)).ToList();
+        Assert.NotNull(results);
+        Assert.Equal(loadTestRunInfos.First().LoadTestRunInfoId, results.First().LoadTestRunInfoId);
+        Assert.Equal(loadTestRunInfos.Count, results.Count);
+        _mockLoadTestRunInfoRepository.Verify();
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_GetRangeByIdAsync_Success_NotFound()
+    {
+        List<LoadTestRunInfo>? loadTestRunInfos = null;
+        var ids = new List<int>
+        {
+            1,2,3
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindRangeByIdAsync(ids))
+            .ReturnsAsync(loadTestRunInfos).Verifiable();
+
+        var result = await _loadTestRunInfoService.GetRangeByIdAsync(ids);
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockLoadTestRunInfoRepository.Verify();
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_GetRangeByIdAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _loadTestRunInfoService.GetRangeByIdAsync(It.IsAny<List<int>>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once);
+    }
+    
+    [Fact]
+    public async Task LoadTestRunInfo_GetFilteredLoadTestRunInfo_Success()
+    {
+        var pagedLoadTestRunInfoResult = new PagedResult<LoadTestRunInfo>();
+
+        var filter = new LoadTestRunInfoFilter
+        {
+            Page = 1,
+            Limit = 2,
+            SortableFields = null,
+            RateTypes = new List<RateTypes> { RateTypes.DirectAuto }
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(repo => repo.FindFilteredLoadTestRunInfosAsync(filter))
+            .ReturnsAsync(pagedLoadTestRunInfoResult).Verifiable();
+
+        var result = await _loadTestRunInfoService.GetFilteredLoadTestRunInfo(filter);
+
+        Assert.NotNull(result);
+        Assert.Equal(pagedLoadTestRunInfoResult, result);
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindFilteredLoadTestRunInfosAsync(It.IsAny<LoadTestRunInfoFilter>()), Times.Once);
+    }
+    
+    [Fact]
+    public async Task LoadTestRunInfo_GetFilteredLoadTestRunInfo_NotFound()
+    {
+        var pagedLoadTestRunInfoResult = new PagedResult<LoadTestRunInfo>
+        {
+            Total = 0,
+            Items = new List<LoadTestRunInfo>()
+        };
+
+        var filter = new LoadTestRunInfoFilter
+        {
+            Page = 1,
+            Limit = 2,
+            SortableFields = null,
+            RateTypes = new List<RateTypes> { RateTypes.DirectAuto }
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(repo => repo.FindFilteredLoadTestRunInfosAsync(filter))
+            .ReturnsAsync(pagedLoadTestRunInfoResult).Verifiable();
+
+        var result = await _loadTestRunInfoService.GetFilteredLoadTestRunInfo(filter);
+
+        Assert.NotNull(result);
+        Assert.Equal(0, result.Total);
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindFilteredLoadTestRunInfosAsync(It.IsAny<LoadTestRunInfoFilter>()), Times.Once);
+    }
+    
+    [Fact]
+    public void LoadTestRunInfo_GetFilteredLoadTestRunInfo_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindFilteredLoadTestRunInfosAsync(It.IsAny<LoadTestRunInfoFilter>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _loadTestRunInfoService.GetFilteredLoadTestRunInfo(It.IsAny<LoadTestRunInfoFilter>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindFilteredLoadTestRunInfosAsync(It.IsAny<LoadTestRunInfoFilter>()), Times.Once);
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_SaveAsync_Success()
+    {
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            RateType = RateTypes.DirectBoat
+        };
+        var LoadTestRunInfoReturned = new LoadTestRunInfo
+        {
+            LoadTestRunInfoId = 1,
+            RateType = RateTypes.DirectPowerSport
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.AddAsync(loadTestRunInfo))
+            .ReturnsAsync(LoadTestRunInfoReturned).Verifiable();
+
+        var result = await _loadTestRunInfoService.SaveAsync(loadTestRunInfo);
+        Assert.NotNull(result);
+        Assert.Equal(LoadTestRunInfoReturned.LoadTestRunInfoId, result.LoadTestRunInfoId);
+        Assert.Equal(LoadTestRunInfoReturned.RateType, result.RateType);
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.AddAsync(It.IsAny<LoadTestRunInfo>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_SaveAsync_Failure_ReturnedNull()
+    {
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            RateType = RateTypes.DirectSignatureLoan
+        };
+        LoadTestRunInfo? loadTestRunInfoReturned = null;
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.AddAsync(loadTestRunInfo))
+            .ReturnsAsync(loadTestRunInfoReturned).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _loadTestRunInfoService.SaveAsync(loadTestRunInfo));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.AddAsync(It.IsAny<LoadTestRunInfo>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_SaveAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.AddAsync(It.IsAny<LoadTestRunInfo>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _loadTestRunInfoService.SaveAsync(It.IsAny<LoadTestRunInfo>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.AddAsync(It.IsAny<LoadTestRunInfo>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_SaveRangeAsync_Success()
+    {
+        var loadTestRunInfos = new List<LoadTestRunInfo>
+        {
+            new() { RateType = RateTypes.DirectAuto },
+            new() { RateType = RateTypes.DirectBoat },
+            new() { RateType = RateTypes.DirectRv }
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.AddRangeAsync(loadTestRunInfos)).Verifiable();
+
+        await _loadTestRunInfoService.SaveRangeAsync(loadTestRunInfos);
+        _mockLoadTestRunInfoRepository.Verify(x =>
+            x.AddRangeAsync(It.IsAny<IEnumerable<LoadTestRunInfo>>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_SaveRangeAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.AddRangeAsync(It.IsAny<IEnumerable<LoadTestRunInfo>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _loadTestRunInfoService.SaveRangeAsync(It.IsAny<IEnumerable<LoadTestRunInfo>>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x =>
+                            x.AddRangeAsync(It.IsAny<IEnumerable<LoadTestRunInfo>>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+    
+    [Fact]
+    public async void LoadTestRunInfo_IncreaseRateProcessingInfosCompleteCountAsync_Success()
+    {
+        var random = new Random();
+        var previousComplete = random.Next(1, 100);
+        var countCompleted = random.Next(1, 100);
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            LoadTestRunInfoId = DateTime.Now.Millisecond,
+            RateProcessingInfosCompleteCount = previousComplete,
+            RateProcessingInfosCount = previousComplete + countCompleted
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfo.LoadTestRunInfoId)).ReturnsAsync(loadTestRunInfo).Verifiable();
+
+        var result = await _loadTestRunInfoService.IncreaseRateProcessingInfosCompleteCountAsync(loadTestRunInfo.LoadTestRunInfoId, countCompleted);
+        
+        Assert.NotNull(result);
+        Assert.Equal(previousComplete + countCompleted, result.RateProcessingInfosCompleteCount);
+        Assert.Equal(DateTime.Now.Date, ((DateTime)result.EndTimeStamp!).Date);
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+    
+    [Fact]
+    public async void LoadTestRunInfo_IncreaseRateProcessingInfosCompleteCountAsync_Failure_ReturnedNull()
+    {
+        var loadTestRuninfoId = new Random().Next(1, 100);
+        LoadTestRunInfo? loadTestRunInfo = null;
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRuninfoId)).ReturnsAsync(loadTestRunInfo).Verifiable();
+
+        var result = await _loadTestRunInfoService.IncreaseRateProcessingInfosCompleteCountAsync(loadTestRuninfoId, 10);
+        
+        Assert.Null(result);
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+    [Fact]
+    public void LoadTestRunInfo_IncreaseRateProcessingInfosCompleteCountAsync_Failure_Exception()
+    {
+        var random = new Random();
+        var previousComplete = random.Next(1, 100);
+        var countCompleted = random.Next(1, 100);
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            LoadTestRunInfoId = DateTime.Now.Millisecond,
+            RateProcessingInfosCompleteCount = previousComplete,
+            RateProcessingInfosCount = previousComplete + countCompleted
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfo.LoadTestRunInfoId))
+                                                            .ThrowsAsync(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>( async () => 
+            await _loadTestRunInfoService.IncreaseRateProcessingInfosCompleteCountAsync(loadTestRunInfo.LoadTestRunInfoId, countCompleted));
+        
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+    
+
+    [Fact]
+    public async void LoadTestRunInfo_UpdateAsync_Success()
+    {
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            LoadTestRunInfoId = 1,
+            RateType = RateTypes.DirectAuto
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfo.LoadTestRunInfoId))
+            .ReturnsAsync(loadTestRunInfo).Verifiable();
+
+        var result = await _loadTestRunInfoService.UpdateAsync(loadTestRunInfo);
+        Assert.NotNull(result);
+        Assert.Equal(loadTestRunInfo.LoadTestRunInfoId, result.LoadTestRunInfoId);
+        Assert.Equal(loadTestRunInfo.RateType, result.RateType);
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_UpdateAsync_Failure_ReturnedNull()
+    {
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            RateType = RateTypes.DirectAuto
+        };
+        LoadTestRunInfo? loadTestRunInfoReturned = null;
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfo.LoadTestRunInfoId))
+            .ReturnsAsync(loadTestRunInfoReturned).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _loadTestRunInfoService.UpdateAsync(loadTestRunInfo));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_UpdateAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .ThrowsAsync(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _loadTestRunInfoService.UpdateAsync(It.IsAny<LoadTestRunInfo>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_UpdateRangeAsync_Success()
+    {
+        var loadTestRunInfos = new List<LoadTestRunInfo>
+        {
+            new()
+            {
+                LoadTestRunInfoId = 1
+            },
+            new()
+            {
+                LoadTestRunInfoId = 2
+            },
+            new()
+            {
+                LoadTestRunInfoId = 3
+            }
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.UpdateRange(loadTestRunInfos)).Verifiable();
+
+        await _loadTestRunInfoService.UpdateRangeAsync(loadTestRunInfos);
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.UpdateRange(It.IsAny<List<LoadTestRunInfo>>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_UpdateRangeAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.UpdateRange(It.IsAny<List<LoadTestRunInfo>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _loadTestRunInfoService.UpdateRangeAsync(It.IsAny<List<LoadTestRunInfo>>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.UpdateRange(It.IsAny<List<LoadTestRunInfo>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_DeleteAsync_Success()
+    {
+        var loadTestRunInfoId = 1;
+
+        var loadTestRunInfo = new LoadTestRunInfo
+        {
+            LoadTestRunInfoId = loadTestRunInfoId
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfoId))
+            .ReturnsAsync(loadTestRunInfo).Verifiable();
+        _mockLoadTestRunInfoRepository.Setup(x => x.Remove(loadTestRunInfo)).Verifiable();
+
+        await _loadTestRunInfoService.DeleteAsync(loadTestRunInfoId);
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockLoadTestRunInfoRepository.Verify(x => x.Remove(It.IsAny<LoadTestRunInfo>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_DeleteAsync_Failure_ReturnedNull()
+    {
+        var loadTestRunInfoId = 1;
+        LoadTestRunInfo? loadTestRunInfo = null;
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(loadTestRunInfoId))
+            .ReturnsAsync(loadTestRunInfo).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _loadTestRunInfoService.DeleteAsync(loadTestRunInfoId));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockLoadTestRunInfoRepository.Verify(x => x.Remove(It.IsAny<LoadTestRunInfo>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_DeleteAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _loadTestRunInfoService.DeleteAsync(It.IsAny<int>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockLoadTestRunInfoRepository.Verify(x => x.Remove(It.IsAny<LoadTestRunInfo>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void LoadTestRunInfo_DeleteRangeAsync_Success()
+    {
+        var loadTestRunInfoIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        var loadTestRunInfos = new List<LoadTestRunInfo>
+        {
+            new()
+            {
+                LoadTestRunInfoId = loadTestRunInfoIds[0]
+                
+            },
+            new()
+            {
+                LoadTestRunInfoId = loadTestRunInfoIds[1]
+            },
+            new()
+            {
+                LoadTestRunInfoId = loadTestRunInfoIds[2]
+            }
+        };
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindRangeByIdAsync(loadTestRunInfoIds)).ReturnsAsync(loadTestRunInfos).Verifiable();
+        _mockLoadTestRunInfoRepository.Setup(x => x.RemoveRange(loadTestRunInfos)).Verifiable();
+
+        await _loadTestRunInfoService.DeleteRangeAsync(loadTestRunInfoIds);
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockLoadTestRunInfoRepository.Verify(x => x.RemoveRange(It.IsAny<List<LoadTestRunInfo>>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_DeleteRangeAsync_Failure_ReturnedNull()
+    {
+        var loadTestRunInfoIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        List<LoadTestRunInfo>? loadTestRunInfos = null;
+
+        _mockLoadTestRunInfoRepository.Setup(x => x.FindRangeByIdAsync(loadTestRunInfoIds))
+            .ReturnsAsync(loadTestRunInfos).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _loadTestRunInfoService.DeleteRangeAsync(loadTestRunInfoIds));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockLoadTestRunInfoRepository.Verify(x => x.RemoveRange(It.IsAny<List<LoadTestRunInfo>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void LoadTestRunInfo_DeleteRangeAsync_Failure_Exception()
+    {
+        _mockLoadTestRunInfoRepository.Setup(x => x.RemoveRange(It.IsAny<List<LoadTestRunInfo>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _loadTestRunInfoService.DeleteRangeAsync(It.IsAny<List<int>>()));
+
+        _mockLoadTestRunInfoRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockLoadTestRunInfoRepository.Verify(x => x.RemoveRange(It.IsAny<List<LoadTestRunInfo>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/LoadTestingServices/LoadTestInitiationServiceTest.cs

@@ -0,0 +1,127 @@
+using System.Globalization;
+using System.Reflection;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.API.Internal.LoanRate.Services.LoadTestingServices;
+using LCU.API.Internal.LoanRate.Services.QueueServices;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LoanRateModels.Entities.LoadTestingEntities;
+using LCU.Library.Internal.LoanRateModels.Enums;
+using LCU.Library.Internal.LoanRateModels.Enums.LoadTestingEnums;
+using LCU.Library.Internal.LoanRateModels.Requests;
+using LCU.Library.Internal.LoanRateModels.Requests.LoadTestRequest;
+using Newtonsoft.Json;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests.LoadTestingServices;
+
+public class LoadTestInitiationServiceTest
+{
+    private readonly Mock<ILoadTestRunInfoService> _mockLoadTestRunInfoService;
+    private readonly Mock<IRateProcessingInfoService> _mockRateProcessingInfoService;
+    private readonly Mock<IQueueLoadTestProcessRateService> _mockQueueLoadTestProcessRateService;
+    private readonly ILoadTestInitiationService _loadTestInitiationService;
+
+    public LoadTestInitiationServiceTest()
+    {
+        _mockLoadTestRunInfoService = new Mock<ILoadTestRunInfoService>();
+        _mockRateProcessingInfoService = new Mock<IRateProcessingInfoService>();
+        _mockQueueLoadTestProcessRateService = new Mock<IQueueLoadTestProcessRateService>();
+        _loadTestInitiationService = new LoadTestInitiationService(_mockLoadTestRunInfoService.Object,
+                                                                   _mockRateProcessingInfoService.Object,
+                                                                   _mockQueueLoadTestProcessRateService.Object);
+    }
+
+    [Fact]
+    public async void HandleLoadTestInitiation_Success()
+    {
+        var propertyCount = new Random().Next(1, 100);
+        var request = GenerateLoadTestInitiateRequest(propertyCount);
+        var loadTestRunInfo = new LoadTestRunInfo { LoadTestRunInfoId = DateTime.Now.Millisecond };
+        var rateProcessingInfos = GenerateRateProcessingInfos(request, loadTestRunInfo.LoadTestRunInfoId).ToList();
+        
+        _mockLoadTestRunInfoService.Setup(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>())).ReturnsAsync(loadTestRunInfo).Verifiable();
+        _mockRateProcessingInfoService.Setup(x => x.SaveRangeAsync(It.Is<List<RateProcessingInfo>>( 
+                                        list => list.All( 
+                                                    rateProcessingInfo => rateProcessingInfo.LoadTestRunInfoId == loadTestRunInfo.LoadTestRunInfoId
+                                                    && !string.IsNullOrWhiteSpace(rateProcessingInfo.Payload)
+                                                    && rateProcessingInfo.RateProcessingStatusType == RateProcessingStatusTypes.Processing)
+                                                && list.Count == propertyCount))).Verifiable();
+        _mockRateProcessingInfoService.Setup(x => x.GetByLoadTestRunInfoId(loadTestRunInfo.LoadTestRunInfoId)).ReturnsAsync(rateProcessingInfos).Verifiable();
+        _mockQueueLoadTestProcessRateService.Setup(x => x.QueueLoadTestProcessRateRequest(It.Is<LoadTestProcessRateRequest>( loadTestRequest => 
+                                        loadTestRequest.RateProcessingInfo.LoadTestRunInfoId == loadTestRunInfo.LoadTestRunInfoId ))).Verifiable();
+
+        await _loadTestInitiationService.HandleLoadTestInitiation(request);
+        
+        _mockLoadTestRunInfoService.Verify(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>()), Times.Once);
+        _mockRateProcessingInfoService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateProcessingInfo>>()), Times.Once);
+        _mockRateProcessingInfoService.Verify(x => x.GetByLoadTestRunInfoId(It.IsAny<int>()), Times.Once);
+        _mockQueueLoadTestProcessRateService.Verify(x => x.QueueLoadTestProcessRateRequest(It.IsAny<LoadTestProcessRateRequest>()), Times.Exactly(rateProcessingInfos.Count));
+    }
+    
+    [Fact]
+    public void HandleLoadTestInitiation_Failure_ThrowsException()
+    {
+        var propertyCount = new Random().Next(1, 100);
+        var request = GenerateLoadTestInitiateRequest(propertyCount);
+        
+        _mockLoadTestRunInfoService.Setup(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>())).ThrowsAsync(new Exception("Test")).Verifiable();
+        
+        Assert.ThrowsAsync<ServiceException>( async () => await _loadTestInitiationService.HandleLoadTestInitiation(request));
+        
+        _mockLoadTestRunInfoService.Verify(x => x.SaveAsync(It.IsAny<LoadTestRunInfo>()), Times.Once);
+        _mockRateProcessingInfoService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateProcessingInfo>>()), Times.Never);
+        _mockRateProcessingInfoService.Verify(x => x.GetByLoadTestRunInfoId(It.IsAny<int>()), Times.Never);
+        _mockQueueLoadTestProcessRateService.Verify(x => x.QueueLoadTestProcessRateRequest(It.IsAny<LoadTestProcessRateRequest>()), Times.Never);
+    }
+
+    private LoadTestInitiateRequest GenerateLoadTestInitiateRequest(int propertyListLength = 1)
+    {
+        var values = Enum.GetValues(typeof(RateTypes));
+        var random = new Random();
+        var rateType = (RateTypes)(values.GetValue(random.Next(values.Length)) ?? RateTypes.DirectAuto);
+
+        var propertyList = new Dictionary<string, List<string>>();
+        var properties = typeof(RateRequest).GetProperties();
+        var availableProperties = properties.Except(new List<PropertyInfo> {properties.First(x => x.Name == nameof(RateRequest.RateType))}).ToList();
+        for (var i = 0; i < propertyListLength; i++)
+        {
+            var key = availableProperties[random.Next(availableProperties.Count)];
+            string value;
+            if (key.PropertyType == typeof(DateTime))
+            {
+                value = new DateTime().AddDays(random.Next(1000)).ToString(CultureInfo.InvariantCulture);
+            }
+            else if (new List<Type> {typeof(int), typeof(decimal), typeof(long)}.Contains(key.PropertyType))
+            {
+                value = random.Next(100).ToString();
+            }
+            else
+            {
+                value = Guid.NewGuid().ToString();
+            }
+
+            if (!propertyList.ContainsKey(key.Name))
+            {
+                propertyList.Add(key.Name, new List<string> { value } );
+            }
+            else
+            {
+                propertyList[key.Name].Add(value);
+            }
+        }
+
+        return new LoadTestInitiateRequest
+        {
+            RateType = rateType,
+            PropertyList = propertyList
+        };
+    }
+
+    private static IEnumerable<RateProcessingInfo> GenerateRateProcessingInfos(LoadTestInitiateRequest request, int loadTestRunInfoId)
+    => request.PropertyList.Select(
+            combination => new RateProcessingInfo
+            {
+                LoadTestRunInfoId = loadTestRunInfoId, 
+                RateProcessingStatusType = RateProcessingStatusTypes.Processing, 
+                Payload = JsonConvert.SerializeObject(combination)
+            }).ToList();
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/LoadTestingServices/LoadTestProcessRateServiceTest.cs

@@ -0,0 +1,73 @@
+using LCU.API.Internal.LoanRate.Services.LoadTestingServices;
+using LCU.API.Internal.LoanRate.Services.LoanRateOperationServices;
+using LCU.API.Internal.LoanRate.Services.QueueServices;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LcuEvaluationModels.Entities;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.Library.Internal.LoanRateModels.Entities.LoadTestingEntities;
+using LCU.Library.Internal.LoanRateModels.Requests;
+using LCU.Library.Internal.LoanRateModels.Requests.LoadTestRequest;
+using Newtonsoft.Json;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests.LoadTestingServices;
+
+public class LoadTestProcessRateServiceTest
+{
+    private readonly Mock<IRateFinderService> _mockRateFinderService;
+    private readonly Mock<IQueueLoadTestRateCompletionService> _mockQueueLoadTestRateCompletionService;
+    private readonly ILoadTestProcessRateService _loadTestProcessRateService;
+
+    public LoadTestProcessRateServiceTest()
+    {
+        _mockRateFinderService = new Mock<IRateFinderService>();
+        _mockQueueLoadTestRateCompletionService = new Mock<IQueueLoadTestRateCompletionService>();
+        _loadTestProcessRateService = new LoadTestProcessRateService(_mockRateFinderService.Object,
+                                                                     _mockQueueLoadTestRateCompletionService.Object);
+    }
+    
+    [Fact]
+    public async void HandleLoadTestProcessRate_Success()
+    {
+        var random = new Random();
+        var request = new LoadTestProcessRateRequest { 
+            RateProcessingInfo = new RateProcessingInfo
+            {
+                LoadTestRunInfoId = random.Next(1, 1000),
+                RateProcessingInfoId = random.Next(1, 1000),
+                Payload = JsonConvert.SerializeObject(new RateRequest())
+            }
+        };
+        
+        _mockRateFinderService.Setup(x => x.DetermineRate(It.IsAny<DateTime>(), It.IsAny<List<EvaluationDetail>>())).ReturnsAsync(( new Rate(), string.Empty ));
+
+        await _loadTestProcessRateService.HandleLoadTestProcessRate(request);
+        
+        _mockRateFinderService.Verify(x => x.DeterminePassedRules(It.IsAny<RateRequest>()), Times.Once);
+        _mockRateFinderService.Verify(x => x.DetermineRate(It.IsAny<DateTime>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateFinderService.Verify(x => x.CalculateFinalRateValue(It.IsAny<RateRequest>(), It.IsAny<Rate>()), Times.Once);
+        _mockQueueLoadTestRateCompletionService.Verify(x => x.QueueLoadTestRateCompletionRequest(It.IsAny<LoadTestRateCompletionRequest>()), Times.Once);
+    }
+    
+    [Fact]
+    public void HandleLoadTestProcessRate_Failure_ThrowsException()
+    {
+        var random = new Random();
+        var request = new LoadTestProcessRateRequest { 
+            RateProcessingInfo = new RateProcessingInfo
+            {
+                LoadTestRunInfoId = random.Next(1, 1000),
+                RateProcessingInfoId = random.Next(1, 1000),
+                Payload = JsonConvert.SerializeObject(new RateRequest())
+            }
+        };
+        
+        _mockRateFinderService.Setup(x => x.DeterminePassedRules(It.IsAny<RateRequest>())).ThrowsAsync(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>( async () => await _loadTestProcessRateService.HandleLoadTestProcessRate(request));
+        
+        _mockRateFinderService.Verify(x => x.DeterminePassedRules(It.IsAny<RateRequest>()), Times.Once);
+        _mockRateFinderService.Verify(x => x.DetermineRate(It.IsAny<DateTime>(), It.IsAny<List<EvaluationDetail>>()), Times.Never);
+        _mockRateFinderService.Verify(x => x.CalculateFinalRateValue(It.IsAny<RateRequest>(), It.IsAny<Rate>()), Times.Never);
+        _mockQueueLoadTestRateCompletionService.Verify(x => x.QueueLoadTestRateCompletionRequest(It.IsAny<LoadTestRateCompletionRequest>()), Times.Once);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/LoadTestingServices/LoadTestRateCompletionServiceTest.cs

@@ -0,0 +1,76 @@
+using LCU.API.Internal.LoanRate.Services;
+using LCU.API.Internal.LoanRate.Services.LoadTestingServices;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LoanRateModels.Entities.LoadTestingEntities;
+using LCU.Library.Internal.LoanRateModels.Requests.LoadTestRequest;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests.LoadTestingServices;
+
+public class LoadTestRateCompletionServiceTest
+{
+    private readonly Mock<IRateProcessingInfoService> _mockRateProcessingInfoService;
+    private readonly Mock<ILoadTestRunInfoService> _mockLoadTestRunInfoService;
+    private readonly ILoadTestRateCompletionService _loadTestRateCompletionService;
+
+    public LoadTestRateCompletionServiceTest()
+    {
+        _mockRateProcessingInfoService = new Mock<IRateProcessingInfoService>();
+        _mockLoadTestRunInfoService = new Mock<ILoadTestRunInfoService>();
+        _loadTestRateCompletionService = new LoadTestRateCompletionService(_mockRateProcessingInfoService.Object, 
+                                                             _mockLoadTestRunInfoService.Object);
+    }
+    
+    [Fact]
+    public async void HandleLoadTestRateCompletion_Success()
+    {
+        var random = new Random();
+        var requestCount = random.Next(1, 100);
+        var requests = GenerateLoadTestRateCompletionRequests(random.Next(1, requestCount), requestCount);
+        var rateProcessingInfos = requests.Select(x => x.RateProcessingInfo).ToList();
+        var loadTestRunInfoGroups = rateProcessingInfos.GroupBy( p => p.LoadTestRunInfoId, p => p.RateProcessingInfoId);
+
+        await _loadTestRateCompletionService.HandleLoadTestRateCompletion(requests);
+        
+        _mockRateProcessingInfoService.Verify(x => x.UpdateRangeAsync(It.IsAny<IEnumerable<RateProcessingInfo>>()), Times.Once);
+        _mockLoadTestRunInfoService.Verify(x => x.IncreaseRateProcessingInfosCompleteCountAsync(It.IsAny<int>(), It.IsAny<int>()), Times.Exactly(loadTestRunInfoGroups.Count()));
+    }
+    
+    [Fact]
+    public void HandleLoadTestRateCompletion_Failure_ThrowsException()
+    {
+        var requests = GenerateLoadTestRateCompletionRequests(1, 2);
+        
+        _mockRateProcessingInfoService.Setup(x => x.UpdateRangeAsync(It.IsAny<IEnumerable<RateProcessingInfo>>())).ThrowsAsync(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>( async () => await _loadTestRateCompletionService.HandleLoadTestRateCompletion(requests));
+        
+        _mockRateProcessingInfoService.Verify(x => x.UpdateRangeAsync(It.IsAny<IEnumerable<RateProcessingInfo>>()), Times.Once);
+        _mockLoadTestRunInfoService.Verify(x => x.IncreaseRateProcessingInfosCompleteCountAsync(It.IsAny<int>(), It.IsAny<int>()), Times.Never);
+    }
+
+    private List<LoadTestRateCompletionRequest> GenerateLoadTestRateCompletionRequests(int loadTestCount, int rateProcessingInfoCount)
+    {
+        var random = new Random();
+        
+        var loadTestIds = new List<int>();
+        for (var i = 0; i < loadTestCount; i++)
+        {
+            loadTestIds.Add(random.Next(1, int.MaxValue));
+        }
+
+        var requests = new List<LoadTestRateCompletionRequest>();
+        for (var i = 0; i < rateProcessingInfoCount; i++)
+        {
+            requests.Add(new LoadTestRateCompletionRequest
+            {
+                RateProcessingInfo = new RateProcessingInfo
+                {
+                    LoadTestRunInfoId = loadTestIds[random.Next(0, loadTestCount - 1)],
+                    RateProcessingInfoId = random.Next(1, int.MaxValue)
+                }
+            });
+        }
+
+        return requests;
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/LoanRateOperationServicesTests/RateFinderServiceTest.cs

@@ -0,0 +1,382 @@
+using LCU.Library.Internal.LcuEvaluation.Services;
+using LCU.Library.Internal.LcuEvaluationModels.Entities;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LoanRateModels.Requests;
+using LCU.API.Internal.LoanRate.Services.LoanRateOperationServices;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.Library.Internal.LcuEvaluation.Services.EvaluationServices;
+using LCU.Library.Internal.LcuEvaluationModels.Enums;
+using LCU.Library.Internal.LcuEvaluationModels.Requests;
+using LCU.Library.Internal.LoanRateModels.Enums;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests.LoanRateOperationServicesTests;
+
+public class RateFinderServiceTest
+{
+    private readonly RateFinderService _rateFinderService;
+    private readonly Mock<IEvaluationDetailService> _mockEvaluationDetailService;
+    private readonly Mock<IRateService> _mockRateService;
+    private readonly Mock<IRateSheetService> _mockRateSheetService;
+    private readonly Mock<IRateEvaluationService> _mockRateEvaluationService;
+    private readonly Mock<IRunRuleService> _mockRunEvaluationService;
+    private readonly Mock<IRunCalculationService> _mockRunCalculationService;
+
+    public RateFinderServiceTest()
+    {
+        _mockEvaluationDetailService = new Mock<IEvaluationDetailService>();
+        _mockRateService = new Mock<IRateService>();
+        _mockRateSheetService = new Mock<IRateSheetService>();
+        _mockRateEvaluationService = new Mock<IRateEvaluationService>();
+        _mockRunEvaluationService = new Mock<IRunRuleService>();
+        _mockRunCalculationService = new Mock<IRunCalculationService>();
+        _rateFinderService = new RateFinderService(_mockEvaluationDetailService.Object,
+                                                   _mockRateService.Object,
+                                                   _mockRateSheetService.Object,
+                                                   _mockRateEvaluationService.Object,
+                                                   _mockRunEvaluationService.Object,
+                                                   _mockRunCalculationService.Object);
+    }
+
+    [Fact]
+    public void FindRate_NoEvaluationsReturned_Exception()
+    {
+        var rateRequest = new RateRequest { ApplicationDate = DateTime.Now};
+        var rateSheetIds = new List<int> { 1, 2, 3 };
+        _mockRateSheetService.Setup(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat)).ReturnsAsync(rateSheetIds);
+        _mockRateEvaluationService.Setup(x => x.GetByRateSheetIdsAsync(rateSheetIds)).ReturnsAsync(new List<RateEvaluation>());
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, new List<int>())).ReturnsAsync(new List<EvaluationDetail>()).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _rateFinderService.FindRate(rateRequest));
+
+        _mockRateSheetService.Verify(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat), Times.Once);
+        _mockRateEvaluationService.Verify(x => x.GetByRateSheetIdsAsync(rateSheetIds), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, new List<int>()), Times.Once);
+    }
+    
+    [Fact]
+    public async Task FindRate_NoRatesReturned_ReturnDefault()
+    {
+        var rateRequest = new RateRequest { ApplicationDate = DateTime.Now};
+        var rateSheetIds = new List<int> { 1, 2, 3 };
+
+        var rateEvaluations = new List<RateEvaluation> {
+            new RateEvaluation
+            {
+                EvaluationDetailId = 1
+            },
+            new RateEvaluation
+            {
+                EvaluationDetailId = 2
+            }
+        };
+        var ratesEvaluationDetailIds = rateEvaluations.GroupBy(rateEvaluation => rateEvaluation.EvaluationDetailId)
+                                                     .Select(group => group.First().EvaluationDetailId)
+                                                     .ToList();
+
+        _mockRateSheetService.Setup(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat)).ReturnsAsync(rateSheetIds);
+        _mockRateEvaluationService.Setup(x => x.GetByRateSheetIdsAsync(rateSheetIds)).ReturnsAsync(rateEvaluations);
+
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, ratesEvaluationDetailIds)).ReturnsAsync(GetFakeEvaluations()).Verifiable();
+
+        var evaluationsReturned = new List<EvaluationDetail>()
+        {
+            new EvaluationDetail
+            {
+               EvaluationDetailId = 1
+            },
+             new EvaluationDetail
+            {
+                EvaluationDetailId = 2
+            }
+        };
+        _mockRunEvaluationService.Setup(x => x.ValidateRequestRules(rateRequest, It.IsAny<List<EvaluationDetail>>())).Returns(evaluationsReturned).Verifiable();
+        
+        var evaluationIds = evaluationsReturned.Select(evaluationReturned => evaluationReturned.EvaluationDetailId).ToList();
+        _mockRateService.Setup(x => x.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), evaluationIds, EvaluationTypes.Rule)).ReturnsAsync(new List<Rate>()).Verifiable();
+
+        var possibleCalculationIds = new List<int> { 1, 2 };
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Calculation, possibleCalculationIds)).ReturnsAsync(GetFakeCalculationsEvaluations()).Verifiable();
+
+
+        _mockRunCalculationService.Setup(x => x.CalculateEvaluationWithSetOfRequests(It.IsAny<List<RateRequest>>(), It.IsAny<EvaluationDetail>()))
+                                  .Returns(new List<EvaluationDetail>());
+        var result = await _rateFinderService.FindRate(rateRequest);
+        Assert.Equal(99, result.Rate);
+
+        _mockRateSheetService.Verify(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat), Times.Once);
+        _mockRateEvaluationService.Verify(x => x.GetByRateSheetIdsAsync(rateSheetIds), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, ratesEvaluationDetailIds), Times.Once); ;
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()), Times.Once);
+        _mockRunCalculationService.Verify(x => x.CalculateEvaluationWithSetOfRequests(It.IsAny<List<EvaluationRequest>>(), It.IsAny<EvaluationDetail>()), Times.Never);
+    }
+
+    [Fact]
+    public void FindRate_NoRatesReturned_Exception()
+    {
+        var rateRequest = new RateRequest { ApplicationDate = DateTime.Now};
+        var rateSheetIds = new List<int> { 1, 2, 3 };
+        var rateEvaluations = new List<RateEvaluation> {
+            new RateEvaluation
+            {
+                EvaluationDetailId = 600
+            },
+            new RateEvaluation
+            {
+                EvaluationDetailId = 700
+            }
+        };
+        var ratesEvaluationDetailIds = rateEvaluations.GroupBy(rateEvaluation => rateEvaluation.EvaluationDetailId)
+                                                     .Select(group => group.First().EvaluationDetailId)
+                                                     .ToList();
+
+        _mockRateSheetService.Setup(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat)).ReturnsAsync(rateSheetIds);
+        _mockRateEvaluationService.Setup(x => x.GetByRateSheetIdsAsync(rateSheetIds)).ReturnsAsync(rateEvaluations);
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate ,EvaluationTypes.Rule, ratesEvaluationDetailIds)).ReturnsAsync(GetFakeEvaluations()).Verifiable();
+
+        var evaluationsReturned = new List<EvaluationDetail>
+        {
+            new EvaluationDetail
+            {
+               EvaluationDetailId = 600
+            },
+             new EvaluationDetail
+            {
+                EvaluationDetailId = 700
+            }
+        };
+        _mockRunEvaluationService.Setup(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>())).Returns(evaluationsReturned).Verifiable();
+
+        var evaluationIds = new List<int> { 600, 700};
+        var date = Convert.ToDateTime("1/1/2023");
+        _mockRateService.Setup(x => x.GetByDateEvaluationIdAndEvaluationTypeAsync(date, evaluationIds, EvaluationTypes.Rule)).ReturnsAsync(GetFakeRates()).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _rateFinderService.FindRate(rateRequest));
+
+        _mockRateSheetService.Verify(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat), Times.Once);
+        _mockRateEvaluationService.Verify(x => x.GetByRateSheetIdsAsync(rateSheetIds), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, ratesEvaluationDetailIds), Times.Once);
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()), Times.Once);
+        _mockRunCalculationService.Verify(x => x.CalculateEvaluationWithSetOfRequests(It.IsAny<List<EvaluationRequest>>(), It.IsAny<EvaluationDetail>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task FindRate_RatesReturned_Success()
+    {
+        var rateRequest = new RateRequest { ApplicationDate = DateTime.Now };
+        var rateSheetIds = new List<int> { 1, 2, 3 };
+
+        var rateEvaluations = new List<RateEvaluation> {
+            new RateEvaluation
+            {
+                EvaluationDetailId = 1
+            },
+            new RateEvaluation
+            {
+                EvaluationDetailId = 2
+            }
+        };
+        var ratesEvaluationDetailIds = rateEvaluations.GroupBy(rateEvaluation => rateEvaluation.EvaluationDetailId)
+                                                     .Select(group => group.First().EvaluationDetailId)
+                                                     .ToList();
+
+        _mockRateSheetService.Setup(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat)).ReturnsAsync(rateSheetIds);
+        _mockRateEvaluationService.Setup(x => x.GetByRateSheetIdsAsync(rateSheetIds)).ReturnsAsync(rateEvaluations);
+
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, ratesEvaluationDetailIds)).ReturnsAsync(GetFakeEvaluations()).Verifiable();
+
+        var evaluationsReturned = new List<EvaluationDetail>()
+        {
+            new EvaluationDetail
+            {
+               EvaluationDetailId = 1
+            },
+             new EvaluationDetail
+            {
+                EvaluationDetailId = 2
+            }
+        };
+        _mockRunEvaluationService.Setup(x => x.ValidateRequestRules(rateRequest, It.IsAny<List<EvaluationDetail>>())).Returns(evaluationsReturned).Verifiable();
+        
+        var evaluationIds = evaluationsReturned.Select(evaluationReturned => evaluationReturned.EvaluationDetailId).ToList();
+        var rate = GetFakeRates().Where(rate => rate.RateId == 1);
+        _mockRateService.Setup(x => x.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), evaluationIds, EvaluationTypes.Rule)).ReturnsAsync(rate).Verifiable();
+
+        var possibleCalculationIds = new List<int> { 1, 2 };
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Calculation, possibleCalculationIds)).ReturnsAsync(GetFakeCalculationsEvaluations()).Verifiable();
+
+
+        _mockRunCalculationService.Setup(x => x.CalculateEvaluationWithSetOfRequests(It.IsAny<List<RateRequest>>(), It.IsAny<EvaluationDetail>()))
+                                  .Returns(new List<EvaluationDetail>());
+        var result = await _rateFinderService.FindRate(rateRequest);
+        Assert.Equal(5.49M, result.Rate);
+
+        _mockRateSheetService.Verify(x => x.GetRateSheetIdsByRateTypeAsync(RateTypes.DirectBoat), Times.Once);
+        _mockRateEvaluationService.Verify(x => x.GetByRateSheetIdsAsync(rateSheetIds), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, ratesEvaluationDetailIds), Times.Once); ;
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()), Times.Once);
+        _mockRunCalculationService.Verify(x => x.CalculateEvaluationWithSetOfRequests(It.IsAny<List<EvaluationRequest>>(), It.IsAny<EvaluationDetail>()), Times.Exactly(2));
+    }
+
+    public static List<EvaluationDetail> GetFakeEvaluations()
+    {
+        var evaluationBuilder1 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 1,
+            Description = "CreditScore Greater Than Or Equal 740.",
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.CreditScore"),
+                new EvaluationParameter(1, ParameterTypes.GreaterThanOrEqual, ""),
+                new EvaluationParameter(2, ParameterTypes.TextInput, "740")
+            }
+        };
+
+        var evaluationBuilder2 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 2,
+            Description = "Model Year Greater than or Equal 2022.",
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.ModelYear"),
+                new EvaluationParameter(1, ParameterTypes.GreaterThanOrEqual, ""),
+                new EvaluationParameter(2, ParameterTypes.TextInput, "2022")
+            }
+        };
+
+        var evaluationBuilder3 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 3,
+            Description = "Model Year Equal 2021.",
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+               new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.ModelYear"),
+               new EvaluationParameter(1, ParameterTypes.Equal, ""),
+               new EvaluationParameter(2, ParameterTypes.TextInput, "2021")
+            }
+        };
+
+        var evaluationBuilder4 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 4,
+            Description = "CreditScore Greater Than Or Equal 700 AND Less Than Or Equal 739.",
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+               new EvaluationParameter(0, ParameterTypes.ParenthesesStart, ""),
+               new EvaluationParameter(1, ParameterTypes.Variable, "RateRequest.CreditScore"),
+               new EvaluationParameter(2, ParameterTypes.GreaterThanOrEqual, ""),
+               new EvaluationParameter(3, ParameterTypes.TextInput, "700"),
+               new EvaluationParameter(4, ParameterTypes.ParenthesesEnd, ""),
+               new EvaluationParameter(5, ParameterTypes.And, ""),
+               new EvaluationParameter(6, ParameterTypes.ParenthesesStart, ""),
+               new EvaluationParameter(7, ParameterTypes.Variable, "RateRequest.CreditScore"),
+               new EvaluationParameter(8, ParameterTypes.LessThanOrEqual, ""),
+               new EvaluationParameter(9, ParameterTypes.TextInput, "739"),
+               new EvaluationParameter(10, ParameterTypes.ParenthesesEnd, "")
+            }
+        };
+
+        var evaluations = new List<EvaluationDetail>() { evaluationBuilder1, evaluationBuilder2, evaluationBuilder3, evaluationBuilder4 };
+        return evaluations;
+    }
+
+    public static List<EvaluationDetail> GetFakeCalculationsEvaluations()
+    {
+        var evaluationBuilder1 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 5,
+            Description = "CreditScore - 1.",
+            EvaluationReturnType = EvaluationReturnTypes.Decimal,
+            EvaluationType = EvaluationTypes.Calculation,
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.CreditScore"),
+                new EvaluationParameter(1, ParameterTypes.Subtraction, ""),
+                new EvaluationParameter(2, ParameterTypes.TextInput, "1")
+            }
+        };
+
+        var evaluationBuilder2 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 6,
+            Description = "CreditScore - 2.",
+            EvaluationReturnType = EvaluationReturnTypes.Decimal,
+            EvaluationType = EvaluationTypes.Calculation,
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.CreditScore"),
+                new EvaluationParameter(1, ParameterTypes.Subtraction, ""),
+                new EvaluationParameter(2, ParameterTypes.TextInput, "2")
+            }
+        };
+
+        var evaluations = new List<EvaluationDetail>() { evaluationBuilder1, evaluationBuilder2 };
+        return evaluations;
+    }
+
+    public static List<Rate> GetFakeRates()
+    {
+        var rate1 = new Rate()
+        {
+            RateId = 1,
+            Value = 5.49M,            
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 1,
+                    RateId = 1,
+                    EvaluationDetailId = 1,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 2,
+                    RateId = 1,
+                    EvaluationDetailId = 2,
+                }
+            }
+        };
+
+        var rate2 = new Rate()
+        {
+            RateId = 2,
+            Value = 5.50M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 3,
+                    RateId = 2,
+                    EvaluationDetailId = 1,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 4,
+                    RateId = 2,
+                    EvaluationDetailId = 3,
+                }
+            }
+        };
+
+        var rate3 = new Rate()
+        {
+            RateId = 3,
+            Value = 5.51M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 5,
+                    RateId = 3,
+                    EvaluationDetailId = 4,
+                }
+            }
+        };
+
+        var rates = new List<Rate>() { rate1, rate2, rate3 };
+        return rates;
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/LoanRateOperationServicesTests/RateUploaderServiceTest.cs

@@ -0,0 +1,781 @@
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.Library.Internal.LcuEvaluation.Services;
+using LCU.Library.Internal.Exceptions;
+using LCU.Api.Internal.FileOperationsLib.Models.ExcelModels.Requests;
+using LCU.API.Internal.LoanRate.Services.LoanRateOperationServices;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.API.Internal.LoanRate.Services.MicroApiServices;
+using LCU.Api.Internal.FileOperationsLib.Models.ExcelModels.Responses;
+using LCU.Library.Internal.LcuEvaluationModels.Entities;
+using LCU.Library.Internal.LoanRateModels.Enums;
+using LCU.Library.Internal.LoanRateModels.Requests;
+using LCU.Library.Internal.TypeExtensions.EnumExtensions;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests.LoanRateOperationServicesTests;
+
+public class RateUploaderServiceTest
+{
+    private readonly RateUploaderService _rateUploaderService;
+    private readonly Mock<IRateService> _mockRateService;
+    private readonly Mock<IRateSheetService> _mockRateSheetService;
+    private readonly Mock<IEvaluationDetailService> _mockEvaluationDetailService;
+    private readonly Mock<IRateEvaluationService> _mockRateEvaluationService;
+    private readonly Mock<IRateUploadInfoService> _mockRateUploadInfoService;
+    private readonly Mock<IFileOperationsApiService> _mockFileOperationsApiService;
+
+    public RateUploaderServiceTest()
+    {
+        _mockRateService = new Mock<IRateService>();
+        _mockRateSheetService = new Mock<IRateSheetService>();
+        _mockFileOperationsApiService = new Mock<IFileOperationsApiService>();
+        _mockEvaluationDetailService = new Mock<IEvaluationDetailService>();
+        _mockRateEvaluationService = new Mock<IRateEvaluationService>();
+        _mockRateUploadInfoService = new Mock<IRateUploadInfoService>();
+        _rateUploaderService = new RateUploaderService(_mockRateService.Object,
+                                                       _mockRateSheetService.Object, 
+                                                       _mockEvaluationDetailService.Object, 
+                                                       _mockRateEvaluationService.Object,
+                                                       _mockRateUploadInfoService.Object,
+                                                       _mockFileOperationsApiService.Object);
+    }
+
+    public ExcelDataResponse FakeExcelDataResponse()
+    {
+        return new ExcelDataResponse
+        {
+            WorkBook = new WorkBook
+            {
+                SheetResponses = new List<SheetResponse>
+                {
+                    new SheetResponse(RateTypes.DirectAuto.GetNameFromValue())
+                    {
+                        CellResponses = new List<CellResponse>
+                        {
+                            new CellResponse
+                            {
+                                ColumnName = "A",
+                                Row = 10,
+                                Value = "2.2",
+                                Formula = ""
+                            },
+                            new CellResponse
+                            {
+                                ColumnName = "B",
+                                Row = 11,
+                                Value = "2.3",
+                                Formula = ""
+                            },
+                            new CellResponse
+                            {
+                                ColumnName = "C",
+                                Row = 12,
+                                Value = "2.4",
+                                Formula = ""
+                            },
+                            new CellResponse
+                            {
+                                ColumnName = "D",
+                                Row = 13,
+                                Value = "2.5",
+                                Formula = ""
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+
+    public List<Rate> FakeRates()
+    {
+        return new List<Rate>
+        {
+            new Rate
+            {
+                RateId = 1,
+                Column = "A",
+                Row = "10",
+                RateSheetId = 1,
+                Value = 2.1M,
+                RateStartDate = Convert.ToDateTime("1-1-2023"),
+                RateEvaluations = new List<RateEvaluation>
+                {
+                    new RateEvaluation
+                    {
+                        RateEvaluationId = 1,
+                        RateId = 1,
+                        EvaluationDetailId = 1
+                    }
+                }
+            },
+            new Rate
+            {
+                RateId = 2,
+                Column = "B",
+                Row = "11",
+                RateSheetId = 1,
+                Value = 0.0M,
+                RateStartDate = Convert.ToDateTime("1-1-2023"),
+                RateEvaluations = new List<RateEvaluation>
+                {
+                     new RateEvaluation
+                    {
+                        RateEvaluationId = 2,
+                        RateId = 2,
+                        EvaluationDetailId = 2
+                    }
+                }
+            }
+        };
+    }
+
+    public List<Rate> FakeRatesToUpdate()
+    {
+        return new List<Rate>()
+        {
+             new Rate
+            {
+                RateId = 1,
+                Column = "A",
+                Row = "10",
+                RateSheetId = 1,
+                Value = 2.2M,
+                RateStartDate = Convert.ToDateTime("1-1-2023"),
+                RateEvaluations = new List<RateEvaluation>
+                {
+                    new RateEvaluation
+                    {
+                        RateEvaluationId = 1,
+                        RateId = 1,
+                        EvaluationDetailId = 1
+                    }
+                }
+            },
+            new Rate
+            {
+                RateId = 2,
+                Column = "B",
+                Row = "11",
+                RateSheetId = 1,
+                Value = 2.3M,
+                RateStartDate = Convert.ToDateTime("1-1-2023"),
+                RateEvaluations = new List<RateEvaluation>
+                {
+                     new RateEvaluation
+                    {
+                        RateEvaluationId = 2,
+                        RateId = 2,
+                        EvaluationDetailId = 2
+                    }
+                }
+            }
+        };
+    }
+
+    public List<Rate> FakeRatesToCreate()
+    {
+        return new List<Rate>
+        {
+           new Rate
+            {
+                RateId = 0,
+                Column = "C",
+                Row = "12",
+                RateSheetId = 1,
+                Value = 2.4M,
+                RateStartDate = Convert.ToDateTime("1-1-2023")
+            },
+            new Rate
+            {
+                RateId = 0,
+                Column = "D",
+                Row = "13",
+                RateSheetId = 1,
+                Value = 2.5M,
+                RateStartDate = Convert.ToDateTime("1-1-2023")
+            }
+        };
+    }
+
+    private List<RateSheet> FakeRateSheets()
+    {
+        var rateTypes = Enum.GetValues(typeof(RateTypes)).Cast<RateTypes>().ToList();
+        return rateTypes.Select((t, i) => new RateSheet { RateSheetId = i + 1, RateType = t }).ToList();
+    }
+
+    private RateUploadInfo FakeRateUploadInfo()
+        => new ()
+        {
+            EffectiveDate = DateTime.Now
+        };
+
+    [Fact]
+    public async Task RateUploader_UploadRates_RateExcelPath_Success()
+    {
+        var effectiveDate = DateTime.Now;
+        var request = new RateUploadRequest
+        {
+            FileName = "Test",
+            FileContent = "Test",
+            EffectiveDate = effectiveDate
+        };
+
+        var excelDataResponse = new ExcelDataResponse
+        {
+            WorkBook = new WorkBook
+            {
+                SheetResponses = new List<SheetResponse>
+                {
+                    new SheetResponse(RateTypes.DirectBoat.GetNameFromValue())
+                    {
+                        CellResponses = new List<CellResponse>
+                        {
+                            new CellResponse
+                            {
+                                ColumnName = "A",
+                                Row = 10,
+                                Value = "2.2",
+                                Formula = ""
+                            },
+                            new CellResponse
+                            {
+                                ColumnName = "B",
+                                Row = 11,
+                                Value = "2.3",
+                                Formula = ""
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        var rates = FakeRates();
+        var rateSheets = FakeRateSheets();
+        var ratesToCreate = FakeRatesToCreate();
+        var previousRateUploadInfo = FakeRateUploadInfo();
+
+        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
+        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
+        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>())).ReturnsAsync(excelDataResponse).Verifiable();
+        
+        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
+        _mockRateUploadInfoService.Setup(x => x.GetLatestVersionOnDate(effectiveDate)).ReturnsAsync(previousRateUploadInfo).Verifiable();
+
+        await _rateUploaderService.UploadRates(request);
+
+        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
+        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);        
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Once);
+    }
+
+    [Fact]
+    public void RateUploader_UploadRates_RateExcelPath_RateServiceGetByDate_ThrowsException()
+    {
+        var request = new RateUploadRequest
+        {
+            FileContent = "Test",
+            FileName = "Test",
+            EffectiveDate = DateTime.Now
+        };
+        
+        var excelDataResponse = FakeExcelDataResponse();
+        var ratesToUpdate = FakeRatesToUpdate();
+        var ratesToCreate = FakeRatesToCreate();
+
+        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).Throws(new Exception("Test")).Verifiable();
+        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>())).ReturnsAsync(excelDataResponse).Verifiable();
+        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
+        _mockRateService.Setup(x => x.UpdateRangeAsync(ratesToUpdate)).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));        
+        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
+        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Never);
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+        _mockRateService.Verify(x => x.UpdateRangeAsync(It.Is<List<Rate>>(rates => rates.Count() == 2)), Times.Never);
+    }
+
+    [Fact]
+    public void RateUploader_UploadRates_RateExcelPath_FileOperations_ThrowsException()
+    {
+        var request = new RateUploadRequest
+        {
+            FileName = "Test",
+            FileContent = "Test",
+            EffectiveDate = DateTime.Now
+        };
+
+        var rates = FakeRates();
+        var rateSheets = FakeRateSheets();
+        var ratesToUpdate = FakeRatesToUpdate();
+        var ratesToCreate = FakeRatesToCreate();
+
+        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
+        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
+        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>())).Throws(new Exception("Test")).Verifiable();       
+        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
+        _mockRateService.Setup(x => x.UpdateRangeAsync(ratesToUpdate)).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));
+
+        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
+        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
+        
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+        _mockRateService.Verify(x => x.UpdateRangeAsync(It.Is<List<Rate>>(rates => rates.Count() == 2)), Times.Never);
+    }    
+
+    [Fact]
+    public async Task RateUploader_UploadRates_ExcelDataRequest_Success()
+    {
+        var effectiveDate = DateTime.Now;
+        var fileContent = "Test";
+        var request = new RateUploadExcelDataRequest
+        {
+            EffectiveDate = effectiveDate,
+            ExcelDataRequest = new ExcelDataRequest
+            {
+                FileContent = fileContent,
+                SheetRequests = new List<SheetRequest>
+                {
+                    new()
+                    {
+                        SheetName = RateTypes.DirectBoat.GetNameFromValue(),
+                        Rows = new List<int> { 10, 11, 12, 13 },
+                        Columns = new List<string> { "A", "B", "C", "D" }
+                    }
+                }
+            }
+        };
+
+        var excelDataResponse = FakeExcelDataResponse();
+        var rates = FakeRates();
+        var rateSheets = FakeRateSheets();
+        var previousRateUploadInfo = FakeRateUploadInfo();
+
+        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(request.ExcelDataRequest)).ReturnsAsync(excelDataResponse).Verifiable();
+        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
+        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
+        _mockRateUploadInfoService.Setup(x => x.SaveAsync(It.IsAny<RateUploadInfo>())).Verifiable();
+        _mockRateUploadInfoService.Setup(x => x.GetLatestVersionOnDate(effectiveDate)).ReturnsAsync(previousRateUploadInfo).Verifiable();
+
+        await _rateUploaderService.UploadRates(request);
+
+        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Once);
+    }
+
+    [Fact]
+    public void RateUploader_UploadRates_ExcelDataRequest_FileOperations_ThrowsException()
+    {
+        var fileContent = "Test";
+        var request = new RateUploadExcelDataRequest
+        {
+            EffectiveDate = DateTime.Now,
+            ExcelDataRequest = new ExcelDataRequest
+            {
+                FileContent = fileContent,
+                SheetRequests = new List<SheetRequest>
+                {
+                    new()
+                    {
+                        SheetName = "Test",
+                        Rows = new List<int> { 10, 11, 12, 13 },
+                        Columns = new List<string> { "A", "B", "C", "D" }
+                    }
+                }
+            }
+        };
+
+        var rates = FakeRates();
+        var ratesToCreate = FakeRatesToCreate();
+
+        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(request.ExcelDataRequest)).Throws(new Exception("Test")).Verifiable();
+        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).ReturnsAsync(rates);
+        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));
+
+        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Never);
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+    }
+
+    [Fact]
+    public void RateUploader_UploadRates_ExcelDataRequest_RateServiceGetByDate_ThrowsException()
+    {
+        var fileContent = "Test";
+        var request = new RateUploadExcelDataRequest
+        {
+            EffectiveDate = DateTime.Now,
+            ExcelDataRequest = new ExcelDataRequest
+            {
+                FileContent = fileContent,
+                SheetRequests = new List<SheetRequest>
+                {
+                    new()
+                    {
+                        SheetName = "Test",
+                        Rows = new List<int> { 10, 11, 12, 13 },
+                        Columns = new List<string> { "A", "B", "C", "D" }
+                    }
+                }
+            }
+        };
+
+        var excelDataResponse = FakeExcelDataResponse();
+        var ratesToCreate = FakeRatesToCreate();
+
+        _mockFileOperationsApiService.Setup(x => x.DirectExtractExcelWorkBookData(request.ExcelDataRequest)).ReturnsAsync(excelDataResponse).Verifiable();
+        _mockRateService.Setup(x => x.GetByDateAsync(It.IsAny<DateTime>())).Throws(new Exception("Test")).Verifiable();
+        _mockRateUploadInfoService.Setup(x => x.SaveAsync( It.Is<RateUploadInfo>(rateUploadInfo => rateUploadInfo.Rates.Count == ratesToCreate.Count)));
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.UploadRates(request));
+
+        _mockFileOperationsApiService.Verify(x => x.DirectExtractExcelWorkBookData(It.IsAny<ExcelDataRequest>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByDateAsync(It.IsAny<DateTime>()), Times.Once);
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+    }
+
+    [Fact]
+    public void RateUploader_BuildExcelDataRequest_Succcess()
+    {
+        var rateExcelContent = "Test";
+        var rates = FakeRates();
+        var rateSheets = FakeRateSheets();
+        var excelDataRequest = _rateUploaderService.BuildExcelDataRequest(rateExcelContent, rates, rateSheets);
+
+        Assert.NotNull(excelDataRequest);
+        Assert.NotNull(excelDataRequest.SheetRequests);
+        Assert.Single(excelDataRequest.SheetRequests);
+        var sheetRequest = excelDataRequest.SheetRequests.FirstOrDefault();
+        Assert.NotNull(sheetRequest);
+        Assert.NotNull(sheetRequest.Rows);
+        Assert.Equal(2, sheetRequest.Rows.Count);
+        Assert.NotNull(sheetRequest.Columns);
+        Assert.Equal(2, sheetRequest.Columns.Count);
+        Assert.Equal(rateExcelContent, excelDataRequest.FileContent);
+    }
+
+    [Fact]
+    public async Task RateUploader_WorkThroughExcelDataResponseAndUpdateRates_Success()
+    {
+        var excelDataResponse = FakeExcelDataResponse();
+        var rates = FakeRates();
+        var rateSheets = FakeRateSheets();
+        var ratesToCreate = FakeRatesToCreate();
+        var rateUploadInfo = FakeRateUploadInfo();
+        rateUploadInfo.Rates = ratesToCreate;
+
+        _mockRateUploadInfoService.Setup(x => x.SaveAsync(It.IsAny<RateUploadInfo>())).Verifiable();
+
+        await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now);
+
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task RateUploader_WorkThroughExcelDataResponseAndUpdateRates_NullWorkbook_Done()
+    {
+        var excelDataResponse = new ExcelDataResponse
+        {
+            WorkBook = null
+        };
+        var rates = FakeRates();
+        var rateSheets = FakeRateSheets();
+        var rateUploadInfo = FakeRateUploadInfo();
+
+        await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now);
+
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task RateUploader_WorkThroughExcelDataResponseAndUpdateRates_NullSheetResponses_Done()
+    {
+        var excelDataResponse = new ExcelDataResponse
+        {
+            WorkBook = new WorkBook
+            {
+                SheetResponses = null
+            }
+        };
+        var rates = FakeRates();
+        var rateSheets = FakeRateSheets();
+        var rateUploadInfo = FakeRateUploadInfo();
+
+        await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now);
+
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
+    }
+
+    [Fact]
+    public void RateUploader_WorkThroughExcelDataResponseAndUpdateRates_NonDecimalCellValue_ServiceException()
+    {
+        var excelDataResponse = new ExcelDataResponse
+        {
+            WorkBook = new WorkBook
+            {
+                SheetResponses = new List<SheetResponse>
+                {
+                    new SheetResponse("Test")
+                    {
+                        CellResponses = new List<CellResponse>
+                        {
+                            new CellResponse
+                            {
+                                ColumnName = "A",
+                                Row = 10,
+                                Value = "2.2",
+                                Formula = ""
+                            },
+                            new CellResponse
+                            {
+                                ColumnName = "B",
+                                Row = 11,
+                                Value = "2.3",
+                                Formula = ""
+                            },
+                            new CellResponse
+                            {
+                                ColumnName = "C",
+                                Row = 12,
+                                Value = "TEST",
+                                Formula = ""
+                            },
+                            new CellResponse
+                            {
+                                ColumnName = "D",
+                                Row = 13,
+                                Value = "2.5",
+                                Formula = ""
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        var rates = FakeRates();
+        var rateSheets  = FakeRateSheets();
+        var rateUploadInfo = FakeRateUploadInfo();
+
+        Assert.ThrowsAsync<ServiceException>(
+            async () => await _rateUploaderService.WorkThroughExcelDataResponseAndUpdateRates(excelDataResponse, rateUploadInfo, rates, rateSheets, DateTime.Now));
+        _mockRateUploadInfoService.Verify(x => x.SaveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
+    }
+    
+    [Fact]
+    public async Task RateUploader_InitiateRatesEvaluations_Success()
+    {
+        var rateSheets = FakeRateSheets();
+        var requests = new List<InitiateRatesEvaluationsRequest>
+        {
+            new()
+            {
+                SheetName = rateSheets[0].SheetName,
+                EvaluationDetailId = DateTime.Now.Millisecond,
+                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
+            },
+            new()
+            {
+                SheetName = rateSheets[1].SheetName,
+                EvaluationDetailId = DateTime.Now.Millisecond,
+                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
+            },
+            new()
+            {
+                SheetName = rateSheets[2].SheetName,
+                EvaluationDetailId = DateTime.Now.Millisecond,
+                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
+            }
+        };
+
+        var rules = new List<EvaluationDetail>
+        {
+            new() { EvaluationDetailId = requests[0].EvaluationDetailId },
+            new() { EvaluationDetailId = requests[1].EvaluationDetailId },
+            new() { EvaluationDetailId = requests[2].EvaluationDetailId }
+        };
+
+        var rates = new List<Rate>
+        {
+            new()
+            {
+                RateSheetId = rateSheets[0].RateSheetId, 
+                Column = requests[0].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[0].RateSheetId, 
+                Column = requests[0].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[0].RateSheetId, 
+                Row = requests[0].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[1].RateSheetId,
+                Column = requests[1].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[1].RateSheetId,
+                Column = requests[1].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[2].RateSheetId,
+                Column = requests[2].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            }
+        };
+
+        var tab1 = rates.Where(rate => rate.RateSheetId == rateSheets[0].RateSheetId);
+        var tab2 = rates.Where(rate => rate.RateSheetId == rateSheets[1].RateSheetId);
+        var tab3 = rates.Where(rate => rate.RateSheetId == rateSheets[2].RateSheetId);
+        
+        _mockRateSheetService.SetupSequence(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>())).ReturnsAsync(tab1)
+                                                                                                  .ReturnsAsync(tab2)
+                                                                                                  .ReturnsAsync(tab3);
+        _mockEvaluationDetailService.SetupSequence(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(rules[0])
+                                                                                        .ReturnsAsync(rules[1])
+                                                                                        .ReturnsAsync(rules[2]);
+
+        var result = (await _rateUploaderService.InitiateRatesEvaluations(requests)).ToList();
+        Assert.NotNull(result);
+        Assert.NotEmpty(result);
+        Assert.Equal(3, result.Count(x => x.Success));
+
+        _mockRateSheetService.Verify(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>()), Times.Exactly(3));
+        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Exactly(3));
+        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.Is<List<RateEvaluation>>( savedRates => savedRates.Count == 5 )), Times.Once);
+    }
+    
+        [Fact]
+    public async Task RateUploader_InitiateRatesEvaluations_NotFound_Success()
+    {
+        var rateSheets = FakeRateSheets();
+        var requests = new List<InitiateRatesEvaluationsRequest>
+        {
+            new()
+            {
+                SheetName = rateSheets[0].SheetName,
+                EvaluationDetailId = DateTime.Now.Millisecond,
+                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
+            },
+            new()
+            {
+                SheetName = rateSheets[1].SheetName,
+                EvaluationDetailId = DateTime.Now.Millisecond,
+                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
+            },
+            new()
+            {
+                SheetName = rateSheets[2].SheetName,
+                EvaluationDetailId = DateTime.Now.Millisecond,
+                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
+            }
+        };
+
+        var rules = new List<EvaluationDetail>
+        {
+            new() { EvaluationDetailId = requests[0].EvaluationDetailId },
+            null,
+            new() { EvaluationDetailId = requests[2].EvaluationDetailId }
+        };
+
+        var rates = new List<Rate>
+        {
+            new()
+            {
+                RateSheetId = rateSheets[0].RateSheetId, 
+                Column = requests[0].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[0].RateSheetId, 
+                Column = requests[0].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[0].RateSheetId, 
+                Column = requests[0].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[1].RateSheetId,
+                Column = requests[1].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[1].RateSheetId,
+                Column = requests[1].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            },
+            new()
+            {
+                RateSheetId = rateSheets[2].RateSheetId,
+                Column = requests[2].RowsOrColumns[0],
+                RateEvaluations = new List<RateEvaluation>()
+            }
+        };
+
+        var tab1 = rates.Where(rate => rate.RateSheetId == rateSheets[0].RateSheetId);
+        var tab2 = rates.Where(rate => rate.RateSheetId == rateSheets[1].RateSheetId);
+        var tab3 = rates.Where(rate => rate.RateSheetId == rateSheets[2].RateSheetId);
+
+        _mockRateSheetService.Setup(x => x.GetAsync()).ReturnsAsync(rateSheets);
+        _mockRateSheetService.SetupSequence(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>())).ReturnsAsync(tab1)
+                                                                                                  .ReturnsAsync(tab2)
+                                                                                                  .ReturnsAsync(tab3);
+        _mockEvaluationDetailService.SetupSequence(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(rules[0])
+                                                                                        .ReturnsAsync(rules[1])
+                                                                                        .ReturnsAsync(rules[2]);
+
+        var result = (await _rateUploaderService.InitiateRatesEvaluations(requests)).ToList();
+        Assert.NotNull(result);
+        Assert.NotEmpty(result);
+        Assert.Equal(3, result.Count(x => x.Success));
+
+        _mockRateSheetService.Verify(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>()), Times.Exactly(3));
+        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Exactly(3));
+        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.Is<List<RateEvaluation>>( savedRates => savedRates.Count == 4 )), Times.Once);
+    }
+    
+    [Fact]
+    public async Task RateUploader_InitiateRatesEvaluations_ThrowsException_Failure()
+    {
+        var requests = new List<InitiateRatesEvaluationsRequest>
+        {
+            new()
+            {
+                SheetName = RateTypes.DirectMotorcycle.GetNameFromValue(),
+                EvaluationDetailId = DateTime.Now.Millisecond,
+                RowsOrColumns = new List<string> { Guid.NewGuid().ToString() }
+            }
+        };
+        
+        _mockRateSheetService.Setup(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>())).Throws(new Exception("Test")).Verifiable();
+
+        await Assert.ThrowsAsync<ServiceException>(async () => await _rateUploaderService.InitiateRatesEvaluations(requests));
+
+        _mockRateSheetService.Verify(x => x.GetRatesByRateTypeAsync(It.IsAny<RateTypes>()), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
+        _mockRateEvaluationService.Verify(x => x.SaveRangeAsync(It.IsAny<List<RateEvaluation>>()), Times.Never);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/LoanRateOperationServicesTests/RateValidationServiceTest.cs

@@ -0,0 +1,176 @@
+using LCU.API.Internal.LoanRate.Services;
+using LCU.API.Internal.LoanRate.Services.LoanRateOperationServices;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Utilities;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.Library.Internal.LoanRateModels.Responses.Validation;
+using LCU.Library.Internal.LoanRateModels.Responses.Validation.RateSheetValidations;
+using LCU.Library.Internal.TypeExtensions.ObjectExtensions;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests.LoanRateOperationServicesTests;
+public class RateValidationServiceTest
+{
+    private readonly RateValidationService _rateValidationService;
+    private readonly Mock<IRateService> _mockRateService;
+    public RateValidationServiceTest()
+    {
+        _mockRateService = new Mock<IRateService>();
+        _rateValidationService = new RateValidationService(_mockRateService.Object);
+    }
+    
+    [Fact]
+    public async Task RateValidation_ValidateAsync_Success_AllPass()
+    {
+        var rates = FakeRates();
+        
+        foreach (var rate in rates)
+        {
+            var originalRate = FakeNewRate(rate, decimal.ToInt32(rate.Value - new Random().Next(0, 10)), decimal.ToInt32(rate.Value));
+            var rateHistory = FakeRateHistory(rate,
+                                              originalRate,
+                                              decimal.ToInt32(rate.Value - new Random().Next(0, 10)), 
+                                              decimal.ToInt32(rate.Value + new Random().Next(0, 10)));
+            
+            _mockRateService.Setup(x => x.GetRateHistory(It.IsAny<Rate>())).ReturnsAsync(rateHistory);
+            _mockRateService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(originalRate);
+        }
+        
+        var result = await _rateValidationService.ValidateAsync(rates);
+        
+        Assert.NotNull(result);
+        Assert.True(result.All(x => x.Pass));
+        Assert.True(result.All(x => x.Validations.Count > 0));
+
+        _mockRateService.Verify(x => x.GetRateHistory(It.IsAny<Rate>()), Times.Exactly(rates.Count));
+        _mockRateService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Exactly(rates.Count));
+    }
+    
+    [Fact]
+    public async Task RateValidation_ValidateAsync_Success_DoesNotPassRange()
+    {
+        var rates = FakeRates();
+        
+        foreach (var rate in rates)
+        {
+            var originalRate = FakeNewRate(rate, decimal.ToInt32(rate.Value - new Random().Next(0, 10)), decimal.ToInt32(rate.Value));
+            var rateHistory = FakeRateHistory(rate,
+                                              originalRate,
+                                              decimal.ToInt32(rate.Value - new Random().Next(0, 10)), 
+                                              decimal.ToInt32(rate.Value + new Random().Next(0, 10)));
+            originalRate.Value += 100;
+            rate.Value += 100;
+            
+            _mockRateService.Setup(x => x.GetRateHistory(It.IsAny<Rate>())).ReturnsAsync(rateHistory);
+            _mockRateService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(originalRate);
+        }
+        
+        var result = await _rateValidationService.ValidateAsync(rates);
+        
+        Assert.NotNull(result);
+        Assert.False(result.All(x => x.Pass));
+        Assert.True(result.All(x => x.Validations.Count > 0));
+        Assert.True(result.All(x => x.Validations.First(y => y.RateSheetValidationType == RateSheetValidationTypes.IsWithinTrendRange).Pass));
+        Assert.False(result.All(x => x.Validations.First(y => y.RateSheetValidationType == RateSheetValidationTypes.IsWithinRange).Pass));
+
+        _mockRateService.Verify(x => x.GetRateHistory(It.IsAny<Rate>()), Times.Exactly(rates.Count));
+        _mockRateService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Exactly(rates.Count));
+    }
+    
+    [Fact]
+    public async Task RateValidation_ValidateAsync_Success_DoesNotPassTrend()
+    {
+        var rates = FakeRates();
+        
+        foreach (var rate in rates)
+        {
+            var originalRate = FakeNewRate(rate, decimal.ToInt32(rate.Value - new Random().Next(0, 10)), decimal.ToInt32(rate.Value));
+            var rateHistory = FakeRateHistory(rate,
+                                              originalRate,
+                                              decimal.ToInt32(rate.Value - new Random().Next(0, 10)), 
+                                              decimal.ToInt32(rate.Value + new Random().Next(0, 10)));
+            rateHistory.First().Value += 100;
+            
+            _mockRateService.Setup(x => x.GetRateHistory(It.IsAny<Rate>())).ReturnsAsync(rateHistory);
+            _mockRateService.Setup(x => x.GetByIdAsync(It.IsAny<int>())).ReturnsAsync(originalRate);
+        }
+        
+        var result = await _rateValidationService.ValidateAsync(rates);
+        
+        Assert.NotNull(result);
+        Assert.False(result.All(x => x.Pass));
+        Assert.True(result.All(x => x.Validations.Count > 0));
+        Assert.False(result.All(x => x.Validations.First(y => y.RateSheetValidationType == RateSheetValidationTypes.IsWithinTrendRange).Pass));
+        Assert.True(result.All(x => x.Validations.First(y => y.RateSheetValidationType == RateSheetValidationTypes.IsWithinRange).Pass));
+
+        _mockRateService.Verify(x => x.GetRateHistory(It.IsAny<Rate>()), Times.Exactly(rates.Count));
+        _mockRateService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Exactly(rates.Count));
+    }
+    
+    [Fact]
+    public async Task RateValidation_ValidateAsync_ThrowsException()
+    {
+        var rates = FakeRates();
+        
+        _mockRateService.Setup(x => x.GetRateHistory(rates[0])).Throws(new Exception("Test")).Verifiable();
+        
+        await Assert.ThrowsAsync<ServiceException>(async () => await _rateValidationService.ValidateAsync(rates));    
+
+        _mockRateService.Verify(x => x.GetRateHistory(It.IsAny<Rate>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByIdAsync(It.IsAny<int>()), Times.Never);
+    }
+    
+    private List<Rate> FakeRates(int count = 3)
+    {
+        var rates = new List<Rate>();
+        
+        for (var i = 0; i < count; i++)
+        {
+            var startDate = (DateTime)typeof(DateTime).GetRandomValue();
+            rates.Add(new Rate
+            {
+                RateId = (int)typeof(int).GetRandomValue(),
+                Value = new Random().Next(20, 30),
+                Row = (string)typeof(string).GetRandomValue(),
+                Column = (string)typeof(string).GetRandomValue(),
+                RateStartDate = startDate,
+                RateEndDate = startDate.AddDays(10),
+                RateSheetId = (int)typeof(int).GetRandomValue()
+            });
+        }
+        
+        return rates;
+    }
+
+    private Rate FakeNewRate(Rate rate, int minValue = int.MinValue, int maxValue = int.MaxValue)
+    {
+        var newRate = rate.DeepCopy();
+        newRate.RateId = (int)typeof(int).GetRandomValue();
+        newRate.Value = new Random().Next(minValue, maxValue);
+        return newRate;
+    }
+
+    private List<Rate> FakeRateHistory(Rate rate, Rate originalRate, int minValue = int.MinValue, int maxValue = int.MaxValue)
+    {
+        var rates = new List<Rate>
+        {
+            FakeNewRate(rate, minValue, decimal.ToInt32(rate.Value)),
+            FakeNewRate(rate, minValue, maxValue),
+            FakeNewRate(rate, decimal.ToInt32(rate.Value), maxValue)
+        };
+        
+        var trend = Math.Round(rate.Value / originalRate.Value, 2);
+        
+        rates[0].RateStartDate = rate.RateStartDate.AddDays(-30);
+        rates[0].RateEndDate = rate.RateStartDate.AddDays(-20);
+        
+        rates[1].RateStartDate = rate.RateStartDate.AddDays(-20);
+        rates[1].RateEndDate = rate.RateStartDate.AddDays(-10);
+        rates[1].Value = Math.Round(rates[0].Value * (trend + 1), 2);
+        
+        rates[2].RateStartDate = rate.RateStartDate.AddDays(-10);
+        rates[2].RateEndDate = rate.RateStartDate;
+        rates[2].Value = Math.Round(rates[1].Value * (trend - 1), 2);
+
+        return rates;
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/RateEvaluationServiceTest.cs

@@ -0,0 +1,511 @@
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.API.Internal.LoanRateLib.Repositories;
+using LCU.API.Internal.LoanRate.Services;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests;
+
+public class RateEvaluationServiceTest
+{
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    private readonly Mock<IRateEvaluationRepository> _mockRateEvaluationRepository;
+    private readonly Mock<IRateService> _mockRateService;
+    private readonly IRateEvaluationService _service;
+
+    public RateEvaluationServiceTest()
+    {
+        _mockRateEvaluationRepository = new Mock<IRateEvaluationRepository>();
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        _mockRateService = new Mock<IRateService>();
+        _service = new RateEvaluationService(_mockUnitOfWork.Object,
+                                             _mockRateEvaluationRepository.Object,
+                                             _mockRateService.Object);
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetAsync_Success()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new() { RateEvaluationId = 1 },
+            new() { RateEvaluationId = 2 },
+            new() { RateEvaluationId = 3 }
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.FindAsync())
+            .ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = (await _service.GetAsync()).ToList();
+        Assert.NotNull(result);
+        Assert.Equal(rateEvaluations.First().RateEvaluationId, result.First().RateEvaluationId);
+        Assert.Equal(rateEvaluations.Count, result.Count);
+        _mockRateEvaluationRepository.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetAsync_Success_NotFound()
+    {
+        List<RateEvaluation>? rateEvaluations = null;
+
+        _mockRateEvaluationRepository.Setup(x => x.FindAsync())
+            .ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = await _service.GetAsync();
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateEvaluationRepository.Verify();
+    }
+
+    [Fact]
+    public void RateEvaluation_GetAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.FindAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetAsync());
+
+        _mockRateEvaluationRepository.Verify(x => x.FindAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetByIdAsync_Success()
+    {
+        var rateEvaluationId = 1;
+        var rateEvaluation = new RateEvaluation
+        {
+            RateEvaluationId = rateEvaluationId
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(rateEvaluationId))
+            .ReturnsAsync(rateEvaluation).Verifiable();
+
+        var result = await _service.GetByIdAsync(rateEvaluationId);
+        Assert.NotNull(result);
+        Assert.Equal(rateEvaluation.RateEvaluationId, result.RateEvaluationId);
+        _mockRateEvaluationRepository.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetByIdAsync_Success_NotFound()
+    {
+        var rateEvaluationId = 1;
+        RateEvaluation? rateEvaluation = null;
+
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(rateEvaluationId))
+            .ReturnsAsync(rateEvaluation).Verifiable();
+
+        var result = await _service.GetByIdAsync(rateEvaluationId);
+        Assert.Null(result);
+        _mockRateEvaluationRepository.Verify();
+    }
+
+    [Fact]
+    public void RateEvaluation_GetByIdAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+                            await _service.GetByIdAsync(It.IsAny<int>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetRangeByIdAsync_Success()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new() { RateEvaluationId = 1 },
+            new() { RateEvaluationId = 2 },
+            new() { RateEvaluationId = 3 }
+        };
+        var ids = rateEvaluations.Select(x => x.RateEvaluationId).ToList();
+
+        _mockRateEvaluationRepository.Setup(x => x.FindRangeByIdAsync(ids))
+            .ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = (await _service.GetRangeByIdAsync(ids)).ToList();
+        Assert.NotNull(result);
+        Assert.Equal(rateEvaluations.First().RateEvaluationId, result.First().RateEvaluationId);
+        Assert.Equal(rateEvaluations.Count, result.Count);
+        _mockRateEvaluationRepository.Verify();
+    }
+
+    [Fact]
+    public async void RateEvaluation_GetRangeByIdAsync_Success_NotFound()
+    {
+        List<RateEvaluation>? rateEvaluations = null;
+        var ids = new List<int>
+        {
+            1,2,3
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.FindRangeByIdAsync(ids))
+            .ReturnsAsync(rateEvaluations).Verifiable();
+
+        var result = await _service.GetRangeByIdAsync(ids);
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateEvaluationRepository.Verify();
+    }
+
+    [Fact]
+    public void RateEvaluation_GetRangeByIdAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetRangeByIdAsync(It.IsAny<List<int>>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once);
+    }
+    
+    [Fact]
+    public async void RateEvaluation_SaveAsync_Success()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            RateId = 1,
+        };
+        var rateEvaluationReturned = new RateEvaluation
+        {
+            RateEvaluationId = 1,
+            RateId = 2
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.AddAsync(rateEvaluation))
+            .ReturnsAsync(rateEvaluationReturned).Verifiable();
+
+        var result = await _service.SaveAsync(rateEvaluation);
+        Assert.NotNull(result);
+        Assert.Equal(rateEvaluationReturned.RateEvaluationId, result.RateEvaluationId);
+        Assert.Equal(rateEvaluationReturned.RateId, result.RateId);
+
+        _mockRateEvaluationRepository.Verify(x => x.AddAsync(It.IsAny<RateEvaluation>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Once);
+    }
+
+    [Fact]
+    public void RateEvaluation_SaveAsync_Failure_ReturnedNull()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            RateId = 1
+        };
+        RateEvaluation? rateEvaluationReturned = null;
+
+        _mockRateEvaluationRepository.Setup(x => x.AddAsync(rateEvaluation))
+            .ReturnsAsync(rateEvaluationReturned).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.SaveAsync(rateEvaluation));
+
+        _mockRateEvaluationRepository.Verify(x => x.AddAsync(It.IsAny<RateEvaluation>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public void RateEvaluation_SaveAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.AddAsync(It.IsAny<RateEvaluation>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.SaveAsync(It.IsAny<RateEvaluation>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.AddAsync(It.IsAny<RateEvaluation>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public async void RateEvaluation_SaveRangeAsync_Success()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new() { RateId = 1 },
+            new() { RateId = 2 },
+            new() { RateId = 3 }
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.AddRangeAsync(rateEvaluations)).Verifiable();
+
+        await _service.SaveRangeAsync(rateEvaluations);
+        _mockRateEvaluationRepository.Verify(x =>
+            x.AddRangeAsync(It.IsAny<IEnumerable<RateEvaluation>>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Once);
+    }
+
+    [Fact]
+    public void RateEvaluation_SaveRangeAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.AddRangeAsync(It.IsAny<IEnumerable<RateEvaluation>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.SaveRangeAsync(It.IsAny<IEnumerable<RateEvaluation>>()));
+
+        _mockRateEvaluationRepository.Verify(x =>
+                            x.AddRangeAsync(It.IsAny<IEnumerable<RateEvaluation>>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public async void RateEvaluation_UpdateAsync_Success()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            RateEvaluationId = 1,
+            RateId = 1
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(rateEvaluation.RateEvaluationId))
+            .ReturnsAsync(rateEvaluation).Verifiable();
+
+        var result = await _service.UpdateAsync(rateEvaluation);
+        Assert.NotNull(result);
+        Assert.Equal(rateEvaluation.RateEvaluationId, result.RateEvaluationId);
+        Assert.Equal(rateEvaluation.RateId, result.RateId);
+        _mockRateEvaluationRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Once);
+    }
+
+    [Fact]
+    public void RateEvaluation_UpdateAsync_Failure_ReturnedNull()
+    {
+        var rateEvaluation = new RateEvaluation
+        {
+            RateId = 1
+        };
+        RateEvaluation? rateEvaluationReturned = null;
+
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(rateEvaluation.RateEvaluationId))
+            .ReturnsAsync(rateEvaluationReturned).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.UpdateAsync(rateEvaluation));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public void RateEvaluation_UpdateAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .ThrowsAsync(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.UpdateAsync(It.IsAny<RateEvaluation>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public async void RateEvaluation_UpdateRangeAsync_Success()
+    {
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new()
+            {
+                RateEvaluationId = 1,
+                RateId = 1
+            },
+            new()
+            {
+                RateEvaluationId = 2,
+                RateId = 2
+            },
+            new()
+            {
+                RateEvaluationId = 3,
+                RateId = 3
+            }
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.UpdateRange(rateEvaluations)).Verifiable();
+
+        await _service.UpdateRangeAsync(rateEvaluations);
+
+        _mockRateEvaluationRepository.Verify(x => x.UpdateRange(It.IsAny<List<RateEvaluation>>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Once);
+    }
+
+    [Fact]
+    public void RateEvaluation_UpdateRangeAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.UpdateRange(It.IsAny<List<RateEvaluation>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.UpdateRangeAsync(It.IsAny<List<RateEvaluation>>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.UpdateRange(It.IsAny<List<RateEvaluation>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public async void RateEvaluation_DeleteAsync_Success()
+    {
+        var rateEvaluationId = 1;
+
+        var rateEvaluation = new RateEvaluation
+        {
+            RateEvaluationId = rateEvaluationId,
+            RateId = 1
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(rateEvaluationId))
+            .ReturnsAsync(rateEvaluation).Verifiable();
+        _mockRateEvaluationRepository.Setup(x => x.Remove(rateEvaluation)).Verifiable();
+
+        await _service.DeleteAsync(rateEvaluationId);
+
+        _mockRateEvaluationRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockRateEvaluationRepository.Verify(x => x.Remove(It.IsAny<RateEvaluation>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Once);
+    }
+
+    [Fact]
+    public void RateEvaluation_DeleteAsync_Failure_ReturnedNull()
+    {
+        var rateEvaluationId = 1;
+        RateEvaluation? rateEvaluation = null;
+
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(rateEvaluationId))
+            .ReturnsAsync(rateEvaluation).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteAsync(rateEvaluationId));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockRateEvaluationRepository.Verify(x => x.Remove(It.IsAny<RateEvaluation>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public void RateEvaluation_DeleteAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.DeleteAsync(It.IsAny<int>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockRateEvaluationRepository.Verify(x => x.Remove(It.IsAny<RateEvaluation>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public async void RateEvaluation_DeleteRangeAsync_Success()
+    {
+        var rateEvaluationIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        var rateEvaluations = new List<RateEvaluation>
+        {
+            new()
+            {
+                RateEvaluationId = rateEvaluationIds[0],
+                RateId = 1
+            },
+            new()
+            {
+                RateEvaluationId = rateEvaluationIds[1],
+                RateId = 2
+            },
+            new()
+            {
+                RateEvaluationId = rateEvaluationIds[2],
+                RateId = 3
+            }
+        };
+
+        _mockRateEvaluationRepository.Setup(x => x.FindRangeByIdAsync(rateEvaluationIds)).ReturnsAsync(rateEvaluations).Verifiable();
+        _mockRateEvaluationRepository.Setup(x => x.RemoveRange(rateEvaluations)).Verifiable();
+
+        await _service.DeleteRangeAsync(rateEvaluationIds);
+
+        _mockRateEvaluationRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockRateEvaluationRepository.Verify(x => x.RemoveRange(It.IsAny<List<RateEvaluation>>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Once);
+    }
+
+    [Fact]
+    public void RateEvaluation_DeleteRangeAsync_Failure_ReturnedNull()
+    {
+        var rateEvaluationIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        List<RateEvaluation>? rateEvaluations = null;
+
+        _mockRateEvaluationRepository.Setup(x => x.FindRangeByIdAsync(rateEvaluationIds))
+            .ReturnsAsync(rateEvaluations).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteRangeAsync(rateEvaluationIds));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockRateEvaluationRepository.Verify(x => x.RemoveRange(It.IsAny<List<RateEvaluation>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+
+    [Fact]
+    public void RateEvaluation_DeleteRangeAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.RemoveRange(It.IsAny<List<RateEvaluation>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.DeleteRangeAsync(It.IsAny<List<int>>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockRateEvaluationRepository.Verify(x => x.RemoveRange(It.IsAny<List<RateEvaluation>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+        _mockRateService.Verify(x => x.ClearCache(), Times.Never);
+    }
+    
+    [Fact]
+    public async void RateEvaluation_CountByEvaluationDetailIdAsync_Success()
+    {
+        var evaluationDetailId = DateTime.Now.Millisecond;
+        var count = DateTime.Now.Minute;
+
+        _mockRateEvaluationRepository.Setup(x => x.CountByEvaluationDetailIdAsync(evaluationDetailId)).ReturnsAsync(count).Verifiable();
+
+        await _service.CountByEvaluationDetailIdAsync(evaluationDetailId);
+
+        _mockRateEvaluationRepository.Verify(x => x.CountByEvaluationDetailIdAsync(It.IsAny<int>()), Times.Once());
+    }
+
+    [Fact]
+    public void RateEvaluation_CountByEvaluationDetailIdAsync_Failure_Exception()
+    {
+        _mockRateEvaluationRepository.Setup(x => x.CountByEvaluationDetailIdAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.CountByEvaluationDetailIdAsync(It.IsAny<int>()));
+
+        _mockRateEvaluationRepository.Verify(x => x.CountByEvaluationDetailIdAsync(It.IsAny<int>()), Times.Once());
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/RateServiceTest.cs

@@ -0,0 +1,649 @@
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.API.Internal.LoanRateLib.Repositories;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.Library.Internal.LcuEvaluationModels.Enums;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests;
+
+public class RateServiceTest
+{
+    private readonly Mock<IRateRepository> _mockRateRepository;
+    private readonly Mock<IRateSheetService> _mockRateSheetService;
+    private readonly Mock<ILoadTestRunInfoService> _mockLoadTestRunInfoService;
+    private readonly Mock<IUnitOfWork> _mockUnitOfWork;
+    private readonly IRateService _service;
+
+    public RateServiceTest()
+    {
+        _mockRateRepository = new Mock<IRateRepository>();
+        _mockRateSheetService = new Mock<IRateSheetService>();
+        _mockLoadTestRunInfoService = new Mock<ILoadTestRunInfoService>();
+        _mockUnitOfWork = new Mock<IUnitOfWork>();
+        _service = new RateService(_mockUnitOfWork.Object, 
+                                   _mockRateRepository.Object,
+                                   _mockRateSheetService.Object,
+                                   _mockLoadTestRunInfoService.Object);
+    }
+
+    [Fact]
+    public async void Rate_GetAsync_Success()
+    {
+        var rates = new List<Rate>
+        {
+            new() { RateId = 1 },
+            new() { RateId = 2 },
+            new() { RateId = 3 }
+        };
+
+        _mockRateRepository.Setup(x => x.FindAsync())
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = (await _service.GetAsync()).ToList();
+        Assert.NotNull(result);
+        Assert.Equal(rates.First().RateId, result.First().RateId);
+        Assert.Equal(rates.Count, result.Count);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetAsync_Success_NotFound()
+    {
+        List<Rate>? rates = null;
+
+        _mockRateRepository.Setup(x => x.FindAsync())
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = await _service.GetAsync();
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public void Rate_GetAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetAsync());
+
+        _mockRateRepository.Verify(x => x.FindAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async void Rate_GetByIdAsync_Success()
+    {
+        var rateId = 1;
+        var rate = new Rate
+        {
+            RateId = rateId
+        };
+
+        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
+            .ReturnsAsync(rate).Verifiable();
+
+        var result = await _service.GetByIdAsync(rateId);
+        Assert.NotNull(result);
+        Assert.Equal(rate.RateId, result.RateId);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetByIdAsync_Success_NotFound()
+    {
+        var rateId = 1;
+        Rate? rate = null;
+
+        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
+            .ReturnsAsync(rate).Verifiable();
+
+        var result = await _service.GetByIdAsync(rateId);
+        Assert.Null(result);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public void Rate_GetByIdAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+                            await _service.GetByIdAsync(It.IsAny<int>()));
+
+        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+    }
+
+    [Fact]
+    public async void Rate_GetByDateAsync_Success()
+    {
+        var rateId = 1;
+        var rates = new List<Rate>{
+            new Rate
+            {
+                RateId = rateId
+            }
+        };
+        var date = Convert.ToDateTime("1/1/2023");
+        _mockRateRepository.Setup(x => x.FindByDateAsync(date))
+            .ReturnsAsync(rates).Verifiable();
+
+        var results = await _service.GetByDateAsync(date);
+        Assert.NotNull(results);
+        Assert.NotEmpty(results);
+        var result = results.FirstOrDefault();
+        Assert.NotNull(result);
+        Assert.Equal(rateId, result.RateId);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetByDateAsync_Success_NotFound()
+    {
+        List<Rate>? rate = null;
+        var date = Convert.ToDateTime("1/1/2023");
+        _mockRateRepository.Setup(x => x.FindByDateAsync(date))
+            .ReturnsAsync(rate).Verifiable();
+
+        var results = await _service.GetByDateAsync(date);
+        Assert.NotNull(results);
+        Assert.Empty(results);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public void Rate_GetByDateAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindByDateAsync(It.IsAny<DateTime>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+                            await _service.GetByDateAsync(It.IsAny<DateTime>()));
+
+        _mockRateRepository.Verify(x => x.FindByDateAsync(It.IsAny<DateTime>()), Times.Once);
+    }
+    
+    [Fact]
+    public async void Rate_GetRateHistoryAsync_Success()
+    {
+        var rate = new Rate
+        {
+            RateId = 1,
+            Column = "A",
+            Row = "2",
+            RateSheetId = 1
+        };
+        var rateHistory = new List<Rate>
+        {
+            new()
+            {
+                Column = rate.Column,
+                Row = rate.Row,
+                RateSheetId = rate.RateSheetId
+            },
+            new()
+            {
+                Column = rate.Column,
+                Row = rate.Row,
+                RateSheetId = rate.RateSheetId
+            },
+            new()
+            {
+                Column = rate.Column,
+                Row = rate.Row,
+                RateSheetId = rate.RateSheetId
+            }
+        };
+        _mockRateRepository.Setup(x => x.FindRateHistoryAsync(rate))
+            .ReturnsAsync(rateHistory).Verifiable();
+
+        var results = (await _service.GetRateHistory(rate))?.ToList();
+        Assert.NotNull(results);
+        Assert.NotEmpty(results);
+        
+        var result = results.FirstOrDefault();
+        Assert.NotNull(result);
+        Assert.Equal(rate.RateSheetId, result.RateSheetId);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetRateHistoryAsync_Success_NotFound()
+    {
+        Rate? rate = null;
+        List<Rate>? rateHistory = null;
+        _mockRateRepository.Setup(x => x.FindRateHistoryAsync(rate))
+            .ReturnsAsync(rateHistory).Verifiable();
+
+        var results = await _service.GetRateHistory(rate);
+        Assert.NotNull(results);
+        Assert.Empty(results);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public void Rate_GetRateHistoryAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindRateHistoryAsync(It.IsAny<Rate>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.GetRateHistory(It.IsAny<Rate>()));
+
+        _mockRateRepository.Verify(x => x.FindRateHistoryAsync(It.IsAny<Rate>()), Times.Once);
+    }
+    
+    [Fact]
+    public async void Rate_GetRangeByIdAsync_Success()
+    {
+        var rates = new List<Rate>
+        {
+            new() { RateId = 1 },
+            new() { RateId = 2 },
+            new() { RateId = 3 }
+        };
+        var ids = rates.Select(x => x.RateId).ToList();
+
+        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(ids))
+            .ReturnsAsync(rates).Verifiable();
+
+        var results = (await _service.GetRangeByIdAsync(ids)).ToList();
+        Assert.NotNull(results);
+        Assert.Equal(rates.First().RateId, results.First().RateId);
+        Assert.Equal(rates.Count, results.Count);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetRangeByIdAsync_Success_NotFound()
+    {
+        List<Rate>? rates = null;
+        var ids = new List<int>
+        {
+            1,2,3
+        };
+
+        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(ids))
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = await _service.GetRangeByIdAsync(ids);
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public void Rate_GetRangeByIdAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetRangeByIdAsync(It.IsAny<List<int>>()));
+
+        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once);
+    }
+
+    [Fact]
+    public async void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Success()
+    {
+        var rateId = 1;
+        var rateSheetId = 1;
+        var date = Convert.ToDateTime("1/1/2023");
+        var rates = new List<Rate>{
+            new Rate
+            {
+                RateId = rateId,
+                RateSheetId = rateSheetId,
+                RateStartDate = date
+            }
+        };
+        var evaluationIds = new List<int> { 10 };
+        var evaluationType = EvaluationTypes.Rule;
+        _mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(date, evaluationIds, evaluationType))
+            .ReturnsAsync(rates).Verifiable();
+
+        var results = await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(date, evaluationIds, evaluationType);
+        Assert.NotNull(results);
+        Assert.NotEmpty(results);
+        var result = results.FirstOrDefault();
+        Assert.NotNull(result);
+        Assert.Equal(rateId, result.RateId);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public async void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Success_NotFound()
+    {
+        var date = Convert.ToDateTime("1/1/2023");
+        List<Rate>? rates = null;
+        var evaluationIds = new List<int> { 10 };
+        var evaluationType = EvaluationTypes.Rule;
+        _mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(date, evaluationIds, evaluationType))
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(date, evaluationIds, evaluationType);
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateRepository.Verify();
+    }
+
+    [Fact]
+    public void Rate_GetByDateEvaluationIdAndEvaluationTypeAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+                            await _service.GetByDateEvaluationIdAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()));
+
+        _mockRateRepository.Verify(x => x.FindByDateEvaluationIdsAndEvaluationTypeAsync(It.IsAny<DateTime>(), It.IsAny<List<int>>(), It.IsAny<EvaluationTypes>()), Times.Once);
+    }
+
+    [Fact]
+    public async void Rate_SaveAsync_Success()
+    {
+        var rate = new Rate
+        {
+            Value = 4.59m
+        };
+        var RateReturned = new Rate
+        {
+            RateId = 1,
+            Value = 4.9m
+        };
+
+        _mockRateRepository.Setup(x => x.AddAsync(rate))
+            .ReturnsAsync(RateReturned).Verifiable();
+
+        var result = await _service.SaveAsync(rate);
+        Assert.NotNull(result);
+        Assert.Equal(RateReturned.RateId, result.RateId);
+        Assert.Equal(RateReturned.Value, result.Value);
+
+        _mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void Rate_SaveAsync_Failure_ReturnedNull()
+    {
+        var rate = new Rate
+        {
+            Value = 4.59m
+        };
+        Rate? rateReturned = null;
+
+        _mockRateRepository.Setup(x => x.AddAsync(rate))
+            .ReturnsAsync(rateReturned).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.SaveAsync(rate));
+
+        _mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void Rate_SaveAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.AddAsync(It.IsAny<Rate>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.SaveAsync(It.IsAny<Rate>()));
+
+        _mockRateRepository.Verify(x => x.AddAsync(It.IsAny<Rate>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void Rate_SaveRangeAsync_Success()
+    {
+        var rates = new List<Rate>
+        {
+            new() { Value = 4.59m },
+            new() { Value = 4.9m },
+            new() { Value = 4m }
+        };
+
+        _mockRateRepository.Setup(x => x.AddRangeAsync(rates)).Verifiable();
+
+        await _service.SaveRangeAsync(rates);
+        _mockRateRepository.Verify(x =>
+            x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void Rate_SaveRangeAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.SaveRangeAsync(It.IsAny<IEnumerable<Rate>>()));
+
+        _mockRateRepository.Verify(x =>
+                            x.AddRangeAsync(It.IsAny<IEnumerable<Rate>>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void Rate_UpdateAsync_Success()
+    {
+        var rate = new Rate
+        {
+            RateId = 1,
+            Value = 4.59m
+        };
+
+        _mockRateRepository.Setup(x => x.FindByIdAsync(rate.RateId))
+            .ReturnsAsync(rate).Verifiable();
+
+        var result = await _service.UpdateAsync(rate);
+        Assert.NotNull(result);
+        Assert.Equal(rate.RateId, result.RateId);
+        Assert.Equal(rate.Value, result.Value);
+        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void Rate_UpdateAsync_Failure_ReturnedNull()
+    {
+        var rate = new Rate
+        {
+            Value = 4.59m
+        };
+        Rate? rateReturned = null;
+
+        _mockRateRepository.Setup(x => x.FindByIdAsync(rate.RateId))
+            .ReturnsAsync(rateReturned).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.UpdateAsync(rate));
+
+        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void Rate_UpdateAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .ThrowsAsync(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.UpdateAsync(It.IsAny<Rate>()));
+
+        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void Rate_UpdateRangeAsync_Success()
+    {
+        var rates = new List<Rate>
+        {
+            new()
+            {
+                RateId = 1,
+                Value = 4.59m
+            },
+            new()
+            {
+                RateId = 2,
+                Value = 4.9m
+            },
+            new()
+            {
+                RateId = 3,
+                Value = 4m
+            }
+        };
+
+        _mockRateRepository.Setup(x => x.UpdateRange(rates)).Verifiable();
+
+        await _service.UpdateRangeAsync(rates);
+
+        _mockRateRepository.Verify(x => x.UpdateRange(It.IsAny<List<Rate>>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void Rate_UpdateRangeAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.UpdateRange(It.IsAny<List<Rate>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.UpdateRangeAsync(It.IsAny<List<Rate>>()));
+
+        _mockRateRepository.Verify(x => x.UpdateRange(It.IsAny<List<Rate>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void Rate_DeleteAsync_Success()
+    {
+        var rateId = 1;
+
+        var rate = new Rate
+        {
+            RateId = rateId,
+            Value = 4.59m
+        };
+
+        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
+            .ReturnsAsync(rate).Verifiable();
+        _mockRateRepository.Setup(x => x.Remove(rate)).Verifiable();
+
+        await _service.DeleteAsync(rateId);
+
+        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void Rate_DeleteAsync_Failure_ReturnedNull()
+    {
+        var rateId = 1;
+        Rate? rate = null;
+
+        _mockRateRepository.Setup(x => x.FindByIdAsync(rateId))
+            .ReturnsAsync(rate).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteAsync(rateId));
+
+        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once());
+        _mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void Rate_DeleteAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.DeleteAsync(It.IsAny<int>()));
+
+        _mockRateRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Once);
+        _mockRateRepository.Verify(x => x.Remove(It.IsAny<Rate>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public async void Rate_DeleteRangeAsync_Success()
+    {
+        var rateIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        var rates = new List<Rate>
+        {
+            new()
+            {
+                RateId = rateIds[0],
+                Value = 4.59m
+            },
+            new()
+            {
+                RateId = rateIds[1],
+                Value = 4.9m
+            },
+            new()
+            {
+                RateId = rateIds[2],
+                Value = 4m
+            }
+        };
+
+        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(rateIds)).ReturnsAsync(rates).Verifiable();
+        _mockRateRepository.Setup(x => x.RemoveRange(rates)).Verifiable();
+
+        await _service.DeleteRangeAsync(rateIds);
+
+        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Once());
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void Rate_DeleteRangeAsync_Failure_ReturnedNull()
+    {
+        var rateIds = new List<int>
+        {
+            1,
+            2,
+            3
+        };
+        List<Rate>? rates = null;
+
+        _mockRateRepository.Setup(x => x.FindRangeByIdAsync(rateIds))
+            .ReturnsAsync(rates).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.DeleteRangeAsync(rateIds));
+
+        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+
+    [Fact]
+    public void Rate_DeleteRangeAsync_Failure_Exception()
+    {
+        _mockRateRepository.Setup(x => x.RemoveRange(It.IsAny<List<Rate>>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () =>
+            await _service.DeleteRangeAsync(It.IsAny<List<int>>()));
+
+        _mockRateRepository.Verify(x => x.FindRangeByIdAsync(It.IsAny<List<int>>()), Times.Once());
+        _mockRateRepository.Verify(x => x.RemoveRange(It.IsAny<List<Rate>>()), Times.Never);
+        _mockUnitOfWork.Verify(x => x.CompleteAsync(), Times.Never);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/RateSheetCellServiceTest.cs

@@ -0,0 +1,19 @@
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.API.Internal.LoanRateLib.Repositories;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Tests;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests;
+
+public class RateSheetCellServiceTest : CrudServiceTest<RateSheetCell>
+{
+    private readonly IRateSheetCellService _service;
+    private readonly Mock<IRateSheetCellRepository> _mockRateSheetCellRepository;
+
+    public RateSheetCellServiceTest()
+    {
+        _mockRateSheetCellRepository = new Mock<IRateSheetCellRepository>();
+        _service = new RateSheetCellService(_mockRateSheetCellRepository.Object);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/RateSheetServiceTest.cs

@@ -0,0 +1,190 @@
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.API.Internal.LoanRateLib.Repositories;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Tests;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Utilities;
+using LCU.Library.Internal.LoanRateModels.Enums;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests;
+
+public class RateSheetServiceTest : CrudServiceTest<RateSheet>
+{
+    private readonly IRateSheetService _service;
+    private readonly Mock<IRateSheetRepository> _mockRateSheetRepository;
+
+    public RateSheetServiceTest()
+    {
+        _mockRateSheetRepository = new Mock<IRateSheetRepository>();
+        _service = new RateSheetService(_mockRateSheetRepository.Object);
+    }
+
+    [Fact]
+    public async void RateSheet_GetIncludeAllAsync_Success()
+    {
+        var rateSheets = new List<RateSheet>
+        {
+            new ()
+            {
+                RateSheetId = (int)typeof(int).GetRandomValue(),
+                RateType = (RateTypes)typeof(RateTypes).GetRandomValue(),
+                Rates = new List<Rate>
+                {
+                    new() { RateId = (int)typeof(int).GetRandomValue() },
+                    new() { RateId = (int)typeof(int).GetRandomValue() },
+                    new() { RateId = (int)typeof(int).GetRandomValue() }
+                }
+            }
+        };
+
+        _mockRateSheetRepository.Setup(x => x.FindIncludeAllAsync())
+            .ReturnsAsync(rateSheets).Verifiable();
+
+        var result = (await _service.GetIncludeAllAsync())?.ToList();
+        Assert.NotNull(result);
+        Assert.Equal(rateSheets.First().RateSheetId, result.First().RateSheetId);
+        Assert.Equal(rateSheets.Count, result.Count);
+        _mockRateSheetRepository.Verify();
+    }
+
+    [Fact]
+    public async void RateSheet_GetIncludeAllAsync_Success_NotFound()
+    {
+        List<RateSheet>? rateSheets = null;
+
+        _mockRateSheetRepository.Setup(x => x.FindIncludeAllAsync())
+            .ReturnsAsync(rateSheets).Verifiable();
+
+        var result = await _service.GetIncludeAllAsync();
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateSheetRepository.Verify();
+    }
+
+    [Fact]
+    public void Rate_GetAsync_Failure_Exception()
+    {
+        _mockRateSheetRepository.Setup(x => x.FindAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetAsync());
+
+        _mockRateSheetRepository.Verify(x => x.FindAsync(), Times.Once);
+    }
+    
+    [Fact]
+    public async void RateSheet_GetRatesByRateTypeAsync_Success()
+    {
+        var rateType = (RateTypes)typeof(RateTypes).GetRandomValue();
+        var rateSheet = new RateSheet
+        {
+            RateSheetId = (int)typeof(int).GetRandomValue(),
+            RateType = (RateTypes)typeof(RateTypes).GetRandomValue(),
+            Rates = new List<Rate>
+            {
+                new() { RateId = (int)typeof(int).GetRandomValue() },
+                new() { RateId = (int)typeof(int).GetRandomValue() },
+                new() { RateId = (int)typeof(int).GetRandomValue() }
+            }
+        };
+        _mockRateSheetRepository.Setup(x => x.FindRatesByRateType(rateType))
+            .ReturnsAsync(rateSheet.Rates).Verifiable();
+
+        var result = (await _service.GetRatesByRateTypeAsync(rateType))?.ToList();
+        Assert.NotNull(result);
+        Assert.Equal(rateSheet.Rates.First().RateId, result.First().RateId);
+        Assert.Equal(rateSheet.Rates.Count, result.Count);
+        _mockRateSheetRepository.Verify();
+    }
+
+    [Fact]
+    public async void RateSheet_GetRatesByRateTypeAsync_Success_NotFound()
+    {
+        List<Rate>? rates = null;
+
+        _mockRateSheetRepository.Setup(x => x.FindRatesByRateType(It.IsAny<RateTypes>()))
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = await _service.GetRatesByRateTypeAsync(It.IsAny<RateTypes>());
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateSheetRepository.Verify();
+    }
+
+    [Fact]
+    public void RateSheet_GetRatesByRateTypeAsync_Failure_Exception()
+    {
+        _mockRateSheetRepository.Setup(x => x.FindRatesByRateType(It.IsAny<RateTypes>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetRatesByRateTypeAsync(It.IsAny<RateTypes>()));
+
+        _mockRateSheetRepository.Verify(x => x.FindRatesByRateType(It.IsAny<RateTypes>()), Times.Once);
+    }
+    
+    [Fact]
+    public async void RateSheet_GetRatesByDateAndRateTypeAsync_Success()
+    {
+        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
+        var rateType = (RateTypes)typeof(RateTypes).GetRandomValue();
+        var rateSheet = new RateSheet
+        {
+            RateSheetId = (int)typeof(int).GetRandomValue(),
+            RateType = (RateTypes)typeof(RateTypes).GetRandomValue(),
+            Rates = new List<Rate>
+            {
+                new()
+                {
+                    RateId = (int)typeof(int).GetRandomValue(), 
+                    RateStartDate = effectiveDate.AddDays(-2), 
+                    RateEndDate = effectiveDate.AddDays(2)
+                },
+                new()
+                {
+                    RateId = (int)typeof(int).GetRandomValue(), 
+                    RateStartDate = effectiveDate.AddDays(-1), 
+                    RateEndDate = effectiveDate.AddDays(3)
+                },
+                new()
+                {
+                    RateId = (int)typeof(int).GetRandomValue(), 
+                    RateStartDate = effectiveDate.AddDays(-5), 
+                    RateEndDate = effectiveDate.AddDays(2)
+                }
+            }
+        };
+        _mockRateSheetRepository.Setup(x => x.FindRatesByDateAndRateType(effectiveDate, rateType))
+            .ReturnsAsync(rateSheet.Rates).Verifiable();
+
+        var result = (await _service.GetRatesByDateAndRateTypeAsync(effectiveDate, rateType))?.ToList();
+        Assert.NotNull(result);
+        Assert.Equal(rateSheet.Rates.First().RateId, result.First().RateId);
+        Assert.Equal(rateSheet.Rates.Count, result.Count);
+        _mockRateSheetRepository.Verify();
+    }
+
+    [Fact]
+    public async void RateSheet_GetRatesByDateAndRateTypeAsync_Success_NotFound()
+    {
+        List<Rate>? rates = null;
+
+        _mockRateSheetRepository.Setup(x => x.FindRatesByDateAndRateType(It.IsAny<DateTime>(), It.IsAny<RateTypes>()))
+            .ReturnsAsync(rates).Verifiable();
+
+        var result = await _service.GetRatesByDateAndRateTypeAsync(It.IsAny<DateTime>(), It.IsAny<RateTypes>());
+        Assert.NotNull(result);
+        Assert.Empty(result);
+        _mockRateSheetRepository.Verify();
+    }
+
+    [Fact]
+    public void RateSheet_GetRatesByDateAndRateTypeAsync_Failure_Exception()
+    {
+        _mockRateSheetRepository.Setup(x => x.FindRatesByDateAndRateType(It.IsAny<DateTime>(), It.IsAny<RateTypes>()))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetRatesByDateAndRateTypeAsync(It.IsAny<DateTime>(), It.IsAny<RateTypes>()));
+
+        _mockRateSheetRepository.Verify(x => x.FindRatesByDateAndRateType(It.IsAny<DateTime>(), It.IsAny<RateTypes>()), Times.Once);
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/RateUploadInfoServiceTest.cs

@@ -0,0 +1,317 @@
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.API.Internal.LoanRateLib.Repositories;
+using LCU.API.Internal.LoanRate.Services;
+using LCU.Library.Internal.Exceptions;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Tests;
+using LCU.Library.Internal.LcuClassPatterns.CrudTests.Utilities;
+using LCU.Library.Internal.LoanRateModels.Requests;
+using LCU.Library.Internal.TypeExtensions.ObjectExtensions;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests;
+
+public class RateUploadInfoServiceTest : CrudServiceTest<RateUploadInfo>
+{
+    private readonly Mock<IRateUploadInfoRepository> _mockRateUploadInfoRepository = new();
+    private readonly Mock<IRateService> _mockRateService = new();
+    private readonly IRateUploadInfoService _service;
+    
+    public RateUploadInfoServiceTest()
+    {
+        _service = new RateUploadInfoService(_mockRateUploadInfoRepository.Object, _mockRateService.Object);
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetLatest_Success()
+    {
+        var version = (int)typeof(int).GetRandomValue();
+        var dateNow = DateTime.Now;
+        var rateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
+            EffectiveDate = dateNow,
+            Version = version
+        };
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync()).ReturnsAsync(rateUploadInfo).Verifiable();
+
+        var result = await _service.GetLatestAsync();
+        
+        Assert.NotNull(result);
+        Assert.Equal(rateUploadInfo.Version, result.Version);
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
+    }
+
+    [Fact]
+    public async void RateUploadInfo_GetLatest_Success_NotFound()
+    {
+        RateUploadInfo? previousRateUploadInfo = null;
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
+            .ReturnsAsync(previousRateUploadInfo).Verifiable();
+
+        var result = await _service.GetLatestAsync();
+        Assert.Null(result);
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
+    }
+
+    [Fact]
+    public void RateUploadInfo_GetLatest_Failure_Exception()
+    {
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetLatestAsync());
+
+        _mockRateUploadInfoRepository.Verify(x => x.FindAsync(), Times.Never);
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetByVersion_Success()
+    {
+        var version = (int)typeof(int).GetRandomValue();
+        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
+        var rateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
+            Version = version
+        };
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindByVersionAsync(version, effectiveDate))
+            .ReturnsAsync(rateUploadInfo).Verifiable();
+
+        var result = await _service.GetByVersionAsync(version, effectiveDate);
+        
+        Assert.NotNull(result);
+        Assert.Equal(rateUploadInfo.RateUploadInfoId, result.RateUploadInfoId);
+        Assert.Equal(rateUploadInfo.Version, result.Version);
+        _mockRateUploadInfoRepository.Verify(x => x.FindByVersionAsync(version, effectiveDate), Times.Once);
+    }
+
+    [Fact]
+    public async void RateUploadInfo_GetByVersion_Success_NotFound()
+    {
+        var version = (int)typeof(int).GetRandomValue();
+        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
+        RateUploadInfo rateUploadInfo = null;
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindByVersionAsync(version, effectiveDate))
+            .ReturnsAsync(rateUploadInfo).Verifiable();
+
+        var result = await _service.GetByVersionAsync(version, effectiveDate);
+        Assert.Null(result);
+        _mockRateUploadInfoRepository.Verify(x => x.FindByVersionAsync(version, effectiveDate), Times.Once);
+    }
+
+    [Fact]
+    public void RateUploadInfo_GetByVersion_Failure_Exception()
+    {
+        var version = (int)typeof(int).GetRandomValue();
+        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
+        RateUploadInfo rateUploadInfo = null;
+        
+        _mockRateUploadInfoRepository.Setup(x => x.FindByVersionAsync(version, effectiveDate))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetByVersionAsync(version, effectiveDate));
+
+        _mockRateUploadInfoRepository.Verify(x => x.FindAsync(), Times.Never);
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_GetLatestVersionByDate_Success()
+    {
+        var version = (int)typeof(int).GetRandomValue();
+        var dateNow = DateTime.Now;
+        var rateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
+            EffectiveDate = dateNow,
+            Version = version
+        };
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(dateNow)).ReturnsAsync(rateUploadInfo).Verifiable();
+
+        var result = await _service.GetLatestVersionOnDate(dateNow);
+        
+        Assert.NotNull(result);
+        Assert.Equal(rateUploadInfo.Version, result.Version);
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestVersionOnDate(dateNow), Times.Once);
+    }
+
+    [Fact]
+    public async void RateUploadInfo_GetLatestVersionByDate_Success_NotFound()
+    {
+        RateUploadInfo? previousRateUploadInfo = null;
+        var dateNow = DateTime.Now;
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(dateNow))
+            .ReturnsAsync(previousRateUploadInfo).Verifiable();
+
+        var result = await _service.GetLatestVersionOnDate(dateNow);
+        Assert.Null(result);
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestVersionOnDate(dateNow), Times.Once);
+    }
+
+    [Fact]
+    public void RateUploadInfo_GetLatestVersionByDate_Failure_Exception()
+    {
+        var dateNow = DateTime.Now;
+        
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(dateNow))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.GetLatestVersionOnDate(dateNow));
+
+        _mockRateUploadInfoRepository.Verify(x => x.FindAsync(), Times.Never);
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_ComplexSave_Success()
+    {
+        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
+        var version = (int)typeof(int).GetRandomValue();
+
+        var rates = new List<Rate>
+        {
+            new() { RateId = (int)typeof(int).GetRandomValue() },
+            new() { RateId = (int)typeof(int).GetRandomValue() },
+            new() { RateId = (int)typeof(int).GetRandomValue() }
+        };    
+        
+        var request = new RateUploadInfoRequest
+        {
+            EffectiveDate = effectiveDate,
+            Rates = rates
+        };
+
+        var originalRateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
+            Version = version,
+            EffectiveDate = effectiveDate.AddDays(-25)
+        };
+
+        var rateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
+            Version = version + 1,
+            EffectiveDate = effectiveDate,
+            Filename = "Complex Save Test",
+            ClosedRates = rates,
+            Rates = rates.DeepCopy()
+        };
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(effectiveDate))
+            .ReturnsAsync(originalRateUploadInfo).Verifiable();
+
+        _mockRateUploadInfoRepository.Setup(x => x.AddAsync(It.IsAny<RateUploadInfo>()))
+            .ReturnsAsync(rateUploadInfo).Verifiable();
+
+        var result = await _service.ComplexSave(request);
+        
+        Assert.NotNull(result);
+        Assert.Equal(rateUploadInfo.RateUploadInfoId, result.RateUploadInfoId);
+        Assert.Equal(rateUploadInfo.Version, result.Version);
+        Assert.Equal(rateUploadInfo.Rates.Count, result.ClosedRates?.Count);
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestVersionOnDate(effectiveDate), Times.Once);
+        _mockRateUploadInfoRepository.Verify(x => x.AddAsync(It.IsAny<RateUploadInfo>()), Times.Once);
+    }
+    
+    [Fact]
+    public void RateUploadInfo_ComplexSave_Failure_Exception()
+    {
+        var effectiveDate = (DateTime)typeof(DateTime).GetRandomValue();
+        RateUploadInfoRequest request = null;
+        
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestVersionOnDate(effectiveDate))
+            .Throws(new Exception("Test")).Verifiable();
+
+        Assert.ThrowsAsync<ServiceException>(async () => await _service.ComplexSave(request));
+
+        _mockRateUploadInfoRepository.Verify(x => x.AddAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_ComplexDelete_Success()
+    {
+        var closedRates = new List<Rate>
+        {
+            new () { RateId = (int)typeof(int).GetRandomValue() },
+            new () { RateId = (int)typeof(int).GetRandomValue() },
+            new() { RateId = (int)typeof(int).GetRandomValue() }
+        };
+        var rateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
+            Rates = new List<Rate>
+            {
+                new () { RateId = (int)typeof(int).GetRandomValue() },
+                new () { RateId = (int)typeof(int).GetRandomValue() },
+                new() { RateId = (int)typeof(int).GetRandomValue() }
+            }
+        };
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
+            .ReturnsAsync(rateUploadInfo).Verifiable();
+        _mockRateService.Setup(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId))
+            .ReturnsAsync(closedRates).Verifiable();
+        _mockRateUploadInfoRepository.Setup(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId))
+            .ReturnsAsync(rateUploadInfo).Verifiable();
+
+        await _service.ComplexDelete(rateUploadInfo.RateUploadInfoId);
+        
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
+        _mockRateService.Verify(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
+        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Once);
+        _mockRateUploadInfoRepository.Verify(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
+        _mockRateUploadInfoRepository.Verify(x => x.RemoveAsync(rateUploadInfo), Times.Once);
+    }
+    
+    [Fact]
+    public async void RateUploadInfo_ComplexDelete_Success_NoClosedRates()
+    {
+        var closedRates = new List<Rate>();
+        var rateUploadInfo = new RateUploadInfo
+        {
+            RateUploadInfoId = (int)typeof(int).GetRandomValue(),
+            Rates = new List<Rate>
+            {
+                new () { RateId = (int)typeof(int).GetRandomValue() },
+                new () { RateId = (int)typeof(int).GetRandomValue() },
+                new() { RateId = (int)typeof(int).GetRandomValue() }
+            }
+        };
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
+            .ReturnsAsync(rateUploadInfo).Verifiable();
+        _mockRateService.Setup(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId))
+            .ReturnsAsync(closedRates).Verifiable();
+        _mockRateUploadInfoRepository.Setup(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId))
+            .ReturnsAsync(rateUploadInfo).Verifiable();
+
+        await _service.ComplexDelete(rateUploadInfo.RateUploadInfoId);
+        
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
+        _mockRateService.Verify(x => x.GetByClosingRateUploadInfoIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
+        _mockRateService.Verify(x => x.UpdateRangeAsync(It.IsAny<List<Rate>>()), Times.Never);
+        _mockRateUploadInfoRepository.Verify(x => x.FindByIdAsync(rateUploadInfo.RateUploadInfoId), Times.Once);
+        _mockRateUploadInfoRepository.Verify(x => x.RemoveAsync(rateUploadInfo), Times.Once);
+    }
+
+    [Fact]
+    public async void RateUploadInfo_ComplexDelete_Failure_Exception()
+    {
+        var rateUploadInfoId = (int)typeof(int).GetRandomValue();
+
+        _mockRateUploadInfoRepository.Setup(x => x.FindLatestAsync())
+            .Throws(new Exception("Test")).Verifiable();
+
+        await Assert.ThrowsAsync<ServiceException>(async () => await _service.ComplexDelete(rateUploadInfoId));
+        
+        _mockRateUploadInfoRepository.Verify(x => x.FindLatestAsync(), Times.Once);
+        _mockRateUploadInfoRepository.Verify(x => x.FindPreviousVersion(It.IsAny<RateUploadInfo>()), Times.Never);
+        _mockRateUploadInfoRepository.Verify(x => x.FindByIdAsync(It.IsAny<int>()), Times.Never);
+        _mockRateUploadInfoRepository.Verify(x => x.RemoveAsync(It.IsAny<RateUploadInfo>()), Times.Never);
+    }
+
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/ServiceTests/ValidateLoanRateServicesTests/ValidateRateEvaluationsServiceTest.cs

@@ -0,0 +1,431 @@
+using LCU.API.Internal.LoanRate.Services;
+using LCU.API.Internal.LoanRate.Services.LoanRateOperationServices;
+using LCU.API.Internal.LoanRate.Services.ValidateLoanRateServices;
+using LCU.Library.Internal.LcuEvaluationModels.Entities;
+using LCU.Library.Internal.LcuEvaluationModels.Enums;
+using LCU.Library.Internal.LcuEvaluation.Services;
+using LCU.Library.Internal.LoanRateModels.Entities;
+using LCU.Library.Internal.LoanRateModels.Requests;
+using LCU.Library.Internal.LcuEvaluation.Services.EvaluationServices;
+
+namespace LCU.API.Internal.LoanRateTests.ServiceTests.ValidateLoanRateServicesTests;
+
+public class ValidateRateEvaluationsServiceTest
+{
+    private readonly ValidateRateEvaluationsService _validateRateEvaluationsService;
+    private readonly Mock<IEvaluationDetailService> _mockEvaluationDetailService;
+    private readonly Mock<IRateService> _mockRateService;
+    private readonly Mock<IRunRuleService> _mockRunEvaluationService;
+    private readonly Mock<IRateFinderService> _mockRateFinderService;
+
+    public ValidateRateEvaluationsServiceTest()
+    {
+        _mockEvaluationDetailService = new Mock<IEvaluationDetailService>();
+        _mockRateService = new Mock<IRateService>();
+        _mockRunEvaluationService = new Mock<IRunRuleService>();
+        _mockRateFinderService = new Mock<IRateFinderService>();
+        _validateRateEvaluationsService = new ValidateRateEvaluationsService(_mockEvaluationDetailService.Object,
+                                                                             _mockRateService.Object,
+                                                                             _mockRunEvaluationService.Object,
+                                                                             _mockRateFinderService.Object);
+    }
+
+    [Fact]
+    public async Task ValidateRatePassesEvaluation_True()
+    {
+        var rateRequest = new RateRequest();
+
+        var evaluationBuilder1 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 1,
+            Description = "CreditScore Greater Than Or Equal 740.",
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new (0, ParameterTypes.Variable, "RateRequest.CreditScore"),
+                new (1, ParameterTypes.GreaterThanOrEqual, ""),
+                new (2, ParameterTypes.TextInput, "740")
+            }
+        };
+
+        _mockEvaluationDetailService.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(evaluationBuilder1).Verifiable();
+
+        var evaluationsReturned = new List<EvaluationDetail>
+        {
+            new EvaluationDetail
+            {
+               EvaluationDetailId = 1
+            },
+             new EvaluationDetail
+            {
+                EvaluationDetailId = 2
+            }
+        };
+        _mockRunEvaluationService.Setup(x => x.ValidateRequestRules(rateRequest, It.IsAny<List<EvaluationDetail>>())).Returns(evaluationsReturned).Verifiable();
+
+        var rate1 = new Rate()
+        {
+            RateId = 1,
+            Value = 5.49M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 1,
+                    RateId = 1,
+                    EvaluationDetailId = 1,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 2,
+                    RateId = 1,
+                    EvaluationDetailId = 2,
+                }
+            }
+        };
+        _mockRateService.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(rate1).Verifiable();
+
+        var result = await _validateRateEvaluationsService.ValidateRatePassesEvaluation(rateRequest, 1, 1);
+        Assert.True(result);
+
+        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(1), Times.Once);
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByIdAsync(1), Times.Once);
+    }
+
+    [Fact]
+    public async Task ValidateRatePassesEvaluation_False()
+    {
+        var rateRequest = new RateRequest();
+
+        var evaluationBuilder1 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 1,
+            Description = "CreditScore Greater Than Or Equal 740.",
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.CreditScore"),
+                new EvaluationParameter(1, ParameterTypes.GreaterThanOrEqual, ""),
+                new EvaluationParameter(2, ParameterTypes.TextInput, "740")
+            }
+        };
+
+        _mockEvaluationDetailService.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(evaluationBuilder1).Verifiable();
+
+        var evaluationsReturned = new List<EvaluationDetail>();
+        _mockRunEvaluationService.Setup(x => x.ValidateRequestRules(rateRequest, It.IsAny<List<EvaluationDetail>>())).Returns(evaluationsReturned).Verifiable();
+
+        var rate1 = new Rate()
+        {
+            RateId = 3,
+            Value = 5.49M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 1,
+                    RateId = 1,
+                    EvaluationDetailId = 1,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 2,
+                    RateId = 1,
+                    EvaluationDetailId = 3,
+                }
+            }
+        };
+        _mockRateService.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(rate1).Verifiable();
+
+        var result = await _validateRateEvaluationsService.ValidateRatePassesEvaluation(rateRequest, 1, 1);
+        Assert.False(result);
+
+        _mockEvaluationDetailService.Verify(x => x.GetByIdAsync(1), Times.Once);
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateService.Verify(x => x.GetByIdAsync(1), Times.Once);
+    }
+
+    [Fact]
+    public async Task ValidateRatePassesEvaluations_True()
+    {
+        var rate1 = new Rate()
+        {
+            RateId = 3,
+            Value = 5.49M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 1,
+                    RateId = 1,
+                    EvaluationDetailId = 3,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 2,
+                    RateId = 1,
+                    EvaluationDetailId = 4,
+                }
+            }
+        };
+        var applicationDate = DateTime.Now;
+        
+        _mockRateService.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(rate1).Verifiable();
+
+        var evaluationIds = rate1.RateEvaluations.Select(rateEvaluation => rateEvaluation.EvaluationDetailId).ToList();
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(applicationDate, EvaluationTypes.Rule, evaluationIds)).ReturnsAsync(GetFakeEvaluations()).Verifiable();
+
+        var evaluationsReturned = new List<EvaluationDetail>
+        {
+            new EvaluationDetail
+            {
+               EvaluationDetailId = 1
+            },
+             new EvaluationDetail
+            {
+                EvaluationDetailId = 2
+            }
+        };
+
+        var rateRequest = new RateRequest { ApplicationDate = applicationDate };
+        _mockRunEvaluationService.Setup(x => x.ValidateRequestRules(rateRequest, It.IsAny<List<EvaluationDetail>>())).Returns(evaluationsReturned).Verifiable();
+
+        var rateReturn = ( new Rate { RateId = 1 }, string.Empty );
+        _mockRateFinderService.Setup(x => x.DetermineRate(applicationDate, evaluationsReturned)).ReturnsAsync(rateReturn).Verifiable();
+
+        var result = await _validateRateEvaluationsService.ValidateRatePassesEvaluations(rateRequest, 1);
+        Assert.True(result);
+
+        _mockRateService.Verify(x => x.GetByIdAsync(1), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetActiveByEvaluationTypeAndIdsAsync(It.IsAny<DateTime>(), It.IsAny<EvaluationTypes>(), It.IsAny<List<int>>()), Times.Once);
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateFinderService.Verify(x => x.DetermineRate(It.IsAny<DateTime>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task ValidateRatePassesEvaluations_False()
+    {
+        var applicationDate = DateTime.Now;
+        var rateRequest = new RateRequest() { ApplicationDate = applicationDate };
+        
+        var rate1 = new Rate()
+        {
+            RateId = 3,
+            Value = 5.49M,
+            RateStartDate = applicationDate.AddDays(-50),
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 1,
+                    RateId = 1,
+                    EvaluationDetailId = 3,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 2,
+                    RateId = 1,
+                    EvaluationDetailId = 4,
+                }
+            }
+        };
+        _mockRateService.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(rate1).Verifiable();
+
+
+        var evaluationIds = rate1.RateEvaluations.Select(rateEvaluation => rateEvaluation.EvaluationDetailId).ToList();
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(rateRequest.ApplicationDate, EvaluationTypes.Rule, evaluationIds)).ReturnsAsync(GetFakeEvaluations()).Verifiable();
+
+        var evaluationsReturned = new List<EvaluationDetail>
+        {
+            new EvaluationDetail
+            {
+               EvaluationDetailId = 1,
+               StartDate = applicationDate.AddDays(-10)
+            },
+             new EvaluationDetail
+            {
+                EvaluationDetailId = 2,
+                StartDate = applicationDate.AddDays(-10)
+            }
+        };
+        
+        _mockRunEvaluationService.Setup(x => x.ValidateRequestRules(rateRequest, It.IsAny<List<EvaluationDetail>>())).Returns(evaluationsReturned).Verifiable();
+
+        var rateReturn = ( new Rate { RateId = 100 }, string.Empty );
+        _mockRateFinderService.Setup(x => x.DetermineRate(applicationDate, evaluationsReturned)).ReturnsAsync(rateReturn).Verifiable();
+
+        var result = await _validateRateEvaluationsService.ValidateRatePassesEvaluations(rateRequest, 1);
+        Assert.False(result);
+
+        _mockRateService.Verify(x => x.GetByIdAsync(1), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetActiveByEvaluationTypeAndIdsAsync(It.IsAny<DateTime>(), It.IsAny<EvaluationTypes>(), It.IsAny<List<int>>()), Times.Once);
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+        _mockRateFinderService.Verify(x => x.DetermineRate(It.IsAny<DateTime>(), It.IsAny<List<EvaluationDetail>>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task ValidateRatePassesEvaluations_False_NoEvaluations()
+    {
+        var rate1 = new Rate()
+        {
+            RateId = 3,
+            Value = 5.49M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 1,
+                    RateId = 1,
+                    EvaluationDetailId = 3,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 2,
+                    RateId = 1,
+                    EvaluationDetailId = 4,
+                }
+            }
+        };
+        _mockRateService.Setup(x => x.GetByIdAsync(1)).ReturnsAsync(rate1).Verifiable();
+
+        _mockEvaluationDetailService.Setup(x => x.GetActiveByEvaluationTypeAndIdsAsync(It.IsAny<DateTime>(), EvaluationTypes.Rule, It.IsAny<List<int>>())).ReturnsAsync(new List<EvaluationDetail>()).Verifiable();
+
+        var rateRequest = new RateRequest();
+        var result = await _validateRateEvaluationsService.ValidateRatePassesEvaluations(rateRequest, 1);
+        Assert.False(result);
+
+        _mockRateService.Verify(x => x.GetByIdAsync(1), Times.Once);
+        _mockEvaluationDetailService.Verify(x => x.GetActiveByEvaluationTypeAndIdsAsync(It.IsAny<DateTime>(), It.IsAny<EvaluationTypes>(), It.IsAny<List<int>>()), Times.Once);
+        _mockRunEvaluationService.Verify(x => x.ValidateRequestRules(It.IsAny<RateRequest>(), It.IsAny<List<EvaluationDetail>>()), Times.Never);
+        _mockRateFinderService.Verify(x => x.DetermineRate(It.IsAny<DateTime>(), It.IsAny<List<EvaluationDetail>>()), Times.Never);
+    }
+
+    public static List<EvaluationDetail> GetFakeEvaluations()
+    {
+        var date = DateTime.Now;
+        var evaluationBuilder1 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 1,
+            Description = "CreditScore Greater Than Or Equal 740.",
+            StartDate = DateTime.Now.AddDays(-10),
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.CreditScore"),
+                new EvaluationParameter(1, ParameterTypes.GreaterThanOrEqual, ""),
+                new EvaluationParameter(2, ParameterTypes.TextInput, "740")
+            }
+        };
+
+        var evaluationBuilder2 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 2,
+            Description = "Model Year Greater than or Equal 2022.",
+            StartDate = DateTime.Now.AddDays(-20),
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+                new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.ModelYear"),
+                new EvaluationParameter(1, ParameterTypes.GreaterThanOrEqual, ""),
+                new EvaluationParameter(2, ParameterTypes.TextInput, "2022")
+            }
+        };
+
+        var evaluationBuilder3 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 3,
+            Description = "Model Year Equal 2021.",
+            StartDate = DateTime.Now.AddDays(-10),
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+               new EvaluationParameter(0, ParameterTypes.Variable, "RateRequest.ModelYear"),
+               new EvaluationParameter(1, ParameterTypes.Equal, ""),
+               new EvaluationParameter(2, ParameterTypes.TextInput, "2021")
+            }
+        };
+
+        var evaluationBuilder4 = new EvaluationDetail()
+        {
+            EvaluationDetailId = 4,
+            StartDate = DateTime.Now.AddDays(-15),
+            Description = "CreditScore Greater Than Or Equal 700 AND Less Than Or Equal 739.",
+            EvaluationParameters = new List<EvaluationParameter>()
+            {
+               new EvaluationParameter(0, ParameterTypes.ParenthesesStart, ""),
+               new EvaluationParameter(1, ParameterTypes.Variable, "RateRequest.CreditScore"),
+               new EvaluationParameter(2, ParameterTypes.GreaterThanOrEqual, ""),
+               new EvaluationParameter(3, ParameterTypes.TextInput, "700"),
+               new EvaluationParameter(4, ParameterTypes.ParenthesesEnd, ""),
+               new EvaluationParameter(5, ParameterTypes.And, ""),
+               new EvaluationParameter(6, ParameterTypes.ParenthesesStart, ""),
+               new EvaluationParameter(7, ParameterTypes.Variable, "RateRequest.CreditScore"),
+               new EvaluationParameter(8, ParameterTypes.LessThanOrEqual, ""),
+               new EvaluationParameter(9, ParameterTypes.TextInput, "739"),
+               new EvaluationParameter(10, ParameterTypes.ParenthesesEnd, "")
+            }
+        };
+
+        var evaluations = new List<EvaluationDetail>() { evaluationBuilder1, evaluationBuilder2, evaluationBuilder3, evaluationBuilder4 };
+        return evaluations;
+    }
+
+    public static List<Rate> GetFakeRates()
+    {
+        var rate1 = new Rate()
+        {
+            RateId = 1,
+            Value = 5.49M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 1,
+                    RateId = 1,
+                    EvaluationDetailId = 1,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 2,
+                    RateId = 1,
+                    EvaluationDetailId = 2,
+                }
+            }
+        };
+
+        var rate2 = new Rate()
+        {
+            RateId = 2,
+            Value = 5.50M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 3,
+                    RateId = 2,
+                    EvaluationDetailId = 1,
+                },
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 4,
+                    RateId = 2,
+                    EvaluationDetailId = 3,
+                }
+            }
+        };
+
+        var rate3 = new Rate()
+        {
+            RateId = 3,
+            Value = 5.51M,
+            RateEvaluations = new List<RateEvaluation>()
+            {
+                new RateEvaluation()
+                {
+                    RateEvaluationId = 5,
+                    RateId = 3,
+                    EvaluationDetailId = 4,
+                }
+            }
+        };
+
+        var rates = new List<Rate>() { rate1, rate2, rate3 };
+        return rates;
+    }
+}

LCU.API.Internal.LoanRate/LCU.API.Internal.LoanRateTests/Usings.cs

@@ -0,0 +1,2 @@
+global using Xunit;
+global using Moq;