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 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 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 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 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 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 DeletesLicenseFromPublicStorageOnDbUpdateFailure(EmbeddedLicenseFileType licenseFileType, PackageStatus originalStatus, bool expectedDelete)
{
Package.PackageStatusKey = originalStatus;
Package.EmbeddedLicenseType = licenseFileType;
var expected = new Exception("Everything failed");
PackageServiceMock
.Setup(ps => ps.UpdateStatusAsync(Package, PackageStatus.Available, true))
.Throws(expected);
var actual = await Assert.ThrowsAsync <Exception>(
() => Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available));
Assert.Same(expected, actual);
if (expectedDelete)
{
CoreLicenseFileServiceMock
.Verify(clfs => clfs.DeleteLicenseFileAsync(Package.Id, Package.NormalizedVersion), Times.Once);
CoreLicenseFileServiceMock
.Verify(clfs => clfs.DeleteLicenseFileAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
else
{
CoreLicenseFileServiceMock
.Verify(clfs => clfs.DeleteLicenseFileAsync(It.IsAny <string>(), It.IsAny <string>()), 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 DoesNotTakeDownAvailablePackages()
{
AddValidation("validation1", ValidationStatus.Failed);
Package.PackageStatusKey = PackageStatus.Available;
var procecssor = CreateProcessor();
await procecssor.ProcessValidationOutcomeAsync(ValidationSet, Package);
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.FailedValidation, It.IsAny <bool>()), Times.Never());
}
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 MarksPackageAsFailedOnFailedValidation()
{
AddValidation("validation1", ValidationStatus.Failed);
PackageServiceMock
.Setup(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.FailedValidation, true))
.Returns(Task.FromResult(0))
.Verifiable();
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, Package);
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.FailedValidation, true), Times.Once());
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()), Times.Once());
}
public async Task PrefersDbOverConfigurationForDeterminingSuccess(
int numConfiguredValidators,
int numDbValidators,
int numSucceededValidators,
ValidationStatus notSucceededStatus,
PackageStatus expectedStatus)
{
for (int cfgValidatorIndex = 0; cfgValidatorIndex < numConfiguredValidators; ++cfgValidatorIndex)
{
Configuration.Validations.Add(new ValidationConfigurationItem
{
Name = "validation" + cfgValidatorIndex,
FailAfter = TimeSpan.FromDays(1),
RequiredValidations = new List <string> {
}
});
}
for (int dbValidatorIndex = 0; dbValidatorIndex < numDbValidators; ++dbValidatorIndex)
{
ValidationSet.PackageValidations.Add(new PackageValidation
{
Type = "validation" + dbValidatorIndex,
ValidationStatus = dbValidatorIndex < numSucceededValidators ? ValidationStatus.Succeeded : notSucceededStatus
});
}
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, Package);
if (expectedStatus != PackageStatus.Validating)
{
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(Package, expectedStatus, true), Times.Once());
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()), Times.Once());
}
else
{
PackageServiceMock
.Verify(ps => ps.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()), 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));
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 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 DoesNotDeletePackageFromPublicStorageOnDbUpdateFailureIfCopiedAndOriginallyAvailable()
{
Package.PackageStatusKey = PackageStatus.Available;
var expected = new Exception("Everything failed");
PackageServiceMock
.Setup(ps => ps.UpdatePackageStatusAsync(Package, PackageStatus.Available, true))
.Throws(expected);
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 DoesNotDeletePackageFromPublicStorageOnDbUpdateFailureIfNotCopied()
{
var expected = new Exception("Everything failed");
PackageServiceMock
.Setup(ps => ps.UpdateStatusAsync(Package, PackageStatus.Available, true))
.Throws(expected);
PackageFileServiceMock
.Setup(x => x.CopyValidationPackageToPackageFileAsync(It.IsAny <PackageValidationSet>()))
.Throws(new InvalidOperationException("Duplicate!"));
var actual = await Assert.ThrowsAsync <Exception>(
() => Target.SetStatusAsync(PackageValidatingEntity, ValidationSet, PackageStatus.Available));
Assert.Same(expected, actual);
PackageFileServiceMock.Verify(
x => x.DeletePackageFileAsync(It.IsAny <PackageValidationSet>()),
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);
}
