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