private bool ValidateNewReport(
BrokenExternalReferencesReport report,
ItInterface includedInterfaceWhichFails,
EndpointValidationError expectedInterfaceError,
BrokenLinkCause brokenLinkCauseForInterface,
ExternalReference includedReferenceWhichFails,
EndpointValidationError expectedReferenceError,
BrokenLinkCause brokenLinkCauseForReference)
{
Assert.Equal(_now, report.Created);
var brokenLinkInInterface = Assert.Single(report.BrokenInterfaceLinks);
Assert.Same(includedInterfaceWhichFails, brokenLinkInInterface.BrokenReferenceOrigin);
Assert.Equal(brokenLinkInInterface.ErrorResponseCode, (int?)expectedInterfaceError.StatusCode);
Assert.Equal(brokenLinkInInterface.Cause, brokenLinkCauseForInterface);
Assert.Equal(brokenLinkInInterface.ValueOfCheckedUrl, includedInterfaceWhichFails.Url);
var brokenLinkInExternalReference = Assert.Single(report.BrokenExternalReferences);
Assert.Same(includedReferenceWhichFails, brokenLinkInExternalReference.BrokenReferenceOrigin);
Assert.Equal(brokenLinkInExternalReference.ErrorResponseCode, (int?)expectedReferenceError.StatusCode);
Assert.Equal(brokenLinkInExternalReference.ValueOfCheckedUrl, includedReferenceWhichFails.URL);
Assert.Equal(brokenLinkInExternalReference.Cause, brokenLinkCauseForReference);
return(true);
}
private static void SetResults <T>(IBrokenLinkWithOrigin <T> item, T origin, EndpointValidationError error, string url) where T : IEntity
{
item.BrokenReferenceOrigin = origin;
item.Cause = ParseCause(error.ErrorType);
item.ErrorResponseCode = error.StatusCode.HasValue ? (int)error.StatusCode.Value : default(int?);
item.ReferenceDateOfLatestLinkChange = origin.LastChanged;
item.ValueOfCheckedUrl = url;
}
public async Task ExecuteAsync_Checks_System_And_Interface_External_Links_And_Replaces_Report()
{
//Arrange
var includedInterfaceWhichFails = new ItInterface {
Url = $"https://www.test-interface.com/{A<int>()}"
};
var includedInterfaceWhichDoesNotFail = new ItInterface {
Url = $"https://www.test-interface.com/{A<int>()}"
};
var excludedInterface = new ItInterface {
Url = null
};
var excludedReference = new ExternalReference {
URL = $"{_rootUrl.Url.AbsoluteUri}/internal-links-are-ignored"
};
var includedReferenceWhichFails = new ExternalReference {
URL = $"https://www.test-system.com/{A<int>()}"
};
var includedReferenceWhichDoesNotFail = new ExternalReference {
URL = $"https://www.test-system.com/{A<int>()}"
};
_interfaceRepository.Setup(x => x.GetInterfacesWithExternalReferenceDefined()).Returns(new[] { includedInterfaceWhichFails, includedInterfaceWhichDoesNotFail, excludedInterface }.AsQueryable());
_referenceRepository.Setup(x => x.GetByRootType(ReferenceRootType.System)).Returns(new[] { excludedReference, includedReferenceWhichFails, includedReferenceWhichDoesNotFail }.AsQueryable());
var expectedInterfaceError = new EndpointValidationError(EndpointValidationErrorType.CommunicationError);
var expectedReferenceError = new EndpointValidationError(EndpointValidationErrorType.ErrorResponseCode, HttpStatusCode.NotFound);
ExpectEndpointValidationResult(includedInterfaceWhichFails.Url, expectedInterfaceError);
ExpectEndpointValidationResult(includedInterfaceWhichDoesNotFail.Url);
ExpectEndpointValidationResult(includedReferenceWhichFails.URL, expectedReferenceError);
ExpectEndpointValidationResult(includedReferenceWhichDoesNotFail.URL);
//Act
var result = await _sut.ExecuteAsync();
//Assert
Assert.True(result.Ok);
_brokenExternalReferencesReportRepository.Verify(
x => x.ReplaceCurrentReport(It.Is <BrokenExternalReferencesReport>(report =>
ValidateNewReport(report, includedInterfaceWhichFails, expectedInterfaceError,
BrokenLinkCause.CommunicationError, includedReferenceWhichFails, expectedReferenceError,
BrokenLinkCause.ErrorResponse))), Times.Once);
}
private void ExpectEndpointValidationResult(string url, EndpointValidationError error = null)
{
_endpointValidationService.Setup(x => x.ValidateAsync(url)).ReturnsAsync(
new EndpointValidation(url, error));
}
public EndpointValidation(string url, EndpointValidationError error = null)
{
Url = url;
Error = error;
}
