587 lines
23 KiB
C#
587 lines
23 KiB
C#
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);
|
|
}
|
|
}
|