Adding test infra to test legacy PR

test/NuGet.Clients.Tests/NuGet.PackageManagement.VisualStudio.Test/NuGet.PackageManagement.VisualStudio.Test.csproj

@@ -28,8 +28,10 @@
     <Compile Include="Feeds\UpdatePackageFeedTests.cs" />
     <Compile Include="Feeds\InstalledPackageFeedTests.cs" />
     <Compile Include="FrameworkAssemblyResolverTests.cs" />
+    <Compile Include="ProjectSystems\LegacyPackageReferenceRestoreUtilityTests.cs" />
     <Compile Include="ProjectSystems\ProjectKNuGetProjectTests.cs" />
     <Compile Include="ProjectSystems\ProjectSystemCacheTests.cs" />
+    <Compile Include="ProjectSystems\TestVSProjectAdapter.cs" />
     <Compile Include="Services\NuGetLockServiceTests.cs" />
     <Compile Include="Telemetry\ActionsTelemetryServiceTests.cs" />
     <Compile Include="Telemetry\NuGetTelemetryServiceTests.cs" />
@@ -90,6 +92,6 @@
     <PackageReference Include="EnvDTE" Version="8.0.1" />
   </ItemGroup>
 
-  <Import Project="$(BuildCommonDirectory)common.targets"/>
+  <Import Project="$(BuildCommonDirectory)common.targets" />
   <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
 </Project>

test/NuGet.Clients.Tests/NuGet.PackageManagement.VisualStudio.Test/ProjectSystems/LegacyPackageReferenceProjectTests.cs

@@ -24,6 +24,7 @@
 using NuGet.Test.Utility;
 using NuGet.Versioning;
 using NuGet.VisualStudio;
+using Test.Utility;
 using Test.Utility.Threading;
 using Xunit;
 using Task = System.Threading.Tasks.Task;
@@ -844,77 +845,77 @@ private static IVsProjectAdapter CreateProjectAdapter(string fullPath)
 
             return projectAdapter.Object;
         }
+    }
 
-        private class TestProjectThreadingService : IVsProjectThreadingService
+    public class TestProjectSystemServices : INuGetProjectServices
+    {
+        public TestProjectSystemServices()
         {
-            public TestProjectThreadingService(JoinableTaskFactory jtf)
-            {
-                JoinableTaskFactory = jtf;
-            }
+            Mock.Get(ReferencesReader)
+                .Setup(x => x.GetProjectReferencesAsync(
+                    It.IsAny<NuGet.Common.ILogger>(), CancellationToken.None))
+                .ReturnsAsync(() => new ProjectRestoreReference[] { });
+
+            Mock.Get(ReferencesReader)
+                .Setup(x => x.GetPackageReferencesAsync(
+                    It.IsAny<NuGetFramework>(), CancellationToken.None))
+                .ReturnsAsync(() => new LibraryDependency[] { });
+        }
 
-            public JoinableTaskFactory JoinableTaskFactory { get; }
+        public IProjectBuildProperties BuildProperties { get; } = Mock.Of<IProjectBuildProperties>();
 
-            public void ExecuteSynchronously(Func<Task> asyncAction)
-            {
-                JoinableTaskFactory.Run(asyncAction);
-            }
+        public IProjectSystemCapabilities Capabilities { get; } = Mock.Of<IProjectSystemCapabilities>();
 
-            public T ExecuteSynchronously<T>(Func<Task<T>> asyncAction)
-            {
-                return JoinableTaskFactory.Run(asyncAction);
-            }
+        public IProjectSystemReferencesReader ReferencesReader { get; } = Mock.Of<IProjectSystemReferencesReader>();
 
-            public void ThrowIfNotOnUIThread(string callerMemberName)
-            {
-                ThreadHelper.ThrowIfNotOnUIThread(callerMemberName);
-            }
-        }
+        public IProjectSystemService ProjectSystem { get; } = Mock.Of<IProjectSystemService>();
 
