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