public async Task WillMarkPackageRegistrationVerifiedFlagCorrectly(bool shouldMarkIdVerified)
{
var id = "Microsoft.Aspnet.Mvc";
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefixes = new List <string> {
"microsoft.", "microsoft.aspnet."
};
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var firstUser = testUsers.First();
var matchingNamepsaces = testNamespaces
.Where(rn => prefixes.Any(pr => id.StartsWith(pr, StringComparison.OrdinalIgnoreCase)))
.ToList();
prefixes.ForEach(p => {
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(p, StringComparison.OrdinalIgnoreCase));
existingNamespace.Owners.Add(firstUser);
});
var reservedNamespaceService = new Mock <IReservedNamespaceService>();
IReadOnlyCollection <ReservedNamespace> userOwnedMatchingNamespaces = matchingNamepsaces;
reservedNamespaceService.Setup(s => s.IsPushAllowed(It.IsAny <string>(), It.IsAny <User>(), out userOwnedMatchingNamespaces))
.Returns(shouldMarkIdVerified);
var packageUploadService = CreateService(reservedNamespaceService: reservedNamespaceService);
var nugetPackage = PackageServiceUtility.CreateNuGetPackage(id: id);
var package = await packageUploadService.GeneratePackageAsync(id, nugetPackage.Object, new PackageStreamMetadata(), firstUser);
Assert.Equal(shouldMarkIdVerified, package.PackageRegistration.IsVerified);
}
public async Task SavesLicenseFile(string licenseFilenName)
{
var fileStorageSvc = new Mock <ICoreFileStorageService>();
var service = CreateService(fileStorageSvc);
var packageStream = GeneratePackageAsync(licenseFilenName);
var package = PackageServiceUtility.CreateTestPackage();
package.EmbeddedLicenseType = EmbeddedLicenseFileType.PlainText;
var savedLicenseBytes = new byte[LicenseFileContents.Length];
var expectedFileName = BuildLicenseFileName(package.Id, package.Version);
fileStorageSvc.Setup(x => x.SaveFileAsync(
CoreConstants.Folders.PackagesContentFolderName,
expectedFileName,
"text/plain",
It.IsAny <Stream>(),
true))
.Completes()
.Callback <string, string, string, Stream, bool>((_, __, ___, s, ____) => s.Read(savedLicenseBytes, 0, savedLicenseBytes.Length))
.Verifiable();
await service.ExtractAndSaveLicenseFileAsync(package, packageStream);
fileStorageSvc
.VerifyAll();
Assert.Equal(LicenseFileContents, savedLicenseBytes);
}
protected static Mock <TestPackageReader> GeneratePackage(string version = "1.2.3-alpha.0", bool isSigned = true)
{
return(PackageServiceUtility.CreateNuGetPackage(
id: "theId",
version: version,
isSigned: isSigned));
}
protected static MemoryStream GeneratePackageStream(
string version = "1.2.3-alpha.0",
RepositoryMetadata repositoryMetadata = null,
bool isSigned = true,
int?desiredTotalEntryCount = null,
Func <string> getCustomNuspecNodes = null,
Uri iconUrl = null,
Uri licenseUrl = null,
string licenseExpression = null,
string licenseFilename = null,
string licenseFileContents = null,
byte[] licenseFileBinaryContents = null,
string iconFilename = null,
byte[] iconFileBinaryContents = null,
IReadOnlyList <string> entryNames = null)
{
return(PackageServiceUtility.CreateNuGetPackageStream(
id: PackageId,
version: version,
repositoryMetadata: repositoryMetadata,
isSigned: isSigned,
desiredTotalEntryCount: desiredTotalEntryCount,
getCustomNuspecNodes: getCustomNuspecNodes,
licenseUrl: licenseUrl,
iconUrl: iconUrl,
licenseExpression: licenseExpression,
licenseFilename: licenseFilename,
licenseFileContents: GetBinaryLicenseFileContents(licenseFileBinaryContents, licenseFileContents),
iconFilename: iconFilename,
iconFileBinaryContents: iconFileBinaryContents,
entryNames: entryNames));
}
private static MemoryStream GeneratePackageAsync(string licenseFileName = null, string licenseExpression = null, bool saveLicenseFile = true)
{
return(PackageServiceUtility.CreateNuGetPackageStream(
licenseExpression: licenseExpression,
licenseFilename: licenseFileName,
licenseFileContents: licenseFileName != null && saveLicenseFile ? LicenseFileContents : null));
}
public async Task SavesReadmeFile(String readmeFileName)
{
var fileServiceMock = new Mock <ICoreFileStorageService>();
var service = CreateService(fileServiceMock);
var packageStream = GeneratePackageWithReadmeFile(readmeFileName);
var package = PackageServiceUtility.CreateTestPackage();
package.HasReadMe = true;
package.EmbeddedReadmeType = EmbeddedReadmeFileType.Markdown;
var savedReadmeBytes = new byte[ReadmeFileContents.Length];
var expectedFileName = BuildReadmeFileName(package.Id, package.Version);
fileServiceMock.Setup(x => x.SaveFileAsync(
CoreConstants.Folders.PackagesContentFolderName,
It.IsAny <string>(),
It.IsAny <Stream>(),
true))
.Completes()
.Callback <string, string, Stream, bool>((_, __, s, ___) => s.Read(savedReadmeBytes, 0, savedReadmeBytes.Length))
.Verifiable();
// Act.
await service.ExtractAndSaveReadmeFileAsync(package, packageStream);
// Assert.
fileServiceMock.VerifyAll();
Assert.Equal(ReadmeFileContents, savedReadmeBytes);
}
public async Task WillMarkPackageRegistrationNotVerifiedIfIdMatchesNonOwnedSharedNamespace()
{
var id = "Microsoft.Aspnet.Mvc";
var testNamespaces = ReservedNamespaceServiceTestData.GetTestNamespaces();
var prefixes = new List <string> {
"microsoft.", "microsoft.aspnet."
};
var testUsers = ReservedNamespaceServiceTestData.GetTestUsers();
var firstUser = testUsers.First();
var lastUser = testUsers.Last();
prefixes.ForEach(p => {
var existingNamespace = testNamespaces.FirstOrDefault(rn => rn.Value.Equals(p, StringComparison.OrdinalIgnoreCase));
existingNamespace.IsSharedNamespace = true;
existingNamespace.Owners.Add(firstUser);
});
var reservedNamespaceService = new Mock <IReservedNamespaceService>();
IReadOnlyCollection <ReservedNamespace> userOwnedMatchingNamespaces = new List <ReservedNamespace>();
reservedNamespaceService.Setup(s => s.IsPushAllowed(It.IsAny <string>(), It.IsAny <User>(), out userOwnedMatchingNamespaces))
.Returns(true);
var packageUploadService = CreateService(reservedNamespaceService: reservedNamespaceService);
var nugetPackage = PackageServiceUtility.CreateNuGetPackage(id: id);
var package = await packageUploadService.GeneratePackageAsync(id, nugetPackage.Object, new PackageStreamMetadata(), lastUser);
Assert.False(package.PackageRegistration.IsVerified);
}
public async Task RemovesOriginalChildEntities()
{
// Arrange
var package = PackageServiceUtility.CreateTestPackage();
package.PackageTypes = new List <PackageType> {
new PackageType {
Name = "Dependency", Version = "0.0"
}
};
var packageService = SetupPackageService(package);
var entitiesContext = SetupEntitiesContext();
var packageFileService = SetupPackageFileService(package);
var service = CreateService(
packageService: packageService,
entitiesContext: entitiesContext,
packageFileService: packageFileService);
// Act
await service.ReflowAsync("test", "1.0.0");
// Assert
entitiesContext.Verify();
}
public async Task WillThrowForMissingSymbolsPackageType()
{
var service = CreateService();
var invalidSymbolPackageStream = TestPackage.CreateTestPackageStream("theId", "1.0.42");
var packageArchiveReader = PackageServiceUtility.CreateArchiveReader(invalidSymbolPackageStream);
await Assert.ThrowsAsync <InvalidPackageException>(async() => await service.EnsureValidAsync(packageArchiveReader));
}
public async Task WillNotThrowForValidSnupkgFile(string extension)
{
var service = CreateService();
var action = CreatePopulatePackageAction(extension);
var validSymbolPackageStream = TestPackage.CreateTestSymbolPackageStream("theId", "1.0.42", populatePackage: action);
var packageArchiveReader = PackageServiceUtility.CreateArchiveReader(validSymbolPackageStream);
await service.EnsureValidAsync(packageArchiveReader);
}
public async Task WillThrowForOwnersMetadataInNuspec()
{
var service = CreateService();
var packageTypes = CreateSymbolPackageTypesObject();
var invalidSymbolPackageStream = TestPackage.CreateTestPackageStream("theId", "1.0.42", owners: "Random owners", packageTypes: packageTypes);
var packageArchiveReader = PackageServiceUtility.CreateArchiveReader(invalidSymbolPackageStream);
await Assert.ThrowsAsync <InvalidDataException>(async() => await service.EnsureValidAsync(packageArchiveReader));
}
public async Task WillThrowForInvalidFilesInSnupkg(string extension)
{
var service = CreateService();
var action = CreatePopulatePackageAction(extension);
var invalidSymbolPackageStream = TestPackage.CreateTestSymbolPackageStream("theId", "1.0.42", populatePackage: action);
var packageArchiveReader = PackageServiceUtility.CreateArchiveReader(invalidSymbolPackageStream);
await Assert.ThrowsAsync <InvalidDataException>(async() => await service.EnsureValidAsync(packageArchiveReader));
}
private MemoryStream CreateSymbolPackageStreamWithEntries(string[] entryNames)
{
var packageType = new NuGet.Packaging.Core.PackageType(name: "SymbolsPackage", version: NuGet.Packaging.Core.PackageType.EmptyVersion);
var packageTypes = new List <NuGet.Packaging.Core.PackageType>()
{
packageType
};
return(PackageServiceUtility.CreateNuGetPackageStream(packageTypes: packageTypes, entryNames: entryNames));
}
public async Task WillThrowForSnupkgFileWithoutSymbols()
{
var service = CreateService();
var action = CreatePopulatePackageAction(".p7s");
var validSymbolPackageStream = TestPackage.CreateTestSymbolPackageStream("theId", "1.0.42", populatePackage: action);
var packageArchiveReader = PackageServiceUtility.CreateArchiveReader(validSymbolPackageStream);
await Assert.ThrowsAsync <InvalidDataException>(async() => await service.EnsureValidAsync(packageArchiveReader));
}
public async Task ThrowsOnMissingReadmeFile()
{
var service = CreateService();
const string readmeFileName = "readme.md";
var packageStream = GeneratePackageWithReadmeFile(readmeFileName, false);
var pacakge = PackageServiceUtility.CreateTestPackage();
var ex = await Assert.ThrowsAsync <FileNotFoundException>(() => service.ExtractAndSaveReadmeFileAsync(pacakge, packageStream));
Assert.Contains(readmeFileName, ex.Message);
}
public async Task UpdatesPackageMetadata()
{
// Arrange
var package = PackageServiceUtility.CreateTestPackage();
var packageService = SetupPackageService(package);
var entitiesContext = SetupEntitiesContext();
var packageFileService = SetupPackageFileService(package);
var service = CreateService(
packageService: packageService,
entitiesContext: entitiesContext,
packageFileService: packageFileService);
// Act
var result = await service.ReflowAsync("test", "1.0.0");
// Assert
Assert.Equal("test", result.PackageRegistration.Id);
Assert.Equal("1.0.0", result.Version);
Assert.Equal("1.0.0", result.NormalizedVersion);
Assert.Equal("Test package", result.Title);
#pragma warning disable 0618
Assert.Equal(2, result.Authors.Count);
Assert.True(result.Authors.Any(a => a.Name == "authora"));
Assert.True(result.Authors.Any(a => a.Name == "authorb"));
#pragma warning restore 0618
Assert.Equal("authora, authorb", result.FlattenedAuthors);
Assert.Equal(false, result.RequiresLicenseAcceptance);
Assert.Equal("package A description.", result.Description);
Assert.Equal("en-US", result.Language);
Assert.Equal("WebActivator:[1.1.0, ):net40|PackageC:[1.1.0, 2.0.1):net40|jQuery:[1.0.0, ):net451", result.FlattenedDependencies);
Assert.Equal(3, result.Dependencies.Count);
Assert.True(result.Dependencies.Any(d =>
d.Id == "WebActivator" &&
d.VersionSpec == "[1.1.0, )" &&
d.TargetFramework == "net40"));
Assert.True(result.Dependencies.Any(d =>
d.Id == "PackageC" &&
d.VersionSpec == "[1.1.0, 2.0.1)" &&
d.TargetFramework == "net40"));
Assert.True(result.Dependencies.Any(d =>
d.Id == "jQuery" &&
d.VersionSpec == "[1.0.0, )" &&
d.TargetFramework == "net451"));
Assert.Equal(0, result.SupportedFrameworks.Count);
}
public async Task ThrowsOnMissingLicenseFile()
{
var service = CreateService();
const string LicenseFileName = "license.txt";
var packageStream = GeneratePackageAsync(LicenseFileName, null, false);
var package = PackageServiceUtility.CreateTestPackage();
var ex = await Assert.ThrowsAsync <FileNotFoundException>(() => service.ExtractAndSaveLicenseFileAsync(package, packageStream));
Assert.Contains(LicenseFileName, ex.Message); // current implementation of the client does not properly set the FileName property
}
public async Task WillThrowForMultiplePackageTypesInNuspec()
{
var service = CreateService();
var packageTypes = CreateSymbolPackageTypesObject();
packageTypes.Add(new ClientPackageType("RandomPackageType", ClientPackageType.EmptyVersion));
var invalidSymbolPackageStream = TestPackage.CreateTestPackageStream("theId", "1.0.42", packageTypes: packageTypes);
var packageArchiveReader = PackageServiceUtility.CreateArchiveReader(invalidSymbolPackageStream);
await Assert.ThrowsAsync <InvalidPackageException>(async() => await service.EnsureValidAsync(packageArchiveReader));
}
[InlineData(null, "MIT")] // should also throw for license expression
public async Task ThrowsWhenNoLicenseFileSpecified(string licenseFileName, string licenseExpression)
{
var service = CreateService();
var packageStream = GeneratePackageAsync(licenseFileName, licenseExpression);
var package = PackageServiceUtility.CreateTestPackage();
package.EmbeddedLicenseType = EmbeddedLicenseFileType.PlainText; // tested method should ignore the package settings and check .nuspec
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => service.ExtractAndSaveLicenseFileAsync(package, packageStream));
Assert.Contains("No license file", ex.Message);
}
public async Task WillThrowForIncorrectSymbolsPackageTypeVersion()
{
var service = CreateService();
var packageTypes = new List <ClientPackageType>()
{
new ClientPackageType("SymbolsPackage", new Version("1.1"))
};
var invalidSymbolPackageStream = TestPackage.CreateTestPackageStream("theId", "1.0.42", packageTypes: packageTypes);
var packageArchiveReader = PackageServiceUtility.CreateArchiveReader(invalidSymbolPackageStream);
await Assert.ThrowsAsync <InvalidPackageException>(async() => await service.EnsureValidAsync(packageArchiveReader));
}
public async Task ThrowsWhenNoReadmeFileSpecified(string readmeFileName)
{
var service = CreateService();
var packageStream = GeneratePackageWithReadmeFile(readmeFileName);
var package = PackageServiceUtility.CreateTestPackage();
package.EmbeddedReadmeType = EmbeddedReadmeFileType.Markdown; // tested method should ignore the package settings and check .nuspec
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => service.ExtractAndSaveReadmeFileAsync(package, packageStream));
Assert.Contains("No readme file", ex.Message);
}
protected static Mock <TestPackageReader> GeneratePackage(
string version = "1.2.3-alpha.0",
RepositoryMetadata repositoryMetadata = null,
bool isSigned = true,
int?desiredTotalEntryCount = null)
{
return(PackageServiceUtility.CreateNuGetPackage(
id: "theId",
version: version,
repositoryMetadata: repositoryMetadata,
isSigned: isSigned,
desiredTotalEntryCount: desiredTotalEntryCount));
}
public async Task WillCallCreatePackageAsyncCorrectly()
{
var packageService = new Mock <IPackageService>();
packageService.Setup(x => x.FindPackageRegistrationById(It.IsAny <string>())).Returns((PackageRegistration)null);
var id = "Microsoft.Aspnet.Mvc";
var packageUploadService = CreateService(packageService);
var nugetPackage = PackageServiceUtility.CreateNuGetPackage(id: id);
var currentUser = new User();
var package = await packageUploadService.GeneratePackageAsync(id, nugetPackage.Object, new PackageStreamMetadata(), currentUser);
packageService.Verify(x => x.CreatePackageAsync(It.IsAny <PackageArchiveReader>(), It.IsAny <PackageStreamMetadata>(), It.IsAny <User>(), It.IsAny <bool>()), Times.Once);
Assert.False(package.PackageRegistration.IsVerified);
}
public async Task WillStartAsynchronousValidation()
{
var validationService = new Mock <IValidationService>();
var id = "Microsoft.Aspnet.Mvc";
var packageUploadService = CreateService(validationService: validationService);
var nugetPackage = PackageServiceUtility.CreateNuGetPackage(id: id);
var currentUser = new User();
var package = await packageUploadService.GeneratePackageAsync(
id,
nugetPackage.Object,
new PackageStreamMetadata(),
currentUser);
validationService.Verify(
x => x.StartValidationAsync(package),
Times.Once);
}
public async Task RetrievesOriginalPackageMetadata()
{
// Arrange
var package = PackageServiceUtility.CreateTestPackage();
var packageService = SetupPackageService(package);
var entitiesContext = SetupEntitiesContext();
var packageFileService = SetupPackageFileService(package);
var service = CreateService(
packageService: packageService,
entitiesContext: entitiesContext,
packageFileService: packageFileService);
// Act
await service.ReflowAsync("test", "1.0.0");
// Assert
packageService.Verify();
}
public async Task ReturnsNullWhenPackageNotFound()
{
// Arrange
var package = PackageServiceUtility.CreateTestPackage();
var packageService = SetupPackageService(package);
var entitiesContext = SetupEntitiesContext();
var packageFileService = SetupPackageFileService(package);
var service = CreateService(
packageService: packageService,
entitiesContext: entitiesContext,
packageFileService: packageFileService);
// Act
var result = await service.ReflowAsync("unknownpackage", "1.0.0");
// Assert
Assert.Null(result);
}
public async Task CallsUpdateIsLatestAsync()
{
// Arrange
var package = PackageServiceUtility.CreateTestPackage();
var packageService = SetupPackageService(package);
var entitiesContext = SetupEntitiesContext();
var packageFileService = SetupPackageFileService(package);
var service = CreateService(
packageService: packageService,
entitiesContext: entitiesContext,
packageFileService: packageFileService);
// Act
var result = await service.ReflowAsync("test", "1.0.0");
// Assert
packageService.Verify(s => s.UpdateIsLatestAsync(package.PackageRegistration, false), Times.Once);
}
public async Task RemovesOriginalFrameworks_Authors_Dependencies()
{
// Arrange
var package = PackageServiceUtility.CreateTestPackage();
var packageService = SetupPackageService(package);
var entitiesContext = SetupEntitiesContext();
var packageFileService = SetupPackageFileService(package);
var service = CreateService(
packageService: packageService,
entitiesContext: entitiesContext,
packageFileService: packageFileService);
// Act
await service.ReflowAsync("test", "1.0.0");
// Assert
entitiesContext.Verify();
}
public async Task UpdatesPackageLastEdited()
{
// Arrange
var package = PackageServiceUtility.CreateTestPackage();
var lastEdited = package.LastEdited;
var packageService = SetupPackageService(package);
var entitiesContext = SetupEntitiesContext();
var packageFileService = SetupPackageFileService(package);
var service = CreateService(
packageService: packageService,
entitiesContext: entitiesContext,
packageFileService: packageFileService);
// Act
var result = await service.ReflowAsync("test", "1.0.0");
// Assert
Assert.NotEqual(lastEdited, result.LastEdited);
}
protected static Mock <TestPackageReader> GeneratePackageWithUserContent(
string version = "1.2.3-alpha.0",
RepositoryMetadata repositoryMetadata = null,
bool isSigned = true,
int?desiredTotalEntryCount = null,
Func <string> getCustomNuspecNodes = null,
Uri iconUrl = null,
Uri licenseUrl = null,
string licenseExpression = null,
string licenseFilename = null,
string licenseFileContents = null,
byte[] licenseFileBinaryContents = null,
string iconFilename = null,
byte[] iconFileBinaryContents = null,
string readmeFilename = null,
string readmeFileContents = null,
byte[] readmeFileBinaryContents = null,
IReadOnlyList <string> entryNames = null)
{
var packageStream = GeneratePackageStream(
version: version,
repositoryMetadata: repositoryMetadata,
isSigned: isSigned,
desiredTotalEntryCount: desiredTotalEntryCount,
getCustomNuspecNodes: getCustomNuspecNodes,
iconUrl: iconUrl,
licenseUrl: licenseUrl,
licenseExpression: licenseExpression,
licenseFilename: licenseFilename,
licenseFileContents: licenseFileContents,
licenseFileBinaryContents: licenseFileBinaryContents,
iconFilename: iconFilename,
iconFileBinaryContents: iconFileBinaryContents,
readmeFilename: readmeFilename,
readmeFileContents: readmeFileContents,
readmeFileBinaryContents: readmeFileBinaryContents,
entryNames: entryNames);
return(PackageServiceUtility.CreateNuGetPackage(packageStream));
}
