public void GetClientPolicy_MutipleConfigs_ReadsParsesAndMergesTrustedSigners() { // Arrange var config1 = @" <configuration> <config> <add key=""signatureValidationMode"" value=""require"" /> </config> <trustedSigners> <author name=""author1""> <certificate fingerprint=""abc"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""false"" /> </author> <repository name=""repository1"" serviceIndex=""https://v3serviceIndex.test/api/json""> <certificate fingerprint=""def"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""false"" /> </repository> </trustedSigners> </configuration>"; var config2 = @" <configuration> <config> <add key=""signatureValidationMode"" value=""require"" /> </config> <trustedSigners> <author name=""author1""> <certificate fingerprint=""xyz"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""false"" /> </author> <repository name=""repository2"" serviceIndex=""https://v3serviceIndex2.test/api/json""> <certificate fingerprint=""rst"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""false"" /> </repository> </trustedSigners> </configuration>"; var config3 = @" <configuration> <config> <add key=""signatureValidationMode"" value=""require"" /> </config> <trustedSigners> <author name=""author2""> <certificate fingerprint=""xyz"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""false"" /> </author> <repository name=""repository1"" serviceIndex=""https://v3serviceIndex.test/api/json""> <certificate fingerprint=""opq"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""false"" /> </repository> </trustedSigners> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var mockBaseDirectory = TestDirectory.Create()) using (var innerMockDirectory = TestDirectory.Create(mockBaseDirectory)) using (var closerDirectory = TestDirectory.Create(innerMockDirectory)) { SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config1); SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, innerMockDirectory, config2); SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, closerDirectory, config3); // Act and Assert var settings = Settings.LoadDefaultSettings(closerDirectory); settings.Should().NotBeNull(); var expectedAllowList = new List <VerificationAllowListEntry>() { new TrustedSignerAllowListEntry(VerificationTarget.Author, SignaturePlacement.PrimarySignature, "xyz", HashAlgorithmName.SHA256), new TrustedSignerAllowListEntry(VerificationTarget.Repository, SignaturePlacement.Any, "rst", HashAlgorithmName.SHA256), new TrustedSignerAllowListEntry(VerificationTarget.Repository, SignaturePlacement.Any, "opq", HashAlgorithmName.SHA256) }; var clientPolicyContext = ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance); clientPolicyContext.Policy.Should().Be(SignatureValidationMode.Require); clientPolicyContext.AllowList.Count.Should().Be(3); clientPolicyContext.AllowList.Should().BeEquivalentTo(expectedAllowList); var verifierSettings = clientPolicyContext.VerifierSettings; verifierSettings.AllowUnsigned.Should().BeFalse(); verifierSettings.AllowIllegal.Should().BeFalse(); verifierSettings.AllowUntrusted.Should().BeFalse(); verifierSettings.AllowIgnoreTimestamp.Should().BeTrue(); verifierSettings.AllowMultipleTimestamps.Should().BeTrue(); verifierSettings.AllowNoTimestamp.Should().BeTrue(); verifierSettings.AllowUnknownRevocation.Should().BeTrue(); verifierSettings.ReportUnknownRevocation.Should().BeTrue(); verifierSettings.VerificationTarget.Should().Be(VerificationTarget.All); verifierSettings.SignaturePlacement.Should().Be(SignaturePlacement.Any); verifierSettings.RepositoryCountersignatureVerificationBehavior.Should().Be(SignatureVerificationBehavior.IfExistsAndIsNecessary); verifierSettings.RevocationMode.Should().Be(RevocationMode.Online); } }
public void GetProjectReferences_WhenDuplicateExistsOrMetadataSpecified_DuplicatesIgnoredAndMetadataReadCorrectly() { using (var testDirectory = TestDirectory.Create()) { var projectA = new MockMSBuildProject(Path.Combine(testDirectory, "ProjectA", "ProjectA.csproj")); var projectB = new MockMSBuildProject(Path.Combine(testDirectory, "ProjectB", "ProjectB.csproj")); var projectC = new MockMSBuildProject(Path.Combine(testDirectory, "ProjectC", "ProjectC.csproj")); var projectD = new MockMSBuildProject(Path.Combine(testDirectory, "ProjectD", "ProjectD.csproj")); var project = new MockMSBuildProject(testDirectory) { Items = new Dictionary <string, IList <IMSBuildItem> > { ["ProjectReference"] = new List <IMSBuildItem> { new MSBuildItem(@"ProjectA\ProjectA.csproj", new Dictionary <string, string> { ["FullPath"] = projectA.FullPath }), new MSBuildItem(@"ProjectA\ProjectA.csproj", new Dictionary <string, string> { ["FullPath"] = "ShouldBeDeduped" }), new MSBuildItem(@"ProjectB\ProjectB.csproj", new Dictionary <string, string> { ["FullPath"] = projectB.FullPath, ["ExcludeAssets"] = $"{LibraryIncludeFlags.Compile};{LibraryIncludeFlags.Runtime}" }), new MSBuildItem(@"ProjectC\ProjectC.csproj", new Dictionary <string, string> { ["FullPath"] = projectC.FullPath, ["IncludeAssets"] = $"{LibraryIncludeFlags.Build};{LibraryIncludeFlags.BuildTransitive}" }), new MSBuildItem(@"ProjectD\ProjectD.csproj", new Dictionary <string, string> { ["FullPath"] = projectD.FullPath, ["PrivateAssets"] = $"{LibraryIncludeFlags.Runtime};{LibraryIncludeFlags.ContentFiles}" }), new MSBuildItem(@"ProjectE\ProjectE.csproj", new Dictionary <string, string> { ["ReferenceOutputAssembly"] = bool.FalseString }), } } }; var actual = MSBuildStaticGraphRestore.GetProjectReferences(project); actual.ShouldBeEquivalentTo(new[] { new ProjectRestoreReference { ProjectPath = projectA.FullPath, ProjectUniqueName = projectA.FullPath }, new ProjectRestoreReference { ProjectPath = projectB.FullPath, ProjectUniqueName = projectB.FullPath, ExcludeAssets = LibraryIncludeFlags.Runtime | LibraryIncludeFlags.Compile }, new ProjectRestoreReference { ProjectPath = projectC.FullPath, ProjectUniqueName = projectC.FullPath, IncludeAssets = LibraryIncludeFlags.Build | LibraryIncludeFlags.BuildTransitive }, new ProjectRestoreReference { ProjectPath = projectD.FullPath, ProjectUniqueName = projectD.FullPath, PrivateAssets = LibraryIncludeFlags.Runtime | LibraryIncludeFlags.ContentFiles } }); } }
public async Task DoesNotSkipPackagesWhenExceptionOccurs(string catalogUri, string expectedCursorBeforeRetry) { // Arrange var storage = new MemoryStorage(); var storageFactory = new TestStorageFactory(name => storage.WithName(name)); MockServerHttpClientHandler mockServer; mockServer = new MockServerHttpClientHandler(); mockServer.SetAction("/", request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK))); var catalogStorage = Catalogs.CreateTestCatalogWithCommitThenTwoPackageCommit(); await mockServer.AddStorageAsync(catalogStorage); // Make the first request for a catalog leaf node fail. This will cause the registration collector // to fail the first time but pass the second time. FailFirstRequest(mockServer, catalogUri); expectedCursorBeforeRetry = expectedCursorBeforeRetry ?? MemoryCursor.MinValue.ToString("O"); ReadWriteCursor front = new DurableCursor( storage.ResolveUri("cursor.json"), storage, MemoryCursor.MinValue); ReadCursor back = MemoryCursor.CreateMax(); using (var testDirectory = TestDirectory.Create()) { var luceneDirectory = new SimpleFSDirectory(new DirectoryInfo(testDirectory)); using (var indexWriter = Catalog2LuceneJob.CreateIndexWriter(luceneDirectory)) { var target = new SearchIndexFromCatalogCollector( new Uri("http://tempuri.org/index.json"), indexWriter, commitEachBatch: true, baseAddress: null, telemetryService: new Mock <ITelemetryService>().Object, logger: new TestLogger(), handlerFunc: () => mockServer); // Act await Assert.ThrowsAsync <Exception>(() => target.RunAsync(front, back, CancellationToken.None)); var cursorBeforeRetry = front.Value; await target.RunAsync(front, back, CancellationToken.None); var cursorAfterRetry = front.Value; // Assert var reader = indexWriter.GetReader(); var documents = Enumerable .Range(0, reader.NumDeletedDocs + reader.NumDocs()) .Where(i => !reader.IsDeleted(i)) .Select(i => reader.Document(i)) .ToList(); Assert.Equal(4, documents.Count); var documentsByType = documents .ToLookup(doc => doc .fields_ForNUnit .FirstOrDefault(f => f.Name == "@type")? .StringValue); var commitDocuments = documentsByType[Schema.DataTypes.CatalogInfastructure.AbsoluteUri.ToString()].ToList(); var packageDocuments = documentsByType[null].ToList(); Assert.Equal(1, commitDocuments.Count); Assert.Equal(3, packageDocuments.Count); Assert.Equal( "UnlistedPackage", packageDocuments[0].fields_ForNUnit.FirstOrDefault(x => x.Name == Constants.LucenePropertyId)?.StringValue); Assert.Equal( "ListedPackage", packageDocuments[1].fields_ForNUnit.FirstOrDefault(x => x.Name == Constants.LucenePropertyId)?.StringValue); Assert.Equal( "AnotherPackage", packageDocuments[2].fields_ForNUnit.FirstOrDefault(x => x.Name == Constants.LucenePropertyId)?.StringValue); Assert.Equal(DateTime.Parse(expectedCursorBeforeRetry).ToUniversalTime(), cursorBeforeRetry); Assert.Equal(DateTime.Parse("2015-10-12T10:08:55.3335317Z").ToUniversalTime(), cursorAfterRetry); } } }
public async Task VerifySignaturesAsync_ExpiredCertificateAndTimestampWithTooLargeRange_Fails() { var testServer = await _testFixture.GetSigningTestServerAsync(); var ca = await _testFixture.GetDefaultTrustedCertificateAuthorityAsync(); var accuracy = new BcAccuracy(seconds: new DerInteger(30), millis: null, micros: null); var serviceOptions = new TimestampServiceOptions() { Accuracy = accuracy }; var timestampService = TimestampService.Create(ca, serviceOptions); var keyPair = SigningTestUtility.GenerateKeyPair(publicKeyLength: 2048); var now = DateTimeOffset.UtcNow; var issueOptions = new IssueCertificateOptions(keyPair.Public) { NotAfter = now.AddSeconds(10), NotBefore = now.AddSeconds(-2), SubjectName = new X509Name("CN=NuGet Test Expired Certificate") }; var bcCertificate = ca.IssueCertificate(issueOptions); using (testServer.RegisterResponder(timestampService)) using (var certificate = new X509Certificate2(bcCertificate.GetEncoded())) using (var directory = TestDirectory.Create()) { certificate.PrivateKey = DotNetUtilities.ToRSA(keyPair.Private as RsaPrivateCrtKeyParameters); var packageContext = new SimpleTestPackageContext(); var signedPackagePath = await SignedArchiveTestUtility.CreateSignedAndTimeStampedPackageAsync( certificate, packageContext, directory, timestampService.Url); var waitDuration = (issueOptions.NotAfter - DateTimeOffset.UtcNow).Add(TimeSpan.FromSeconds(1)); // Wait for the certificate to expire. Trust of the signature will require a valid timestamp. if (waitDuration > TimeSpan.Zero) { await Task.Delay(waitDuration); } Assert.True(DateTime.UtcNow > issueOptions.NotAfter); var verifier = new PackageSignatureVerifier(_trustProviders, SignedPackageVerifierSettings.VerifyCommandDefaultPolicy); using (var packageReader = new PackageArchiveReader(signedPackagePath)) { var results = await verifier.VerifySignaturesAsync(packageReader, CancellationToken.None); var result = results.Results.Single(); Assert.False(results.Valid); Assert.Equal(SignatureVerificationStatus.Untrusted, result.Trust); Assert.Equal(1, result.Issues.Count(issue => issue.Level == LogLevel.Error)); Assert.Equal(0, result.Issues.Count(issue => issue.Level == LogLevel.Warning)); Assert.Contains(result.Issues, issue => issue.Code == NuGetLogCode.NU3011 && issue.Level == LogLevel.Error && issue.Message == "The primary signature validity period has expired."); } } }
public async Task GetPackageSpecsAsync_ReadSettingsWithFullPaths(string restorePackagesPath, string sources, string fallbackFolders) { // Arrange using (var testDirectory = TestDirectory.Create()) { var projectAdapter = CreateProjectAdapter(testDirectory); Mock.Get(projectAdapter) .SetupGet(x => x.RestorePackagesPath) .Returns(restorePackagesPath); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreSources) .Returns(sources); Mock.Get(projectAdapter) .SetupGet(x => x.RestoreFallbackFolders) .Returns(fallbackFolders); var projectServices = new TestProjectSystemServices(); var testProject = new LegacyPackageReferenceProject( projectAdapter, Guid.NewGuid().ToString(), projectServices, _threadingService); var settings = NullSettings.Instance; var testDependencyGraphCacheContext = new DependencyGraphCacheContext(NullLogger.Instance, settings); await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync(); // Act var packageSpecs = await testProject.GetPackageSpecsAsync(testDependencyGraphCacheContext); // Assert Assert.NotNull(packageSpecs); var actualRestoreSpec = packageSpecs.Single(); SpecValidationUtility.ValidateProjectSpec(actualRestoreSpec); // Assert packagespath Assert.Equal(restorePackagesPath != null ? restorePackagesPath : SettingsUtility.GetGlobalPackagesFolder(settings), actualRestoreSpec.RestoreMetadata.PackagesPath); // assert sources var specSources = actualRestoreSpec.RestoreMetadata.Sources.Select(e => e.Source); var expectedSources = sources != null?MSBuildStringUtility.Split(sources) : SettingsUtility.GetEnabledSources(settings).Select(e => e.Source); Assert.True(Enumerable.SequenceEqual(expectedSources.OrderBy(t => t), specSources.OrderBy(t => t))); // assert fallbackfolders var specFallback = actualRestoreSpec.RestoreMetadata.FallbackFolders; var expectedFolders = fallbackFolders != null?MSBuildStringUtility.Split(fallbackFolders) : SettingsUtility.GetFallbackPackageFolders(settings); Assert.True(Enumerable.SequenceEqual(expectedFolders.OrderBy(t => t), specFallback.OrderBy(t => t))); // Verify Mock.Get(projectAdapter) .Verify(x => x.RestorePackagesPath, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreSources, Times.Once); Mock.Get(projectAdapter) .Verify(x => x.RestoreFallbackFolders, Times.Once); } }
public async Task LocalDependencyInfoResource_ResolvePackagesNearestDependencyGroup() { using (var root = TestDirectory.Create()) { // Arrange var testLogger = new TestLogger(); var packageA = new SimpleTestPackageContext() { Id = "a", Version = "1.0", Nuspec = XDocument.Parse($@"<?xml version=""1.0"" encoding=""utf-8""?> <package> <metadata> <id>a</id> <version>1.0</version> <title /> <dependencies> <group> <dependency id=""b"" version=""1.0"" /> </group> <group targetFramework=""net46""> <dependency id=""x"" /> </group> <group targetFramework=""net461""> </group> </dependencies> </metadata> </package>") }; var packageContexts = new SimpleTestPackageContext[] { packageA }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var source = Repository.Factory.GetCoreV3(root); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalDependencyInfoResource(localResource, source); // Act var resultNet462 = (await resource.ResolvePackages( "a", NuGetFramework.Parse("net462"), NullSourceCacheContext.Instance, testLogger, CancellationToken.None)).Single(); var resultNet46 = (await resource.ResolvePackages( "a", NuGetFramework.Parse("net46"), NullSourceCacheContext.Instance, testLogger, CancellationToken.None)).Single(); var resultWin8 = (await resource.ResolvePackages( "a", NuGetFramework.Parse("win8"), NullSourceCacheContext.Instance, testLogger, CancellationToken.None)).Single(); // Assert Assert.Equal(0, resultNet462.Dependencies.Count()); Assert.Equal(1, resultNet46.Dependencies.Count()); Assert.Equal(1, resultWin8.Dependencies.Count()); Assert.Equal("x", resultNet46.Dependencies.Single().Id); Assert.Equal(VersionRange.All, resultNet46.Dependencies.Single().VersionRange); Assert.Equal("b", resultWin8.Dependencies.Single().Id); Assert.Equal(VersionRange.Parse("1.0"), resultWin8.Dependencies.Single().VersionRange); } }
public async Task ProjectResolution_MSBuildProjectDoesNotResolveByDirectory() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""dependencies"": { ""project2"": ""1.0.0-*"" }, ""frameworks"": { ""net45"": { } } }"; var project2Json = @" { ""version"": ""1.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; var globalJson = @" { ""projects"": [ ""projects"" ] }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); packagesDir.Create(); packageSource.Create(); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson); var project1CSProjPath = Path.Combine(project1.FullName, "project1.csproj"); File.WriteAllText(project1CSProjPath, string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1).EnsureProjectJsonRestoreMetadata(); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2).EnsureProjectJsonRestoreMetadata(); var logger = new TestLogger(); var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); request.ExternalProjects.Add( new ExternalProjectReference("project1", spec1, project1CSProjPath, new string[] { })); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); var lockFile = result.LockFile; await result.CommitAsync(logger, CancellationToken.None); // Assert Assert.False(result.Success); Assert.Equal(1, result.GetAllUnresolved().Count); Assert.Equal("project2", result.GetAllUnresolved().Single().Name); } }
public async Task GetInstalledVersion_WithAssetsFile_ChangingPackageSpec_ReturnsVersionsFromAssetsSpecs() { using (var testDirectory = TestDirectory.Create()) { // Setup var projectName = "project1"; var projectFullPath = Path.Combine(testDirectory.Path, projectName + ".csproj"); // Project var projectCache = new ProjectSystemCache(); IVsProjectAdapter projectAdapter = (new Mock <IVsProjectAdapter>()).Object; var project = CreateNetCorePackageReferenceProject(projectName, projectFullPath, projectCache); var projectNames = GetTestProjectNames(projectFullPath, projectName); var packageSpec = GetPackageSpec(projectName, projectFullPath, "[2.0.0, )"); // Restore info var projectRestoreInfo = ProjectJsonTestHelpers.GetDGSpecFromPackageSpecs(packageSpec); projectCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, new List <IAssetsLogMessage>()); projectCache.AddProject(projectNames, projectAdapter, project).Should().BeTrue(); // Package directories var sources = new List <PackageSource>(); var packagesDir = new DirectoryInfo(Path.Combine(testDirectory, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(testDirectory, "packageSource")); packagesDir.Create(); packageSource.Create(); sources.Add(new PackageSource(packageSource.FullName)); var logger = new TestLogger(); var request = new TestRestoreRequest(packageSpec, sources, packagesDir.FullName, logger) { LockFilePath = Path.Combine(testDirectory, "project.assets.json") }; await SimpleTestPackageUtility.CreateFullPackageAsync(packageSource.FullName, "packageA", "2.0.0"); await SimpleTestPackageUtility.CreateFullPackageAsync(packageSource.FullName, "packageA", "3.0.0"); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var packages = await project.GetInstalledPackagesAsync(CancellationToken.None); // Asert Assert.True(result.Success); packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("2.0.0")))); // Setup packageSpec = GetPackageSpec(projectName, projectFullPath, "[3.0.0, )"); // Restore info projectRestoreInfo = ProjectJsonTestHelpers.GetDGSpecFromPackageSpecs(packageSpec); projectCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, new List <IAssetsLogMessage>()); projectCache.AddProject(projectNames, projectAdapter, project).Should().BeTrue(); request = new TestRestoreRequest(packageSpec, sources, packagesDir.FullName, logger) { LockFilePath = Path.Combine(testDirectory, "project.assets.json") }; // Act command = new RestoreCommand(request); result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); packages = await project.GetInstalledPackagesAsync(CancellationToken.None); // Asert Assert.True(result.Success); packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("3.0.0")))); } }
public async Task ProjectResolution_ExternalReferenceWithNoProjectJson() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); packagesDir.Create(); packageSource.Create(); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); var msbuidPath1 = Path.Combine(project2.FullName, "project1.xproj"); var msbuidPath2 = Path.Combine(project2.FullName, "project2.csproj"); File.WriteAllText(msbuidPath1, string.Empty); File.WriteAllText(msbuidPath2, string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1).EnsureProjectJsonRestoreMetadata(); var logger = new TestLogger(); var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); request.ExternalProjects.Add(new ExternalProjectReference( "project1", spec1, msbuidPath1, new string[] { "project2" })); request.ExternalProjects.Add(new ExternalProjectReference( "project2", null, msbuidPath2, new string[] { })); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); var lockFile = result.LockFile; await result.CommitAsync(logger, CancellationToken.None); var targetLib = lockFile.Targets.Single().Libraries.Single(); // Assert Assert.True(result.Success); // External projects that did not provide a framework should leave the framework property out Assert.Null(targetLib.Framework); } }
public async Task ProjectResolution_HigherVersionForProjectReferences() { // Arrange var project1Json = @" { ""version"": ""1.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; var project2Json = @" { ""version"": ""2.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); packagesDir.Create(); packageSource.Create(); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var logger = new TestLogger(); var restoreContext = new RestoreArgs() { Sources = new List <string>() { packageSource.FullName }, GlobalPackagesFolder = packagesDir.FullName, Log = logger, CacheContext = new SourceCacheContext() }; // Modify specs for netcore spec2 = spec2.WithTestRestoreMetadata(); spec1 = spec1.WithTestRestoreMetadata().WithTestProjectReference(spec2); var request = await ProjectTestHelpers.GetRequestAsync(restoreContext, spec1, spec2); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); var lockFile = result.LockFile; await result.CommitAsync(logger, CancellationToken.None); // Assert Assert.True(result.Success); Assert.Equal(0, result.GetAllUnresolved().Count); Assert.Equal(0, logger.Messages.Where(s => s.IndexOf("Dependency specified was") > -1).Count()); } }
public async Task ProjectResolution_ProjectReferenceWithInCompatibleTFMNoRange() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; var project2Json = @" { ""version"": ""2.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net46"": { } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); packagesDir.Create(); packageSource.Create(); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var logger = new TestLogger(); var restoreContext = new RestoreArgs() { Sources = new List <string>() { packageSource.FullName }, GlobalPackagesFolder = packagesDir.FullName, Log = logger, CacheContext = new SourceCacheContext() }; // Modify specs for netcore spec2 = spec2.WithTestRestoreMetadata(); spec1 = spec1.WithTestRestoreMetadata().WithTestProjectReference(spec2); var request = await ProjectTestHelpers.GetRequestAsync(restoreContext, spec1, spec2); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); var lockFile = result.LockFile; await result.CommitAsync(logger, CancellationToken.None); var issue = result.CompatibilityCheckResults.SelectMany(ccr => ccr.Issues).Single(); // Assert Assert.False(result.Success); Assert.Equal(0, result.GetAllUnresolved().Count); Assert.Equal("Project project2 is not compatible with net45 (.NETFramework,Version=v4.5). Project project2 supports: net46 (.NETFramework,Version=v4.6)", issue.Format()); Assert.Equal(1, logger.ErrorMessages.Count()); Assert.Contains("Project project2 is not compatible with net45 (.NETFramework,Version=v4.5). Project project2 supports: net46 (.NETFramework,Version=v4.6)", logger.ErrorMessages.Last()); } }
public async Task ProjectResolution_ProjectFrameworkAssemblyReferences() { // Arrange var project1Json = @" { ""version"": ""1.0.0-*"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; var project2Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { ""frameworkAssemblies"": { ""ReferenceA"": """", ""ReferenceB"": """", }, } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); packagesDir.Create(); packageSource.Create(); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var logger = new TestLogger(); var restoreContext = new RestoreArgs() { Sources = new List <string>() { packageSource.FullName }, GlobalPackagesFolder = packagesDir.FullName, Log = logger, CacheContext = new SourceCacheContext() }; // Modify specs for netcore spec2 = spec2.WithTestRestoreMetadata(); spec1 = spec1.WithTestRestoreMetadata().WithTestProjectReference(spec2); var request = await ProjectTestHelpers.GetRequestAsync(restoreContext, spec1, spec2); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); var lockFile = result.LockFile; await result.CommitAsync(logger, CancellationToken.None); var target = result.LockFile.GetTarget(NuGetFramework.Parse("net45"), null); var project2Lib = target.Libraries.Where(lib => lib.Name == "project2").Single(); var frameworkReferences = project2Lib.FrameworkAssemblies; // Assert Assert.True(result.Success); Assert.Equal(2, frameworkReferences.Count); Assert.Equal("ReferenceA", frameworkReferences[0]); Assert.Equal("ReferenceB", frameworkReferences[1]); } }
[InlineData("{0}push")] // delete package endpoint public void DeleteCommand_WithApiKeyFromConfig(string configKeyFormatString) { // Arrange Util.ClearWebCache(); var testApiKey = Guid.NewGuid().ToString(); using (var testFolder = TestDirectory.Create()) { using (var server = new MockServer()) { // Server setup var indexJson = Util.CreateIndexJson(); Util.AddFlatContainerResource(indexJson, server); Util.AddPublishResource(indexJson, server); server.Get.Add("/index.json", r => { return(new Action <HttpListenerResponse>(response => { response.StatusCode = 200; response.ContentType = "text/javascript"; MockServer.SetResponseContent(response, indexJson.ToString()); })); }); server.Delete.Add("/push/testPackage1/1.1", r => { var h = r.Headers[ApiKeyHeader]; if (!string.Equals(h, testApiKey, StringComparison.OrdinalIgnoreCase)) { return(HttpStatusCode.Unauthorized); } return(HttpStatusCode.OK); }); server.Start(); var configKey = string.Format(configKeyFormatString, server.Uri); var config = $@"<?xml version='1.0' encoding='utf-8'?> <configuration> <packageSources> <add key='MockServer' value='{server.Uri}index.json' protocolVersion='3' /> </packageSources> <apikeys> <add key='{configKey}' value='{Configuration.EncryptionUtility.EncryptString(testApiKey)}' /> </apikeys> </configuration>"; var configFileName = Path.Combine(testFolder, "nuget.config"); File.WriteAllText(configFileName, config); // Act var args = new[] { "delete", "testPackage1", "1.1.0", "-Source", "MockServer", "-ConfigFile", configFileName, "-NonInteractive" }; var result = CommandRunner.Run( NuGetExePath, Directory.GetCurrentDirectory(), string.Join(" ", args), waitForExit: true); server.Stop(); // Assert Assert.True(0 == result.Item1, $"{result.Item2} {result.Item3}"); Assert.Contains("testPackage1 1.1.0 was deleted successfully.", result.Item2); } } }
public async Task LocalPackageMetadataResourceTests_GetMetadataPrerelease() { using (var root = TestDirectory.Create()) { // Arrange var testLogger = new TestLogger(); var packageX = new SimpleTestPackageContext() { Id = "x", Version = "1.0.0" }; var packageA1 = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageX } }; var packageA2 = new SimpleTestPackageContext() { Id = "a", Version = "2.0.0-preview.12.4+server.a", Dependencies = new List <SimpleTestPackageContext>() { packageX } }; var packageContexts = new SimpleTestPackageContext[] { packageA1, packageA2, packageX }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalPackageMetadataResource(localResource); // Act var results = (await resource.GetMetadataAsync( "A", includePrerelease: true, includeUnlisted: false, log: testLogger, token: CancellationToken.None)) .ToList(); var package = results.OrderByDescending(p => p.Identity.Version).First(); // Assert Assert.Equal("a", package.Identity.Id); Assert.Equal("2.0.0-preview.12.4+server.a", package.Identity.Version.ToFullString()); } }
public async Task GetInstallActionsAsync_WithPackagesConfigProject_WhenUpdatingPackage_ReturnsCorrectActions() { const string projectName = "a"; string projectId = Guid.NewGuid().ToString(); using (TestDirectory testDirectory = TestDirectory.Create()) { var packageV1 = new SimpleTestPackageContext(packageId: "b", version: "1.0.0"); var packageV2 = new SimpleTestPackageContext(packageV1.Id, version: "2.0.0"); string packageSourceDirectoryPath = Path.Combine(testDirectory, "packageSource"); await SimpleTestPackageUtility.CreateFolderFeedV3Async( packageSourceDirectoryPath, PackageSaveMode.Defaultv3, packageV1, packageV2); var packageSource = new PackageSource(packageSourceDirectoryPath); var packageSources = new List <PackageSource>() { packageSource }; Initialize(packageSources); string projectFullPath = Path.Combine(testDirectory.Path, $"{projectName}.csproj"); NuGetFramework targetFramework = NuGetFramework.Parse("net46"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext()); var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, testDirectory.Path, projectFullPath, projectId); _solutionManager.NuGetProjects.Add(project); string[] projectIds = new[] { projectId }; string[] packageSourceNames = new[] { packageSource.Name }; await PerformOperationAsync(async (projectManager) => { IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync( projectIds, packageV1.Identity, VersionConstraints.None, includePrelease: true, DependencyBehavior.Lowest, packageSourceNames, CancellationToken.None); Assert.NotEmpty(actions); Assert.Equal(1, actions.Count); ProjectAction action = actions[0]; Assert.Equal(packageV1.Identity, action.PackageIdentity); Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType); Assert.Equal(projectId, action.ProjectId); Assert.Empty(action.ImplicitActions); await projectManager.ExecuteActionsAsync(actions, CancellationToken.None); }); await PerformOperationAsync(async (projectManager) => { IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync( projectIds, packageV2.Identity, VersionConstraints.None, includePrelease: true, DependencyBehavior.Lowest, packageSourceNames, CancellationToken.None); Assert.NotEmpty(actions); Assert.Equal(2, actions.Count); ProjectAction action = actions[0]; Assert.Equal(packageV1.Identity, action.PackageIdentity); Assert.Equal(NuGetProjectActionType.Uninstall, action.ProjectActionType); Assert.Equal(projectId, action.ProjectId); action = actions[1]; Assert.Equal(packageV2.Identity, action.PackageIdentity); Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType); Assert.Equal(projectId, action.ProjectId); }); } }
public async Task RestoreRunner_RestoreWithRuntimeAsync() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); packagesDir.Create(); packageSource.Create(); project1.Create(); sources.Add(new PackageSource(packageSource.FullName)); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); spec1 = spec1.EnsureRestoreMetadata(); spec1.RestoreMetadata.Sources = new List <PackageSource> { new PackageSource(packageSource.FullName) }; spec1.RestoreMetadata.PackagesPath = packagesDir.FullName; var dgSpec = new DependencyGraphSpec(); dgSpec.AddProject(spec1); dgSpec.AddRestore("project1"); var logger = new TestLogger(); var lockPath1 = Path.Combine(project1.FullName, "project.assets.json"); var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList(); var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { var restoreContext = new RestoreArgs() { CacheContext = cacheContext, DisableParallel = true, GlobalPackagesFolder = spec1.RestoreMetadata.PackagesPath, Sources = new List <string>() { packageSource.FullName }, Log = logger, CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)), PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>() { new DependencyGraphSpecRequestProvider(providerCache, dgSpec) } }; restoreContext.Runtimes.Add("linux-x86"); // Act var summaries = await RestoreRunner.RunAsync(restoreContext); var success = summaries.All(s => s.Success); var lockFormat = new LockFileFormat(); var lockFile = lockFormat.Read(lockPath1); // Assert Assert.True(success, "Failed: " + string.Join(Environment.NewLine, logger.Messages)); Assert.True(lockFile.Targets.Any(graph => graph.RuntimeIdentifier == "linux-x86")); } } }
public async Task GetUpdateActionsAsync_WithPackageReferenceProject_WhenUpdatingPackage_ReturnsCorrectActions() { const string projectName = "a"; string projectId = Guid.NewGuid().ToString(); var projectSystemCache = new ProjectSystemCache(); using (TestDirectory testDirectory = TestDirectory.Create()) { var packageV1 = new SimpleTestPackageContext(packageId: "b", version: "1.0.0"); var packageV2 = new SimpleTestPackageContext(packageV1.Id, version: "2.0.0"); string packageSourceDirectoryPath = Path.Combine(testDirectory, "packageSource"); await SimpleTestPackageUtility.CreateFolderFeedV3Async( packageSourceDirectoryPath, PackageSaveMode.Defaultv3, packageV1, packageV2); var packageSource = new PackageSource(packageSourceDirectoryPath); var packageSources = new List <PackageSource>() { packageSource }; Initialize(packageSources); var unconfiguredProject = new Mock <UnconfiguredProject>(); var configuredProject = new Mock <ConfiguredProject>(); var projectServices = new Mock <ConfiguredProjectServices>(); var packageReferencesService = new Mock <IPackageReferencesService>(); var result = new Mock <IUnresolvedPackageReference>(); unconfiguredProject.Setup(x => x.GetSuggestedConfiguredProjectAsync()) .ReturnsAsync(configuredProject.Object); configuredProject.SetupGet(x => x.Services) .Returns(projectServices.Object); projectServices.SetupGet(x => x.PackageReferences) .Returns(packageReferencesService.Object); packageReferencesService.Setup(x => x.AddAsync(It.IsNotNull <string>(), It.IsNotNull <string>())) .ReturnsAsync(new AddReferenceResult <IUnresolvedPackageReference>(result.Object, added: true)); var nuGetProjectServices = new Mock <INuGetProjectServices>(); nuGetProjectServices.SetupGet(x => x.ScriptService) .Returns(Mock.Of <IProjectScriptHostService>()); PackageSpec packageSpec = ProjectTestHelpers.GetPackageSpec(projectName, testDirectory); var projectFullPath = packageSpec.RestoreMetadata.ProjectPath; var project = new CpsPackageReferenceProject( projectName: projectName, projectUniqueName: projectFullPath, projectFullPath: projectFullPath, projectSystemCache, unconfiguredProject.Object, nuGetProjectServices.Object, projectId); DependencyGraphSpec projectRestoreInfo = ProjectTestHelpers.GetDGSpecFromPackageSpecs(packageSpec); projectRestoreInfo.AddProject(packageSpec); var projectNames = new ProjectNames( fullName: projectFullPath, uniqueName: projectFullPath, shortName: projectName, customUniqueName: projectName, projectId: projectId); projectSystemCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, Array.Empty <IAssetsLogMessage>()); _solutionManager.NuGetProjects.Add(project); string[] projectIds = new[] { projectId }; string[] packageSourceNames = new[] { packageSource.Name }; await PerformOperationAsync(async (projectManager) => { IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync( projectIds, packageV1.Identity, VersionConstraints.None, includePrelease: true, DependencyBehavior.Lowest, packageSourceNames, CancellationToken.None); Assert.NotEmpty(actions); Assert.Equal(1, actions.Count); ProjectAction action = actions[0]; Assert.Equal(packageV1.Identity, action.PackageIdentity); Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType); Assert.Equal(projectId, action.ProjectId); Assert.Equal(1, action.ImplicitActions.Count); ImplicitProjectAction implicitAction = action.ImplicitActions[0]; Assert.Equal(packageV1.Identity, implicitAction.PackageIdentity); Assert.Equal(NuGetProjectActionType.Install, implicitAction.ProjectActionType); await projectManager.ExecuteActionsAsync(actions, CancellationToken.None); AddPackageDependency(projectSystemCache, projectNames, packageSpec, packageV1); }); await PerformOperationAsync(async (projectManager) => { IReadOnlyList <ProjectAction> actions = await projectManager.GetUpdateActionsAsync( projectIds, new[] { packageV2.Identity }, VersionConstraints.None, includePrelease: true, DependencyBehavior.Lowest, packageSourceNames, CancellationToken.None); Assert.NotEmpty(actions); Assert.Equal(1, actions.Count); ProjectAction action = actions[0]; Assert.Equal(packageV2.Identity, action.PackageIdentity); Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType); Assert.Equal(projectId, action.ProjectId); Assert.Equal(2, action.ImplicitActions.Count); ImplicitProjectAction implicitAction = action.ImplicitActions[0]; Assert.Equal(packageV1.Identity, implicitAction.PackageIdentity); Assert.Equal(NuGetProjectActionType.Uninstall, implicitAction.ProjectActionType); implicitAction = action.ImplicitActions[1]; Assert.Equal(packageV2.Identity, implicitAction.PackageIdentity); Assert.Equal(NuGetProjectActionType.Install, implicitAction.ProjectActionType); }); } }
internal PluginResourceProviderPositiveTest( string pluginFilePath, PluginFileState pluginFileState, IEnumerable <PositiveTestExpectation> expectations) { _expectations = expectations; _pluginFilePath = pluginFilePath; _reader = new Mock <IEnvironmentVariableReader>(MockBehavior.Strict); _reader.Setup(x => x.GetEnvironmentVariable( It.Is <string>(value => value == EnvironmentVariableConstants.PluginPaths))) .Returns(pluginFilePath); _reader.Setup(x => x.GetEnvironmentVariable( It.Is <string>(value => value == EnvironmentVariableConstants.DesktopPluginPaths))) .Returns((string)null); _reader.Setup(x => x.GetEnvironmentVariable( It.Is <string>(value => value == EnvironmentVariableConstants.CorePluginPaths))) .Returns((string)null); _reader.Setup(x => x.GetEnvironmentVariable( It.Is <string>(value => value == EnvironmentVariableConstants.RequestTimeout))) .Returns("RequestTimeout"); _reader.Setup(x => x.GetEnvironmentVariable( It.Is <string>(value => value == EnvironmentVariableConstants.IdleTimeout))) .Returns("IdleTimeout"); _reader.Setup(x => x.GetEnvironmentVariable( It.Is <string>(value => value == EnvironmentVariableConstants.HandshakeTimeout))) .Returns("HandshakeTimeout"); _pluginDiscoverer = new Mock <IPluginDiscoverer>(MockBehavior.Strict); _pluginDiscoverer.Setup(x => x.Dispose()); _pluginDiscoverer.Setup(x => x.DiscoverAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(new[] { new PluginDiscoveryResult(new PluginFile(pluginFilePath, new Lazy <PluginFileState>(() => pluginFileState))) }); _connection = new Mock <IConnection>(MockBehavior.Strict); _connection.Setup(x => x.Dispose()); _connection.SetupGet(x => x.Options) .Returns(ConnectionOptions.CreateDefault()); _connection.SetupGet(x => x.ProtocolVersion) .Returns(ProtocolConstants.Version100); _connection.Setup(x => x.SendRequestAndReceiveResponseAsync <MonitorNuGetProcessExitRequest, MonitorNuGetProcessExitResponse>( It.Is <MessageMethod>(m => m == MessageMethod.MonitorNuGetProcessExit), It.IsNotNull <MonitorNuGetProcessExitRequest>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new MonitorNuGetProcessExitResponse(MessageResponseCode.Success)); _connection.Setup(x => x.SendRequestAndReceiveResponseAsync <InitializeRequest, InitializeResponse>( It.Is <MessageMethod>(m => m == MessageMethod.Initialize), It.IsNotNull <InitializeRequest>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new InitializeResponse(MessageResponseCode.Success)); foreach (var expectation in expectations) { _connection.Setup(x => x.SendRequestAndReceiveResponseAsync <GetOperationClaimsRequest, GetOperationClaimsResponse>( It.Is <MessageMethod>(m => m == MessageMethod.GetOperationClaims), It.Is <GetOperationClaimsRequest>( g => g.PackageSourceRepository == expectation.SourceRepository.PackageSource.Source), It.IsAny <CancellationToken>())) .ReturnsAsync(new GetOperationClaimsResponse(expectation.OperationClaims.ToArray())); if (expectation.OperationClaims.Any()) { _connection.Setup(x => x.SendRequestAndReceiveResponseAsync <SetCredentialsRequest, SetCredentialsResponse>( It.Is <MessageMethod>(m => m == MessageMethod.SetCredentials), It.Is <SetCredentialsRequest>( g => g.PackageSourceRepository == expectation.SourceRepository.PackageSource.Source), It.IsAny <CancellationToken>())) .ReturnsAsync(new SetCredentialsResponse(MessageResponseCode.Success)); } } _plugin = new Mock <IPlugin>(MockBehavior.Strict); _plugin.Setup(x => x.Dispose()); _plugin.SetupGet(x => x.Connection) .Returns(_connection.Object); _plugin.SetupGet(x => x.Id) .Returns("id"); _factory = new Mock <IPluginFactory>(MockBehavior.Strict); _factory.Setup(x => x.Dispose()); _factory.Setup(x => x.GetOrCreateAsync( It.Is <string>(p => p == pluginFilePath), It.IsNotNull <IEnumerable <string> >(), It.IsNotNull <IRequestHandlers>(), It.IsNotNull <ConnectionOptions>(), It.IsAny <CancellationToken>())) .ReturnsAsync(_plugin.Object); _testDirectory = TestDirectory.Create(); PluginManager = new PluginManager( _reader.Object, new Lazy <IPluginDiscoverer>(() => _pluginDiscoverer.Object), (TimeSpan idleTimeout) => _factory.Object, new Lazy <string>(() => _testDirectory.Path)); Provider = new PluginResourceProvider(PluginManager); }
public void NoOpRestoreResult_IsLazy() { const string lockFileContent = @"{ ""version"": 1, ""targets"": { "".NETPlatform,Version=v5.0"": { ""System.Runtime/4.0.10-beta-23008"": { ""compile"": { ""ref/dotnet/System.Runtime.dll"": {} } } } }, ""libraries"": { ""System.Runtime/4.0.10-beta-23008"": { ""sha512"": ""JkGp8sCzxxRY1GS+p1SEk8WcaT8pu++/5b94ar2i/RaUN/OzkcGP/6OLFUxUf1uar75pUvotpiMawVt1dCEUVA=="", ""type"": ""Package"", ""files"": [ ""_rels/.rels"", ""System.Runtime.nuspec"", ""License.rtf"", ""ref/dotnet/System.Runtime.dll"", ""ref/net451/_._"", ""lib/net451/_._"", ""ref/win81/_._"", ""lib/win81/_._"", ""ref/netcore50/System.Runtime.dll"", ""package/services/metadata/core-properties/cdec43993f064447a2d882cbfd022539.psmdcp"", ""[Content_Types].xml"" ] } }, ""projectFileDependencyGroups"": { """": [ ""System.Runtime >= 4.0.10-beta-*"" ], "".NETPlatform,Version=v5.0"": [] } } "; // Arrange using (var td = TestDirectory.Create()) { var path = Path.Combine(td, "project.lock.json"); File.WriteAllText(path, lockFileContent); var logger = new TestLogger(); var result = new NoOpRestoreResult( success: true, lockFilePath: path, new Lazy <LockFile>(() => LockFileUtilities.GetLockFile(path, logger)), cacheFile: new CacheFile("NotSoRandomString"), cacheFilePath: null, projectStyle: ProjectStyle.Unknown, elapsedTime: TimeSpan.MinValue); // Act var actual = result.LockFile; // Assert Assert.Equal(1, actual.Libraries.Count); Assert.Equal("System.Runtime", actual.Libraries[0].Name); } }
public async Task LocalDependencyInfoResource_Basic() { using (var root = TestDirectory.Create()) { // Arrange var testLogger = new TestLogger(); var packageX = new SimpleTestPackageContext() { Id = "x", Version = "1.0.0" }; var packageD = new SimpleTestPackageContext() { Id = "d", Version = "1.0.0" }; var packageD2 = new SimpleTestPackageContext() { Id = "d", Version = "2.0.0" }; var packageD3 = new SimpleTestPackageContext() { Id = "d", Version = "0.1.0" }; var packageC = new SimpleTestPackageContext() { Id = "c", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageD } }; var packageB = new SimpleTestPackageContext() { Id = "b", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageD2 } }; var packageA = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageC, packageB } }; var packageContexts = new SimpleTestPackageContext[] { packageA, packageB, packageC, packageD, packageD2, packageD3, packageX }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var source = Repository.Factory.GetCoreV3(root); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalDependencyInfoResource(localResource, source); // Act var resultsA = (await resource.ResolvePackages("a", NuGetFramework.Parse("net46"), NullSourceCacheContext.Instance, testLogger, CancellationToken.None)).ToList(); var resultsX = (await resource.ResolvePackages("x", NuGetFramework.Parse("net46"), NullSourceCacheContext.Instance, testLogger, CancellationToken.None)).ToList(); var resultsY = (await resource.ResolvePackages("y", NuGetFramework.Parse("net46"), NullSourceCacheContext.Instance, testLogger, CancellationToken.None)).ToList(); // Assert Assert.Equal(1, resultsA.Count); Assert.Equal(packageA.Identity, resultsA[0], PackageIdentity.Comparer); Assert.True(resultsA[0].Listed); Assert.Contains("a.1.0.0.nupkg", resultsA[0].DownloadUri.LocalPath); Assert.Equal(2, resultsA[0].Dependencies.Count()); Assert.Equal("c", resultsA[0].Dependencies.First().Id); Assert.Equal("[1.0.0, )", resultsA[0].Dependencies.First().VersionRange.ToNormalizedString()); Assert.Equal("b", resultsA[0].Dependencies.Skip(1).First().Id); Assert.Equal("[1.0.0, )", resultsA[0].Dependencies.Skip(1).First().VersionRange.ToNormalizedString()); // no dependencies Assert.Equal(1, resultsX.Count); Assert.Equal(packageX.Identity, resultsX[0], PackageIdentity.Comparer); Assert.True(resultsX[0].Listed); Assert.Contains("x.1.0.0.nupkg", resultsX[0].DownloadUri.LocalPath); Assert.Equal(0, resultsX[0].Dependencies.Count()); // not found Assert.Equal(0, resultsY.Count); } }
public async Task GetInstalledSatelliteFilesAsync_ReturnsInstalledSatelliteFiles() { 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( testDirectory.Path, packageStream, packagePathResolver, new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, clientPolicyContext : null, logger : NullLogger.Instance), CancellationToken.None); } // Install satellite package using (var packageReader = new PackageArchiveReader(File.OpenRead(satellitePackageInfo.FullName))) using (var packageStream = File.OpenRead(satellitePackageInfo.FullName)) { await PackageExtractor.ExtractPackageAsync( testDirectory.Path, packageReader, packageStream, packagePathResolver, new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, clientPolicyContext : null, logger : 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.ToArray(); var packageDirectoryName = $"{packageIdentity.Id}.{packageIdentity.Version.ToNormalizedString()}"; Assert.Equal(Path.Combine(testDirectory.Path, packageDirectoryName), runtimePackageDirectory); Assert.Equal(1, satelliteFiles.Length); Assert.Equal(Path.Combine(testDirectory.Path, packageDirectoryName, "lib/net45/fr/A.resources.dll"), satelliteFiles[0].FileFullPath); } } }
public NuGetUITests(GlobalServiceProvider sp) { sp.Reset(); _testDirectory = TestDirectory.Create(); }
public async Task RestoreRunner_BasicRestore_VerifyFailureWritesFilesAsync() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { ""dependencies"": { ""x"": ""1.0.0"" } } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); packagesDir.Create(); packageSource.Create(); project1.Create(); sources.Add(new PackageSource(packageSource.FullName)); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); spec1 = spec1.EnsureRestoreMetadata(); spec1.RestoreMetadata.Sources = new List <PackageSource> { new PackageSource(packageSource.FullName) }; spec1.RestoreMetadata.PackagesPath = packagesDir.FullName; var dgFile = new DependencyGraphSpec(); dgFile.AddProject(spec1); dgFile.AddRestore("project1"); var logger = new TestLogger(); var lockPath = Path.Combine(project1.FullName, "project.assets.json"); var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList(); var packageX = new SimpleTestPackageContext() { Id = "x", Version = "1.0.0" }; packageX.AddFile("build/net45/x.targets"); var packageY = new SimpleTestPackageContext("y"); packageX.Dependencies.Add(packageY); var yPath = await SimpleTestPackageUtility.CreateFullPackageAsync(packageSource.FullName, packageY); await SimpleTestPackageUtility.CreateFullPackageAsync(packageSource.FullName, packageX); // y does not exist yPath.Delete(); var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { var restoreContext = new RestoreArgs() { CacheContext = cacheContext, DisableParallel = true, GlobalPackagesFolder = packagesDir.FullName, Sources = new List <string>() { packageSource.FullName }, Log = logger, CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)), PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>() { new DependencyGraphSpecRequestProvider(providerCache, dgFile) } }; var targetsPath = Path.Combine(project1.FullName, "project1.csproj.nuget.g.targets"); var propsPath = Path.Combine(project1.FullName, "project1.nuget.props"); // Act var summaries = await RestoreRunner.RunAsync(restoreContext); var summary = summaries.Single(); var targets = TargetsUtility.GetMSBuildPackageImports(targetsPath); // Assert Assert.False(summary.Success); Assert.True(File.Exists(lockPath), lockPath); Assert.True(File.Exists(targetsPath)); Assert.False(File.Exists(propsPath)); Assert.Equal(1, targets.Count); } } }
public PreinstalledRepositoryProviderTests() { _testDirectory = TestDirectory.Create(); }
public async Task RestoreRunner_BasicRestore_VerifyFailureWritesFiles_NETCoreAsync() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { ""dependencies"": { ""x"": ""1.0.0"" } } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); packagesDir.Create(); packageSource.Create(); project1.Create(); sources.Add(new PackageSource(packageSource.FullName)); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); spec1.RestoreMetadata = new ProjectRestoreMetadata { OutputPath = Path.Combine(project1.FullName, "obj"), ProjectStyle = ProjectStyle.PackageReference, ProjectName = "project1", ProjectPath = Path.Combine(project1.FullName, "project1.csproj") }; spec1.RestoreMetadata.ProjectUniqueName = spec1.RestoreMetadata.ProjectPath; spec1.RestoreMetadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"))); spec1.RestoreMetadata.OriginalTargetFrameworks.Add("net45"); spec1.FilePath = spec1.RestoreMetadata.ProjectPath; var dgSpec = new DependencyGraphSpec(); dgSpec.AddProject(spec1); dgSpec.AddRestore(spec1.RestoreMetadata.ProjectUniqueName); var logger = new TestLogger(); var assetsPath = Path.Combine(project1.FullName, "obj", "project.assets.json"); var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList(); var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { var restoreContext = new RestoreArgs() { CacheContext = cacheContext, DisableParallel = true, GlobalPackagesFolder = packagesDir.FullName, Sources = new List <string>() { packageSource.FullName }, Log = logger, CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)), PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>() { new DependencyGraphSpecRequestProvider(providerCache, dgSpec) } }; // Act var summaries = await RestoreRunner.RunAsync(restoreContext); var summary = summaries.Single(); // Assert Assert.False(summary.Success); Assert.True(File.Exists(assetsPath), assetsPath); Assert.True(File.Exists(Path.Combine(project1.FullName, "obj", "project1.csproj.nuget.g.props"))); Assert.True(File.Exists(Path.Combine(project1.FullName, "obj", "project1.csproj.nuget.g.targets"))); } } }
public void AddPkg_ArgParsing(string packageOption, string package, string versionOption, string version, string dgFileOption, string dgFilePath, string projectOption, string project, string frameworkOption, string frameworkString, string sourceOption, string sourceString, string packageDirectoryOption, string packageDirectory, string noRestoreSwitch, string interactiveSwitch) { // Arrange using (var testDirectory = TestDirectory.Create()) { var projectPath = Path.Combine(testDirectory, project); var frameworks = MSBuildStringUtility.Split(frameworkString); var sources = MSBuildStringUtility.Split(sourceString); File.Create(projectPath).Dispose(); var argList = new List <string>() { "add", packageOption, package, versionOption, version, dgFileOption, dgFilePath, projectOption, projectPath }; if (!string.IsNullOrEmpty(frameworkOption)) { foreach (var framework in frameworks) { argList.Add(frameworkOption); argList.Add(framework); } } if (!string.IsNullOrEmpty(sourceOption)) { foreach (var source in sources) { argList.Add(sourceOption); argList.Add(source); } } if (!string.IsNullOrEmpty(packageDirectoryOption)) { argList.Add(packageDirectoryOption); argList.Add(packageDirectory); } if (!string.IsNullOrEmpty(noRestoreSwitch)) { argList.Add(noRestoreSwitch); } if (!string.IsNullOrEmpty(interactiveSwitch)) { argList.Add(interactiveSwitch); } var logger = new TestCommandOutputLogger(); var testApp = new CommandLineApplication(); var mockCommandRunner = new Mock <IPackageReferenceCommandRunner>(); mockCommandRunner .Setup(m => m.ExecuteCommand(It.IsAny <PackageReferenceArgs>(), It.IsAny <MSBuildAPIUtility>())) .ReturnsAsync(0); testApp.Name = "dotnet nuget_test"; AddPackageReferenceCommand.Register(testApp, () => logger, () => mockCommandRunner.Object); // Act var result = testApp.Execute(argList.ToArray()); XPlatTestUtils.DisposeTemporaryFile(projectPath); // Assert mockCommandRunner.Verify(m => m.ExecuteCommand(It.Is <PackageReferenceArgs>(p => p.PackageDependency.Id == package && p.PackageDependency.VersionRange.OriginalString == version && p.ProjectPath == projectPath && p.DgFilePath == dgFilePath && p.NoRestore == !string.IsNullOrEmpty(noRestoreSwitch) && (string.IsNullOrEmpty(frameworkOption) || !string.IsNullOrEmpty(frameworkOption) && p.Frameworks.SequenceEqual(frameworks)) && (string.IsNullOrEmpty(sourceOption) || !string.IsNullOrEmpty(sourceOption) && p.Sources.SequenceEqual(MSBuildStringUtility.Split(sourceString))) && (string.IsNullOrEmpty(packageDirectoryOption) || !string.IsNullOrEmpty(packageDirectoryOption) && p.PackageDirectory == packageDirectory) && p.Interactive == !string.IsNullOrEmpty(interactiveSwitch)), It.IsAny <MSBuildAPIUtility>())); Assert.Equal(0, result); } }
public async Task RestoreRunner_BasicRestoreWithConfigFileAsync() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; var configFile = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <packageSources> <add key=""nuget.org"" value=""{0}"" /> </packageSources> </configuration> "; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); packagesDir.Create(); packageSource.Create(); project1.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(workingDir, "NuGet.Config"), string.Format(configFile, packageSource.FullName)); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var configPath = Path.Combine(workingDir, "NuGet.Config"); var dgFile = new DependencyGraphSpec(); spec1 = spec1.EnsureRestoreMetadata(); spec1.RestoreMetadata.ConfigFilePaths = new List <string> { configPath }; spec1.RestoreMetadata.Sources = new List <PackageSource> { new PackageSource(packageSource.FullName) }; spec1.RestoreMetadata.PackagesPath = packagesDir.FullName; dgFile.AddProject(spec1); dgFile.AddRestore("project1"); var logger = new TestLogger(); var lockPath = Path.Combine(project1.FullName, "project.assets.json"); var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { var restoreContext = new RestoreArgs() { CacheContext = cacheContext, DisableParallel = true, GlobalPackagesFolder = spec1.RestoreMetadata.PackagesPath, ConfigFile = configPath, Log = logger, CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(new List <PackageSource>())), PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider> { new DependencyGraphSpecRequestProvider(providerCache, dgFile) } }; // Act var summaries = await RestoreRunner.RunAsync(restoreContext); var summary = summaries.Single(); // Assert Assert.True(summary.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages)); Assert.Equal(1, summary.FeedsUsed.Count); Assert.True(File.Exists(lockPath), lockPath); } } }
public void GetPackageReferences_WhenDuplicatesOrMetadataSpecified_DuplicatesIgnoredAndMetadataReadCorrectly() { using (var testDirectory = TestDirectory.Create()) { var project = new MockMSBuildProject(testDirectory) { Items = new Dictionary <string, IList <IMSBuildItem> > { ["PackageReference"] = new List <IMSBuildItem> { new MSBuildItem("PackageA", new Dictionary <string, string> { ["Version"] = "1.1.1" }), new MSBuildItem("PackageA", new Dictionary <string, string> { ["Version"] = "2.0.0" }), new MSBuildItem("PackageB", new Dictionary <string, string> { ["Version"] = "1.2.3", ["IsImplicitlyDefined"] = bool.TrueString }), new MSBuildItem("PackageC", new Dictionary <string, string> { ["Version"] = "4.5.6", ["GeneratePathProperty"] = bool.TrueString }), new MSBuildItem("PackageD", new Dictionary <string, string> { ["Version"] = "1.2.3", ["IncludeAssets"] = $"{LibraryIncludeFlags.Build};{LibraryIncludeFlags.Analyzers}" }), new MSBuildItem("PackageE", new Dictionary <string, string> { ["Version"] = "1.2.3", ["PrivateAssets"] = $"{LibraryIncludeFlags.Runtime};{LibraryIncludeFlags.Compile}" }), new MSBuildItem("PackageF", new Dictionary <string, string> { ["Version"] = "1.2.3", ["ExcludeAssets"] = $"{LibraryIncludeFlags.Build};{LibraryIncludeFlags.Analyzers}" }), new MSBuildItem("PackageG", new Dictionary <string, string> { ["Version"] = "1.2.3", ["IncludeAssets"] = $"{LibraryIncludeFlags.Build};{LibraryIncludeFlags.Analyzers};{LibraryIncludeFlags.Compile}", ["ExcludeAssets"] = $"{LibraryIncludeFlags.Analyzers}" }), new MSBuildItem("PackageH", new Dictionary <string, string> { ["Version"] = "1.2.3", ["NoWarn"] = "NU1001;\tNU1006 ; NU3017 " }), new MSBuildItem("PackageI", new Dictionary <string, string> { ["Version"] = null }), new MSBuildItem("PackageJ", new Dictionary <string, string> { ["Version"] = "1.2.4", ["Aliases"] = "Core" }), } } }; var actual = MSBuildStaticGraphRestore.GetPackageReferences(project, false); actual.ShouldBeEquivalentTo(new List <LibraryDependency> { new LibraryDependency { LibraryRange = new LibraryRange("PackageA", VersionRange.Parse("1.1.1"), LibraryDependencyTarget.Package), }, new LibraryDependency { AutoReferenced = true, LibraryRange = new LibraryRange("PackageB", VersionRange.Parse("1.2.3"), LibraryDependencyTarget.Package), }, new LibraryDependency { GeneratePathProperty = true, LibraryRange = new LibraryRange("PackageC", VersionRange.Parse("4.5.6"), LibraryDependencyTarget.Package), }, new LibraryDependency { IncludeType = LibraryIncludeFlags.Build | LibraryIncludeFlags.Analyzers, LibraryRange = new LibraryRange("PackageD", VersionRange.Parse("1.2.3"), LibraryDependencyTarget.Package), }, new LibraryDependency { SuppressParent = LibraryIncludeFlags.Runtime | LibraryIncludeFlags.Compile, LibraryRange = new LibraryRange("PackageE", VersionRange.Parse("1.2.3"), LibraryDependencyTarget.Package), }, new LibraryDependency { IncludeType = LibraryIncludeFlags.Runtime | LibraryIncludeFlags.Compile | LibraryIncludeFlags.Native | LibraryIncludeFlags.ContentFiles | LibraryIncludeFlags.BuildTransitive, LibraryRange = new LibraryRange("PackageF", VersionRange.Parse("1.2.3"), LibraryDependencyTarget.Package), }, new LibraryDependency { IncludeType = LibraryIncludeFlags.Compile | LibraryIncludeFlags.Build, LibraryRange = new LibraryRange("PackageG", VersionRange.Parse("1.2.3"), LibraryDependencyTarget.Package), }, new LibraryDependency { LibraryRange = new LibraryRange("PackageH", VersionRange.Parse("1.2.3"), LibraryDependencyTarget.Package), NoWarn = new List <NuGetLogCode> { NuGetLogCode.NU1001, NuGetLogCode.NU1006, NuGetLogCode.NU3017 } }, new LibraryDependency { LibraryRange = new LibraryRange("PackageI", VersionRange.All, LibraryDependencyTarget.Package), }, new LibraryDependency { LibraryRange = new LibraryRange("PackageJ", VersionRange.Parse("1.2.4"), LibraryDependencyTarget.Package), Aliases = "Core" } }); } }
public async Task RestoreRunner_RestoreWithExternalFile_NetCoreOutputAsync() { // Arrange var sources = new List <PackageSource>(); var targetFrameworkInfo1 = new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse("net45") }; var frameworks1 = new[] { targetFrameworkInfo1 }; var targetFrameworkInfo2 = new TargetFrameworkInformation { FrameworkName = NuGetFramework.Parse("net45") }; var frameworks2 = new[] { targetFrameworkInfo2 }; // Create two net45 projects var spec1 = new PackageSpec(frameworks1) { RestoreMetadata = new ProjectRestoreMetadata { ProjectUniqueName = "project1", ProjectName = "project1", ProjectStyle = ProjectStyle.PackageReference } }; spec1.RestoreMetadata.OriginalTargetFrameworks.Add("net45"); var spec2 = new PackageSpec(frameworks2) { RestoreMetadata = new ProjectRestoreMetadata { ProjectUniqueName = "project2", ProjectName = "project2", ProjectStyle = ProjectStyle.PackageReference } }; spec2.RestoreMetadata.OriginalTargetFrameworks.Add("net45"); var specs = new[] { spec1, spec2 }; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); packagesDir.Create(); packageSource.Create(); project1.Create(); project2.Create(); sources.Add(new PackageSource(packageSource.FullName)); var projPath1 = Path.Combine(project1.FullName, "project1.csproj"); var projPath2 = Path.Combine(project2.FullName, "project2.csproj"); File.WriteAllText(projPath1, string.Empty); File.WriteAllText(projPath2, string.Empty); spec1.RestoreMetadata.ProjectPath = projPath1; spec1.FilePath = projPath1; spec1.Name = "project1"; spec2.RestoreMetadata.ProjectPath = projPath2; spec2.FilePath = projPath1; spec2.Name = "project2"; var logger = new TestLogger(); var objPath1 = Path.Combine(project1.FullName, "obj"); var objPath2 = Path.Combine(project2.FullName, "obj"); spec1.RestoreMetadata.OutputPath = objPath1; spec2.RestoreMetadata.OutputPath = objPath2; spec1.RestoreMetadata.OriginalTargetFrameworks.Add("net45"); spec2.RestoreMetadata.OriginalTargetFrameworks.Add("net45"); var lockPath1 = Path.Combine(objPath1, "project.assets.json"); var lockPath2 = Path.Combine(objPath2, "project.assets.json"); // Link projects spec1.TargetFrameworks.Single().Dependencies.Add(new LibraryDependency() { LibraryRange = new LibraryRange() { Name = "project2", TypeConstraint = LibraryDependencyTarget.ExternalProject } }); spec1.RestoreMetadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"))); spec1.RestoreMetadata.TargetFrameworks .Single() .ProjectReferences .Add(new ProjectRestoreReference() { ProjectPath = projPath2, ProjectUniqueName = "project2" }); // Create dg file var dgFile = new DependencyGraphSpec(); foreach (var spec in specs) { dgFile.AddRestore(spec.RestoreMetadata.ProjectName); dgFile.AddProject(spec); } var dgPath = Path.Combine(workingDir, "input.dg"); dgFile.Save(dgPath); var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList(); var providerCache = new RestoreCommandProvidersCache(); using (var cacheContext = new SourceCacheContext()) { var restoreContext = new RestoreArgs() { CacheContext = cacheContext, DisableParallel = true, GlobalPackagesFolder = packagesDir.FullName, Sources = new List <string>() { packageSource.FullName }, Inputs = new List <string>() { dgPath }, Log = logger, CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)), RequestProviders = new List <IRestoreRequestProvider>() { new DependencyGraphFileRequestProvider(providerCache) } }; // Act var summaries = await RestoreRunner.RunAsync(restoreContext); var success = summaries.All(s => s.Success); var lockFormat = new LockFileFormat(); var lockFile1 = lockFormat.Read(lockPath1); var project2Lib = lockFile1.Libraries.First(); // Assert Assert.True(success, "Failed: " + string.Join(Environment.NewLine, logger.Messages)); Assert.True(File.Exists(lockPath1), lockPath1); Assert.True(File.Exists(lockPath2), lockPath2); Assert.Equal("project2", project2Lib.Name); } } }
public void DeleteDirectory() { // Setup var fileSystem = new TestFileSystem(); var directory = new TestDirectory(fileSystem, "\\this\\is\\a\\directory"); directory.Create(); // Execute directory.Delete(); // Assert Assert.IsFalse(directory.Exists); }
public async Task LocalPackageMetadataResourceTests_VerifyAllFields() { using (var root = TestDirectory.Create()) { // Arrange var testLogger = new TestLogger(); var nuspec = XDocument.Parse($@"<?xml version=""1.0"" encoding=""utf-8""?> <package> <metadata> <id>a</id> <version>1.0.0-alpha.1.2+5</version> <title>myTitle</title> <authors>a,b,c</authors> <owners>a,b</owners> <description>package description</description> <releaseNotes>notes</releaseNotes> <summary>sum</summary> <language>en-us</language> <projectUrl>http://nuget.org/</projectUrl> <iconUrl>http://nuget.org/nuget.jpg</iconUrl> <licenseUrl>http://nuget.org/license.txt</licenseUrl> <requireLicenseAcceptance>true</requireLicenseAcceptance> <copyright>MIT</copyright> <tags>a b c</tags> <developmentDependency>true</developmentDependency> <dependencies> <group> <dependency id=""b"" version=""1.0"" /> </group> <group targetFramework=""net461""> </group> </dependencies> </metadata> </package>"); var packageA = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0-alpha.1.2+5", Nuspec = nuspec }; var packageA2 = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0-alpha.1.1" }; var packageContexts = new SimpleTestPackageContext[] { packageA, packageA2 }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalPackageMetadataResource(localResource); // Act var packages = (await resource.GetMetadataAsync( "A", includePrerelease: true, includeUnlisted: false, log: testLogger, token: CancellationToken.None)) .OrderByDescending(p => p.Identity.Version) .ToList(); var package = packages.First(); // Assert Assert.Equal(2, packages.Count); Assert.Equal("a,b,c", package.Authors); Assert.Equal(2, package.DependencySets.Count()); Assert.Equal("package description", package.Description); Assert.Equal(0, package.DownloadCount); Assert.Equal(new Uri("http://nuget.org/nuget.jpg"), package.IconUrl); Assert.Equal("1.0.0-alpha.1.2+5", package.Identity.Version.ToFullString()); Assert.Equal(new Uri("http://nuget.org/license.txt"), package.LicenseUrl); Assert.Equal("a,b", package.Owners); Assert.Equal(new Uri("http://nuget.org/"), package.ProjectUrl); Assert.NotNull(package.Published); Assert.Null(package.ReportAbuseUrl); Assert.True(package.RequireLicenseAcceptance); Assert.Equal("sum", package.Summary); Assert.Equal("a b c", package.Tags); Assert.Equal("myTitle", package.Title); } }