public void PackageReader_ReferencesWithoutGroups()
{
using (var packageFile = TestPackages.GetLegacyTestPackageWithPre25References())
{
var zip = TestPackages.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(3, 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("net40"), groups[1].TargetFramework);
Assert.Equal(1, groups[1].Items.Count());
Assert.Equal("lib/net40/test.dll", groups[1].Items.Single());
Assert.Equal(NuGetFramework.Parse("net451"), groups[2].TargetFramework);
Assert.Equal(1, groups[1].Items.Count());
Assert.Equal("lib/net451/test.dll", groups[2].Items.Single());
}
}
}
public void PackageReader_NestedReferenceItemsMixed()
{
using (var packageFile = TestPackages.GetLibEmptyFolderPackage())
{
var zip = TestPackages.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(3, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework);
Assert.Equal(2, groups[0].Items.Count());
Assert.Equal("lib/a.dll", groups[0].Items.ToArray()[0]);
Assert.Equal("lib/x86/b.dll", groups[0].Items.ToArray()[1]);
Assert.Equal(NuGetFramework.Parse("net40"), groups[1].TargetFramework);
Assert.Equal(2, groups[1].Items.Count());
Assert.Equal("lib/net40/test40.dll", groups[1].Items.ToArray()[0]);
Assert.Equal("lib/net40/x86/testx86.dll", groups[1].Items.ToArray()[1]);
Assert.Equal(NuGetFramework.Parse("net45"), groups[2].TargetFramework);
Assert.Equal(0, groups[2].Items.Count());
}
}
}
public void PackageReader_LegacyFolders()
{
// Verify legacy folder names such as 40 and 35 parse to frameworks
var zip = TestPackages.GetZip(TestPackages.GetLegacyFolderPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(4, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework);
Assert.Equal("lib/a.dll", groups[0].Items.ToArray()[0]);
Assert.Equal(NuGetFramework.Parse("net35"), groups[1].TargetFramework);
Assert.Equal("lib/35/b.dll", groups[1].Items.ToArray()[0]);
Assert.Equal(NuGetFramework.Parse("net4"), groups[2].TargetFramework);
Assert.Equal("lib/40/test40.dll", groups[2].Items.ToArray()[0]);
Assert.Equal("lib/40/x86/testx86.dll", groups[2].Items.ToArray()[1]);
Assert.Equal(NuGetFramework.Parse("net45"), groups[3].TargetFramework);
Assert.Equal("lib/45/a.dll", groups[3].Items.ToArray()[0]);
}
}
public async Task TestFolderNuGetProjectInstall()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var randomTestSourcePath = TestFilesystemUtility.CreateRandomTestFolder();
var packageFileInfo = TestPackages.GetLegacyTestPackage(randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var randomTestDestinationPath = TestFilesystemUtility.CreateRandomTestFolder();
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = packageFileInfo.OpenRead())
{
// Act
await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.True(File.Exists(Path.Combine(packageInstallPath, "lib/test.dll")));
using (var packageStream = File.OpenRead(nupkgFilePath))
{
var zipArchive = new ZipArchive(packageStream);
Assert.Equal(5, zipArchive.Entries.Count);
}
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(randomTestSourcePath, randomTestDestinationPath);
}
public void PackageFolderReader_Basic()
{
using (var packageFile = TestPackages.GetLegacyTestPackage())
{
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());
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 void Init()
{
_nugetFeedFolder = Path.Combine(Environment.CurrentDirectory, "testnuget");
Folder.EnsureDeleted(_nugetFeedFolder);
Folder.EnsureExists(_nugetFeedFolder);
var version10 = new Version(1, 0);
TestPackages.CopyHostPackageTo(_nugetFeedFolder);
TestPackages.CopyTest10To(_nugetFeedFolder);
_basePath = Folder.Combine(_nugetFeedFolder, "extracted");
_context = new DeploymentTaskContext()
{
Folders = new ServiceFolders
{
DeployFolder = (FullPath)_basePath,
},
KeepOnUpdate = new FileList(new string[0]),
PackageDetails = new PackageDetails(
"Codestellation.Galaxy.Host",
_nugetFeedFolder,
version10)
};
_context.Parameters.Version = version10.ToString();
new InstallPackage().Execute(_context);
}
public void PackageReader_SupportedFrameworksForInvalidPortableFrameworkThrows()
{
using (var packageFile = TestPackages.GetLegacyTestPackageWithInvalidPortableFrameworkFolderName())
{
var zip = TestPackages.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var ex = Assert.Throws <PackagingException>(
() => reader.GetSupportedFrameworks());
Assert.Equal(
"The framework in the folder name of '" +
"lib/portable-net+win+wpa+wp+sl+net-cf+netmf+MonoAndroid+MonoTouch+Xamarin.iOS/test.dll" +
"' in package 'packageA.2.0.3' could not be parsed.",
ex.Message);
Assert.NotNull(ex.InnerException);
Assert.IsType <ArgumentException>(ex.InnerException);
Assert.Equal(
"Invalid portable frameworks '" +
"net+win+wpa+wp+sl+net-cf+netmf+MonoAndroid+MonoTouch+Xamarin.iOS" +
"'. A hyphen may not be in any of the portable framework names.",
ex.InnerException.Message);
}
}
}
public void CreateFeed()
{
_nugetFeedFolder = Path.Combine(Environment.CurrentDirectory, "testnuget");
Folder.EnsureDeleted(_nugetFeedFolder);
Folder.EnsureExists(_nugetFeedFolder);
TestPackages.CopyTest10To(_nugetFeedFolder);
TestPackages.CopyTest11To(_nugetFeedFolder);
}
public async Task PackageExpander_CleansExtraFiles()
{
// Arrange
using (var package = TestPackages.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestFileSystemUtility.CreateRandomTestFolder();
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);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
var randomFile = Path.Combine(packageDir, package.Id + "." + package.Version + ".random");
Directory.CreateDirectory(packageDir);
File.WriteAllBytes(randomFile, new byte[] { });
var randomFolder = Path.Combine(packageDir, "random");
Directory.CreateDirectory(randomFolder);
Assert.True(File.Exists(randomFile), randomFile + " does not exist");
AssertDirectoryExists(randomFolder);
// Act
using (var stream = package.File.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
versionFolderPathContext,
token);
}
// Assert
AssertDirectoryExists(packageDir, packageDir + " does not exist");
var filePath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(filePath), filePath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
Assert.False(File.Exists(randomFile), randomFile + " does exist");
Assert.False(Directory.Exists(randomFolder), randomFolder + " does exist");
}
}
public void PackageReader_MinClientVersion(string minClientVersion, string expected)
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackageMinClient(minClientVersion));
using (PackageReader reader = new PackageReader(zip))
{
var version = reader.GetMinClientVersion();
Assert.Equal(expected, version.ToNormalizedString());
}
}
public void PackageReader_ContentWithFrameworks()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyContentPackageWithFrameworks());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetContentItems().ToArray();
Assert.Equal(3, groups.Count());
}
}
public void Init()
{
_nugetFeedFolder = Path.Combine(Environment.CurrentDirectory, "testnuget");
Folder.EnsureDeleted(_nugetFeedFolder);
Folder.EnsureExists(_nugetFeedFolder);
TestPackages.CopyHostPackageTo(_nugetFeedFolder);
TestPackages.CopyTest10To(_nugetFeedFolder);
_targetPath = Path.Combine(_nugetFeedFolder, "extracted");
}
public async Task Test_ExtractionIgnoresNupkgHashFile()
{
// Arrange
var package = new PackageIdentity("packageA", new NuGetVersion("2.0.3"));
using (var packagesDirectory = TestFileSystemUtility.CreateRandomTestFolder())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageFileInfo = await TestPackages.GetPackageWithSHA512AtRoot(
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 hashPath = pathResolver.GetHashPath(package.Id, package.Version);
var hashFileInfo = new FileInfo(hashPath);
Assert.True(File.Exists(hashFileInfo.FullName));
Assert.NotEqual(0, hashFileInfo.Length);
var bsha512Path = Path.Combine(packageVersionDirectory, "lib", "net45", "B.sha512");
var bsha512FileInfo = new FileInfo(bsha512Path);
Assert.True(File.Exists(bsha512FileInfo.FullName));
Assert.Equal(0, bsha512FileInfo.Length);
var csha512Path = Path.Combine(packageVersionDirectory, "C.sha512");
var csha512FileInfo = new FileInfo(csha512Path);
Assert.True(File.Exists(csha512FileInfo.FullName));
Assert.Equal(0, csha512FileInfo.Length);
}
}
public void PackageReader_AgnosticFramework()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyContentPackage());
using (PackageReader reader = new PackageReader(zip))
{
string[] frameworks = reader.GetSupportedFrameworks().Select(f => f.DotNetFrameworkName).ToArray();
Assert.Equal("Agnostic, Version=v0.0", frameworks[0]);
Assert.Equal(frameworks.Length, 1);
}
}
public async Task PackageExpander_Recovers_WhenStreamIsCorrupt()
{
// Arrange
using (var package = TestPackages.GetNearestReferenceFilteringPackage())
{
var version = new NuGetVersion(package.Version);
var identity = new PackageIdentity(package.Id, version);
var packagesDir = TestFileSystemUtility.CreateRandomTestFolder();
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);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
Assert.False(Directory.Exists(packageDir), packageDir + " exist");
// Act
using (var stream = package.File.OpenRead())
{
await Assert.ThrowsAnyAsync <CorruptionException>(async() =>
await PackageExtractor.InstallFromSourceAsync(
async(d) => await new CorruptStreamWrapper(stream).CopyToAsync(d),
versionFolderPathContext,
token));
}
AssertDirectoryExists(packageDir, packageDir + " does not exist");
Assert.NotEmpty(Directory.EnumerateFiles(packageDir));
using (var stream = package.File.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
versionFolderPathContext,
token);
}
// Assert
var filePath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
Assert.True(File.Exists(filePath), filePath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.True(File.Exists(dllPath), dllPath + " does not exist");
}
}
public async Task TestCheckForMissingPackages()
{
// Arrange
var testSolutionManager = new TestSolutionManager();
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var randomPackageSourcePath = TestFilesystemUtility.CreateRandomTestFolder();
var packageFileInfo = TestPackages.GetLegacyTestPackage(randomPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = packageFileInfo.OpenRead())
{
// Act
await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSettings = NullSettings.Instance;
var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager);
int packagesMissingEventCount = 0;
bool packagesMissing = false;
packageRestoreManager.PackagesMissingStatusChanged += delegate(object sender, PackagesMissingStatusEventArgs args)
{
packagesMissingEventCount++;
packagesMissing = args.PackagesMissing;
};
// Act
await packageRestoreManager.RaisePackagesMissingEventForSolution(token);
// Assert
Assert.Equal(1, packagesMissingEventCount);
Assert.False(packagesMissing);
// Delete packages folder
Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true);
// Act
await packageRestoreManager.RaisePackagesMissingEventForSolution(token);
// Assert
Assert.Equal(2, packagesMissingEventCount);
Assert.True(packagesMissing);
}
public void PackageReader_NoReferences()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(3, groups.Count());
Assert.Equal(4, groups.SelectMany(e => e.Items).Count());
}
}
public void PackageReader_EmptyLibFolder()
{
var zip = TestPackages.GetZip(TestPackages.GetLibEmptyFolderPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
var emptyGroup = groups.Where(g => g.TargetFramework == NuGetFramework.ParseFolder("net45")).Single();
Assert.Equal(0, emptyGroup.Items.Count());
}
}
public void SerializationTest()
{
var pkg = TestPackages.Get();
var s = new ConfigSerializer();
XmlSerializer serializer = new XmlSerializer(typeof(GlobalExtractConfiguration));
using (var writer = new StringWriter())
{
serializer.Serialize(writer, s.GetGlobalConfig());
var g = writer.ToString();
}
}
public async Task PackageExpander_ExpandsPackage_SkipsIfShaIsThere()
{
// Arrange
using (var package = TestPackages.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);
var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
Directory.CreateDirectory(packageDir);
var nupkgPath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
var shaPath = pathResolver.GetHashPath(package.Id, identity.Version);
File.WriteAllBytes(shaPath, new byte[] { });
Assert.True(File.Exists(shaPath));
// Act
using (var stream = package.File.OpenRead())
{
await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
versionFolderPathContext,
token);
}
// Assert
AssertDirectoryExists(packageDir, packageDir + " does not exist");
Assert.False(File.Exists(nupkgPath), nupkgPath + " does not exist");
var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
Assert.False(File.Exists(dllPath), dllPath + " does not exist");
Assert.Equal(1, Directory.EnumerateFiles(packageDir).Count());
}
}
public void PackageReader_SupportedFrameworks()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackage());
using (PackageReader reader = new PackageReader(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(frameworks.Length, 3);
}
}
public void PackageReader_ContentWithMixedFrameworks()
{
using (var packageFile = TestPackages.GetLegacyContentPackageMixed())
{
var zip = TestPackages.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
var groups = reader.GetContentItems().ToArray();
Assert.Equal(3, groups.Count());
}
}
}
public void PackageReader_ContentNoFrameworks()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyContentPackage());
using (PackageReader reader = new PackageReader(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 TestFolderNuGetProjectDeletePackage()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var randomTestSourcePath = TestFilesystemUtility.CreateRandomTestFolder();
var packageFileInfo = TestPackages.GetLegacyContentPackage(randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var randomTestDestinationPath = TestFilesystemUtility.CreateRandomTestFolder();
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = packageFileInfo.OpenRead())
{
// Act
await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
var unNormalizedPackageIdentity = new PackageIdentity(packageIdentity.Id,
new NuGetVersion(packageIdentity.Version + ".0"));
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.True(File.Exists(Path.Combine(packageInstallPath, "Content/Scripts/test1.js")));
using (var packageStream = File.OpenRead(nupkgFilePath))
{
var zipArchive = new ZipArchive(packageStream);
Assert.Equal(6, zipArchive.Entries.Count);
}
Assert.True(folderNuGetProject.PackageExists(packageIdentity));
var packageDirectoryPath = folderNuGetProject.GetInstalledPath(unNormalizedPackageIdentity);
Assert.True(!String.IsNullOrEmpty(packageDirectoryPath));
Assert.True(Directory.Exists(packageDirectoryPath));
// Main Act
await folderNuGetProject.DeletePackage(packageIdentity, testNuGetProjectContext, CancellationToken.None);
// Assert
Assert.False(folderNuGetProject.PackageExists(unNormalizedPackageIdentity));
// Check that the package directories are deleted
Assert.False(Directory.Exists(packageDirectoryPath));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(randomTestSourcePath, randomTestDestinationPath);
}
public void PackageReader_NestedReferenceItems()
{
var zip = TestPackages.GetZip(TestPackages.GetLibSubFolderPackage());
using (PackageReader reader = new PackageReader(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 void PackageReader_Serviceable()
{
// Arrange
using (var packageFile = TestPackages.GetServiceablePackage())
{
var zip = TestPackages.GetZip(packageFile);
using (PackageArchiveReader reader = new PackageArchiveReader(zip))
{
// Act
var actual = reader.IsServiceable();
// Assert
Assert.True(actual);
}
}
}
public void PackageReader_ReferencesWithGroups()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackageWithReferenceGroups());
using (PackageReader reader = new PackageReader(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 Test_ExtractionHonorsFileTimestamp()
{
// Arrange
var package = 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 = TestFileSystemUtility.CreateRandomTestFolder())
{
var pathResolver = new VersionFolderPathResolver(packagesDirectory);
var packageFileInfo = await TestPackages.GeneratePackageAsync(
packagesDirectory,
package.Id,
package.Version.ToNormalizedString(),
entryModifiedTime,
"lib/net45/A.dll");
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);
var dllPath = Path.Combine(packageVersionDirectory, "lib", "net45", "A.dll");
var dllFileInfo = new FileInfo(dllPath);
AssertFileExists(dllFileInfo.FullName);
Assert.Equal(entryModifiedTime, dllFileInfo.LastWriteTime);
}
}
public void PackageReader_RespectReferencesAccordingToDifferentFrameworks()
{
// Copy of the InstallPackageRespectReferencesAccordingToDifferentFrameworks functional test
// Arrange
var zip = TestPackages.GetZip(TestPackages.GetNearestReferenceFilteringPackage());
var reader = new PackageReader(zip);
// Act
var references = reader.GetReferenceItems();
var netResult = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(references, NuGetFramework.Parse("net45"));
var slResult = NuGetFrameworkUtility.GetNearest <FrameworkSpecificGroup>(references, NuGetFramework.Parse("sl5"));
// Assert
Assert.Equal(2, netResult.Items.Count());
Assert.Equal(1, slResult.Items.Count());
Assert.Equal("lib/sl40/a.dll", slResult.Items.First());
Assert.Equal("lib/net40/one.dll", netResult.Items.First());
Assert.Equal("lib/net40/three.dll", netResult.Items.Skip(1).First());
}
// [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 TestPackages.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 = 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());
}
}
