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