Adding

2026-04-07 14:21:04 -05:00
parent e37826fe30
commit 75ea216a17
264 changed files with 15920 additions and 0 deletions
@@ -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();
+}
@@ -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);
+    }
+}
@@ -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;
+    }
+}