public async Task Test_ExtractionHonorsFileTimestamp()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
var entryModifiedTime = new DateTimeOffset(1985, 11, 20, 12, 0, 0, TimeSpan.FromHours(-7.0)).DateTime;
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageFileInfo = await TestPackagesCore.GeneratePackageAsync(
packagesDirectory,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString(),
entryModifiedTime,
"lib/net45/A.dll");
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
clientPolicyContext: null,
logger: NullLogger.Instance);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDirectory);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
packageFileInfo.FullName,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
AssertDirectoryExists(packageVersionDirectory);
var dllPath = Path.Combine(packageVersionDirectory, "lib", "net45", "A.dll");
var dllFileInfo = new FileInfo(dllPath);
AssertFileExists(dllFileInfo.FullName);
Assert.Equal(entryModifiedTime, dllFileInfo.LastWriteTime);
}
}
public async Task GetInstalledSatelliteFilesAsync_ReturnsEmptyEnumerableForNoInstalledSatelliteFiles()
{
using (var test = PackageHelperTest.Create(TestPackagesCore.GetPackageContentReaderTestPackage()))
{
using (var testDirectory = TestDirectory.Create())
{
var packageIdentity = new PackageIdentity("A", new NuGetVersion("1.2.3"));
var packagePathResolver = new PackagePathResolver(testDirectory.Path);
var packageFileInfo = await TestPackagesCore.GetRuntimePackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var satellitePackageInfo = await TestPackagesCore.GetSatellitePackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString(),
language : "fr");
// Install runtime package
using (var packageReader = new PackageArchiveReader(File.OpenRead(packageFileInfo.FullName)))
using (var packageStream = File.OpenRead(packageFileInfo.FullName))
{
await PackageExtractor.ExtractPackageAsync(
packageReader,
packageStream,
packagePathResolver,
new PackageExtractionContext(NullLogger.Instance),
CancellationToken.None);
}
using (var packageReader = new PackageArchiveReader(File.OpenRead(satellitePackageInfo.FullName)))
{
var result = await PackageHelper.GetInstalledSatelliteFilesAsync(
packageReader,
packagePathResolver,
PackageSaveMode.Defaultv3,
CancellationToken.None);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2;
var packageDirectoryName = $"{packageIdentity.Id}.{packageIdentity.Version.ToNormalizedString()}";
Assert.Equal(Path.Combine(testDirectory.Path, packageDirectoryName), runtimePackageDirectory);
Assert.Empty(satelliteFiles);
}
}
}
}
public async Task PackageExpander_ExpandsPackage_WithNupkgCopy()
{
// Arrange
using (var package = TestPackagesCore.GetPackageWithNupkgCopy())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
using (var packagesDir = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
clientPolicyContext: null,
logger: logger);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDir);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
package.File.FullName,
identity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
identity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
token);
}
// Assert
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
AssertDirectoryExists(packageDir, packageDir + " does not exist");
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(nupkgPath), nupkgPath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
}
}
}
public async Task GetFilesAsync_ReturnsFiles()
{
using (var test = PackageReaderTest.Create(TestPackagesCore.GetPackageCoreReaderTestPackage()))
{
var files = (await test.Reader.GetFilesAsync(CancellationToken.None))
.OrderBy(file => file)
.ToArray();
Assert.NotNull(files);
Assert.Equal(3, files.Length);
Assert.Equal("Aa.nuspec", files[0]);
Assert.Equal("lib/net45/a.dll", files[1]);
Assert.Equal("lib/net45/b.dll", files[2]);
}
}
public async Task Test_ExtractionIgnoresNupkgFile()
{
// Arrange
var package = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageFileInfo = await TestPackagesCore.GetPackageWithNupkgAtRoot(
packagesDirectory,
package.Id,
package.Version.ToNormalizedString());
var versionFolderPathContext = new VersionFolderPathContext(
package,
packagesDirectory,
NullLogger.Instance,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var packageFileStream = packageFileInfo.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(
stream => packageFileStream.CopyToAsync(stream),
versionFolderPathContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(package.Id, package.Version);
AssertDirectoryExists(packageVersionDirectory);
AssertFileExists(packageVersionDirectory, pathResolver.GetPackageFilePath(package.Id, package.Version));
AssertFileExists(packageVersionDirectory, pathResolver.GetManifestFileName(package.Id, package.Version));
AssertFileExists(packageVersionDirectory, "lib", "net45", "A.dll");
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, package.Version);
var nupkgFileInfo = new FileInfo(nupkgPath);
Assert.True(File.Exists(nupkgFileInfo.FullName));
Assert.NotEqual(0, nupkgFileInfo.Length);
var bnupkgPath = Path.Combine(packageVersionDirectory, "lib", "net45", "B.nupkg");
var bnupkgFileInfo = new FileInfo(bnupkgPath);
Assert.True(File.Exists(bnupkgFileInfo.FullName));
Assert.Equal(0, bnupkgFileInfo.Length);
}
}
public void PackageReader_NoReferences()
{
using (var packageFile = TestPackagesCore.GetLegacyTestPackage())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(3, groups.Count());
Assert.Equal(4, groups.SelectMany(e => e.Items).Count());
}
}
}
public void PackageReader_EmptyLibFolder()
{
using (var packageFile = TestPackagesCore.GetLibEmptyFolderPackage())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
var emptyGroup = groups.Where(g => g.TargetFramework == NuGetFramework.ParseFolder("net45")).Single();
Assert.Equal(0, emptyGroup.Items.Count());
}
}
}
public async Task PushToServerWhichRejectsDuplicates_SkipDuplicate_Succeeds(PackageSource packageSource)
{
// Arrange
using (var packageDir = TestDirectory.Create())
using (TestFileSystemUtility.SetCurrentDirectory(packageDir))
{
var packageId = "XPlatPushTests.PushToServerSucceeds";
var packageVersion = "1.0.0";
var packageFile = await TestPackagesCore.GetRuntimePackageAsync(packageDir, packageId, packageVersion);
var configFile = XPlatTestUtils.CopyFuncTestConfig(packageDir);
var logFirstPush = new TestCommandOutputLogger();
var logSecondPush = new TestCommandOutputLogger();
var apiKey = XPlatTestUtils.ReadApiKey(packageSource.Name);
Assert.False(string.IsNullOrEmpty(apiKey));
var pushArgs = new List <string>
{
"push",
packageFile.FullName,
"--source",
packageSource.Source,
"--api-key",
apiKey,
"--skip-duplicate"
};
// Act
var exitCodeFirstPush = NuGet.CommandLine.XPlat.Program.MainInternal(pushArgs.ToArray(), logFirstPush);
var exitCodeSecondPush = NuGet.CommandLine.XPlat.Program.MainInternal(pushArgs.ToArray(), logSecondPush);
// Assert First Push - it should happen without error.
var outputMessagesFirstPush = logFirstPush.ShowMessages();
Assert.Equal(string.Empty, logFirstPush.ShowErrors());
Assert.Equal(0, exitCodeFirstPush);
// Assert Second Push - it should happen without error, even though a duplicate is present.
var outputMessagesSecondPush = logSecondPush.ShowMessages();
Assert.Equal(string.Empty, logSecondPush.ShowErrors());
Assert.Equal(0, exitCodeSecondPush);
Assert.Contains($"PUT {packageSource.Source}", outputMessagesSecondPush);
Assert.DoesNotContain("already exists at feed", outputMessagesSecondPush);
Assert.Contains("Your package was pushed.", outputMessagesSecondPush);
}
}
public void PackageReader_Serviceable()
{
// Arrange
using (var packageFile = TestPackagesCore.GetServiceablePackage())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
// Act
var actual = reader.IsServiceable();
// Assert
Assert.True(actual);
}
}
}
public void PackageReader_SupportedFrameworks()
{
using (var packageFile = TestPackagesCore.GetLegacyTestPackage())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
string[] frameworks = reader.GetSupportedFrameworks().Select(f => f.DotNetFrameworkName).ToArray();
Assert.Equal("Any,Version=v0.0", frameworks[0]);
Assert.Equal(".NETFramework,Version=v4.0", frameworks[1]);
Assert.Equal(".NETFramework,Version=v4.5", frameworks[2]);
Assert.Equal(3, frameworks.Length);
}
}
}
public void PackagesEndedWithResourcesShouldBeProcessed()
{
var packageName = "solution.resources";
using (var packageFile = TestPackagesCore.GetLegacyResourcesPackage(packageName))
{
using (var zip = new ZipArchive(File.OpenRead(packageFile)))
using (var zipReader = new PackageArchiveReader(zip))
{
var folder = Path.Combine(Path.GetDirectoryName(packageFile), Guid.NewGuid().ToString());
using (var zipFile = new ZipArchive(File.OpenRead(packageFile)))
{
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
var libs1 = zipReader.GetLibItems().Count();
var libs2 = folderReader.GetLibItems().Count();
Assert.Equal(libs1, libs2);
var group1 = zipReader.GetReferenceItems();
var group2 = folderReader.GetReferenceItems();
Assert.Equal(group1.Count(), group2.Count());
// Check that assemblies with the 'resource' in a title are not filtered out.
Assert.True(group1.First().Items.Any(p => p.EndsWith("resources.dll")));
// Check that resource assembly not filtered out.
Assert.True(group2.First().Items.Any(p => p.EndsWith("resources.dll")));
foreach (var item in group1)
{
Assert.False(item.Items.Any(p => p.EndsWith(packageName)));
}
foreach (var item in group2)
{
Assert.False(item.Items.Any(p => p.EndsWith(packageName)));
}
}
}
}
}
public async Task Verify_UnSignedPackage_Fails()
{
using (var packageDir = TestDirectory.Create())
{
var packageId = "Unsigned.PackageX";
var packageVersion = "1.0.0";
var packageFile = await TestPackagesCore.GetRuntimePackageAsync(packageDir, packageId, packageVersion);
//Act
var result = _msbuildFixture.RunDotnet(
packageDir,
$"nuget verify {packageFile.FullName}",
ignoreExitCode: true);
result.Success.Should().BeFalse(because: result.AllOutput);
result.Output.Should().Contain(_notSignedErrorCode);
}
}
public void PackageReader_ContentNoFrameworks()
{
using (var packageFile = TestPackagesCore.GetLegacyContentPackage())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetContentItems().ToArray();
Assert.Equal(1, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups.Single().TargetFramework);
Assert.Equal(3, groups.Single().Items.Count());
}
}
}
public async Task Test_ExtractionDoesNotExtractFiles_IfPackageSaveModeDoesNotIncludeFiles()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packageFileInfo = TestPackagesCore.GetLegacyTestPackage())
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Nuspec | PackageSaveMode.Nupkg,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
logger: NullLogger.Instance,
signedPackageVerifier: null,
signedPackageVerifierSettings: null);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDirectory);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
packageFileInfo,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
AssertDirectoryExists(packageVersionDirectory);
AssertFileExists(packageVersionDirectory, pathResolver.GetPackageFileName(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, pathResolver.GetManifestFileName(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, "packagea.2.0.3.nupkg.sha512");
Assert.False(File.Exists(Path.Combine(packageVersionDirectory, "lib", "test.dll")));
}
}
public async Task PushToServerSkipDuplicateSucceeds(PackageSource packageSource)
{
// Arrange
using (var packageDir = TestDirectory.Create())
using (TestFileSystemUtility.SetCurrentDirectory(packageDir))
{
var packageId = "XPlatPushTests.PushToServerSucceeds";
var packageVersion = "1.0.0";
var packageFile = await TestPackagesCore.GetRuntimePackageAsync(packageDir, packageId, packageVersion);
var configFile = XPlatTestUtils.CopyFuncTestConfig(packageDir);
var log = new TestCommandOutputLogger();
var apiKey = XPlatTestUtils.ReadApiKey(packageSource.Name);
Assert.False(string.IsNullOrEmpty(apiKey));
var pushArgs = new List <string>
{
"push",
packageFile.FullName,
"--source",
packageSource.Source,
"--api-key",
apiKey,
"--skip-duplicate"
};
// Act
var exitCode = NuGet.CommandLine.XPlat.Program.MainInternal(pushArgs.ToArray(), log);
// Assert
var outputMessages = log.ShowMessages();
Assert.Equal(string.Empty, log.ShowErrors());
Assert.Equal(0, exitCode);
Assert.Contains($"PUT {packageSource.Source}", outputMessages);
//info: PUT http://localhost:5000/api/v2/package/
//info: Conflict http://localhost:5000/api/v2/package/ 127ms
Assert.Contains("already exists at feed", outputMessages);
Assert.Contains("Your package was pushed.", outputMessages);
}
}
public async Task GetInstalledPackageFilesAsync_ReturnsInstalledPackageFiles()
{
using (var test = PackageHelperTest.Create(TestPackagesCore.GetPackageContentReaderTestPackage()))
{
using (var packageStream = test.GetPackageStream())
{
await PackageExtractor.ExtractPackageAsync(
test.Root,
test.Reader,
packageStream,
test.Resolver,
new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext : null,
logger : NullLogger.Instance),
CancellationToken.None);
}
var packageIdentity = test.Reader.GetIdentity();
var packageDirectoryName = $"{packageIdentity.Id}.{packageIdentity.Version.ToNormalizedString()}";
// Delete some files so that the set of installed files is incomplete.
Directory.Delete(Path.Combine(test.Root, packageDirectoryName, "lib"), recursive: true);
var files = (await PackageHelper.GetInstalledPackageFilesAsync(
test.Reader,
test.Reader.GetIdentity(),
test.Resolver,
PackageSaveMode.Defaultv3,
CancellationToken.None)).ToArray();
Assert.Equal(9, files.Length);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "build/net45/a.dll"), files[0].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "build/net45/a.props"), files[1].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "build/net45/a.targets"), files[2].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "content/net45/b"), files[3].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "content/net45/c"), files[4].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "other/net45/h"), files[5].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "other/net45/i"), files[6].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "tools/net45/j"), files[7].FileFullPath);
Assert.Equal(Path.Combine(test.Root, packageDirectoryName, "tools/net45/k"), files[8].FileFullPath);
}
}
public void GetPackageDependencies_ReturnsPackageDependencies()
{
using (var test = PackageReaderTest.Create(TestPackagesCore.GetPackageContentReaderTestPackage()))
{
var groups = test.Reader.GetPackageDependencies().ToArray();
Assert.Equal(2, groups.Length);
Assert.Equal(".NETFramework,Version=v4.0", groups[0].TargetFramework.DotNetFrameworkName);
var packages = groups[0].Packages.ToArray();
Assert.Equal(2, packages.Length);
Assert.Equal("l", packages[0].Id);
Assert.Equal("m", packages[1].Id);
Assert.Empty(groups[1].Packages);
Assert.Equal(".NETFramework,Version=v4.5", groups[1].TargetFramework.DotNetFrameworkName);
}
}
public async Task GetPackageDependenciesAsync_ReturnsPackageDependencies()
{
using (var test = PackageReaderTest.Create(TestPackagesCore.GetPackageContentReaderTestPackage()))
{
var groups = (await test.Reader.GetPackageDependenciesAsync(CancellationToken.None)).ToArray();
Assert.Equal(2, groups.Length);
Assert.Equal(".NETFramework,Version=v4.0", groups[0].TargetFramework.DotNetFrameworkName);
var packages = groups[0].Packages.ToArray();
Assert.Equal(2, packages.Length);
Assert.Equal("l", packages[0].Id);
Assert.Equal("m", packages[1].Id);
Assert.Empty(groups[1].Packages);
Assert.Equal(".NETFramework,Version=v4.5", groups[1].TargetFramework.DotNetFrameworkName);
}
}
public void PackageReader_NestedReferenceItems()
{
using (var packageFile = TestPackagesCore.GetLibSubFolderPackage())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(1, groups.Count());
Assert.Equal(NuGetFramework.Parse("net40"), groups[0].TargetFramework);
Assert.Equal(2, groups[0].Items.Count());
Assert.Equal("lib/net40/test40.dll", groups[0].Items.ToArray()[0]);
Assert.Equal("lib/net40/x86/testx86.dll", groups[0].Items.ToArray()[1]);
}
}
}
public async Task CopyFilesAsync_ReturnsCopiedFilePaths()
{
using (var testDirectory = TestDirectory.Create())
using (var test = PackageReaderTest.Create(TestPackagesCore.GetPackageCoreReaderTestPackage()))
{
var files = await test.Reader.CopyFilesAsync(
testDirectory.Path,
new[] { "Aa.nuspec" },
ExtractFile,
NullLogger.Instance,
CancellationToken.None);
var expectedFilePath = Path.Combine(testDirectory.Path, "Aa.nuspec");
Assert.Equal(1, files.Count());
Assert.Equal(expectedFilePath, files.Single());
Assert.True(File.Exists(expectedFilePath));
}
}
public async Task Test_ExtractPackage()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packageFileInfo = TestPackagesCore.GetLegacyTestPackage())
using (var packagesDirectory = TestDirectory.Create())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None,
clientPolicyContext: null,
logger: NullLogger.Instance);
var versionFolderPathResolver = new VersionFolderPathResolver(packagesDirectory);
// Act
using (var packageDownloader = new LocalPackageArchiveDownloader(
null,
packageFileInfo,
packageIdentity,
NullLogger.Instance))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
CancellationToken.None);
}
// Assert
var packageVersionDirectory = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
AssertDirectoryExists(packageVersionDirectory);
AssertFileExists(packageVersionDirectory, pathResolver.GetPackageFileName(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, pathResolver.GetManifestFileName(packageIdentity.Id, packageIdentity.Version));
AssertFileExists(packageVersionDirectory, "packagea.2.0.3.nupkg.sha512");
AssertFileExists(packageVersionDirectory, "lib", "test.dll");
}
}
public void PathTooLongWarning_PackageWithOutLongPath_NoWarn()
{
using (var packageFile = TestPackagesCore.GetPackageCoreReaderTestPackage())
{
var zip = TestPackagesCore.GetZip(packageFile);
var ruleSet = RuleSet.PackageCreationRuleSet;
using (var reader = new PackageArchiveReader(zip))
{
var issues = new List <PackagingLogMessage>();
foreach (var rule in ruleSet)
{
issues.AddRange(rule.Validate(reader).OrderBy(p => p.Code.ToString(), StringComparer.CurrentCulture));
}
Assert.False(issues.Any(p => p.Code == NuGetLogCode.NU5123));
}
}
}
// [InlineData(TestServers.Klondike, nameof(TestServers.Klondike), false)] // 500 Internal Server Error pushing
// [InlineData(TestServers.NuGetServer, nameof(TestServers.NuGetServer), false)] // 500 - missing manifest?
public async Task PushToServerSucceeds(string sourceUri, string feedName, bool mustDeleteFirst)
{
// Arrange
using (var packageDir = TestDirectory.Create())
using (TestFileSystemUtility.SetCurrentDirectory(packageDir))
{
var packageId = "XPlatPushTests.PushToServerSucceeds";
var packageVersion = "1.0.0";
var packageFile = await TestPackagesCore.GetRuntimePackageAsync(packageDir, packageId, packageVersion);
var configFile = XPlatTestUtils.CopyFuncTestConfig(packageDir);
var log = new TestCommandOutputLogger();
var apiKey = XPlatTestUtils.ReadApiKey(feedName);
Assert.False(string.IsNullOrEmpty(apiKey));
if (mustDeleteFirst)
{
DeletePackageBeforePush(packageId, packageVersion, sourceUri, apiKey);
}
var pushArgs = new List <string>()
{
"push",
packageFile.FullName,
"--source",
sourceUri,
"--api-key",
apiKey
};
// Act
int exitCode = NuGet.CommandLine.XPlat.Program.MainInternal(pushArgs.ToArray(), log);
// Assert
Assert.Equal(string.Empty, log.ShowErrors());
Assert.Equal(0, exitCode);
Assert.Contains($"PUT {sourceUri}", log.ShowMessages());
Assert.Contains("Your package was pushed.", log.ShowMessages());
}
}
public void PackageReader_PackageTypes()
{
// Arrange
using (var packageFile = TestPackagesCore.GetPackageWithPackageTypes())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
// Act
var actual = reader.GetPackageTypes();
// Assert
Assert.Equal(2, actual.Count);
Assert.Equal("foo", actual[0].Name);
Assert.Equal(new Version(0, 0), actual[0].Version);
Assert.Equal("bar", actual[1].Name);
Assert.Equal(new Version(2, 0, 0), actual[1].Version);
}
}
}
public void PackageReader_ReferencesWithGroups()
{
using (var packageFile = TestPackagesCore.GetLegacyTestPackageWithReferenceGroups())
{
var zip = TestPackagesCore.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(2, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework);
Assert.Equal(1, groups[0].Items.Count());
Assert.Equal("lib/test.dll", groups[0].Items.Single());
Assert.Equal(NuGetFramework.Parse("net45"), groups[1].TargetFramework);
Assert.Equal(1, groups[1].Items.Count());
Assert.Equal("lib/net45/test45.dll", groups[1].Items.Single());
}
}
}
public async Task PackageExpander_ExpandsPackage()
{
// Arrange
using (var package = TestPackagesCore.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestDirectory.Create();
var pathResolver = new VersionFolderPathResolver(packagesDir);
var token = CancellationToken.None;
var logger = NullLogger.Instance;
var versionFolderPathContext = new VersionFolderPathContext(
identity,
packagesDir,
logger,
packageSaveMode: PackageSaveMode.Defaultv3,
xmlDocFileSaveMode: XmlDocFileSaveMode.None);
// Act
using (var stream = package.File.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
versionFolderPathContext,
token);
}
// Assert
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
AssertDirectoryExists(packageDir, packageDir + " does not exist");
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(nupkgPath), nupkgPath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
}
}
public async Task GetInstalledSatelliteFilesAsync_ReturnsRuntimePackageDirectoryIfRuntimePackageExistsButIsNotInstalled()
{
using (var test = PackageHelperTest.Create(TestPackagesCore.GetPackageContentReaderTestPackage()))
{
using (var testDirectory = TestDirectory.Create())
{
var packageIdentity = new PackageIdentity("A", new NuGetVersion("1.2.3"));
var packagePathResolver = new PackagePathResolver(testDirectory.Path);
var packageFileInfo = await TestPackagesCore.GetRuntimePackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var satellitePackageInfo = await TestPackagesCore.GetSatellitePackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString(),
language : "fr");
using (var packageReader = new PackageArchiveReader(File.OpenRead(satellitePackageInfo.FullName)))
{
var result = await PackageHelper.GetInstalledSatelliteFilesAsync(
packageReader,
packagePathResolver,
PackageSaveMode.Defaultv3,
CancellationToken.None);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2;
Assert.Equal(testDirectory.Path, runtimePackageDirectory);
Assert.Empty(satelliteFiles);
}
}
}
}
public async Task GetSatelliteFilesAsync_ReturnsEmptyEnumerableIfRuntimePackageDoesNotExist()
{
using (var testDirectory = TestDirectory.Create())
{
var packageIdentity = new PackageIdentity("A", new NuGetVersion("1.2.3"));
var packagePathResolver = new PackagePathResolver(testDirectory.Path);
var satellitePackageInfo = await TestPackagesCore.GetSatellitePackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString(),
language : "fr");
using (var packageReader = new PackageArchiveReader(File.OpenRead(satellitePackageInfo.FullName)))
{
var result = await PackageHelper.GetSatelliteFilesAsync(packageReader, packagePathResolver, CancellationToken.None);
var runtimePackageDirectory = result.Item1;
var satelliteFiles = result.Item2;
Assert.Null(runtimePackageDirectory);
Assert.Empty(satelliteFiles);
}
}
}
public void PackageFolderReader_Basic()
{
using (var packageFile = TestPackagesCore.GetLegacyTestPackage())
{
using (var zip = new ZipArchive(File.OpenRead(packageFile)))
using (var zipReader = new PackageArchiveReader(zip))
using (var testDirectory = TestDirectory.Create())
using (var zipFile = new ZipArchive(File.OpenRead(packageFile)))
{
zipFile.ExtractAll(testDirectory);
using (var folderReader = new PackageFolderReader(testDirectory))
{
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count());
Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First());
}
}
}
}
public async Task PushMultiplePathsToFileSystemSource()
{
using (var packageDirectory = TestDirectory.Create())
using (var source = TestDirectory.Create())
{
// Arrange
var log = new TestCommandOutputLogger();
var packageInfoCollection = new[]
{
await TestPackagesCore.GetRuntimePackageAsync(packageDirectory, "testPackageA", "1.1.0"),
await TestPackagesCore.GetRuntimePackageAsync(packageDirectory, "testPackageB", "1.1.0"),
};
var pushArgs = new List <string>
{
"push",
packageInfoCollection[0].FullName,
packageInfoCollection[1].FullName,
"--source",
source,
};
// Act
var exitCode = CommandLine.XPlat.Program.MainInternal(pushArgs.ToArray(), log);
// Assert
Assert.Equal(string.Empty, log.ShowErrors());
Assert.Equal(0, exitCode);
foreach (var packageInfo in packageInfoCollection)
{
Assert.Contains($"Pushing {packageInfo.Name}", log.ShowMessages());
Assert.True(File.Exists(Path.Combine(source, packageInfo.Name)));
}
}
}
