/// <remarks> /// This method will create the symbol package entity. The caller should validate the ownership of packages and /// metadata for the symbols associated for this package. Its the caller's responsibility to commit as well. /// </remarks> public SymbolPackage CreateSymbolPackage(Package nugetPackage, PackageStreamMetadata symbolPackageStreamMetadata) { if (nugetPackage == null) { throw new ArgumentNullException(nameof(nugetPackage)); } if (symbolPackageStreamMetadata == null) { throw new ArgumentNullException(nameof(symbolPackageStreamMetadata)); } try { var symbolPackage = new SymbolPackage() { Package = nugetPackage, PackageKey = nugetPackage.Key, Created = DateTime.UtcNow, FileSize = symbolPackageStreamMetadata.Size, HashAlgorithm = symbolPackageStreamMetadata.HashAlgorithm, Hash = symbolPackageStreamMetadata.Hash }; _symbolPackageRepository.InsertOnCommit(symbolPackage); return(symbolPackage); } catch (Exception ex) when(ex is EntityException) { throw new InvalidPackageException(ex.Message, ex); } }
public async Task WillDeleteFailedValidationSnupkg() { // Arrange var symbolPackageService = new Mock <ISymbolPackageService>(); symbolPackageService .Setup(x => x.CreateSymbolPackage(It.IsAny <Package>(), It.IsAny <PackageStreamMetadata>())) .Returns((Package package1, PackageStreamMetadata streamMetadata) => { var symbolPackage = new SymbolPackage() { Package = package1, PackageKey = package1.Key, Created = DateTime.UtcNow, StatusKey = PackageStatus.Validating }; return(symbolPackage); }) .Verifiable(); var symbolPackageFileService = new Mock <ISymbolPackageFileService>(); symbolPackageFileService .Setup(x => x.DoesValidationPackageFileExistAsync(It.IsAny <Package>())) .ReturnsAsync(true) .Verifiable(); symbolPackageFileService .Setup(x => x.DeleteValidationPackageFileAsync(It.IsAny <string>(), It.IsAny <string>())) .Completes() .Verifiable(); symbolPackageFileService .Setup(x => x.SaveValidationPackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>())) .Completes() .Verifiable(); var service = CreateService(symbolPackageService: symbolPackageService, symbolPackageFileService: symbolPackageFileService); var package = new Package() { PackageRegistration = new PackageRegistration() { Id = "theId" }, Version = "1.0.23" }; package.SymbolPackages.Add(new SymbolPackage() { StatusKey = PackageStatus.FailedValidation, Key = 1232, Package = package }); // Act var result = await service.CreateAndUploadSymbolsPackage(package, new MemoryStream()); // Assert Assert.NotNull(result); Assert.Equal(PackageCommitResult.Success, result); symbolPackageFileService.VerifyAll(); }
public async Task WillReturnSymbolPackageExistsForPendingValidation() { // Arrange var packageService = new Mock <IPackageService>(); Package package = new Package() { PackageStatusKey = PackageStatus.Available }; var symbolPackage = new SymbolPackage() { Package = package, Key = 10, StatusKey = PackageStatus.Validating }; package.SymbolPackages.Add(symbolPackage); packageService .Setup(x => x.FindPackageByIdAndVersionStrict(It.IsAny <string>(), It.IsAny <string>())) .Returns(package); var service = CreateService(packageService: packageService); var symbolPackageStream = TestPackage.CreateTestSymbolPackageStream("theId", "1.0.42"); // Act var result = await service.ValidateUploadedSymbolsPackage(symbolPackageStream, new User()); // Assert Assert.NotNull(result); Assert.Equal(SymbolPackageValidationResultType.SymbolsPackagePendingValidation, result.Type); }
public async Task StartValidationAsync(SymbolPackage symbolPackage) { var symbolPackageStatus = await _symbolPackageValidationInitiator.StartValidationAsync(symbolPackage); await _symbolPackageService.UpdateStatusAsync(symbolPackage, symbolPackageStatus, commitChanges: false); }
public IReadOnlyList <ValidationIssue> GetLatestPackageValidationIssues(SymbolPackage symbolPackage) { if (symbolPackage == null) { return(new List <ValidationIssue>()); } return(GetValidationIssues(symbolPackage.Key, symbolPackage.StatusKey, ValidatingType.SymbolPackage)); }
private static SymbolPackageUploadService CreateService( Mock <ISymbolPackageService> symbolPackageService = null, Mock <ISymbolPackageFileService> symbolPackageFileService = null, Mock <IEntitiesContext> entitiesContext = null, Mock <IValidationService> validationService = null) { if (symbolPackageService == null) { symbolPackageService = new Mock <ISymbolPackageService>(); symbolPackageService .Setup(x => x.CreateSymbolPackage(It.IsAny <Package>(), It.IsAny <PackageStreamMetadata>())) .Returns((Package package, PackageStreamMetadata streamMetadata) => { var symbolPackage = new SymbolPackage() { Package = package, PackageKey = package.Key, Created = DateTime.UtcNow }; package.SymbolPackages.Add(symbolPackage); return(symbolPackage); }) .Verifiable(); } if (symbolPackageFileService == null) { symbolPackageFileService = new Mock <ISymbolPackageFileService>(); symbolPackageFileService .Setup(x => x.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>(), It.IsAny <bool>())) .Completes(); symbolPackageFileService .Setup(x => x.DeletePackageFileAsync(It.IsAny <string>(), It.IsAny <string>())) .Completes(); symbolPackageFileService .Setup(x => x.DeleteValidationPackageFileAsync(It.IsAny <string>(), It.IsAny <string>())) .Completes(); } if (entitiesContext == null) { entitiesContext = new Mock <IEntitiesContext>(); entitiesContext .Setup(x => x.SaveChangesAsync()) .CompletesWith(0); } validationService = validationService ?? new Mock <IValidationService>(); var symbolPackageUploadService = new Mock <SymbolPackageUploadService>( symbolPackageService.Object, symbolPackageFileService.Object, entitiesContext.Object, validationService.Object); return(symbolPackageUploadService.Object); }
public async Task RejectsNullPackage() { // Arrange SymbolPackage symbolPackage = null; var service = CreateService(); // Act & Assert await Assert.ThrowsAsync <ArgumentNullException>( () => service.UpdateStatusAsync(symbolPackage, PackageStatus.Deleted, commitChanges: true)); }
public async Task DeleteSymbolsPackageAsync(SymbolPackage symbolPackage) { if (symbolPackage == null) { throw new ArgumentNullException(nameof(symbolPackage)); } if (await _symbolPackageFileService.DoesPackageFileExistAsync(symbolPackage.Package)) { await _symbolPackageFileService.DeletePackageFileAsync(symbolPackage.Id, symbolPackage.Version); } await _symbolPackageService.UpdateStatusAsync(symbolPackage, PackageStatus.Deleted, commitChanges : true); }
public async Task WillMarkExistingSymbolPackagesForDeletionAndOverwriteFiles() { // Arrange var symbolPackageFileService = new Mock <ISymbolPackageFileService>(); var telemetryService = new Mock <ITelemetryService>(); symbolPackageFileService .Setup(x => x.SavePackageFileAsync(It.IsAny <Package>(), It.IsAny <Stream>(), It.IsAny <bool>())) .Completes() .Verifiable(); var service = CreateService(symbolPackageFileService: symbolPackageFileService, telemetryService: telemetryService); var package = new Package() { PackageRegistration = new PackageRegistration() { Id = "TheId" }, Version = "1.0.0" }; var existingAvailableSymbolPackage = new SymbolPackage() { Package = package, Key = 1, StatusKey = PackageStatus.Available }; var existingDeletedSymbolPackage = new SymbolPackage() { Package = package, Key = 2, StatusKey = PackageStatus.Deleted }; package.SymbolPackages.Add(existingAvailableSymbolPackage); package.SymbolPackages.Add(existingDeletedSymbolPackage); // Act var result = await service.CreateAndUploadSymbolsPackage(package, new MemoryStream()); // Assert Assert.Equal(PackageStatus.Deleted, existingAvailableSymbolPackage.StatusKey); Assert.Equal(PackageStatus.Deleted, existingDeletedSymbolPackage.StatusKey); symbolPackageFileService.Verify(x => x.SavePackageFileAsync(package, It.IsAny <Stream>(), true), Times.Once); telemetryService.Verify(x => x.TrackSymbolPackagePushEvent(package.PackageRegistration.Id, package.NormalizedVersion), Times.Once); Assert.NotNull(result); Assert.Equal(PackageCommitResult.Success, result); }
public async Task WillDeleteSymbolsPackageIfItDoesExist() { // Arrange var symbolPackage = new SymbolPackage() { Package = new Package() { PackageRegistration = new PackageRegistration() { Id = "foo" }, Version = "1.0.0", NormalizedVersion = "1.0.0" }, StatusKey = PackageStatus.Available }; var symbolPackageFileService = new Mock <ISymbolPackageFileService>(); symbolPackageFileService .Setup(x => x.DoesPackageFileExistAsync(It.IsAny <Package>())) .ReturnsAsync(true) .Verifiable(); symbolPackageFileService .Setup(x => x.DeletePackageFileAsync(It.IsAny <string>(), It.IsAny <string>())) .Completes() .Verifiable(); var symbolPackageService = new Mock <ISymbolPackageService>(); symbolPackageService .Setup(x => x.UpdateStatusAsync(symbolPackage, PackageStatus.Deleted, true)) .Completes() .Verifiable(); var service = CreateService(symbolPackageFileService: symbolPackageFileService, symbolPackageService: symbolPackageService); // Act await service.DeleteSymbolsPackageAsync(symbolPackage); // Assert symbolPackageService.Verify(); symbolPackageFileService.Verify(); }
public async Task CommitsTheCorrectNumberOfTimes(bool commitChanges, int commitCount) { // Arrange var symbolPackageRepository = new Mock <IEntityRepository <SymbolPackage> >(); var symbolPackage = new SymbolPackage { Package = new Package { PackageRegistration = new PackageRegistration(), }, StatusKey = PackageStatus.Validating }; var service = CreateService(symbolPackageRepository: symbolPackageRepository); // Act await service.UpdateStatusAsync(symbolPackage, PackageStatus.Available, commitChanges); // Assert symbolPackageRepository.Verify(x => x.CommitChangesAsync(), Times.Exactly(commitCount)); }
public async Task DoesNotCommitWhenNoChangeOfStatus() { // Arrange var symbolPackageRepository = new Mock <IEntityRepository <SymbolPackage> >(); var symbolPackage = new SymbolPackage { Package = new Package { PackageRegistration = new PackageRegistration(), }, StatusKey = PackageStatus.Available }; var service = CreateService(symbolPackageRepository: symbolPackageRepository); // Act await service.UpdateStatusAsync(symbolPackage, PackageStatus.Available, commitChanges : true); // Assert symbolPackageRepository.Verify(x => x.CommitChangesAsync(), Times.Never); }
public virtual async Task UpdateStatusAsync(SymbolPackage symbolPackage, PackageStatus newPackageStatus, bool commitChanges = true) { if (symbolPackage == null) { throw new ArgumentNullException(nameof(symbolPackage)); } // Avoid all of this work if the package status is not changing. if (symbolPackage.StatusKey != newPackageStatus) { symbolPackage.StatusKey = newPackageStatus; /// If the package is being made available. if (newPackageStatus == PackageStatus.Available) { symbolPackage.Published = DateTime.UtcNow; } if (commitChanges) { await _symbolPackageRepository.CommitChangesAsync(); } } }
public FactsBase() { _appConfiguration = new Mock <IAppConfiguration>(); _packageService = new Mock <IPackageService>(); _packageInitiator = new Mock <IPackageValidationInitiator <Package> >(); _symbolInitiator = new Mock <IPackageValidationInitiator <SymbolPackage> >(); _validationSets = new Mock <IEntityRepository <PackageValidationSet> >(); _telemetryService = new Mock <ITelemetryService>(); _symbolPackageService = new Mock <ISymbolPackageService>(); _package = new Package(); _symbolPackage = new SymbolPackage() { Package = _package }; _target = new ValidationService( _appConfiguration.Object, _packageService.Object, _packageInitiator.Object, _symbolInitiator.Object, _telemetryService.Object, _symbolPackageService.Object, _validationSets.Object); }
public async Task UpdatePackageAsync(SymbolPackage symbolPackage) { var symbolPackageStatus = _symbolPackageValidationInitiator.GetPackageStatus(symbolPackage); await UpdateSymbolPackageInternalAsync(symbolPackage, symbolPackageStatus); }
public Task <ActionResult> CreateDownloadSymbolPackageActionResultAsync(Uri requestUrl, SymbolPackage symbolPackage) { var fileName = FileNameHelper.BuildFileName(symbolPackage.Package, CoreConstants.PackageFileSavePathTemplate, CoreConstants.NuGetSymbolPackageFileExtension); return(_fileStorageService.CreateDownloadFileActionResultAsync(requestUrl, CoreConstants.Folders.SymbolPackagesFolderName, fileName)); }
public async Task StartValidationAsync(SymbolPackage symbolPackage) { var symbolPackageStatus = await _symbolPackageValidationInitiator.StartValidationAsync(symbolPackage); await UpdateSymbolPackageInternalAsync(symbolPackage, symbolPackageStatus); }
private async Task UpdateSymbolPackageInternalAsync(SymbolPackage symbolPackage, PackageStatus symbolPackageStatus) { await _symbolPackageService.UpdateStatusAsync(symbolPackage, symbolPackageStatus, commitChanges : false); }
public async Task RevalidateAsync(SymbolPackage symbolPackage) { await _symbolPackageValidationInitiator.StartValidationAsync(symbolPackage); _telemetryService.TrackSymbolPackageRevalidate(symbolPackage.Id, symbolPackage.Version); }