public async Task DependencyGraphRestoreUtility_NoopRestoreTest() { // Arrange var projectName = "testproj"; var logger = new TestLogger(); using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); var sources = new[] { Repository.Factory.GetVisualStudio(new PackageSource("https://www.nuget.org/api/v2/")) }; var targetFramework = NuGetFramework.Parse("net46"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext()); var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, rootFolder, projectFolder.FullName); var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance); var restoreContext = new DependencyGraphCacheContext(logger, NullSettings.Instance); var projects = new List <IDependencyGraphProject>() { project }; using (var solutionManager = new TestSolutionManager()) { solutionManager.NuGetProjects.Add(project); // Act await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, Guid.Empty, false, true, logger, CancellationToken.None); // Assert Assert.Equal(0, logger.Errors); Assert.Equal(0, logger.Warnings); } } }
public async Task RestorePackages( IEnumerable <BuildIntegratedNuGetProject> projects, CancellationToken cancellationToken) { var spec = await MonoDevelopDependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, projects, context, cancellationToken); var now = DateTime.UtcNow; Action <SourceCacheContext> cacheContextModifier = c => c.MaxAge = now; bool forceRestore = false; bool isRestoreOriginalAction = true; var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, spec, context, new RestoreCommandProvidersCache(), cacheContextModifier, sourceRepositories, Guid.NewGuid(), forceRestore, isRestoreOriginalAction, context.Logger, cancellationToken); bool restoreFailed = false; int noOpRestoreCount = 0; foreach (RestoreSummary restoreSummary in restoreSummaries) { if (restoreSummary.Success && restoreSummary.NoOpRestore) { noOpRestoreCount++; } else if (!restoreSummary.Success) { restoreFailed = true; } } if (noOpRestoreCount == projects.Count()) { // Nothing to do. return; } if (restoreFailed) { logger.LogInformation(string.Empty); logger.LogSavedErrors(); throw new ApplicationException(GettextCatalog.GetString("Restore failed.")); } await OnProjectsRestored(projects); }
public async Task BuildIntegratedRestoreUtility_RestoreProjectNameProjectJson() { // Arrange var projectName = "testproj"; using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "testproj.project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); using (var solutionManager = new TestSolutionManager()) { solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger, NullSettings.Instance); // Act await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); // Assert Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "testproj.project.lock.json"))); Assert.True(testLogger.Errors == 0); Assert.False(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json"))); } } }
public async Task RestoreAsync_WithProgressReporter_WhenFilesAreWriten_ProgressIsReported() { // Arrange using var pathContext = new SimpleTestPathContext(); var settings = Settings.LoadDefaultSettings(pathContext.SolutionRoot); var packageSpec = ProjectTestHelpers.GetPackageSpec(settings, projectName: "projectName", rootPath: pathContext.SolutionRoot); var progressReporter = new Mock <IRestoreProgressReporter>(); // Act IReadOnlyList <RestoreSummary> result = await DependencyGraphRestoreUtility.RestoreAsync( ProjectTestHelpers.GetDGSpecFromPackageSpecs(packageSpec), new DependencyGraphCacheContext(), new RestoreCommandProvidersCache(), cacheContextModifier : _ => { }, sources : new SourceRepository[0], parentId : Guid.Empty, forceRestore : false, isRestoreOriginalAction : true, additionalMessages : null, progressReporter : progressReporter.Object, new TestLogger(), CancellationToken.None); // Assert result.Should().HaveCount(1); RestoreSummary restoreSummary = result[0]; restoreSummary.Success.Should().BeTrue(); restoreSummary.NoOpRestore.Should().BeFalse(); var assetsFilePath = Path.Combine(packageSpec.RestoreMetadata.OutputPath, LockFileFormat.AssetsFileName); File.Exists(assetsFilePath).Should().BeTrue(because: $"{assetsFilePath}"); var propsFile = BuildAssetsUtils.GetMSBuildFilePath(packageSpec, BuildAssetsUtils.PropsExtension); var targetsFile = BuildAssetsUtils.GetMSBuildFilePath(packageSpec, BuildAssetsUtils.TargetsExtension); IReadOnlyList <string> expectedFileList = new string[] { assetsFilePath, propsFile, targetsFile }; var pathComparer = PathUtility.GetStringComparerBasedOnOS(); progressReporter.Verify(r => r.StartProjectUpdate( It.Is <string>(e => e.Equals(packageSpec.FilePath)), It.Is <IReadOnlyList <string> >(e => e.OrderedEquals(expectedFileList, (f) => f, pathComparer, pathComparer))), Times.Once); progressReporter.Verify(r => r.EndProjectUpdate( It.Is <string>(e => e.Equals(packageSpec.FilePath)), It.Is <IReadOnlyList <string> >(e => e.OrderedEquals(expectedFileList, (f) => f, pathComparer, pathComparer))), Times.Once); }
public async Task RestoreAsync_WithProgressReporter_WhenProjectNoOps_ProgressIsNotReported() { // Arrange using var pathContext = new SimpleTestPathContext(); var settings = Settings.LoadDefaultSettings(pathContext.SolutionRoot); var packageSpec = ProjectTestHelpers.GetPackageSpec(settings, projectName: "projectName", rootPath: pathContext.SolutionRoot); var dgSpec = ProjectTestHelpers.GetDGSpecFromPackageSpecs(packageSpec); var progressReporter = new Mock <IRestoreProgressReporter>(); // Pre-Conditions IReadOnlyList <RestoreSummary> result = await DependencyGraphRestoreUtility.RestoreAsync( dgSpec, new DependencyGraphCacheContext(), new RestoreCommandProvidersCache(), cacheContextModifier : _ => { }, sources : new SourceRepository[0], parentId : Guid.Empty, forceRestore : false, isRestoreOriginalAction : true, additionalMessages : null, progressReporter : progressReporter.Object, new TestLogger(), CancellationToken.None); // Pre-Conditions result.Should().HaveCount(1); RestoreSummary restoreSummary = result[0]; restoreSummary.Success.Should().BeTrue(); restoreSummary.NoOpRestore.Should().BeFalse(); progressReporter.Verify(r => r.StartProjectUpdate( It.IsAny <string>(), It.IsAny <IReadOnlyList <string> >()), Times.Once); progressReporter.Verify(r => r.EndProjectUpdate( It.IsAny <string>(), It.IsAny <IReadOnlyList <string> >()), Times.Once); var noopProgressReporter = new Mock <IRestoreProgressReporter>(); // Act result = await DependencyGraphRestoreUtility.RestoreAsync( dgSpec, new DependencyGraphCacheContext(), new RestoreCommandProvidersCache(), cacheContextModifier : _ => { }, sources : new SourceRepository[0], parentId : Guid.Empty, forceRestore : false, isRestoreOriginalAction : true, additionalMessages : null, progressReporter : noopProgressReporter.Object, new TestLogger(), CancellationToken.None); // Assert result.Should().HaveCount(1); restoreSummary = result[0]; restoreSummary.Success.Should().BeTrue(); restoreSummary.NoOpRestore.Should().BeTrue(); noopProgressReporter.Verify(r => r.StartProjectUpdate( It.IsAny <string>(), It.IsAny <IReadOnlyList <string> >()), Times.Never); noopProgressReporter.Verify(r => r.EndProjectUpdate( It.IsAny <string>(), It.IsAny <IReadOnlyList <string> >()), Times.Never); }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChangesFallbackFolder() { // Arrange var projectName = "testproj"; using (var globalFolder = TestDirectory.Create()) using (var fallbackFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); // Restore to the fallback folder var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger, NullSettings.Instance); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); var packageFolders = new List <string> { globalFolder, fallbackFolder }; // Act //var actual = await project.IsRestoreRequired( // packageFolders.Select(p => new VersionFolderPathResolver(p)), // new HashSet<PackageIdentity>(), // restoreContext); // Assert //Assert.False(actual); } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, dgSpec1, testLogger, CancellationToken.None); var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, dgSpec2, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } var resolver = new VersionFolderPathResolver(packagesFolder); var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); using (var writer = new StreamWriter(hashPath)) { writer.Write("ANAWESOMELYWRONGHASH!!!"); } var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } } }
public async Task BuildIntegratedRestoreUtility_RestoreDeferredProjectLoad() { // Arrange var projectName = "testproj"; var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { ""dependencies"": { ""packageA"": ""1.0.0"" } } } }"; using (var packageSource = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <PackageSource>() { new PackageSource(packageSource.Path) }); var packageContext = new SimpleTestPackageContext("packageA"); packageContext.AddFile("lib/net45/a.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource); var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = Path.Combine(projectFolder.FullName, "project.json"); var projectPath = Path.Combine(projectFolder.FullName, $"{projectName}.csproj"); var packageSpec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", projectConfig); var metadata = new ProjectRestoreMetadata(); packageSpec.RestoreMetadata = metadata; metadata.ProjectStyle = ProjectStyle.ProjectJson; metadata.ProjectPath = projectPath; metadata.ProjectJsonPath = packageSpec.FilePath; metadata.ProjectName = packageSpec.Name; metadata.ProjectUniqueName = projectPath; foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName)) { metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework)); } var solutionManager = new TestSolutionManager(false); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger); restoreContext.DeferredPackageSpecs.Add(packageSpec); // Act await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sourceRepositoryProvider.GetRepositories(), NullSettings.Instance, testLogger, CancellationToken.None); // Assert Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json"))); Assert.True(testLogger.Errors == 0); } }
public async Task DependencyGraphRestoreUtility_NoopIsRestoreRequiredAsyncTest() { // Arrange var projectName = "testproj"; var logger = new TestLogger(); using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "testproj.project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var restoreContext = new DependencyGraphCacheContext(logger, NullSettings.Instance); var projects = new List <IDependencyGraphProject>() { project }; var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var sources = new[] { Repository.Factory.GetVisualStudio(new PackageSource("https://www.nuget.org/api/v2/")) }; // Act await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), logger, CancellationToken.None); var pathContext = NuGetPathContext.Create(NullSettings.Instance); //var oldHash = restoreContext.SolutionSpecHash; //var newContext = new DependencyGraphCacheContext(logger, NullSettings.Instance); //// Act //var result = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync( // solutionManager, // forceRestore: false, // pathContext: pathContext, // cacheContext: newContext, // oldDependencyGraphSpecHash: oldHash); //// Assert //Assert.Equal(false, result); Assert.Equal(0, logger.Errors); Assert.Equal(0, logger.Warnings); Assert.Equal(2, logger.MinimalMessages.Count); } }
private async Task RestorePackageSpecProjectsAsync( List <IDependencyGraphProject> projects, bool forceRestore, bool isSolutionAvailable, IReadOnlyList <PackageSpec> packageSpecs, CancellationToken token) { // Only continue if there are some build integrated type projects. if (!(projects.Any(project => project is BuildIntegratedNuGetProject) || packageSpecs.Any(project => IsProjectBuildIntegrated(project)))) { return; } if (IsConsentGranted(_settings)) { if (!isSolutionAvailable) { var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings); if (!Path.IsPathRooted(globalPackagesFolder)) { await _logger.DoAsync((l, _) => { var message = string.Format( CultureInfo.CurrentCulture, Resources.RelativeGlobalPackagesFolder, globalPackagesFolder); l.WriteLine(VerbosityLevel.Quiet, message); }); // Cannot restore packages since globalPackagesFolder is a relative path // and the solution is not available return; } } // Cache p2ps discovered from DTE var cacheContext = new DependencyGraphCacheContext(_logger); var pathContext = NuGetPathContext.Create(_settings); // add deferred projects package spec in cacheContext packageSpecCache cacheContext.DeferredPackageSpecs.AddRange(packageSpecs); var isRestoreRequired = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync( _solutionManager, forceRestore, pathContext, cacheContext, _dependencyGraphProjectCacheHash); // No-op all project closures are up to date and all packages exist on disk. if (isRestoreRequired) { // Save the project between operations. _dependencyGraphProjectCacheHash = cacheContext.SolutionSpecHash; // NOTE: During restore for build integrated projects, // We might show the dialog even if there are no packages to restore // When both currentStep and totalSteps are 0, we get a marquee on the dialog await _logger.RunWithProgressAsync( async (l, _, t) => { // Display the restore opt out message if it has not been shown yet await l.WriteHeaderAsync(); var sources = _sourceRepositoryProvider .GetRepositories() .ToList(); var providerCache = new RestoreCommandProvidersCache(); Action <SourceCacheContext> cacheModifier = (cache) => { }; var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( _solutionManager, cacheContext, providerCache, cacheModifier, sources, _settings, l, t); _packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum(); var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false); if (isRestoreFailed) { _status = NuGetOperationStatus.Failed; } }, token); } } }
public async Task RestoreAsync_WithMinimalProjectAndAdditionalErrorMessage_WritesErrorsToAssetsFile() { // Arrange var projectName = "testproj"; var logger = new TestLogger(); using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var objFolder = projectFolder.CreateSubdirectory("obj"); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); var globalPackagesFolder = Path.Combine(rootFolder, "gpf"); var sources = new SourceRepository[0]; var restoreContext = new DependencyGraphCacheContext(logger, NullSettings.Instance); var solutionManager = new Mock <ISolutionManager>(); var restoreCommandProvidersCache = new RestoreCommandProvidersCache(); // When a VS nomination results in an exception, we use this minimal DGSpec to do a restore. var dgSpec = DependencyGraphSpecTestUtilities.CreateMinimalDependencyGraphSpec(msbuildProjectPath.FullName, objFolder.FullName); dgSpec.AddRestore(dgSpec.Projects[0].FilePath); // CpsPackageReferenceProject sets some additional properties, from settings, in GetPackageSpecsAndAdditionalMessages(...) dgSpec.Projects[0].RestoreMetadata.PackagesPath = globalPackagesFolder; // Having an "additional" error message is also critical var restoreLogMessage = new RestoreLogMessage(LogLevel.Error, NuGetLogCode.NU1000, "Test error") { FilePath = msbuildProjectPath.FullName, ProjectPath = msbuildProjectPath.FullName }; var additionalMessages = new List <IAssetsLogMessage>() { AssetsLogMessage.Create(restoreLogMessage) }; // Act await DependencyGraphRestoreUtility.RestoreAsync( dgSpec, restoreContext, restoreCommandProvidersCache, cacheContextModifier : _ => { }, sources, parentId : Guid.Empty, forceRestore : false, isRestoreOriginalAction : true, additionalMessages, progressReporter : null, logger, CancellationToken.None); // Assert var assetsFilePath = Path.Combine(objFolder.FullName, "project.assets.json"); Assert.True(File.Exists(assetsFilePath), "Assets file does not exist"); LockFile assetsFile = new LockFileFormat().Read(assetsFilePath); IAssetsLogMessage actualMessage = Assert.Single(assetsFile.LogMessages); Assert.Equal(restoreLogMessage.Level, actualMessage.Level); Assert.Equal(restoreLogMessage.Code, actualMessage.Code); Assert.Equal(restoreLogMessage.Message, actualMessage.Message); } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512() { // Arrange var projectName = "testproj"; using (var solutionManager = new TestSolutionManager(false)) { var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var testLogger = new TestLogger(); var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config"); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, dgSpec1, restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, dgSpec2, restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder); var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); File.Delete(hashPath); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } var filePath = Path.Combine( NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), "nuget-dg", "nugetSpec.dg"); Assert.True(File.Exists(filePath)); } }
public async Task BuildIntegratedRestoreUtility_RestoreToRelativePathGlobalPackagesFolder() { // Arrange var projectName = "testproj"; using (var solutionManager = new TestSolutionManager()) { var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName)); projectFolder.Create(); var projectJson = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); File.WriteAllText(projectJson.FullName, BuildIntegrationTestUtility.ProjectJsonWithPackage); var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectJson.FullName, msbuildProjectPath.FullName); var configContents = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <config> <add key=""globalPackagesFolder"" value=""..\NuGetPackages"" /> </config> <packageSources> <add key=""nuget.org.v2"" value=""https://www.nuget.org/api/v2/"" /> </packageSources> </configuration>"; var configLocation = solutionManager.NuGetConfigPath; // delete the default config from the solution manager if (File.Exists(configLocation)) { File.Delete(configLocation); } File.WriteAllText(configLocation, configContents); var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config"); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); // Act await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); // Assert Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json"))); var packagesFolder = Path.Combine(solutionManager.SolutionDirectory, @"..\NuGetPackages"); Assert.True(Directory.Exists(packagesFolder)); Assert.True(File.Exists(Path.Combine( packagesFolder, "EntityFramework", "5.0.0", "EntityFramework.5.0.0.nupkg"))); Assert.True(testLogger.Errors == 0, testLogger.ShowErrors()); } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredMissingPackage() { // Arrange var projectName = "testproj"; using (var solutionManager = new TestSolutionManager(false)) { var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config"); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder); var pathToDelete = resolver.GetInstallPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); TestFileSystemUtility.DeleteRandomTestFolder(pathToDelete); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var testLogger = new TestLogger(); var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, packagesFolder, NullSettings.Instance, testLogger, CancellationToken.None); var resolver = new VersionFolderPathResolver(packagesFolder); var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); using (var writer = new StreamWriter(hashPath)) { writer.Write("ANAWESOMELYWRONGHASH!!!"); } // Act var actual = await project.IsRestoreRequired( new[] { resolver }, new HashSet <PackageIdentity>(), restoreContext); // Assert Assert.True(actual); } }
public async Task BuildIntegratedNuGetProject_IsRestoreNotRequiredWithFloatingVersion() { // Arrange var projectName = "testproj"; using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); json.Add("dependencies", JObject.Parse("{ \"nuget.versioning\": \"1.0.*\" }")); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem); var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, NullSettings.Instance, testLogger, CancellationToken.None); // Act var actual = await project.IsRestoreRequired( new[] { new VersionFolderPathResolver(effectiveGlobalPackagesFolder) }, new HashSet <PackageIdentity>(), restoreContext); // Assert Assert.False(actual); } }
public async Task RestoreAsync_WithProgressReporter_WithMultipleProjects_ProgressIsNotReportedForChangedProjetsOnly() { // Arrange using var pathContext = new SimpleTestPathContext(); var settings = Settings.LoadDefaultSettings(pathContext.SolutionRoot); var project1 = ProjectTestHelpers.GetPackageSpec(settings, projectName: "project1", rootPath: pathContext.SolutionRoot); var project2 = ProjectTestHelpers.GetPackageSpec(settings, projectName: "project2", rootPath: pathContext.SolutionRoot); var progressReporter = new Mock <IRestoreProgressReporter>(); // Pre-Conditions IReadOnlyList <RestoreSummary> result = await DependencyGraphRestoreUtility.RestoreAsync( ProjectTestHelpers.GetDGSpecFromPackageSpecs(project1, project2), new DependencyGraphCacheContext(), new RestoreCommandProvidersCache(), cacheContextModifier : _ => { }, sources : new SourceRepository[0], parentId : Guid.Empty, forceRestore : false, isRestoreOriginalAction : true, additionalMessages : null, progressReporter : progressReporter.Object, new TestLogger(), CancellationToken.None); // Pre-Conditions result.Should().HaveCount(2); foreach (RestoreSummary restoreSummary in result) { restoreSummary.Success.Should().BeTrue(); restoreSummary.NoOpRestore.Should().BeFalse(); } progressReporter.Verify(r => r.StartProjectUpdate( It.Is <string>(e => e.Equals(project1.FilePath)), It.IsAny <IReadOnlyList <string> >()), Times.Once); progressReporter.Verify(r => r.EndProjectUpdate( It.Is <string>(e => e.Equals(project1.FilePath)), It.IsAny <IReadOnlyList <string> >()), Times.Once); progressReporter.Verify(r => r.StartProjectUpdate( It.Is <string>(e => e.Equals(project2.FilePath)), It.IsAny <IReadOnlyList <string> >()), Times.Once); progressReporter.Verify(r => r.EndProjectUpdate( It.Is <string>(e => e.Equals(project2.FilePath)), It.IsAny <IReadOnlyList <string> >()), Times.Once); progressReporter.Verify(r => r.StartProjectUpdate( It.IsAny <string>(), It.IsAny <IReadOnlyList <string> >()), Times.Exactly(2)); progressReporter.Verify(r => r.EndProjectUpdate( It.IsAny <string>(), It.IsAny <IReadOnlyList <string> >()), Times.Exactly(2)); var secondaryProgressReporter = new Mock <IRestoreProgressReporter>(); // Act result = await DependencyGraphRestoreUtility.RestoreAsync( ProjectTestHelpers.GetDGSpecFromPackageSpecs(project1.WithTestProjectReference(project2), project2), new DependencyGraphCacheContext(), new RestoreCommandProvidersCache(), cacheContextModifier : _ => { }, sources : new SourceRepository[0], parentId : Guid.Empty, forceRestore : false, isRestoreOriginalAction : true, additionalMessages : null, progressReporter : secondaryProgressReporter.Object, new TestLogger(), CancellationToken.None); // Assert result.Should().HaveCount(2); var project1Summary = result.Single(e => e.InputPath.Equals(project1.FilePath)); var project2Summary = result.Single(e => e.InputPath.Equals(project2.FilePath)); project1Summary.Success.Should().BeTrue(); project1Summary.NoOpRestore.Should().BeFalse(); // One no-op project2Summary.Success.Should().BeTrue(); project2Summary.NoOpRestore.Should().BeTrue(); progressReporter.Verify(r => r.StartProjectUpdate( It.Is <string>(e => e.Equals(project1.FilePath)), It.IsAny <IReadOnlyList <string> >()), Times.Once); progressReporter.Verify(r => r.EndProjectUpdate( It.Is <string>(e => e.Equals(project1.FilePath)), It.IsAny <IReadOnlyList <string> >()), Times.Once); }
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_LockedMode() { using (var packageSource = TestDirectory.Create()) { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <Configuration.PackageSource>() { new Configuration.PackageSource(packageSource.Path) }); using (var testSolutionManager = new TestSolutionManager(true)) using (var randomProjectFolderPath = TestDirectory.Create()) { var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath); var testNuGetProjectContext = new TestNuGetProjectContext(); var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var projectTargetFrameworkStr = "net45"; var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj"); var projectNames = new ProjectNames( fullName: fullProjectPath, uniqueName: Path.GetFileName(fullProjectPath), shortName: Path.GetFileNameWithoutExtension(fullProjectPath), customUniqueName: Path.GetFileName(fullProjectPath)); var vsProjectAdapter = new TestVSProjectAdapter( fullProjectPath, projectNames, projectTargetFrameworkStr, restorePackagesWithLockFile: "true", restoreLockedMode: true); var projectServices = new TestProjectSystemServices(); projectServices.SetupInstalledPackages( NuGetFramework.Parse(projectTargetFrameworkStr), new LibraryDependency { LibraryRange = new LibraryRange( "packageA", VersionRange.Parse("1.*"), LibraryDependencyTarget.Package) }); var legacyPRProject = new LegacyPackageReferenceProject( vsProjectAdapter, Guid.NewGuid().ToString(), projectServices, _threadingService); testSolutionManager.NuGetProjects.Add(legacyPRProject); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings); var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0"); packageContextA.AddFile("lib/net45/a.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContextA, packageSource); var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0"); packageContextB.AddFile("lib/net45/b.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContextB, packageSource); var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( testSolutionManager, dgSpec, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sourceRepositoryProvider.GetRepositories(), Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } Assert.True(File.Exists(Path.Combine(randomProjectFolderPath, "packages.lock.json"))); // install a new package projectServices.SetupInstalledPackages( NuGetFramework.Parse(projectTargetFrameworkStr), new LibraryDependency { LibraryRange = new LibraryRange( "packageA", VersionRange.Parse("1.*"), LibraryDependencyTarget.Package) }, new LibraryDependency { LibraryRange = new LibraryRange( "packageB", VersionRange.Parse("1.0.0"), LibraryDependencyTarget.Package) }); // update the proeject with new ProjectService instance restoreContext.PackageSpecCache.Clear(); dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext); // Act restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( testSolutionManager, dgSpec, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sourceRepositoryProvider.GetRepositories(), Guid.Empty, false, true, testLogger, CancellationToken.None); // Assert foreach (var restoreSummary in restoreSummaries) { Assert.False(restoreSummary.Success); } } } }
public async Task BuildIntegratedNuGetProject_RestoreFailed_PersistDGSpecFile() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); // invalid version for nuget.versioning package which will make this restore fail. JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("3000.0.0"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, dgSpec, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.False(restoreSummary.Success); } var filePath = Path.Combine( NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), "nuget-dg", "nugetSpec.dg"); Assert.True(File.Exists(filePath)); } }
public async Task BuildIntegratedNuGetProject_IsRestoreNotRequiredWithFloatingVersion() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); json.Add("dependencies", JObject.Parse("{ \"nuget.versioning\": \"1.0.*\" }")); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.AddOrUpdate(ConfigurationConstants.Config, new AddItem("globalPackagesFolder", packagesFolder)); using (var solutionManager = new TestSolutionManager()) { solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } } } }
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_GenerateLockFile() { using (var packageSource = TestDirectory.Create()) { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <Configuration.PackageSource>() { new Configuration.PackageSource(packageSource.Path) }); using (var testSolutionManager = new TestSolutionManager(true)) using (var randomProjectFolderPath = TestDirectory.Create()) { var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath); var testNuGetProjectContext = new TestNuGetProjectContext(); var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); // set up projects var projectTargetFrameworkStr = "net45"; var fullProjectPathB = Path.Combine(randomProjectFolderPath, "ProjectB", "project2.csproj"); var projectNamesB = new ProjectNames( fullName: fullProjectPathB, uniqueName: Path.GetFileName(fullProjectPathB), shortName: Path.GetFileNameWithoutExtension(fullProjectPathB), customUniqueName: Path.GetFileName(fullProjectPathB)); var vsProjectAdapterB = new TestVSProjectAdapter( fullProjectPathB, projectNamesB, projectTargetFrameworkStr); var projectServicesB = new TestProjectSystemServices(); projectServicesB.SetupInstalledPackages( NuGetFramework.Parse(projectTargetFrameworkStr), new LibraryDependency { LibraryRange = new LibraryRange( "packageB", VersionRange.Parse("1.*"), LibraryDependencyTarget.Package) }); var legacyPRProjectB = new LegacyPackageReferenceProject( vsProjectAdapterB, Guid.NewGuid().ToString(), projectServicesB, _threadingService); var projectPathA = Path.Combine(randomProjectFolderPath, "ProjectA"); var fullProjectPathA = Path.Combine(projectPathA, "project1.csproj"); var projectNamesA = new ProjectNames( fullName: fullProjectPathA, uniqueName: Path.GetFileName(fullProjectPathA), shortName: Path.GetFileNameWithoutExtension(fullProjectPathA), customUniqueName: Path.GetFileName(fullProjectPathA)); var vsProjectAdapterA = new TestVSProjectAdapter( fullProjectPathA, projectNamesA, projectTargetFrameworkStr, restorePackagesWithLockFile: "true"); var projectServicesA = new TestProjectSystemServices(); projectServicesA.SetupInstalledPackages( NuGetFramework.Parse(projectTargetFrameworkStr), new LibraryDependency { LibraryRange = new LibraryRange( "packageA", VersionRange.Parse("1.*"), LibraryDependencyTarget.Package) }); projectServicesA.SetupProjectDependencies( new ProjectRestoreReference { ProjectUniqueName = fullProjectPathB, ProjectPath = fullProjectPathB }); var legacyPRProjectA = new LegacyPackageReferenceProject( vsProjectAdapterA, Guid.NewGuid().ToString(), projectServicesA, _threadingService); testSolutionManager.NuGetProjects.Add(legacyPRProjectB); testSolutionManager.NuGetProjects.Add(legacyPRProjectA); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings); var providersCache = new RestoreCommandProvidersCache(); var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0"); packageContextA.AddFile("lib/net45/a.dll"); var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0"); packageContextB.AddFile("lib/net45/b.dll"); var packages = new List <SimpleTestPackageContext>() { packageContextA, packageContextB }; SimpleTestPackageUtility.CreateOPCPackages(packages, packageSource); var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext); // Act var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( testSolutionManager, dgSpec, restoreContext, providersCache, (c) => { }, sourceRepositoryProvider.GetRepositories(), Guid.Empty, false, true, testLogger, CancellationToken.None); // Assert foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } Assert.True(File.Exists(Path.Combine(projectPathA, "packages.lock.json"))); var lockFile = PackagesLockFileFormat.Read(Path.Combine(projectPathA, "packages.lock.json")); Assert.Equal(1, lockFile.Targets.Count); Assert.Equal(".NETFramework,Version=v4.5", lockFile.Targets[0].Name); Assert.Equal(3, lockFile.Targets[0].Dependencies.Count); Assert.Equal("packageA", lockFile.Targets[0].Dependencies[0].Id); Assert.Equal(PackageDependencyType.Direct, lockFile.Targets[0].Dependencies[0].Type); Assert.Equal("packageB", lockFile.Targets[0].Dependencies[1].Id); Assert.Equal(PackageDependencyType.Transitive, lockFile.Targets[0].Dependencies[1].Type); Assert.Equal("project2", lockFile.Targets[0].Dependencies[2].Id); Assert.Equal(PackageDependencyType.Project, lockFile.Targets[0].Dependencies[2].Type); } } }
private async Task RestorePackageSpecProjectsAsync( List <IDependencyGraphProject> projects, bool forceRestore, bool isSolutionAvailable, RestoreOperationSource restoreSource, IntervalTracker intervalTracker, CancellationToken token) { // Only continue if there are some build integrated type projects. if (!(projects.Any(project => project is BuildIntegratedNuGetProject))) { return; } if (_packageRestoreConsent.IsGranted) { if (!isSolutionAvailable) { var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings); if (!Path.IsPathRooted(globalPackagesFolder)) { var message = string.Format( CultureInfo.CurrentCulture, Resources.RelativeGlobalPackagesFolder, globalPackagesFolder); await _logger.WriteLineAsync(VerbosityLevel.Quiet, message); // Cannot restore packages since globalPackagesFolder is a relative path // and the solution is not available return; } } DependencyGraphCacheContext cacheContext; DependencyGraphSpec originalDgSpec; DependencyGraphSpec dgSpec; IReadOnlyList <IAssetsLogMessage> additionalMessages; using (intervalTracker.Start(RestoreTelemetryEvent.SolutionDependencyGraphSpecCreation)) { // Cache p2ps discovered from DTE cacheContext = new DependencyGraphCacheContext(_logger, _settings); var pathContext = NuGetPathContext.Create(_settings); // Get full dg spec (originalDgSpec, additionalMessages) = await DependencyGraphRestoreUtility.GetSolutionRestoreSpecAndAdditionalMessages(_solutionManager, cacheContext); } using (intervalTracker.Start(RestoreTelemetryEvent.SolutionUpToDateCheck)) { // Run solution based up to date check. var projectsNeedingRestore = _solutionUpToDateChecker.PerformUpToDateCheck(originalDgSpec, _logger).AsList(); var specialReferencesCount = originalDgSpec.Projects .Where(x => x.RestoreMetadata.ProjectStyle != ProjectStyle.PackageReference && x.RestoreMetadata.ProjectStyle != ProjectStyle.PackagesConfig && x.RestoreMetadata.ProjectStyle != ProjectStyle.ProjectJson) .Count(); dgSpec = originalDgSpec; // Only use the optimization results if the restore is not `force`. // Still run the optimization check anyways to prep the cache. if (!forceRestore) { // Update the dg spec. dgSpec = originalDgSpec.WithoutRestores(); foreach (var uniqueProjectId in projectsNeedingRestore) { dgSpec.AddRestore(uniqueProjectId); // Fill DGSpec copy only with restore-needed projects } // Calculate the number of up to date projects _upToDateProjectCount = originalDgSpec.Restore.Count - specialReferencesCount - projectsNeedingRestore.Count; _noOpProjectsCount = _upToDateProjectCount; } } using (intervalTracker.Start(RestoreTelemetryEvent.PackageReferenceRestoreDuration)) { // Avoid restoring if all the projects are up to date, or the solution does not have build integrated projects. if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec)) { // NOTE: During restore for build integrated projects, // We might show the dialog even if there are no packages to restore // When both currentStep and totalSteps are 0, we get a marquee on the dialog await _logger.RunWithProgressAsync( async (l, _, t) => { // Display the restore opt out message if it has not been shown yet await l.WriteHeaderAsync(); var sources = _sourceRepositoryProvider .GetRepositories() .ToList(); var providerCache = new RestoreCommandProvidersCache(); Action <SourceCacheContext> cacheModifier = (cache) => { }; var isRestoreOriginalAction = true; var isRestoreSucceeded = true; IReadOnlyList <RestoreSummary> restoreSummaries = null; try { restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( _solutionManager, dgSpec, cacheContext, providerCache, cacheModifier, sources, _nuGetProjectContext.OperationId, forceRestore, isRestoreOriginalAction, additionalMessages, l, t); _packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum(); isRestoreSucceeded = restoreSummaries.All(summary => summary.Success == true); _noOpProjectsCount += restoreSummaries.Where(summary => summary.NoOpRestore == true).Count(); _solutionUpToDateChecker.SaveRestoreStatus(restoreSummaries); } catch { isRestoreSucceeded = false; throw; } finally { if (isRestoreSucceeded) { if (_noOpProjectsCount < restoreSummaries.Count) { _status = NuGetOperationStatus.Succeeded; } else { _status = NuGetOperationStatus.NoOp; } } else { _status = NuGetOperationStatus.Failed; } } }, token); } } } else if (restoreSource == RestoreOperationSource.Explicit) { await _logger.ShowErrorAsync(Resources.PackageRefNotRestoredBecauseOfNoConsent); } }
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_PackageShaValidationFailed() { using (var packageSource = TestDirectory.Create()) { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <Configuration.PackageSource>() { new Configuration.PackageSource(packageSource.Path) }); using (var testSolutionManager = new TestSolutionManager(true)) using (var randomProjectFolderPath = TestDirectory.Create()) { var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath); var testNuGetProjectContext = new TestNuGetProjectContext(); var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var projectTargetFrameworkStr = "net45"; var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj"); var projectNames = new ProjectNames( fullName: fullProjectPath, uniqueName: Path.GetFileName(fullProjectPath), shortName: Path.GetFileNameWithoutExtension(fullProjectPath), customUniqueName: Path.GetFileName(fullProjectPath)); var vsProjectAdapter = new TestVSProjectAdapter( fullProjectPath, projectNames, projectTargetFrameworkStr); var projectServices = new TestProjectSystemServices(); projectServices.SetupInstalledPackages( NuGetFramework.Parse(projectTargetFrameworkStr), new LibraryDependency { LibraryRange = new LibraryRange( "packageA", VersionRange.Parse("1.*"), LibraryDependencyTarget.Package) }); var legacyPRProject = new LegacyPackageReferenceProject( vsProjectAdapter, Guid.NewGuid().ToString(), projectServices, _threadingService); testSolutionManager.NuGetProjects.Add(legacyPRProject); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings); var packageContext = new SimpleTestPackageContext("packageA", "1.0.0"); packageContext.AddFile("lib/net45/a.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource); var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext); var projectLockFilePath = Path.Combine(randomProjectFolderPath, "packages.project1.lock.json"); File.Create(projectLockFilePath).Close(); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( testSolutionManager, dgSpec, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sourceRepositoryProvider.GetRepositories(), Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } Assert.True(File.Exists(projectLockFilePath)); // delete existing restore output files File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project.assets.json")); File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project1.csproj.nuget.cache")); // clean packages folder var packagesFolder = Path.Combine(randomProjectFolderPath, "packages"); Directory.Delete(packagesFolder, true); Directory.CreateDirectory(packagesFolder); // add a new package var newPackageContext = new SimpleTestPackageContext("packageA", "1.0.0"); newPackageContext.AddFile("lib/net45/a1.dll"); SimpleTestPackageUtility.CreateOPCPackage(newPackageContext, packageSource); // Act restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( testSolutionManager, dgSpec, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sourceRepositoryProvider.GetRepositories(), Guid.Empty, false, true, testLogger, CancellationToken.None); // Assert foreach (var restoreSummary in restoreSummaries) { Assert.False(restoreSummary.Success); Assert.True(restoreSummary.Errors.Count > 0); Assert.NotNull(restoreSummary.Errors.FirstOrDefault(message => (message as RestoreLogMessage).Code == NuGetLogCode.NU1403)); } } } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChanges() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder); var providersCache = new RestoreCommandProvidersCache(); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } } }
private async Task RestorePackageSpecProjectsAsync( List <IDependencyGraphProject> projects, bool forceRestore, bool isSolutionAvailable, RestoreOperationSource restoreSource, CancellationToken token) { // Only continue if there are some build integrated type projects. if (!(projects.Any(project => project is BuildIntegratedNuGetProject))) { return; } if (_packageRestoreConsent.IsGranted) { if (!isSolutionAvailable) { var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings); if (!Path.IsPathRooted(globalPackagesFolder)) { await _logger.DoAsync((l, _) => { var message = string.Format( CultureInfo.CurrentCulture, Resources.RelativeGlobalPackagesFolder, globalPackagesFolder); l.WriteLine(VerbosityLevel.Quiet, message); }); // Cannot restore packages since globalPackagesFolder is a relative path // and the solution is not available return; } } // Cache p2ps discovered from DTE var cacheContext = new DependencyGraphCacheContext(_logger, _settings); var pathContext = NuGetPathContext.Create(_settings); // Get full dg spec // TODO: pass this down instead of creating it twice. var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(_solutionManager, cacheContext); // Avoid restoring solutions with zero potential PackageReference projects. if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec)) { // NOTE: During restore for build integrated projects, // We might show the dialog even if there are no packages to restore // When both currentStep and totalSteps are 0, we get a marquee on the dialog await _logger.RunWithProgressAsync( async (l, _, t) => { // Display the restore opt out message if it has not been shown yet await l.WriteHeaderAsync(); var sources = _sourceRepositoryProvider .GetRepositories() .ToList(); var providerCache = new RestoreCommandProvidersCache(); Action <SourceCacheContext> cacheModifier = (cache) => { }; var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( _solutionManager, cacheContext, providerCache, cacheModifier, sources, forceRestore, dgSpec, l, t); _packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum(); var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false); _noOpProjectsCount = restoreSummaries.Where(summary => summary.NoOpRestore == true).Count(); if (isRestoreFailed) { _status = NuGetOperationStatus.Failed; } else if (_noOpProjectsCount < restoreSummaries.Count) { _status = NuGetOperationStatus.Succeeded; } }, token); } } else if (restoreSource == RestoreOperationSource.Explicit) { // Log an error when restore is disabled and user explicitly restore. await _logger.DoAsync((l, _) => { l.ShowError(Resources.PackageRefNotRestoredBecauseOfNoConsent); }); } }
public async Task BuildIntegratedRestoreUtility_RestoreToRelativePathGlobalPackagesFolder() { // Arrange var projectName = "testproj"; using (var rootFolder = TestDirectory.Create()) using (var configFolder = TestDirectory.Create()) using (var solutionFolderParent = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); File.WriteAllText(projectConfig.FullName, BuildIntegrationTestUtility.ProjectJsonWithPackage); var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem); var configContents = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <config> <add key=""globalPackagesFolder"" value=""..\NuGetPackages"" /> </config> </configuration>"; var configSubFolder = Path.Combine(configFolder, "sub"); Directory.CreateDirectory(configSubFolder); File.WriteAllText(Path.Combine(configFolder, "sub", "nuget.config"), configContents); var settings = new Configuration.Settings(configSubFolder); var solutionFolder = new DirectoryInfo(Path.Combine(solutionFolderParent, "solutionFolder")); solutionFolder.Create(); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger); // Act await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, settings, testLogger, CancellationToken.None); // Assert Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json"))); var packagesFolder = Path.Combine(configFolder, "NuGetPackages"); Assert.True(Directory.Exists(packagesFolder)); Assert.True(File.Exists(Path.Combine( packagesFolder, "EntityFramework", "5.0.0", "EntityFramework.5.0.0.nupkg"))); Assert.True(testLogger.Errors == 0, testLogger.ShowErrors()); } }