public FactsBase(int maximumValidationFailures = 5)
{
_certificateStore = new Mock <ICertificateStore>();
_certificateValidationService = new Mock <ICertificateValidationService>();
_certificateVerifier = new Mock <ICertificateVerifier>();
_validationEnqueuer = new Mock <IPackageValidationEnqueuer>();
_featureFlagService = new Mock <IFeatureFlagService>();
_featureFlagService.SetReturnsDefault(true);
_message = new CertificateValidationMessage(
CertificateKey,
ValidationId,
revalidateRevokedCertificate: false,
sendCheckValidator: true);
var logger = new Mock <ILogger <CertificateValidationMessageHandler> >();
_target = new CertificateValidationMessageHandler(
_certificateStore.Object,
_certificateValidationService.Object,
_certificateVerifier.Object,
_validationEnqueuer.Object,
_featureFlagService.Object,
logger.Object,
maximumValidationFailures);
}
public async Task EnqueueVerificationAsync(IValidationRequest request, EndCertificate certificate)
{
var message = new CertificateValidationMessage(certificate.Key, request.ValidationId);
var brokeredMessage = _serializer.Serialize(message);
await _topicClient.SendAsync(brokeredMessage);
}
public Task <EndCertificateValidation> FindCertificateValidationAsync(CertificateValidationMessage message)
{
// Fetch the validation, the end certificate that this validation is for, and all of the parent
// certificates that the end certificate depends on.
return(_context
.CertificateValidations
.Where(v => v.ValidationId == message.ValidationId && v.EndCertificateKey == message.CertificateKey)
.Include(v => v.EndCertificate.CertificateChainLinks.Select(l => l.ParentCertificate))
.FirstOrDefaultAsync());
}
public async Task EnqueueVerificationAsync(IValidationRequest request, EndCertificate certificate)
{
var message = new CertificateValidationMessage(certificate.Key, request.ValidationId);
var brokeredMessage = _serializer.Serialize(message);
var visibleAt = DateTimeOffset.UtcNow + (_configuration.Value.MessageDelay ?? TimeSpan.Zero);
brokeredMessage.ScheduledEnqueueTimeUtc = visibleAt;
await _topicClient.SendAsync(brokeredMessage);
}
public async Task EnqueueValidationAsync(Guid validationId, EndCertificate certificate)
{
var message = new CertificateValidationMessage(
certificate.Key,
validationId,
revalidateRevokedCertificate: false,
sendCheckValidator: false);
var brokeredMessage = _serializer.Serialize(message);
await _topicClient.SendAsync(brokeredMessage);
}
public async Task DoesNotSendCheckValidatorIfFeatureFlagIsDisabled()
{
// Arrange
var result = new CertificateVerificationResult(
status: EndCertificateStatus.Good,
statusFlags: X509ChainStatusFlags.NoError);
_message = new CertificateValidationMessage(
CertificateKey,
ValidationId,
revalidateRevokedCertificate: false,
sendCheckValidator: true);
_certificateValidationService
.Setup(s => s.FindCertificateValidationAsync(It.IsAny <CertificateValidationMessage>()))
.ReturnsAsync(new EndCertificateValidation
{
Status = null,
EndCertificate = new EndCertificate
{
Status = EndCertificateStatus.Unknown,
Use = EndCertificateUse.CodeSigning,
CertificateChainLinks = new CertificateChainLink[0],
}
});
_featureFlagService.Setup(x => x.IsQueueBackEnabled()).Returns(false);
_certificateStore
.Setup(s => s.LoadAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new X509Certificate2());
_certificateVerifier
.Setup(v => v.VerifyCodeSigningCertificate(It.IsAny <X509Certificate2>(), It.IsAny <X509Certificate2[]>()))
.Returns(result);
_certificateValidationService
.Setup(s => s.TrySaveResultAsync(It.IsAny <EndCertificateValidation>(), It.IsAny <CertificateVerificationResult>()))
.ReturnsAsync(true);
// Act & Assert
Assert.True(await _target.HandleAsync(_message));
_certificateValidationService
.Verify(s => s.TrySaveResultAsync(It.IsAny <EndCertificateValidation>(), It.IsAny <CertificateVerificationResult>()), Times.Once);
_validationEnqueuer.Verify(
x => x.SendMessageAsync(It.IsAny <PackageValidationMessageData>()),
Times.Never);
}
public FactsBase(int maximumValidationFailures = 5)
{
_certificateStore = new Mock <ICertificateStore>();
_certificateValidationService = new Mock <ICertificateValidationService>();
_certificateVerifier = new Mock <ICertificateVerifier>();
_message = new CertificateValidationMessage(CertificateKey, ValidationId, revalidateRevokedCertificate: false);
var logger = new Mock <ILogger <CertificateValidationMessageHandler> >();
_target = new CertificateValidationMessageHandler(
_certificateStore.Object,
_certificateValidationService.Object,
_certificateVerifier.Object,
logger.Object,
maximumValidationFailures);
}
public async Task SendsSerializeMessage()
{
CertificateValidationMessage message = null;
_serializer
.Setup(x => x.Serialize(It.IsAny <CertificateValidationMessage>()))
.Returns(() => _brokeredMessage.Object)
.Callback <CertificateValidationMessage>(x => message = x);
await _target.EnqueueVerificationAsync(_validationRequest.Object, _endCertificate);
Assert.Equal(_validationRequest.Object.ValidationId, message.ValidationId);
Assert.Equal(_endCertificate.Key, message.CertificateKey);
Assert.False(message.RevalidateRevokedCertificate);
_serializer.Verify(
x => x.Serialize(It.IsAny <CertificateValidationMessage>()),
Times.Once);
_topicClient.Verify(x => x.SendAsync(_brokeredMessage.Object), Times.Once);
_topicClient.Verify(x => x.SendAsync(It.IsAny <IBrokeredMessage>()), Times.Once);
}
public async Task ReturnsNullIfCertificateValidationDoesntExist()
{
// Arrange
_context.Mock(
certificateValidations: new[]
{
_certificateValidation1,
_certificateValidation2,
}
);
var message = new CertificateValidationMessage(
certificateKey: EndCertificateKey1,
validationId: ValidationId2);
// Act & Assert
var result = await _target.FindCertificateValidationAsync(message);
Assert.Null(result);
}
public async Task ReturnsCertificateValidationIfExists()
{
// Arrange
_context.Mock(
certificateValidations: new[]
{
_certificateValidation1,
_certificateValidation2,
}
);
var message = new CertificateValidationMessage(
certificateKey: EndCertificateKey2,
validationId: ValidationId2);
// Act & Assert
var result = await _target.FindCertificateValidationAsync(message);
Assert.NotNull(result);
Assert.Equal(EndCertificateKey2, result.EndCertificateKey);
Assert.Equal(ValidationId2, result.ValidationId);
}
