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