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