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