public async Task TestGetMissingPackagesForSolution_NoPackagesInstalled() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); // Act var packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token)); Assert.False(packagesFromSolution.Any()); } }
private async Task <IEnumerable <NuGetProjectAction> > PacManCleanInstall(SourceRepositoryProvider sourceRepositoryProvider, PackageIdentity target) { // Arrange using (var testSolutionManager = new TestSolutionManager()) using (var randomPackagesConfigFolderPath = TestDirectory.Create()) { var testSettings = NullSettings.Instance; var token = CancellationToken.None; var deleteOnRestartManger = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManger); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath); // Act var nugetProjectActions = await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, target, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); return(nugetProjectActions); } }
private CompositionContainer Initialize() { var assemblyName = Assembly.GetEntryAssembly().FullName; var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var catalog = new AggregateCatalog( new AssemblyCatalog(Assembly.Load(assemblyName)), new DirectoryCatalog(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "NuGet*.dll")); var container = new CompositionContainer(catalog); var settings = Settings.LoadDefaultSettings(null, null, null); container.ComposeExportedValue(settings); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetVisualStudio()); container.ComposeExportedValue <ISourceRepositoryProvider>(sourceRepositoryProvider); var testSolutionManager = new TestSolutionManager(@"c:\temp\test"); var projectA = testSolutionManager.AddNewMSBuildProject("projectA"); container.ComposeExportedValue <ISolutionManager>(testSolutionManager); var sourceControlManager = new TestSourceControlManager(); var sourceControlManagerProvider = new TestSourceControlManagerProvider(sourceControlManager); container.ComposeExportedValue <ISourceControlManagerProvider>(sourceControlManagerProvider); container.ComposeParts(this); return(container); }
public async Task TestPackageRestoredEvent() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = Packages[0]; var testNuGetProjectContext = new TestNuGetProjectContext(); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var resolutionContext = new ResolutionContext(); var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); var restoredPackages = new List <PackageIdentity>(); packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args) { if (args.Restored) { restoredPackages.Add(args.Package); } }; Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(packageIdentity)); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, testNuGetProjectContext, new TestLogger(), CancellationToken.None); Assert.Equal(1, restoredPackages.Count); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); } }
public async Task TestCheckForMissingPackages() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) using (var randomPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder()) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomPackageSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); var packagesMissingEventCount = 0; var packagesMissing = false; packageRestoreManager.PackagesMissingStatusChanged += delegate(object sender, PackagesMissingStatusEventArgs args) { packagesMissingEventCount++; packagesMissing = args.PackagesMissing; }; // Act await packageRestoreManager.RaisePackagesMissingEventForSolutionAsync(testSolutionManager.SolutionDirectory, token); // Assert Assert.Equal(1, packagesMissingEventCount); Assert.False(packagesMissing); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); // Act await packageRestoreManager.RaisePackagesMissingEventForSolutionAsync(testSolutionManager.SolutionDirectory, token); // Assert Assert.Equal(2, packagesMissingEventCount); Assert.True(packagesMissing); } }
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 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 InstallingPackageShouldCreateLockFile_CustomLockFileName() { // Arrange using (var packageSource = TestDirectory.Create()) using (var testSolutionManager = new TestSolutionManager()) { var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <PackageSource>() { new PackageSource(packageSource.Path) }); var testSettings = NullSettings.Instance; var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packageContext = new SimpleTestPackageContext("packageA"); packageContext.AddFile("lib/net45/a.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource); var msBuildNuGetProject = testSolutionManager.AddNewMSBuildProject(); var msBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem as TestMSBuildNuGetProjectSystem; msBuildNuGetProjectSystem.SetPropertyValue("RestorePackagesWithLockFile", "true"); msBuildNuGetProjectSystem.SetPropertyValue("NuGetLockFilePath", "my.lock.json"); var packagesConfigPath = msBuildNuGetProject.PackagesConfigNuGetProject.FullPath; var packagesLockPath = packagesConfigPath.Replace("packages.config", "my.lock.json"); var packageIdentity = packageContext.Identity; // Pre-Assert // Check that the packages.lock.json file does not exist Assert.False(File.Exists(packagesLockPath)); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.lock.json file exists after the installation Assert.True(File.Exists(packagesLockPath)); Assert.True(msBuildNuGetProjectSystem.FileExistsInProject("my.lock.json")); // Check the number of target frameworks and dependencies in the lock file var lockFile = PackagesLockFileFormat.Read(packagesLockPath); Assert.Equal(1, lockFile.Targets.Count); Assert.Equal(1, lockFile.Targets[0].Dependencies.Count); } }
public async Task TestGetMissingPackagesForSolution() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) using (var randomPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder()) { var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomPackageSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); // Act var packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token)); var packagesFromSolutionList = packagesFromSolution.ToList(); var missingPackagesFromSolutionList = packagesFromSolution.Where(p => p.IsMissing).ToList(); Assert.Equal(1, packagesFromSolutionList.Count); Assert.Equal(0, missingPackagesFromSolutionList.Count); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token)); packagesFromSolutionList = packagesFromSolution.ToList(); missingPackagesFromSolutionList = packagesFromSolution.Where(p => p.IsMissing).ToList(); Assert.Equal(1, missingPackagesFromSolutionList.Count); } }
private void CreatePackageManagerControl() { _container = Initialize(); // This method is called from MainWindow's constructor. Current thread is the main thread var mainThread = Thread.CurrentThread; var synchronizationContext = SynchronizationContext.Current; NuGetUIThreadHelper.SetCustomJoinableTaskFactory(mainThread, synchronizationContext); Title = "NuGet Standalone UI"; Height = 800; Width = 1000; var repositoryProvider = new SourceRepositoryProvider(_settings, Repository.Provider.GetVisualStudio()); var settings = new DefaultSettings(); var testSolutionManager = new TestSolutionManager(@"c:\temp\test"); var projectA = testSolutionManager.AddNewMSBuildProject("projectA"); //var projectB = testSolutionManager.AddNewMSBuildProject("projectB"); //var projectC = testSolutionManager.AddProjectKProject("projectK"); var projectBuildIntegrated = testSolutionManager.AddBuildIntegratedProject("BuildIntProj", NuGetFramework.Parse("net46")); var projects = new[] { projectBuildIntegrated }; var packageRestoreManager = new PackageRestoreManager( repositoryProvider, settings, testSolutionManager); var contextFactory = new StandaloneUIContextFactory( repositoryProvider, testSolutionManager, settings, packageRestoreManager: packageRestoreManager, optionsPage: null); var context = contextFactory.Create(@"c:\temp\test\settings.txt", projects); var uiController = _uiServiceFactory.Create( context, new NuGetUIProjectContext(new StandaloneUILogger(_textBox, _scrollViewer), _sourceControlManagerProvider, _commonOperations)); var model = new PackageManagerModel(uiController, context, isSolution: false, editorFactoryGuid: Guid.Empty); model.SolutionName = "test solution"; _packageManagerControl = new PackageManagerControl(model, _settings, new SimpleSearchBoxFactory(), vsShell: null); layoutGrid.Children.Add(_packageManagerControl); }
public async Task UnzippedPackageInstall_Basic() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); using (var testSolutionManager = new TestSolutionManager(true)) using (var randomPackagesConfigFolderPath = TestDirectory.Create()) { var testSettings = new Configuration.NullSettings(); var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var token = CancellationToken.None; var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath); var packageIdentity = NoDependencyLibPackages[0]; // Pre-Assert // Check that the packages.config file does not exist Assert.False(File.Exists(randomPackagesConfigPath)); // Check that there are no packages returned by PackagesConfigProject var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(0, packagesInPackagesConfig.Count); Assert.Equal(0, msBuildNuGetProjectSystem.References.Count); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.config file exists after the installation Assert.True(File.Exists(randomPackagesConfigPath)); // Check the number of packages and packages returned by PackagesConfigProject after the installation packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList(); Assert.Equal(1, packagesInPackagesConfig.Count); Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity); Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework); } }
public async Task DoNotCreateLockFileWhenFeatureDisabled() { // Arrange using (var packageSource = TestDirectory.Create()) using (var testSolutionManager = new TestSolutionManager()) { var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider( new List <PackageSource>() { new PackageSource(packageSource.Path) }); var testSettings = NullSettings.Instance; var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var packageContext = new SimpleTestPackageContext("packageA"); packageContext.AddFile("lib/net45/a.dll"); SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource); var msBuildNuGetProject = testSolutionManager.AddNewMSBuildProject(); var msBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem as TestMSBuildNuGetProjectSystem; msBuildNuGetProjectSystem.SetPropertyValue("RestorePackagesWithLockFile", "false"); var packagesConfigPath = msBuildNuGetProject.PackagesConfigNuGetProject.FullPath; var packagesLockPath = packagesConfigPath.Replace("packages.config", "packages.lock.json"); var packageIdentity = packageContext.Identity; // Pre-Assert // Check that the packages.lock.json file does not exist Assert.False(File.Exists(packagesLockPath)); // Act await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); // Assert // Check that the packages.lock.json still does not exist after the installation Assert.False(File.Exists(packagesLockPath)); } }
public async Task TestGetMissingPackagesForSolution() { // Arrange var testSolutionManager = new TestSolutionManager(); var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); var randomPackageSourcePath = TestFilesystemUtility.CreateRandomTestFolder(); var packageFileInfo = TestPackages.GetLegacyTestPackage(randomPackageSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString()); var testNuGetProjectContext = new TestNuGetProjectContext(); var token = CancellationToken.None; using (var packageStream = packageFileInfo.OpenRead()) { // Act await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token); } var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = NullSettings.Instance; var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager); // Act var packageReferencesFromSolution = (await packageRestoreManager.GetPackageReferencesFromSolution(token)).ToList(); var missingPackagesFromSolution = (await packageRestoreManager.GetMissingPackagesInSolution(token)).ToList(); Assert.Equal(2, packageReferencesFromSolution.Count); Assert.Equal(0, missingPackagesFromSolution.Count); // Delete packages folder Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true); packageReferencesFromSolution = (await packageRestoreManager.GetPackageReferencesFromSolution(token)).ToList(); missingPackagesFromSolution = (await packageRestoreManager.GetMissingPackagesInSolution(token)).ToList(); Assert.Equal(2, packageReferencesFromSolution.Count); Assert.Equal(1, missingPackagesFromSolution.Count); }
private void CreatePackageManagerControl() { _container = Initialize(); this.Title = "NuGet Standalone UI"; Height = 800; Width = 1000; var repositoryProvider = new SourceRepositoryProvider(_settings, Repository.Provider.GetVisualStudio()); var settings = new DefaultSettings(); var testSolutionManager = new TestSolutionManager(@"c:\temp\test"); var projectA = testSolutionManager.AddNewMSBuildProject("projectA"); var projectB = testSolutionManager.AddNewMSBuildProject("projectB"); //var projectC = testSolutionManager.AddProjectKProject("projectK"); var projects = new NuGetProject[] { projectA, projectB }; var packageRestoreManager = new PackageRestoreManager(repositoryProvider, settings, testSolutionManager); var contextFactory = new StandaloneUIContextFactory( repositoryProvider, testSolutionManager, settings, packageRestoreManager: packageRestoreManager, optionsPage: null); var context = contextFactory.Create(@"c:\temp\test\settings.txt", projects); var uiController = _uiServiceFactory.Create( context, new NuGetUIProjectContext(new StandaloneUILogger(_textBox, _scrollViewer), _sourceControlManagerProvider, _commonOperations)); PackageManagerModel model = new PackageManagerModel(uiController, context); model.SolutionName = "test solution"; _packageManagerControl = new PackageManagerControl(model, _settings); layoutGrid.Children.Add(_packageManagerControl); }
public async Task TestRestoreMissingPackages() { // Arrange var testSolutionManager = new TestSolutionManager(); var projectA = testSolutionManager.AddNewMSBuildProject(); var projectB = testSolutionManager.AddNewMSBuildProject(); var packageIdentity = Packages[0]; var testNuGetProjectContext = new TestNuGetProjectContext(); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = NullSettings.Instance; var resolutionContext = new ResolutionContext(); var token = CancellationToken.None; var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager); await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity, resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(packageIdentity)); // Delete packages folder Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(CancellationToken.None); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); }
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); } } }
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 EnumeratePackagesAsync_ForPackagesConfig_ReturnsOrderedItems() { var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); using (var testDirectory = TestDirectory.Create()) { var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, testDirectory); var solutionDirectory = Path.Combine(testDirectory.Path, "solutionA"); Directory.CreateDirectory(solutionDirectory); var testSolutionManager = new TestSolutionManager(solutionDirectory); var userPackageFolder = Path.Combine(testDirectory.Path, "packagesA"); Directory.CreateDirectory(userPackageFolder); testSettings.SetValue("config", "repositoryPath", userPackageFolder); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath( solutionDirectory, testSettings); var packageBar = new SimpleTestPackageContext { Id = "Bar", Version = "1.0.2" }; var packageFoo = new SimpleTestPackageContext { Id = "Foo", Version = "1.0.1", Dependencies = new List <SimpleTestPackageContext> { packageBar } }; await SimpleTestPackageUtility.CreateFolderFeedPackagesConfigAsync( packagesFolderPath, packageFoo, packageBar); var target = new InstalledPackageEnumerator( testSolutionManager, testSettings, getLockFileOrNullAsync: _ => Task.FromResult <LockFile>(null)); var projectSystem = Mock.Of <IMSBuildProjectSystem>(); Mock.Get(projectSystem) .SetupGet(x => x.TargetFramework) .Returns(NuGetFramework.Parse("net45")); var project = new Mock <MSBuildNuGetProject>( projectSystem, packagesFolderPath, testDirectory.Path); project .Setup(x => x.GetInstalledPackagesAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(new[] { new PackageReference( new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1")), NuGetFramework.Parse("net45")), new PackageReference( new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2")), NuGetFramework.Parse("net45")) }) .Verifiable(); testSolutionManager.NuGetProjects.Add(project.Object); var testPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, packagesFolderPath); // Act var installedPackages = await target.EnumeratePackagesAsync( testPackageManager, CancellationToken.None); // Assert: Order is important! installedPackages.Should().Equal( new PackageItem( new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2")), Path.Combine(packagesFolderPath, "Bar.1.0.2")), new PackageItem( new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1")), Path.Combine(packagesFolderPath, "Foo.1.0.1"))); project.Verify(); } }
public async Task Test_PackageRestoreFailure_WithRaisedEvents() { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) using (var randomTestPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder()) { var projectA = testSolutionManager.AddNewMSBuildProject("projectA"); var projectB = testSolutionManager.AddNewMSBuildProject("projectB"); var projectC = testSolutionManager.AddNewMSBuildProject("projectC"); var jQuery144 = Packages[0]; var jQueryValidation = Packages[2]; var testNuGetProjectContext = new TestNuGetProjectContext(); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var testSettings = Configuration.NullSettings.Instance; var resolutionContext = new ResolutionContext(); var token = CancellationToken.None; var deleteOnRestartManager = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManager); await nuGetPackageManager.InstallPackageAsync(projectA, jQueryValidation, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); await nuGetPackageManager.InstallPackageAsync(projectB, jQueryValidation, resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token); var testPackage1 = new PackageIdentity("package1A", new NuGetVersion("1.0.0")); var testPackage2 = new PackageIdentity("package1B", new NuGetVersion("1.0.0")); var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomTestPackageSourcePath, testPackage1.Id, testPackage1.Version.ToNormalizedString()); using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectB.InstallPackageAsync(testPackage1, packageStream, testNuGetProjectContext, token); await projectC.InstallPackageAsync(testPackage1, packageStream, testNuGetProjectContext, token); } packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomTestPackageSourcePath, testPackage2.Id, testPackage2.Version.ToNormalizedString()); using (var packageStream = GetDownloadResult(packageFileInfo)) { // Act await projectA.InstallPackageAsync(testPackage2, packageStream, testNuGetProjectContext, token); await projectC.InstallPackageAsync(testPackage2, packageStream, testNuGetProjectContext, token); } var packageRestoreManager = new PackageRestoreManager( sourceRepositoryProvider, testSettings, testSolutionManager); var restoredPackages = new List <PackageIdentity>(); packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args) { restoredPackages.Add(args.Package); }; var restoreFailedPackages = new ConcurrentDictionary <Packaging.PackageReference, IEnumerable <string> >(new PackageReferenceComparer()); packageRestoreManager.PackageRestoreFailedEvent += delegate(object sender, PackageRestoreFailedEventArgs args) { restoreFailedPackages.AddOrUpdate(args.RestoreFailedPackageReference, args.ProjectNames, (Packaging.PackageReference packageReference, IEnumerable <string> oldValue) => { return(oldValue); }); }; Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation)); // Delete packages folder TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages")); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(jQuery144)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage1)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage2)); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, testNuGetProjectContext, CancellationToken.None); // Assert Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQuery144)); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage1)); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage2)); Assert.Equal(4, restoredPackages.Count); // The ordering is not guaranteed and can vary. Do not assert based on that Assert.True(restoredPackages.Contains(jQuery144)); Assert.True(restoredPackages.Contains(jQueryValidation)); Assert.True(restoredPackages.Contains(testPackage1)); Assert.True(restoredPackages.Contains(testPackage2)); Assert.Equal(2, restoreFailedPackages.Count); // The ordering is not guaranteed and can vary. Do not assert based on that var restoreFailedPackageKeys = restoreFailedPackages.Keys; var testPackage1Key = restoreFailedPackageKeys.Where(r => r.PackageIdentity.Equals(testPackage1)).First(); var testPackage1ProjectNames = restoreFailedPackages[testPackage1Key].ToList(); Assert.Equal(2, testPackage1ProjectNames.Count); Assert.True(testPackage1ProjectNames.Contains("projectB", StringComparer.OrdinalIgnoreCase)); Assert.True(testPackage1ProjectNames.Contains("projectC", StringComparer.OrdinalIgnoreCase)); var testPackage2Key = restoreFailedPackageKeys.Where(r => r.PackageIdentity.Equals(testPackage2)).First(); var testPackage2ProjectNames = restoreFailedPackages[testPackage2Key].ToList(); Assert.Equal(2, testPackage2ProjectNames.Count); Assert.True(testPackage2ProjectNames.Contains("projectA", StringComparer.OrdinalIgnoreCase)); Assert.True(testPackage2ProjectNames.Contains("projectC", StringComparer.OrdinalIgnoreCase)); } }
public async Task EnumeratePackagesAsync_ForBuildIntegratedProject_ReturnsOrderedItems() { var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); using (var testDirectory = TestDirectory.Create()) { var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, testDirectory); var solutionDirectory = Path.Combine(testDirectory.Path, "solutionA"); Directory.CreateDirectory(solutionDirectory); var testSolutionManager = new TestSolutionManager(solutionDirectory); testSolutionManager.NuGetProjects.Add(Mock.Of <BuildIntegratedNuGetProject>()); var userPackageFolder = Path.Combine(testDirectory.Path, "userPackages"); Directory.CreateDirectory(userPackageFolder); await SimpleTestPackageUtility.CreateFolderFeedV3Async( userPackageFolder, new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1"))); var fallbackPackageFolder = Path.Combine(testDirectory.Path, "fallbackPackages"); Directory.CreateDirectory(fallbackPackageFolder); await SimpleTestPackageUtility.CreateFolderFeedV3Async( fallbackPackageFolder, new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2"))); var target = new InstalledPackageEnumerator( testSolutionManager, testSettings, getLockFileOrNullAsync: _ => Task.FromResult( new LockFile { PackageFolders = new[] { new LockFileItem(userPackageFolder), new LockFileItem(fallbackPackageFolder) }, Targets = new[] { new LockFileTarget { TargetFramework = NuGetFramework.Parse("netcoreapp2.0"), Libraries = new[] { new LockFileTargetLibrary { Type = LibraryType.Package, Name = "Foo", Version = NuGetVersion.Parse("1.0.1"), Dependencies = new[] { new PackageDependency("Bar") } }, new LockFileTargetLibrary { Type = LibraryType.Package, Name = "Bar", Version = NuGetVersion.Parse("1.0.2") } } } }, Libraries = new[] { new LockFileLibrary { Type = LibraryType.Package, Name = "Foo", Version = NuGetVersion.Parse("1.0.1") }, new LockFileLibrary { Type = LibraryType.Package, Name = "Bar", Version = NuGetVersion.Parse("1.0.2") } } })); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath( solutionDirectory, testSettings); var testPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, packagesFolderPath); // Act var installedPackages = await target.EnumeratePackagesAsync( testPackageManager, CancellationToken.None); // Assert: Order is important! installedPackages.Should().Equal( new PackageItem( new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2")), Path.Combine(fallbackPackageFolder, "bar", "1.0.2")), new PackageItem( new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1")), Path.Combine(userPackageFolder, "foo", "1.0.1"))); } }
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_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 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); } } }
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 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 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_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 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); } }
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); } } }