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 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 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);
}
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 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 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 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 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);
}
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 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 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 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 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 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 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());
}
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));
PackageFileServiceMock
.Setup(x => x.DownloadPackageFileToDiskAsync(Package))
.ReturnsAsync(stream);
await Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available);
PackageServiceMock.Verify(
x => x.UpdatePackageStreamMetadataAsync(It.IsAny <Package>(), It.IsAny <PackageStreamMetadata>(), It.IsAny <bool>()),
Times.Never);
}
public async Task TracksMissingNupkgForAvailablePackage(bool validationFileExists)
{
Package.PackageStatusKey = PackageStatus.Available;
PackageFileServiceMock
.Setup(pfs => pfs.DoesPackageFileExistAsync(Package))
.ReturnsAsync(false);
PackageFileServiceMock
.Setup(pfs => pfs.DoesValidationPackageFileExistAsync(Package))
.ReturnsAsync(validationFileExists);
await Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available);
TelemetryServiceMock.Verify(
x => x.TrackMissingNupkgForAvailablePackage(
ValidationSet.PackageId,
ValidationSet.PackageNormalizedVersion,
ValidationSet.ValidationTrackingId.ToString()),
Times.Once);
}
public async Task CopyDbUpdateDeleteInCorrectOrder()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Validating;
var operations = new List <string>();
var stream = new MemoryStream();
PackageFileServiceMock
.Setup(pfs => pfs.DownloadValidationPackageFileAsync(Package))
.ReturnsAsync(stream)
.Callback(() => operations.Add(nameof(ICorePackageFileService.DownloadValidationPackageFileAsync)));
PackageFileServiceMock
.Setup(pfs => pfs.SavePackageFileAsync(Package, stream))
.Returns(Task.FromResult(0))
.Callback(() => operations.Add(nameof(ICorePackageFileService.SavePackageFileAsync)));
PackageServiceMock
.Setup(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.Available, true))
.Returns(Task.FromResult(0))
.Callback(() => operations.Add(nameof(ICorePackageService.UpdatePackageStatusAsync)));
PackageFileServiceMock
.Setup(pfs => pfs.DeleteValidationPackageFileAsync(Package.PackageRegistration.Id, Package.Version))
.Returns(Task.FromResult(0))
.Callback(() => operations.Add(nameof(ICorePackageFileService.DeleteValidationPackageFileAsync)));
var procecssor = CreateProcessor();
await procecssor.ProcessValidationOutcomeAsync(ValidationSet, Package);
var expectedOrder = new[]
{
nameof(ICorePackageFileService.DownloadValidationPackageFileAsync),
nameof(ICorePackageFileService.SavePackageFileAsync),
nameof(ICorePackageService.UpdatePackageStatusAsync),
nameof(ICorePackageFileService.DeleteValidationPackageFileAsync)
};
Assert.Equal(expectedOrder, operations);
}
public async Task DoesNotDeletePackageFromPublicStorageOnDbUpdateFailureIfNotCopied()
{
var expected = new Exception("Everything failed");
PackageServiceMock
.Setup(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.Available, true))
.Throws(expected);
PackageFileServiceMock
.Setup(x => x.CopyValidationPackageToPackageFileAsync(It.IsAny <string>(), It.IsAny <string>()))
.Throws(new InvalidOperationException("Duplicate!"));
var actual = await Assert.ThrowsAsync <Exception>(
() => Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available));
Assert.Same(expected, actual);
PackageFileServiceMock.Verify(
x => x.DeletePackageFileAsync(It.IsAny <string>(), It.IsAny <string>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Never);
}
public async Task DeletesPackageFromPublicStorageOnDbUpdateFailure()
{
AddValidation("validation1", ValidationStatus.Succeeded);
Package.PackageStatusKey = PackageStatus.Validating;
const string exceptionText = "Everything failed";
PackageServiceMock
.Setup(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.Available, true))
.Throws(new Exception(exceptionText))
.Verifiable();
PackageFileServiceMock
.Setup(pfs => pfs.DeletePackageFileAsync(Package.PackageRegistration.Id, Package.Version))
.Returns(Task.FromResult(0))
.Verifiable();
var procecssor = CreateProcessor();
var exception = await Assert.ThrowsAsync <Exception>(() => procecssor.ProcessValidationOutcomeAsync(ValidationSet, Package));
PackageFileServiceMock
.Verify(pfs => pfs.DeletePackageFileAsync(Package.PackageRegistration.Id, Package.Version), Times.AtLeastOnce());
Assert.Equal(exceptionText, exception.Message);
}
public void ThrowsIfNupkgDoesNotExist()
{
UseDefaultValidatorProvider();
var validator = AddValidation("validation1", TimeSpan.FromDays(1));
PackageFileServiceMock
.Setup(pfs => pfs.DoesPackageFileExistAsync(Package))
.ReturnsAsync(false);
PackageFileServiceMock
.Setup(pfs => pfs.DoesValidationPackageFileExistAsync(Package))
.ReturnsAsync(false);
var processor = CreateProcessor();
var ex = Assert.ThrowsAsync <Exception>(() => processor.ProcessValidationsAsync(ValidationSet, Package));
PackageFileServiceMock
.Verify(pfs => pfs.DoesPackageFileExistAsync(Package), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.DoesPackageFileExistAsync(It.IsAny <Package>()), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.DoesValidationPackageFileExistAsync(Package), Times.Once());
PackageFileServiceMock
.Verify(pfs => pfs.DoesValidationPackageFileExistAsync(It.IsAny <Package>()), Times.Once());
}