-        private class TestProjectSystemServices : INuGetProjectServices
-        {
-            public TestProjectSystemServices()
-            {
-                Mock.Get(ReferencesReader)
-                    .Setup(x => x.GetProjectReferencesAsync(
-                        It.IsAny<Common.ILogger>(), CancellationToken.None))
-                    .ReturnsAsync(() => new ProjectRestoreReference[] { });
-
-                Mock.Get(ReferencesReader)
-                    .Setup(x => x.GetPackageReferencesAsync(
-                        It.IsAny<NuGetFramework>(), CancellationToken.None))
-                    .ReturnsAsync(() => new LibraryDependency[] { });
-            }
+        public IProjectSystemReferencesService References { get; } = Mock.Of<IProjectSystemReferencesService>();
 
-            public IProjectBuildProperties BuildProperties { get; } = Mock.Of<IProjectBuildProperties>();
+        public IProjectScriptHostService ScriptService { get; } = Mock.Of<IProjectScriptHostService>();
 
-            public IProjectSystemCapabilities Capabilities { get; } = Mock.Of<IProjectSystemCapabilities>();
+        public T GetGlobalService<T>() where T : class
+        {
+            throw new NotImplementedException();
+        }
 
-            public IProjectSystemReferencesReader ReferencesReader { get; } = Mock.Of<IProjectSystemReferencesReader>();
+        public void SetupInstalledPackages(NuGetFramework targetFramework, params LibraryDependency[] dependencies)
+        {
+            Mock.Get(ReferencesReader)
+                .Setup(x => x.GetPackageReferencesAsync(targetFramework, CancellationToken.None))
+                .ReturnsAsync(dependencies.ToList());
+        }
 
-            public IProjectSystemService ProjectSystem { get; } = Mock.Of<IProjectSystemService>();
+        public void SetupProjectDependencies(params ProjectRestoreReference[] dependencies)
+        {
+            Mock.Get(ReferencesReader)
+                .Setup(x => x.GetProjectReferencesAsync(It.IsAny<NuGet.Common.ILogger>(), CancellationToken.None))
+                .ReturnsAsync(dependencies.ToList());
+        }
+    }
 
-            public IProjectSystemReferencesService References { get; } = Mock.Of<IProjectSystemReferencesService>();
+    public class TestProjectThreadingService : IVsProjectThreadingService
+    {
+        public TestProjectThreadingService(JoinableTaskFactory jtf)
+        {
+            JoinableTaskFactory = jtf;
+        }
 
-            public IProjectScriptHostService ScriptService { get; } = Mock.Of<IProjectScriptHostService>();
+        public JoinableTaskFactory JoinableTaskFactory { get; }
 
-            public T GetGlobalService<T>() where T : class
-            {
-                throw new NotImplementedException();
-            }
+        public void ExecuteSynchronously(Func<System.Threading.Tasks.Task> asyncAction)
+        {
+            JoinableTaskFactory.Run(asyncAction);
+        }
 
-            public void SetupInstalledPackages(NuGetFramework targetFramework, params LibraryDependency[] dependencies)
-            {
-                Mock.Get(ReferencesReader)
-                    .Setup(x => x.GetPackageReferencesAsync(targetFramework, CancellationToken.None))
-                    .ReturnsAsync(dependencies.ToList());
-            }
+        public T ExecuteSynchronously<T>(Func<Task<T>> asyncAction)
+        {
+            return JoinableTaskFactory.Run(asyncAction);
+        }
 
-            public void SetupProjectDependencies(params ProjectRestoreReference[] dependencies)
-            {
-                Mock.Get(ReferencesReader)
-                    .Setup(x => x.GetProjectReferencesAsync(It.IsAny<Common.ILogger>(), CancellationToken.None))
-                    .ReturnsAsync(dependencies.ToList());
-            }
+        public void ThrowIfNotOnUIThread(string callerMemberName)
+        {
+            ThreadHelper.ThrowIfNotOnUIThread(callerMemberName);
         }
     }
 }

