public VerifyTestCaseData(
VerifyWarrantyCaseRequest request,
VerifyWarrantyCaseResponse expectedResponse)
{
Request = request;
ExpectedResponse = expectedResponse;
}
public async Task Verify(
VerifyWarrantyCaseRequest request,
IList <Guid> requestIds,
IList <ExternalPartyCall> externalPartyCalls,
VerifyWarrantyCaseResponse expectedResponse,
int expectedWarrantyCaseVerificationCount,
IList <WarrantyCaseVerification> expectedWarrantyCaseVerifications,
int expectedWarrantyProofCount,
IList <WarrantyProof?> expectedWarrantyProofs, // corresponds to requestIds
int expectedExternalPartyRequestCount,
IList <ExternalPartyRequest?> expectedExternalPartyRequests, // corresponds to requestIds
int expectedExternalPartyResponseCount,
IList <ExternalPartyResponse?> expectedExternalPartyResponses) // corresponds to requestIds
{
var services = GetServices();
var mockedRequestIdGenerator = new Mock <IRequestIdGenerator>(MockBehavior.Strict);
var mockedRequestIdGeneratorSetupSequence = mockedRequestIdGenerator
.SetupSequence(m => m.GenerateRequestId());
foreach (var requestId in requestIds)
{
mockedRequestIdGeneratorSetupSequence.Returns(requestId);
}
services.AddSingleton(_ => mockedRequestIdGenerator.Object);
List <WarrantyRequest> actualExternalPartyCallRequests = new List <WarrantyRequest>();
var externalPartyProxyCallSequence = new MockSequence();
var mockedExternalPartyProxy = new Mock <IExternalPartyProxy>(MockBehavior.Strict);
foreach (var externalPartyCall in externalPartyCalls)
{
var mockedExternalPartyProxySetup = mockedExternalPartyProxy
.InSequence(externalPartyProxyCallSequence)
.Setup(m => m.Call(It.IsAny <WarrantyRequest>()))
.Callback <WarrantyRequest>(warrantyRequest => actualExternalPartyCallRequests.Add(warrantyRequest));
if (externalPartyCall.Throws)
{
mockedExternalPartyProxySetup.Throws(new NetworkException("Network exception."));
}
else
{
mockedExternalPartyProxySetup.ReturnsAsync(externalPartyCall.Response !);
}
}
services.AddScoped(_ => mockedExternalPartyProxy.Object);
var serviceProvider = services.BuildServiceProvider();
using var serviceScope = serviceProvider.CreateScope();
var warrantyService = serviceScope.ServiceProvider.GetRequiredService <IWarrantyService>();
var actual = await warrantyService.Verify(request);
// assert
Assert.Equal(expectedResponse.IsSuccess, actual.IsSuccess);
actual.WarrantyCaseResponse.Should().BeEquivalentTo(expectedResponse.WarrantyCaseResponse);
Assert.Equal(expectedResponse.FailureType, actual.FailureType);
Assert.Equal(expectedResponse.FailureMessage is null, actual.FailureMessage is null);
mockedExternalPartyProxy.Verify(
m => m.Call(It.IsAny <WarrantyRequest>()),
Times.Exactly(externalPartyCalls.Count));
actualExternalPartyCallRequests.Should().BeEquivalentTo(externalPartyCalls.Select(c => c.ExpectedRequest).ToList());
// assert saved data
using (var comprehensiveDbContext = serviceScope.ServiceProvider.GetRequiredService <ComprehensiveDataDbContext>())
{
var actualWarrantyCaseVerificationCount = comprehensiveDbContext.WarrantyCaseVerification
.Where(v => v.OrderId == request.OrderId)
.Count();
Assert.Equal(expectedWarrantyCaseVerificationCount, actualWarrantyCaseVerificationCount);
foreach ((WarrantyCaseVerification expectedWarrantyCaseVerification, int i) in
expectedWarrantyCaseVerifications.Select((y, i) => (y, i)))
{
var actualWarrantyCaseVerification = comprehensiveDbContext.WarrantyCaseVerification
.Where(v => v.OrderId == request.OrderId)
.OrderByDescending(v => v.DateTime)
.Skip(expectedWarrantyCaseVerifications.Count - 1 - i)
.First();
actualWarrantyCaseVerification.Should().BeEquivalentTo(
expectedWarrantyCaseVerification,
opt => opt
.Excluding(v => v.Id)
.Excluding(v => v.DateTime)
.Excluding(v => v.FailureMessage)
.Excluding(v => v.ConvertedResponse));
Assert.Equal(
expectedWarrantyCaseVerification.FailureMessage is null,
actualWarrantyCaseVerification.FailureMessage is null);
var expectedConvertedResponse = JsonConvert.DeserializeObject <WarrantyCaseResponse?>(expectedWarrantyCaseVerification.ConvertedResponse ?? "");
var actualConvertedResponse = JsonConvert.DeserializeObject <WarrantyCaseResponse?>(actualWarrantyCaseVerification.ConvertedResponse ?? "");
actualConvertedResponse.Should().BeEquivalentTo(expectedConvertedResponse);
}
var actualWarrantyProofCount = comprehensiveDbContext.WarrantyProof
.Where(p => p.OrderId == request.OrderId)
.Count();
Assert.Equal(actualWarrantyProofCount, expectedWarrantyProofCount);
foreach ((WarrantyProof? expectedWarrantyProof, int i) in
expectedWarrantyProofs.Select((y, i) => (y, i)))
{
var actualWarrantyProof = comprehensiveDbContext.WarrantyProof
.Where(p => p.RequestId == requestIds.Last())
.SingleOrDefault();
actualWarrantyProof.Should().BeEquivalentTo(
expectedWarrantyProof,
opt => opt
.Excluding(req => req.Id)
.Excluding(req => req.DateTime));
}
}
using (var budgetDbContext = serviceScope.ServiceProvider.GetRequiredService <BudgetDataDbContext>())
{
var actualExternalPartyRequestCount = budgetDbContext.ExternalPartyRequest
.Where(req => req.OrderId == request.OrderId)
.Count();
Assert.Equal(expectedExternalPartyRequestCount, actualExternalPartyRequestCount);
foreach ((ExternalPartyRequest? expectedExternalPartyRequest, int i) in
expectedExternalPartyRequests.Select((y, i) => (y, i)))
{
var actualExternalPartyRequest = budgetDbContext.ExternalPartyRequest
.Where(req => req.OrderId == request.OrderId && req.RequestId == requestIds[i])
.SingleOrDefault();
actualExternalPartyRequest.Should().BeEquivalentTo(
expectedExternalPartyRequest,
opt => opt
.Excluding(req => req.Id)
.Excluding(req => req.DateTime)
.Excluding(req => req.Request));
var expectedRawRequest = JsonConvert.DeserializeObject <WarrantyResponse?>(expectedExternalPartyRequest.Request ?? "");
var actualRawRequest = JsonConvert.DeserializeObject <WarrantyResponse?>(actualExternalPartyRequest.Request ?? "");
actualRawRequest.Should().BeEquivalentTo(expectedRawRequest);
}
var actualExternalPartyResponseCount = budgetDbContext.ExternalPartyResponse
.Where(res => res.OrderId == request.OrderId)
.Count();
Assert.Equal(expectedExternalPartyResponseCount, actualExternalPartyResponseCount);
foreach ((ExternalPartyResponse? expectedExternalPartyResponse, int i) in
expectedExternalPartyResponses.Select((y, i) => (y, i)))
{
var actualExternalPartyResponse = budgetDbContext.ExternalPartyResponse
.Where(req => req.OrderId == request.OrderId && req.RequestId == requestIds[i])
.SingleOrDefault();
actualExternalPartyResponse.Should().BeEquivalentTo(
expectedExternalPartyResponse,
opt => opt
.Excluding(res => res.Id)
.Excluding(res => res.DateTime)
.Excluding(res => res.Response));
var expectedRawResponse = JsonConvert.DeserializeObject <WarrantyResponse?>(expectedExternalPartyResponse.Response ?? "");
var actualRawResponse = JsonConvert.DeserializeObject <WarrantyResponse?>(actualExternalPartyResponse.Response ?? "");
actualRawResponse.Should().BeEquivalentTo(expectedRawResponse);
}
}
}
