public async Task AllowsPackageAlreadyInPublicContainerWhenValidationSetPackageDoesNotExist()
{
PackageFileServiceMock
.Setup(x => x.DoesValidationSetPackageExistAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(false);
PackageFileServiceMock
.Setup(x => x.CopyValidationPackageToPackageFileAsync(It.IsAny <PackageValidationSet>()))
.Throws(new InvalidOperationException("Duplicate!"));
await Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available);
PackageFileServiceMock.Verify(
x => x.UpdatePackageBlobMetadataInValidationAsync(It.IsAny <PackageValidationSet>()),
Times.Once);
PackageFileServiceMock.Verify(
x => x.CopyValidationPackageToPackageFileAsync(ValidationSet),
Times.Once);
PackageServiceMock.Verify(
x => x.UpdateStatusAsync(Package, PackageStatus.Available, true),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeleteValidationPackageFileAsync(ValidationSet),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Never);
}
public async Task DoesNotSetPackageStreamMetadataIfNotChanged()
{
var content = "Hello, world.";
Package.PackageFileSize = content.Length;
Package.HashAlgorithm = "SHA512";
Package.Hash = "rQw3wx1psxXzqB8TyM3nAQlK2RcluhsNwxmcqXE2YbgoDW735o8TPmIR4uWpoxUERddvFwjgRSGw7gNPCwuvJg==";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(content));
var corePackageService = new Mock <ICorePackageService>();
var mockPackageEntityRepository = new Mock <IEntityRepository <Package> >();
var entityPackageService = new PackageEntityService(corePackageService.Object, mockPackageEntityRepository.Object);
PackageFileServiceMock
.Setup(x => x.DownloadPackageFileToDiskAsync(ValidationSet))
.ReturnsAsync(stream);
var streamMetadata = new PackageStreamMetadata()
{
Size = Package.PackageFileSize,
Hash = Package.Hash,
HashAlgorithm = Package.HashAlgorithm
};
PackageFileServiceMock
.Setup(x => x.UpdatePackageBlobMetadataAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(streamMetadata);
await Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available);
corePackageService.Verify(
x => x.UpdatePackageStreamMetadataAsync(It.IsAny <Package>(), It.IsAny <PackageStreamMetadata>(), It.IsAny <bool>()),
Times.Never);
}
public async Task MarksPackageStatusBasedOnValidatorResults(
ValidationStatus validation,
PackageStatus fromStatus,
PackageStatus toStatus,
bool expectedSetPackageStatusCall)
{
AddValidation("validation1", validation);
Package.PackageStatusKey = fromStatus;
TimeSpan duration = default(TimeSpan);
TelemetryServiceMock
.Setup(ts => ts.TrackTotalValidationDuration(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TimeSpan>(), It.IsAny <bool>()))
.Callback <string, string, Guid, TimeSpan, bool>((_1, _2, _3, t, _4) => duration = t);
ProcessorStats.AnyRequiredValidationSucceeded = true;
ProcessorStats.AnyValidationSucceeded = true;
var processor = CreateProcessor();
var before = DateTime.UtcNow;
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
var after = DateTime.UtcNow;
if (expectedSetPackageStatusCall)
{
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(PackageValidatingEntity, ValidationSet, toStatus),
Times.Once);
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(It.IsAny <PackageValidatingEntity>(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()),
Times.Once);
}
else
{
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(It.IsAny <PackageValidatingEntity>(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()),
Times.Never);
}
if (validation != ValidationStatus.Failed)
{
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Never);
}
else
{
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Once);
}
TelemetryServiceMock
.Verify(ts => ts.TrackTotalValidationDuration(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TimeSpan>(), It.IsAny <bool>()), Times.Once());
Assert.InRange(duration, before - ValidationSet.Created, after - ValidationSet.Created);
Assert.Equal(ValidationSetStatus.Completed, ValidationSet.ValidationSetStatus);
}
public async Task DoesNotReEnqueueProcessingIfValidationSetTimesOut()
{
const int postponeMinutes = 1;
AddValidation("validation1", ValidationStatus.Incomplete);
Configuration.TimeoutValidationSetAfter = TimeSpan.FromDays(1);
Configuration.ValidationMessageRecheckPeriod = TimeSpan.FromMinutes(postponeMinutes);
ValidationSet.Created = DateTime.UtcNow - TimeSpan.FromDays(1) - TimeSpan.FromHours(1);
ValidationStorageServiceMock
.Setup(s => s.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Callback <PackageValidationSet>(s => s.Updated = DateTime.UtcNow)
.Returns(Task.FromResult(0));
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
TelemetryServiceMock
.Verify(t => t.TrackValidationSetTimeout(Package.PackageRegistration.Id, Package.NormalizedVersion, ValidationSet.ValidationTrackingId));
ValidationEnqueuerMock
.Verify(ve => ve.StartValidationAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Never);
PackageFileServiceMock
.Verify(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
}
public async Task SavesPackageLicenseFileWhenPresent(EmbeddedLicenseFileType licenseFileType, bool expectedSave)
{
var content = "Hello, world.";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(content));
Package.EmbeddedLicenseType = licenseFileType;
PackageFileServiceMock
.Setup(x => x.DownloadPackageFileToDiskAsync(ValidationSet))
.ReturnsAsync(stream);
await Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available);
if (expectedSave)
{
CoreLicenseFileServiceMock
.Verify(clfs => clfs.ExtractAndSaveLicenseFileAsync(PackageValidatingEntity.EntityRecord, stream), Times.Once);
CoreLicenseFileServiceMock
.Verify(clfs => clfs.ExtractAndSaveLicenseFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()), Times.Once);
}
else
{
CoreLicenseFileServiceMock
.Verify(clfs => clfs.ExtractAndSaveLicenseFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()), Times.Never);
}
}
public async Task SetsPackageStreamMetadataIfChanged()
{
var content = "Hello, world.";
var expectedHash = "rQw3wx1psxXzqB8TyM3nAQlK2RcluhsNwxmcqXE2YbgoDW735o8TPmIR4uWpoxUERddvFwjgRSGw7gNPCwuvJg==";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(content));
PackageStreamMetadata actual = null;
PackageFileServiceMock
.Setup(x => x.DownloadPackageFileToDiskAsync(Package))
.ReturnsAsync(stream);
PackageServiceMock
.Setup(x => x.UpdatePackageStreamMetadataAsync(Package, It.IsAny <PackageStreamMetadata>(), false))
.Returns(Task.CompletedTask)
.Callback <Package, PackageStreamMetadata, bool>((_, m, __) => actual = m);
await Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available);
Assert.NotNull(actual);
Assert.Equal(content.Length, actual.Size);
Assert.Equal(expectedHash, actual.Hash);
Assert.Equal("SHA512", actual.HashAlgorithm);
PackageServiceMock.Verify(
x => x.UpdatePackageStreamMetadataAsync(Package, actual, false),
Times.Once);
TelemetryServiceMock.Verify(
x => x.TrackDurationToHashPackage(
It.Is <TimeSpan>(y => y > TimeSpan.Zero),
Package.PackageRegistration.Id,
Package.NormalizedVersion,
"SHA512",
"System.IO.MemoryStream"),
Times.Once);
}
public async Task CopyDbUpdateDeleteInCorrectOrderWhenValidationSetPackageExists()
{
var operations = new List <string>();
PackageFileServiceMock
.Setup(x => x.DoesValidationSetPackageExistAsync(ValidationSet))
.ReturnsAsync(true)
.Callback(() => operations.Add(nameof(IValidationFileService.DoesValidationSetPackageExistAsync)));
PackageFileServiceMock
.Setup(x => x.CopyValidationSetPackageToPackageFileAsync(ValidationSet, It.IsAny <IAccessCondition>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationFileService.CopyValidationSetPackageToPackageFileAsync)));
PackageServiceMock
.Setup(x => x.UpdateStatusAsync(Package, PackageStatus.Available, true))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IEntityService <Package> .UpdateStatusAsync)));
PackageFileServiceMock
.Setup(x => x.DeleteValidationPackageFileAsync(ValidationSet))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationFileService.DeleteValidationPackageFileAsync)));
await Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available);
var expectedOrder = new[]
{
nameof(IValidationFileService.DoesValidationSetPackageExistAsync),
nameof(IValidationFileService.CopyValidationSetPackageToPackageFileAsync),
nameof(IEntityService <Package> .UpdateStatusAsync),
nameof(IValidationFileService.DeleteValidationPackageFileAsync),
};
Assert.Equal(expectedOrder, operations);
}
public async Task UsesProperNupkgUrl(bool existsInPublicContainer, bool existsInValidationContainer, string expectedUrlSubstring)
{
UseDefaultValidatorProvider();
var validator = AddValidation("validation1", TimeSpan.FromDays(1));
PackageFileServiceMock
.Setup(pfs => pfs.DoesPackageFileExistAsync(Package))
.ReturnsAsync(existsInPublicContainer);
PackageFileServiceMock
.Setup(pfs => pfs.DoesValidationPackageFileExistAsync(Package))
.ReturnsAsync(existsInValidationContainer);
IValidationRequest validationRequest = null;
validator
.Setup(v => v.GetStatusAsync(It.IsAny <IValidationRequest>()))
.ReturnsAsync(ValidationStatus.NotStarted)
.Callback <IValidationRequest>(vr => validationRequest = vr);
var processor = CreateProcessor();
await processor.ProcessValidationsAsync(ValidationSet, Package);
validator
.Verify(v => v.GetStatusAsync(It.IsAny <IValidationRequest>()), Times.AtLeastOnce());
Assert.NotNull(validationRequest);
Assert.Contains(expectedUrlSubstring, validationRequest.NupkgUrl);
Assert.Equal(Package.PackageRegistration.Id, validationRequest.PackageId);
Assert.Equal(Package.NormalizedVersion, validationRequest.PackageVersion);
}
public async Task TriesToGetValidationSetFirst()
{
ValidationStorageMock
.Setup(vs => vs.GetValidationSetAsync(ValidationSet.ValidationTrackingId))
.ReturnsAsync(ValidationSet)
.Verifiable();
var provider = CreateProvider();
var set = await provider.TryGetOrCreateValidationSetAsync(PackageValidationMessageData, PackageValidatingEntity);
ValidationStorageMock
.Verify(vs => vs.GetValidationSetAsync(ValidationSet.ValidationTrackingId), Times.Once());
Assert.Same(ValidationSet, set);
PackageFileServiceMock.Verify(
x => x.CopyPackageFileForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.CopyValidationPackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.BackupPackageFileFromValidationSetPackageAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
TelemetryServiceMock.Verify(
x => x.TrackDurationToValidationSetCreation(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TimeSpan>()),
Times.Never);
}
public async Task ThrowsExceptionWhenValidationSetPackageAndDestinationPackageBothExist(PackageStatus packageStatus)
{
ValidationSet.PackageETag = null;
Package.PackageStatusKey = packageStatus;
var expected = new InvalidOperationException("Duplicate!");
PackageFileServiceMock
.Setup(x => x.DoesValidationSetPackageExistAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(true);
PackageFileServiceMock
.Setup(x => x.CopyValidationSetPackageToPackageFileAsync(It.IsAny <PackageValidationSet>(), It.IsAny <IAccessCondition>()))
.Throws(expected);
var actual = await Assert.ThrowsAsync <InvalidOperationException>(
() => Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available));
Assert.Same(expected, actual);
PackageFileServiceMock.Verify(
x => x.CopyValidationSetPackageToPackageFileAsync(ValidationSet, It.Is <IAccessCondition>(y => y.IfNoneMatchETag == "*")),
Times.Once);
PackageServiceMock.Verify(
x => x.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeleteValidationPackageFileAsync(It.IsAny <string>(), It.IsAny <string>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
}
private List <string> RecordOperationOrder()
{
var operations = new List <string>();
PackageStateProcessorMock
.Setup(x => x.SetStatusAsync(It.IsAny <IValidatingEntity <Package> >(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IStatusProcessor <Package> .SetStatusAsync)));
ValidationStorageServiceMock
.Setup(x => x.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationStorageService.UpdateValidationSetAsync)));
MessageServiceMock
.Setup(x => x.SendPublishedMessageAsync(It.IsAny <Package>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IMessageService <Package> .SendPublishedMessageAsync)));
MessageServiceMock
.Setup(x => x.SendValidationFailedMessageAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IMessageService <Package> .SendValidationFailedMessageAsync)));
TelemetryServiceMock
.Setup(x => x.TrackTotalValidationDuration(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <TimeSpan>(), It.IsAny <bool>()))
.Callback(() => operations.Add(nameof(ITelemetryService.TrackTotalValidationDuration)));
PackageFileServiceMock
.Setup(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationFileService.DeletePackageForValidationSetAsync)));
return(operations);
}
public async Task ThrowsExceptionWhenValidationSetPackageAndDestinationPackageDoesNotMatchETag()
{
ValidationSet.PackageETag = "\"some-etag\"";
Package.PackageStatusKey = PackageStatus.Available;
var expected = new StorageException(new RequestResult {
HttpStatusCode = (int)HttpStatusCode.PreconditionFailed
}, "Changed!", null);
PackageFileServiceMock
.Setup(x => x.DoesValidationSetPackageExistAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(true);
PackageFileServiceMock
.Setup(x => x.CopyValidationSetPackageToPackageFileAsync(It.IsAny <PackageValidationSet>(), It.IsAny <IAccessCondition>()))
.Throws(expected);
var actual = await Assert.ThrowsAsync <StorageException>(
() => Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available));
Assert.Same(expected, actual);
PackageFileServiceMock.Verify(
x => x.CopyValidationSetPackageToPackageFileAsync(ValidationSet, It.Is <IAccessCondition>(y => y.IfMatchETag == "\"some-etag\"")),
Times.Once);
PackageServiceMock.Verify(
x => x.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeleteValidationPackageFileAsync(It.IsAny <string>(), It.IsAny <string>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
}
public async Task CopiesPackageToPublicStorageAndSendsEmailUponSuccess()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Validating;
var stream = new MemoryStream();
PackageFileServiceMock
.Setup(pfs => pfs.DownloadValidationPackageFileAsync(Package))
.ReturnsAsync(stream)
.Verifiable();
PackageFileServiceMock
.Setup(pfs => pfs.SavePackageFileAsync(Package, stream))
.Returns(Task.FromResult(0))
.Verifiable();
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, Package);
PackageFileServiceMock
.Verify(pfs => pfs.DownloadValidationPackageFileAsync(Package), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.DownloadValidationPackageFileAsync(It.IsAny <Package>()), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.SavePackageFileAsync(Package, stream), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendPackagePublishedMessage(Package), Times.Once());
MessageServiceMock
.Verify(ms => ms.SendPackagePublishedMessage(It.IsAny <Package>()), Times.Once());
}
public async Task CopyDbUpdateDeleteInCorrectOrderWhenValidationSetPackageDoesNotExist()
{
var operations = new List <string>();
PackageFileServiceMock
.Setup(x => x.DoesValidationSetPackageExistAsync(ValidationSet))
.ReturnsAsync(false)
.Callback(() => operations.Add(nameof(IValidationPackageFileService.DoesValidationSetPackageExistAsync)));
PackageFileServiceMock
.Setup(x => x.CopyValidationPackageToPackageFileAsync(Package.PackageRegistration.Id, Package.NormalizedVersion))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationPackageFileService.CopyValidationPackageToPackageFileAsync)));
PackageServiceMock
.Setup(x => x.UpdatePackageStatusAsync(Package, PackageStatus.Available, true))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(ICorePackageService.UpdatePackageStatusAsync)));
PackageFileServiceMock
.Setup(x => x.DeleteValidationPackageFileAsync(Package.PackageRegistration.Id, Package.Version))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationPackageFileService.DeleteValidationPackageFileAsync)));
await Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available);
var expectedOrder = new[]
{
nameof(IValidationPackageFileService.DoesValidationSetPackageExistAsync),
nameof(IValidationPackageFileService.CopyValidationPackageToPackageFileAsync),
nameof(ICorePackageService.UpdatePackageStatusAsync),
nameof(IValidationPackageFileService.DeleteValidationPackageFileAsync),
};
Assert.Equal(expectedOrder, operations);
}
public async Task GetOrCreateValidationSetAsyncDoesNotCreateDuplicateValidationSet()
{
Guid validationTrackingId = Guid.NewGuid();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetAsync(validationTrackingId))
.ReturnsAsync((PackageValidationSet)null);
ValidationStorageMock
.Setup(vs => vs.OtherRecentValidationSetForPackageExists(
Package.Key,
It.IsAny <TimeSpan>(),
validationTrackingId))
.ReturnsAsync(true);
var provider = CreateProvider();
var result = await provider.TryGetOrCreateValidationSetAsync(validationTrackingId, Package);
Assert.Null(result);
ValidationStorageMock
.Verify(
vs => vs.OtherRecentValidationSetForPackageExists(
Package.Key,
It.IsAny <TimeSpan>(),
validationTrackingId),
Times.Once);
ValidationStorageMock
.Verify(vs => vs.CreateValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
PackageFileServiceMock.Verify(
x => x.CopyPackageFileForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.CopyValidationPackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
}
public async Task DoesNotSendValidatingTooLongMessageOnRevalidations()
{
const int postponeMinutes = 1;
AddValidation("validation1", ValidationStatus.Incomplete);
Configuration.TimeoutValidationSetAfter = TimeSpan.FromDays(1);
Configuration.ValidationSetNotificationTimeout = TimeSpan.FromMinutes(20);
Configuration.ValidationMessageRecheckPeriod = TimeSpan.FromMinutes(postponeMinutes);
ValidationSet.Created = DateTime.UtcNow - TimeSpan.FromMinutes(21);
ValidationSet.Updated = DateTime.UtcNow - TimeSpan.FromMinutes(15);
ValidationStorageServiceMock
.Setup(s => s.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Callback <PackageValidationSet>(s => s.Updated = DateTime.UtcNow)
.Returns(Task.FromResult(0));
ValidationStorageServiceMock
.Setup(s => s.GetValidationSetCountAsync(PackageValidatingEntity))
.Returns(Task.FromResult(2));
// Process the outcome once - the "too long to validate" message should NOT be sent.
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
TelemetryServiceMock
.Verify(t => t.TrackSentValidationTakingTooLongMessage(Package.PackageRegistration.Id, Package.NormalizedVersion, ValidationSet.ValidationTrackingId), Times.Never);
MessageServiceMock
.Verify(m => m.SendValidationTakingTooLongMessageAsync(Package), Times.Never);
ValidationEnqueuerMock
.Verify(ve => ve.StartValidationAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Once);
PackageFileServiceMock
.Verify(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
}
public async Task TracksTimedOutValidators()
{
const int postponeMinutes = 1;
AddValidation(
"IncompleteAndNotTimedOut",
ValidationStatus.Incomplete,
validationStart: DateTime.UtcNow,
trackAfter: TimeSpan.FromDays(1));
AddValidation(
"IncompleteButTimedOut",
ValidationStatus.Incomplete,
validationStart: DateTime.UtcNow + TimeSpan.FromDays(-5),
trackAfter: TimeSpan.FromDays(1));
Configuration.TimeoutValidationSetAfter = TimeSpan.FromDays(1);
Configuration.ValidationMessageRecheckPeriod = TimeSpan.FromMinutes(postponeMinutes);
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
TelemetryServiceMock
.Verify(t => t.TrackValidatorTimeout("IncompleteButTimedOut"));
ValidationEnqueuerMock
.Verify(ve => ve.StartValidationAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Once);
PackageFileServiceMock
.Verify(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
}
public async Task SetsPackageStreamMetadataIfChanged()
{
var content = "Hello, world.";
var expectedHash = "rQw3wx1psxXzqB8TyM3nAQlK2RcluhsNwxmcqXE2YbgoDW735o8TPmIR4uWpoxUERddvFwjgRSGw7gNPCwuvJg==";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(content));
PackageStreamMetadata actual = null;
PackageFileServiceMock
.Setup(x => x.DownloadPackageFileToDiskAsync(ValidationSet))
.ReturnsAsync(stream);
var streamMetadata = new PackageStreamMetadata()
{
Size = stream.Length,
Hash = expectedHash,
HashAlgorithm = CoreConstants.Sha512HashAlgorithmId
};
PackageFileServiceMock
.Setup(x => x.UpdatePackageBlobMetadataAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(streamMetadata);
PackageServiceMock
.Setup(x => x.UpdateMetadataAsync(Package, It.IsAny <PackageStreamMetadata>(), false))
.Returns(Task.CompletedTask)
.Callback <Package, PackageStreamMetadata, bool>((_, m, __) => actual = m);
await Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available);
Assert.NotNull(actual);
Assert.Equal(content.Length, actual.Size);
Assert.Equal(expectedHash, actual.Hash);
Assert.Equal("SHA512", actual.HashAlgorithm);
PackageServiceMock.Verify(
x => x.UpdateMetadataAsync(Package, actual, false),
Times.Once);
}
public async Task CopiesToValidationSetContainerBeforeAddingDbRecord()
{
const string validation1 = "validation1";
Configuration.Validations = new List <ValidationConfigurationItem>
{
new ValidationConfigurationItem
{
Name = validation1,
TrackAfter = TimeSpan.FromDays(1),
RequiredValidations = new List <string> {
}
}
};
Package.PackageStatusKey = PackageStatus.Available;
var operations = new List <string>();
Guid validationTrackingId = Guid.NewGuid();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetAsync(validationTrackingId))
.ReturnsAsync((PackageValidationSet)null)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.OtherRecentValidationSetForPackageExists(It.IsAny <int>(), It.IsAny <TimeSpan>(), validationTrackingId))
.ReturnsAsync(false);
PackageFileServiceMock
.Setup(x => x.CopyPackageFileForValidationSetAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(ETag)
.Callback <PackageValidationSet>(_ => operations.Add(nameof(IValidationPackageFileService.CopyPackageFileForValidationSetAsync)));
PackageFileServiceMock
.Setup(x => x.BackupPackageFileFromValidationSetPackageAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>()))
.Returns(Task.CompletedTask)
.Callback(() => operations.Add(nameof(IValidationPackageFileService.BackupPackageFileFromValidationSetPackageAsync)));
ValidationStorageMock
.Setup(vs => vs.CreateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns <PackageValidationSet>(pvs => Task.FromResult(pvs))
.Callback <PackageValidationSet>(_ => operations.Add(nameof(IValidationStorageService.CreateValidationSetAsync)));
ValidationStorageMock
.Setup(vs => vs.GetValidationSetCountAsync(It.IsAny <int>()))
.ReturnsAsync(1);
var provider = CreateProvider();
await provider.TryGetOrCreateValidationSetAsync(validationTrackingId, Package);
Assert.Equal(new[]
{
nameof(IValidationPackageFileService.CopyPackageFileForValidationSetAsync),
nameof(IValidationPackageFileService.BackupPackageFileFromValidationSetPackageAsync),
nameof(IValidationStorageService.CreateValidationSetAsync),
}, operations);
}
public async Task CopiesPackageFromValidationContainerWhenNotAvailable(PackageStatus packageStatus)
{
const string validation1 = "validation1";
Configuration.Validations = new List <ValidationConfigurationItem>
{
new ValidationConfigurationItem()
{
Name = validation1,
TrackAfter = TimeSpan.FromDays(1),
RequiredValidations = new List <string>(),
ShouldStart = true,
}
};
Package.PackageStatusKey = packageStatus;
Guid validationTrackingId = Guid.NewGuid();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetAsync(validationTrackingId))
.ReturnsAsync((PackageValidationSet)null)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.OtherRecentValidationSetForPackageExists(It.IsAny <IValidatingEntity <Package> >(), It.IsAny <TimeSpan>(), validationTrackingId))
.ReturnsAsync(false);
PackageValidationSet createdSet = null;
ValidationStorageMock
.Setup(vs => vs.CreateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns <PackageValidationSet>(pvs => Task.FromResult(pvs))
.Callback <PackageValidationSet>(pvs => createdSet = pvs)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetCountAsync(It.IsAny <IValidatingEntity <Package> >()))
.ReturnsAsync(1);
var provider = CreateProvider();
var packageValidationMessageData = new ProcessValidationSetData(
Package.PackageRegistration.Id,
Package.NormalizedVersion,
validationTrackingId,
ValidatingType.Package,
Package.Key);
var actual = await provider.TryGetOrCreateValidationSetAsync(packageValidationMessageData, PackageValidatingEntity);
PackageFileServiceMock.Verify(x => x.CopyPackageFileForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
PackageFileServiceMock.Verify(x => x.CopyValidationPackageForValidationSetAsync(createdSet), Times.Once);
PackageFileServiceMock.Verify(x => x.CopyValidationPackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Once);
PackageFileServiceMock.Verify(x => x.BackupPackageFileFromValidationSetPackageAsync(createdSet), Times.Once);
Assert.Null(actual.PackageETag);
}
public async Task AlwaysUsesValidationSetPackageWhenHasAnyProcessor()
{
ValidationSet.PackageValidations = new List <PackageValidation>
{
new PackageValidation {
Type = "SomeValidatorA"
},
new PackageValidation {
Type = "SomeValidatorB"
},
new PackageValidation {
Type = "SomeProcessorA"
},
new PackageValidation {
Type = "SomeProcessorB"
},
};
var expected = new StorageException("Validation set package not found!");
ValidatorProviderMock
.Setup(x => x.IsNuGetProcessor(It.Is <string>(n => n.Contains("Processor"))))
.Returns(true);
PackageFileServiceMock
.Setup(x => x.CopyValidationSetPackageToPackageFileAsync(ValidationSet, It.IsAny <IAccessCondition>()))
.Throws(expected);
var actual = await Assert.ThrowsAsync <StorageException>(
() => Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available));
Assert.Same(expected, actual);
PackageFileServiceMock.Verify(
x => x.UpdatePackageBlobMetadataInValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Once);
PackageFileServiceMock.Verify(
x => x.UpdatePackageBlobMetadataInValidationAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.CopyValidationPackageToPackageFileAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DoesValidationSetPackageExistAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
ValidatorProviderMock.Verify(
x => x.IsNuGetProcessor("SomeValidatorA"),
Times.Once);
ValidatorProviderMock.Verify(
x => x.IsNuGetProcessor("SomeValidatorB"),
Times.Once);
ValidatorProviderMock.Verify(
x => x.IsNuGetProcessor("SomeProcessorA"),
Times.Once);
ValidatorProviderMock.Verify(
x => x.IsNuGetProcessor("SomeProcessorB"),
Times.Never); // Never checked, since SomeProcessorA was found.
}
public async Task DoesNotBackUpThePackageWhenThereAreNoValidators()
{
const string validation1 = "validation1";
Configuration.Validations = new List <ValidationConfigurationItem>
{
new ValidationConfigurationItem()
{
Name = validation1, TrackAfter = TimeSpan.FromDays(1), RequiredValidations = new List <string> {
}
}
};
ValidatorProvider
.Setup(x => x.IsNuGetProcessor(validation1))
.Returns(false);
Guid validationTrackingId = Guid.NewGuid();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetAsync(validationTrackingId))
.ReturnsAsync((PackageValidationSet)null)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.OtherRecentValidationSetForPackageExists(It.IsAny <IValidatingEntity <Package> >(), It.IsAny <TimeSpan>(), validationTrackingId))
.ReturnsAsync(false);
PackageValidationSet createdSet = null;
ValidationStorageMock
.Setup(vs => vs.CreateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns <PackageValidationSet>(pvs => Task.FromResult(pvs))
.Callback <PackageValidationSet>(pvs => createdSet = pvs)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetCountAsync(It.IsAny <IValidatingEntity <Package> >()))
.ReturnsAsync(1);
var provider = CreateProvider();
var packageValidationMessageData = new ProcessValidationSetData(
Package.PackageRegistration.Id,
Package.NormalizedVersion,
validationTrackingId,
ValidatingType.Package,
Package.Key);
var actual = await provider.TryGetOrCreateValidationSetAsync(packageValidationMessageData, PackageValidatingEntity);
PackageFileServiceMock.Verify(
x => x.BackupPackageFileFromValidationSetPackageAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
}
public async Task ProcessesFailedValidationAccordingToFailureBehavior(ValidationFailureBehavior failureBehavior, PackageStatus expectedPackageStatus)
{
AddValidation("validation1", ValidationStatus.Failed, failureBehavior);
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(PackageValidatingEntity, ValidationSet, expectedPackageStatus),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Once);
}
public async Task DoesNotCopyPackageIfItsAvailable()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Available;
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, Package);
PackageFileServiceMock
.Verify(pfs => pfs.DownloadValidationPackageFileAsync(It.IsAny <Package>()), Times.Never());
PackageFileServiceMock
.Verify(pfs => pfs.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>()), Times.Never());
}
public async Task CopiesPackageFromPackagesContainerWhenAvailable()
{
const string validation1 = "validation1";
Configuration.Validations = new List <ValidationConfigurationItem>
{
new ValidationConfigurationItem()
{
Name = validation1, TrackAfter = TimeSpan.FromDays(1), RequiredValidations = new List <string> {
}
}
};
Package.PackageStatusKey = PackageStatus.Available;
Guid validationTrackingId = Guid.NewGuid();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetAsync(validationTrackingId))
.ReturnsAsync((PackageValidationSet)null)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.OtherRecentValidationSetForPackageExists(It.IsAny <int>(), It.IsAny <TimeSpan>(), validationTrackingId))
.ReturnsAsync(false);
PackageValidationSet createdSet = null;
ValidationStorageMock
.Setup(vs => vs.CreateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Returns <PackageValidationSet>(pvs => Task.FromResult(pvs))
.Callback <PackageValidationSet>(pvs => createdSet = pvs)
.Verifiable();
ValidationStorageMock
.Setup(vs => vs.GetValidationSetCountAsync(It.IsAny <int>()))
.ReturnsAsync(1);
var provider = CreateProvider();
var actual = await provider.TryGetOrCreateValidationSetAsync(validationTrackingId, Package);
PackageFileServiceMock.Verify(x => x.CopyPackageFileForValidationSetAsync(createdSet), Times.Once);
PackageFileServiceMock.Verify(x => x.CopyPackageFileForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Once);
PackageFileServiceMock.Verify(x => x.CopyValidationPackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
PackageFileServiceMock.Verify(x => x.BackupPackageFileFromValidationSetPackageAsync(Package, createdSet), Times.Once);
Assert.Equal(ETag, actual.PackageETag);
}
public async Task DeletesValidationPackageOnSuccess(PackageStatus fromStatus, bool delete)
{
Package.PackageStatusKey = fromStatus;
await Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available);
PackageFileServiceMock.Verify(
x => x.DeleteValidationPackageFileAsync(Package.PackageRegistration.Id, Package.Version),
delete ? Times.Once() : Times.Never());
PackageFileServiceMock.Verify(
x => x.DeleteValidationPackageFileAsync(It.IsAny <string>(), It.IsAny <string>()),
delete ? Times.Once() : Times.Never());
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Never);
}
public async Task ReEnqueuesProcessingIfNotAllComplete()
{
const int postponeMinutes = 1;
AddValidation("validation1", ValidationStatus.Incomplete);
Configuration.ValidationMessageRecheckPeriod = TimeSpan.FromMinutes(postponeMinutes);
Configuration.TimeoutValidationSetAfter = TimeSpan.FromDays(1);
PackageValidationMessageData messageData = null;
DateTimeOffset postponeTill = DateTimeOffset.MinValue;
ValidationEnqueuerMock
.Setup(ve => ve.SendMessageAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()))
.Returns(Task.FromResult(0))
.Callback <PackageValidationMessageData, DateTimeOffset>((pv, pt) => {
messageData = pv;
postponeTill = pt;
});
var processor = CreateProcessor();
var startTime = DateTimeOffset.Now;
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats, ScheduleNextCheck);
ValidationStorageServiceMock
.Verify(s => s.UpdateValidationSetAsync(ValidationSet), Times.Once);
ValidationEnqueuerMock
.Verify(ve => ve.SendMessageAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Once());
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(It.IsAny <PackageValidatingEntity>(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
Assert.NotNull(messageData);
Assert.Equal(PackageValidationMessageType.ProcessValidationSet, messageData.Type);
Assert.Equal(ValidationSet.ValidationTrackingId, messageData.ProcessValidationSet.ValidationTrackingId);
Assert.Equal(ValidationSet.PackageId, messageData.ProcessValidationSet.PackageId);
Assert.Equal(Package.NormalizedVersion, messageData.ProcessValidationSet.PackageVersion);
Assert.Equal(ValidationSet.ValidatingType, messageData.ProcessValidationSet.ValidatingType);
Assert.Equal(ValidationSet.PackageKey, messageData.ProcessValidationSet.EntityKey);
Assert.Equal(postponeMinutes, (postponeTill - startTime).TotalMinutes, 0);
Assert.Equal(ValidationSetStatus.InProgress, ValidationSet.ValidationSetStatus);
}
public async Task SetsPackageStatusToFailedValidation()
{
await Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.FailedValidation);
PackageServiceMock.Verify(
x => x.UpdatePackageStatusAsync(Package, PackageStatus.FailedValidation, true),
Times.Once);
PackageServiceMock.Verify(
x => x.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()),
Times.Once);
TelemetryServiceMock.Verify(
x => x.TrackPackageStatusChange(PackageStatus.Validating, PackageStatus.FailedValidation),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Never);
}
public async Task MarksPackageStatusBasedOnValidatorResults(
ValidationStatus validation,
PackageStatus fromStatus,
PackageStatus toStatus,
bool setPackageStatus)
{
AddValidation("validation1", validation);
Package.PackageStatusKey = fromStatus;
TimeSpan duration = default(TimeSpan);
TelemetryServiceMock
.Setup(ts => ts.TrackTotalValidationDuration(It.IsAny <TimeSpan>(), It.IsAny <bool>()))
.Callback <TimeSpan, bool>((t, _) => duration = t);
var processor = CreateProcessor();
var before = DateTime.UtcNow;
await processor.ProcessValidationOutcomeAsync(ValidationSet, Package);
var after = DateTime.UtcNow;
if (setPackageStatus)
{
PackageStateProcessorMock.Verify(
x => x.SetPackageStatusAsync(Package, ValidationSet, toStatus),
Times.Once);
PackageStateProcessorMock.Verify(
x => x.SetPackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()),
Times.Once);
}
else
{
PackageStateProcessorMock.Verify(
x => x.SetPackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageValidationSet>(), It.IsAny <PackageStatus>()),
Times.Never);
}
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Once);
TelemetryServiceMock
.Verify(ts => ts.TrackTotalValidationDuration(It.IsAny <TimeSpan>(), It.IsAny <bool>()), Times.Once());
Assert.InRange(duration, before - ValidationSet.Created, after - ValidationSet.Created);
}
public async Task DeletesValidationPackageOnSuccess()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Validating;
PackageFileServiceMock
.Setup(pfs => pfs.DeleteValidationPackageFileAsync(Package.PackageRegistration.Id, Package.Version))
.Returns(Task.FromResult(0))
.Verifiable();
var procecssor = CreateProcessor();
await procecssor.ProcessValidationOutcomeAsync(ValidationSet, Package);
PackageFileServiceMock
.Verify(pfs => pfs.DeleteValidationPackageFileAsync(Package.PackageRegistration.Id, Package.Version), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.DeleteValidationPackageFileAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Once());
}
