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 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 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 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 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 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 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());
}
}