test/NuGet.Clients.Tests/NuGet.PackageManagement.VisualStudio.Test/ProjectSystems/LegacyPackageReferenceRestoreUtilityTests.cs

@@ -0,0 +1,127 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using Microsoft;
+using NuGet.Commands;
+using NuGet.Configuration;
+using NuGet.ProjectManagement;
+using NuGet.Protocol.Core.Types;
+using NuGet.Test.Utility;
+using NuGet.Versioning;
+using NuGet.VisualStudio;
+using Test.Utility;
+using Test.Utility.Threading;
+using Xunit;
+
+namespace NuGet.PackageManagement.VisualStudio.Test
+{
+    [Collection(DispatcherThreadCollection.CollectionName)]
+    public class LegacyPackageReferenceRestoreUtilityTests
+    {
+        private readonly IVsProjectThreadingService _threadingService;
+
+        public LegacyPackageReferenceRestoreUtilityTests(DispatcherThreadFixture fixture)
+        {
+            Assumes.Present(fixture);
+
+            _threadingService = new TestProjectThreadingService(fixture.JoinableTaskFactory);
+        }
+
+        [Fact]
+        public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Success()
+        {
+            // Set up Package Source
+            var packages = new List<SourcePackageDependencyInfo>
+            {
+                new SourcePackageDependencyInfo("packageA", new NuGetVersion(1, 0, 0), new Packaging.Core.PackageDependency[] { }, true, null),
+                new SourcePackageDependencyInfo("packageA", new NuGetVersion(2, 0, 0), new Packaging.Core.PackageDependency[] { }, true, null)
+            };
+
+            // Arrange
+            var sourceRepositoryProvider = CreateSource(packages);
+
+            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 = "net46";
+                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 legacyPRProject = new LegacyPackageReferenceProject(
+                    vsProjectAdapter,
+                    Guid.NewGuid().ToString(),
+                    new TestProjectSystemServices(),
+                    _threadingService);
+                testSolutionManager.NuGetProjects.Add(legacyPRProject);
+
+                var testLogger = new TestLogger();
+                var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
+                var providersCache = new RestoreCommandProvidersCache();
+
+                var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
+
+                // Act
+                var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
+                    testSolutionManager,
+                    restoreContext,
+                    providersCache,
+                    (c) => { },
+                    sourceRepositoryProvider.GetRepositories(),
+                    Guid.Empty,
+                    false,
+                    dgSpec,
+                    testLogger,
+                    CancellationToken.None);
+
+                // Assert
+                foreach (var restoreSummary in restoreSummaries)
+                {
+                    Assert.True(restoreSummary.Success);
+                    Assert.False(restoreSummary.NoOpRestore);
+                }
+            }
+        }
+
+        private ISettings PopulateSettingsWithSources(SourceRepositoryProvider sourceRepositoryProvider, TestDirectory settingsDirectory)
+        {
+            var Settings = new Settings(settingsDirectory);
+            foreach (var source in sourceRepositoryProvider.GetRepositories())
+                Settings.SetValue(ConfigurationConstants.PackageSources, ConfigurationConstants.PackageSources, source.PackageSource.Source);
+
+            return Settings;
+        }
+
+        private SourceRepositoryProvider CreateSource(List<SourcePackageDependencyInfo> packages)
+        {
+            var resourceProviders = new List<Lazy<INuGetResourceProvider>>();
+            resourceProviders.Add(new Lazy<INuGetResourceProvider>(() => new TestDependencyInfoProvider(packages)));
+            resourceProviders.Add(new Lazy<INuGetResourceProvider>(() => new TestMetadataProvider(packages)));
+
+            var packageSource = new Configuration.PackageSource("http://temp");
+            var packageSourceProvider = new TestPackageSourceProvider(new[] { packageSource });
+
+            return new SourceRepositoryProvider(packageSourceProvider, resourceProviders);
+        }
+    }
+}