public SharedServiceStateTests(GlobalServiceProvider globalServiceProvider) : base(globalServiceProvider) { var solutionManager = new Mock <IVsSolutionManager>(); solutionManager.SetupGet(x => x.SolutionDirectory) .Returns(@"C:\a"); SourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); AddService <IDeleteOnRestartManager>(Task.FromResult <object>(Mock.Of <IDeleteOnRestartManager>())); AddService <ISettings>(Task.FromResult <object>(Mock.Of <ISettings>())); AddService <ISourceRepositoryProvider>(Task.FromResult <object>(sourceRepositoryProvider)); AddService <IVsSolutionManager>(Task.FromResult <object>(solutionManager.Object)); }
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 TestRestoreMissingPackages() { // 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); 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.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); } }
public async Task TestPackageRestoredEvent() { // 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); 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 Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true); Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); // Act await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(CancellationToken.None); Assert.Equal(1, restoredPackages.Count); Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity))); }
public async Task Simple_ReportsNoOp_Async() { var restoreMan = Mock.Of <IPackageRestoreManager>(); _globalProvider.AddService(typeof(IPackageRestoreManager), restoreMan); var slnMan = Mock.Of <IVsSolutionManager>(); _globalProvider.AddService(typeof(IVsSolutionManager), slnMan); ISourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); _globalProvider.AddService(typeof(ISourceRepositoryProvider), sourceRepositoryProvider); var restoreChecker = Mock.Of <ISolutionRestoreChecker>(); var eventsPublisher = Mock.Of <IRestoreEventsPublisher>(); var settings = Mock.Of <ISettings>(); Mock.Get(settings) .Setup(x => x.GetSection("packageRestore")) .Returns(() => new VirtualSettingSection("packageRestore", new AddItem("automatic", bool.TrueString))); var consoleProvider = Mock.Of <IOutputConsoleProvider>(); var logger = new RestoreOperationLogger(new Lazy <IOutputConsoleProvider>(() => consoleProvider)); var job = new SolutionRestoreJob( asyncServiceProvider: AsyncServiceProvider.GlobalProvider, packageRestoreManager: restoreMan, solutionManager: slnMan, sourceRepositoryProvider: sourceRepositoryProvider, restoreEventsPublisher: eventsPublisher, settings: settings, solutionRestoreChecker: restoreChecker); var restoreRequest = new SolutionRestoreRequest( forceRestore: true, RestoreOperationSource.OnBuild); var restoreJobContext = new SolutionRestoreJobContext(); await job.ExecuteAsync( request : restoreRequest, jobContext : restoreJobContext, logger : logger, isSolutionLoadRestore : true, token : CancellationToken.None); Assert.Equal(NuGetOperationStatus.NoOp, job.Status); }
public async Task TestDownloadPackage_MultipleSources_NotFound() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { new Configuration.PackageSource("https://www.myget.org/F/aspnetvnext/api/v2/"), new Configuration.PackageSource("http://blah.com"), }); var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2")); await Assert.ThrowsAsync <FatalProtocolException>(async() => await PackageDownloader.GetDownloadResourceResultAsync(sourceRepositoryProvider.GetRepositories(), packageIdentity, Configuration.NullSettings.Instance, Common.NullLogger.Instance, CancellationToken.None)); }
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 GetTotalCountAsync_Works() { var uiContext = Mock.Of <INuGetUIContext>(); var source1 = new Configuration.PackageSource("https://dotnet.myget.org/F/nuget-volatile/api/v3/index.json", "NuGetVolatile"); var source2 = new Configuration.PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org"); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 }); var repositories = sourceRepositoryProvider.GetRepositories(); var context = new PackageLoadContext(repositories, false, uiContext); var packageFeed = new MultiSourcePackageFeed(repositories, logger: null); var loader = new PackageItemLoader(context, packageFeed, "nuget"); var totalCount = await loader.GetTotalCountAsync(100, CancellationToken.None); Assert.NotInRange(totalCount, 0, 99); }
public async Task MultipleSources_Works() { var solutionManager = Mock.Of <IVsSolutionManager>(); var uiContext = Mock.Of <INuGetUIContext>(); Mock.Get(uiContext) .Setup(x => x.SolutionManager) .Returns(solutionManager); var source1 = new Configuration.PackageSource("https://dotnet.myget.org/F/nuget-volatile/api/v3/index.json", "NuGetVolatile"); var source2 = new Configuration.PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org"); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 }); var repositories = sourceRepositoryProvider.GetRepositories(); var context = new PackageLoadContext(repositories, false, uiContext); var packageFeed = new MultiSourcePackageFeed(repositories, logger: null); var loader = new PackageItemLoader(context, packageFeed, "nuget"); var loaded = new List <PackageItemListViewModel>(); foreach (var page in Enumerable.Range(0, 5)) { await loader.LoadNextAsync(null, CancellationToken.None); while (loader.State.LoadingStatus == LoadingStatus.Loading) { await Task.Delay(TimeSpan.FromSeconds(1)); await loader.UpdateStateAsync(null, CancellationToken.None); } var items = loader.GetCurrent(); loaded.AddRange(items); if (loader.State.LoadingStatus != LoadingStatus.Ready) { break; } } Assert.NotEmpty(loaded); }
public async Task GetDownloadResourceResultAsync_MultipleSources_PackageDownloadedWhenFoundInMultipleSources() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { TestSourceRepositoryUtility.V3PackageSource, TestSourceRepositoryUtility.V3PackageSource, new PackageSource("http://unit.test"), TestSourceRepositoryUtility.V2PackageSource, TestSourceRepositoryUtility.V2PackageSource, }); var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2")); // Act using (var cacheContext = new SourceCacheContext()) { var downloadContext = new PackageDownloadContext(cacheContext) { ExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, PackageExtractionBehavior.XmlDocFileSaveMode, NullLogger.Instance, signedPackageVerifier: null, signedPackageVerifierSettings: null) }; using (var packagesDirectory = TestDirectory.Create()) using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync( sourceRepositoryProvider.GetRepositories(), packageIdentity, downloadContext, packagesDirectory, NullLogger.Instance, CancellationToken.None)) { var targetPackageStream = downloadResult.PackageStream; // Assert Assert.True(targetPackageStream.CanSeek); } } }
public async Task PackageReader_NotNull() { // Prepare var solutionManager = Mock.Of <INuGetSolutionManagerService>(); var uiContext = new Mock <INuGetUIContext>(); uiContext.Setup(x => x.SolutionManagerService) .Returns(solutionManager); uiContext.Setup(x => x.ServiceBroker) .Returns(Mock.Of <IServiceBroker>()); using (var localFeedDir = TestDirectory.Create()) // local feed { // create test package var pkgId = new PackageIdentity("nuget.lpsm.test", new NuGetVersion(0, 0, 1)); var pkg = new SimpleTestPackageContext(pkgId.Id, pkgId.Version.ToNormalizedString()); await SimpleTestPackageUtility.CreatePackagesAsync(localFeedDir.Path, pkg); // local test source var localUri = new Uri(localFeedDir.Path, UriKind.Absolute); var localSource = new PackageSource(localUri.ToString(), "LocalSource"); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { localSource }); var repositories = sourceRepositoryProvider.GetRepositories(); var context = new PackageLoadContext(repositories, isSolution: false, uiContext.Object); var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: null); var loader = new PackageItemLoader(context, packageFeed, "nuget"); // Act await loader.LoadNextAsync(progress : null, CancellationToken.None); var results = loader.GetCurrent(); // Assert Assert.Single(results); Assert.NotNull(results.First().PackageReader); } }
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); }
public async Task GetDownloadResourceResultAsync_MultipleSources_DownloadsPackage() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { new PackageSource("https://www.myget.org/F/aspnetvnext/api/v2/"), TestSourceRepositoryUtility.V3PackageSource, new PackageSource("http://unit.test"), }); var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2")); // Act using (var cacheContext = new SourceCacheContext()) { var downloadContext = new PackageDownloadContext(cacheContext) { ExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, PackageExtractionBehavior.XmlDocFileSaveMode, clientPolicyContext: null, logger: NullLogger.Instance) }; using (var packagesDirectory = TestDirectory.Create()) using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync( sourceRepositoryProvider.GetRepositories(), packageIdentity, downloadContext, packagesDirectory, NullLogger.Instance, CancellationToken.None)) { var targetPackageStream = downloadResult.PackageStream; // Assert Assert.True(targetPackageStream.CanSeek); } } }
public SharedServiceStateTests(GlobalServiceProvider globalServiceProvider) : base(globalServiceProvider) { var solutionManager = new Mock <IVsSolutionManager>(); solutionManager.SetupGet(x => x.SolutionDirectory) .Returns(@"C:\a"); SourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var componentModel = new Mock <IComponentModel>(); componentModel.Setup(x => x.GetService <IDeleteOnRestartManager>()).Returns(Mock.Of <IDeleteOnRestartManager>()); componentModel.Setup(x => x.GetService <ISettings>()).Returns(Mock.Of <ISettings>()); componentModel.Setup(x => x.GetService <ISourceRepositoryProvider>()).Returns(sourceRepositoryProvider); componentModel.Setup(x => x.GetService <IVsSolutionManager>()).Returns(solutionManager.Object); globalServiceProvider.AddService(typeof(SComponentModel), componentModel.Object); var service = Package.GetGlobalService(typeof(SAsyncServiceProvider)) as IAsyncServiceProvider; ServiceLocator.InitializePackageServiceProvider(service); }
public async Task TestDownloadPackage_InV2() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider(); var v2sourceRepository = sourceRepositoryProvider.GetRepositories().First(); var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2")); // Act using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(v2sourceRepository, packageIdentity, Configuration.NullSettings.Instance, Common.NullLogger.Instance, CancellationToken.None)) { var targetPackageStream = downloadResult.PackageStream; // Assert // jQuery.1.8.2 is of size 185476 bytes. Make sure the download is successful Assert.Equal(185476, targetPackageStream.Length); Assert.True(targetPackageStream.CanSeek); } }
private void Initialize(IReadOnlyList <PackageSource> packageSources = null) { SourceRepositoryProvider sourceRepositoryProvider; if (packageSources == null || packageSources.Count == 0) { sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); } else { sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(packageSources); } _solutionManager = new TestVsSolutionManager(); _testDirectory = TestDirectory.Create(); ISettings testSettings = CreateSettings(sourceRepositoryProvider, _testDirectory); var deleteOnRestartManager = new TestDeleteOnRestartManager(); _packageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, _solutionManager, deleteOnRestartManager); _state = new NuGetProjectManagerServiceState(); _sharedState = new TestSharedServiceState( new Microsoft.VisualStudio.Threading.AsyncLazy <NuGetPackageManager>( () => Task.FromResult(_packageManager)), new Microsoft.VisualStudio.Threading.AsyncLazy <IVsSolutionManager>( () => Task.FromResult <IVsSolutionManager>(_solutionManager)), sourceRepositoryProvider, new Microsoft.VisualStudio.Threading.AsyncLazy <IReadOnlyCollection <SourceRepository> >( () => Task.FromResult <IReadOnlyCollection <SourceRepository> >(sourceRepositoryProvider.GetRepositories().ToList()))); _projectManager = new NuGetProjectManagerService( default(ServiceActivationOptions), Mock.Of <IServiceBroker>(), new AuthorizationServiceClient(Mock.Of <IAuthorizationService>()), _state, _sharedState); }
public async Task GetDownloadResourceResultAsync_V3_DownloadsPackage() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider(); var v3sourceRepository = sourceRepositoryProvider.GetRepositories().First(); var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2")); // Act using (var cacheContext = new SourceCacheContext()) { var downloadContext = new PackageDownloadContext(cacheContext) { ExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv3, PackageExtractionBehavior.XmlDocFileSaveMode, NullLogger.Instance, signedPackageVerifier: null, signedPackageVerifierSettings: null) }; using (var packagesDirectory = TestDirectory.Create()) using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync( v3sourceRepository, packageIdentity, downloadContext, packagesDirectory, NullLogger.Instance, CancellationToken.None)) { var targetPackageStream = downloadResult.PackageStream; // Assert // jQuery.1.8.2 is of size 185476 bytes. Make sure the download is successful Assert.Equal(185476, targetPackageStream.Length); Assert.True(targetPackageStream.CanSeek); } } }
public async Task GetTotalCountAsync_Works() { var solutionManager = Mock.Of <INuGetSolutionManagerService>(); var uiContext = Mock.Of <INuGetUIContext>(); Mock.Get(uiContext) .Setup(x => x.SolutionManagerService) .Returns(solutionManager); var source1 = new PackageSource("https://pkgs.dev.azure.com/dnceng/public/_packaging/nuget-build/nuget/v3/index.json", "NuGetBuild"); var source2 = new PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org"); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 }); var repositories = sourceRepositoryProvider.GetRepositories(); var context = new PackageLoadContext(repositories, false, uiContext); var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: null); var loader = new PackageItemLoader(context, packageFeed, "nuget"); var totalCount = await loader.GetTotalCountAsync(100, CancellationToken.None); Assert.NotInRange(totalCount, 0, 99); }
public async Task GetDownloadResourceResultAsync_MultipleSources_PackageNotFound() { // Arrange var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { new PackageSource("https://www.myget.org/F/aspnetvnext/api/v2/"), new PackageSource("http://unit.test"), }); var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2")); using (var packagesDirectory = TestDirectory.Create()) using (var cacheContext = new SourceCacheContext()) { await Assert.ThrowsAsync <FatalProtocolException>( async() => await PackageDownloader.GetDownloadResourceResultAsync( sourceRepositoryProvider.GetRepositories(), packageIdentity, new PackageDownloadContext(cacheContext), packagesDirectory, NullLogger.Instance, CancellationToken.None)); } }
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 PackageReader_NotNull() { // Prepare var solutionManager = Mock.Of <INuGetSolutionManagerService>(); var uiContext = new Mock <INuGetUIContext>(); uiContext.Setup(x => x.SolutionManagerService) .Returns(solutionManager); var searchService = new Mock <INuGetSearchService>(MockBehavior.Strict); var packageSearchMetadata = new PackageSearchMetadataBuilder.ClonedPackageSearchMetadata() { Identity = new PackageIdentity("NuGet.org", new NuGetVersion("1.0")), PrefixReserved = true }; var packageSearchMetadataContextInfo = new List <PackageSearchMetadataContextInfo>() { PackageSearchMetadataContextInfo.Create(packageSearchMetadata) }; var searchResult = new SearchResultContextInfo(packageSearchMetadataContextInfo, new Dictionary <string, LoadingStatus> { { "Search", LoadingStatus.Loading } }, false); searchService.Setup(x => x.SearchAsync( It.IsAny <IReadOnlyCollection <IProjectContextInfo> >(), It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(), It.IsAny <IReadOnlyCollection <string> >(), It.IsAny <string>(), It.IsAny <SearchFilter>(), It.IsAny <NuGet.VisualStudio.Internal.Contracts.ItemFilter>(), It.IsAny <bool>(), It.IsAny <CancellationToken>())) .Returns(new ValueTask <SearchResultContextInfo>(searchResult)); uiContext.Setup(x => x.ServiceBroker) .Returns(Mock.Of <IServiceBroker>()); using (var localFeedDir = TestDirectory.Create()) // local feed { // create test package var pkgId = new PackageIdentity("nuget.lpsm.test", new NuGetVersion(0, 0, 1)); var pkg = new SimpleTestPackageContext(pkgId.Id, pkgId.Version.ToNormalizedString()); await SimpleTestPackageUtility.CreatePackagesAsync(localFeedDir.Path, pkg); // local test source var localUri = new Uri(localFeedDir.Path, UriKind.Absolute); var localSource = new PackageSource(localUri.ToString(), "LocalSource"); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { localSource }); var repositories = sourceRepositoryProvider.GetRepositories(); var context = new PackageLoadContext(isSolution: false, uiContext.Object); var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: null); var loader = await PackageItemLoader.CreateAsync( Mock.Of <IServiceBroker>(), context, new List <PackageSourceContextInfo> { PackageSourceContextInfo.Create(localSource) }, NuGet.VisualStudio.Internal.Contracts.ItemFilter.All, searchService.Object, TestSearchTerm); // Act await loader.LoadNextAsync(progress : null, CancellationToken.None); var results = loader.GetCurrent(); // Assert Assert.Single(results); Assert.NotNull(results.First().PackageReader); } }
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 EmitsSearchTelemetryEvents() { // Arrange var solutionManager = Mock.Of <IVsSolutionManager>(); var uiContext = Mock.Of <INuGetUIContext>(); Mock.Get(uiContext) .Setup(x => x.SolutionManager) .Returns(solutionManager); var telemetryService = new Mock <INuGetTelemetryService>(); var eventsQueue = new ConcurrentQueue <TelemetryEvent>(); telemetryService .Setup(x => x.EmitTelemetryEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(e => eventsQueue.Enqueue(e)); // Mock all the remote calls our test will try to make. var source = NuGetConstants.V3FeedUrl; var query = "https://api-v2v3search-0.nuget.org/query"; var responses = new Dictionary <string, string> { { source, ProtocolUtility.GetResource("NuGet.PackageManagement.UI.Test.compiler.resources.index.json", typeof(PackageItemLoaderTests)) }, { query + "?q=nuget&skip=0&take=26&prerelease=true&semVerLevel=2.0.0", ProtocolUtility.GetResource("NuGet.PackageManagement.UI.Test.compiler.resources.nugetSearchPage1.json", typeof(PackageItemLoaderTests)) }, { query + "?q=nuget&skip=25&take=26&prerelease=true&semVerLevel=2.0.0", ProtocolUtility.GetResource("NuGet.PackageManagement.UI.Test.compiler.resources.nugetSearchPage2.json", typeof(PackageItemLoaderTests)) }, }; using (var httpSource = new TestHttpSource(new PackageSource(source), responses)) { var injectedHttpSources = new Dictionary <string, HttpSource>(); injectedHttpSources.Add(source, httpSource); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { new PackageSource(source) }, new Lazy <INuGetResourceProvider>[] { new Lazy <INuGetResourceProvider>(() => new TestHttpSourceResourceProvider(injectedHttpSources)) }); var repositories = sourceRepositoryProvider.GetRepositories(); var context = new PackageLoadContext(repositories, false, uiContext); var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: telemetryService.Object); // Act var loader = new PackageItemLoader(context, packageFeed, searchText: "nuget", includePrerelease: true); await loader.LoadNextAsync(null, CancellationToken.None); await loader.LoadNextAsync(null, CancellationToken.None); // Assert var events = eventsQueue.ToArray(); Assert.True(4 == events.Length, string.Join(Environment.NewLine, events.Select(e => e.Name))); var search = Assert.Single(events, e => e.Name == "Search"); Assert.Equal(true, search["IncludePrerelease"]); Assert.Equal("nuget", search.GetPiiData().First(p => p.Key == "Query").Value); var operationId = Assert.IsType <string>(search["OperationId"]); var parsedOperationId = Guid.ParseExact(operationId, "D"); var sources = Assert.Single(events, e => e.Name == "SearchPackageSourceSummary"); Assert.Equal(1, sources["NumHTTPv3Feeds"]); Assert.Equal("YesV3", sources["NuGetOrg"]); Assert.Equal(operationId, sources["ParentId"]); var page0 = Assert.Single(events, e => e.Name == "SearchPage" && e["PageIndex"] is int && (int)e["PageIndex"] == 0); Assert.Equal("Ready", page0["LoadingStatus"]); Assert.Equal(operationId, page0["ParentId"]); Assert.IsType <int>(page0["ResultCount"]); Assert.IsType <double>(page0["Duration"]); Assert.IsType <double>(page0["ResultsAggregationDuration"]); Assert.IsType <string>(page0["IndividualSourceDurations"]); Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page0["IndividualSourceDurations"])).Values <double>().Count()); var page1 = Assert.Single(events, e => e.Name == "SearchPage" && e["PageIndex"] is int && (int)e["PageIndex"] == 1); Assert.Equal("Ready", page1["LoadingStatus"]); Assert.Equal(operationId, page1["ParentId"]); Assert.IsType <int>(page1["ResultCount"]); Assert.IsType <double>(page1["Duration"]); Assert.IsType <double>(page1["ResultsAggregationDuration"]); Assert.IsType <string>(page1["IndividualSourceDurations"]); Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page1["IndividualSourceDurations"])).Values <double>().Count()); Assert.Equal(parsedOperationId, loader.State.OperationId); } }
public async Task EmitsSearchTelemetryEvents() { // Arrange var solutionManager = Mock.Of <IVsSolutionManager>(); var uiContext = Mock.Of <INuGetUIContext>(); Mock.Get(uiContext) .Setup(x => x.SolutionManager) .Returns(solutionManager); var telemetryService = new Mock <INuGetTelemetryService>(); var eventsQueue = new ConcurrentQueue <TelemetryEvent>(); telemetryService .Setup(x => x.EmitTelemetryEvent(It.IsAny <TelemetryEvent>())) .Callback <TelemetryEvent>(e => eventsQueue.Enqueue(e)); var source = new Configuration.PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org"); var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source }); var repositories = sourceRepositoryProvider.GetRepositories(); var context = new PackageLoadContext(repositories, false, uiContext); var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: telemetryService.Object); // Act var loader = new PackageItemLoader(context, packageFeed, searchText: "nuget", includePrerelease: true); await loader.LoadNextAsync(null, CancellationToken.None); await loader.LoadNextAsync(null, CancellationToken.None); // Assert var events = eventsQueue.ToArray(); Assert.Equal(4, events.Length); var search = events[0]; Assert.Equal("Search", search.Name); Assert.Equal(true, search["IncludePrerelease"]); Assert.Equal("nuget", search.GetPiiData().First(p => p.Key == "Query").Value); var operationId = Assert.IsType <string>(search["OperationId"]); var parsedOperationId = Guid.ParseExact(operationId, "D"); var sources = events[1]; Assert.Equal("SearchPackageSourceSummary", sources.Name); Assert.Equal(1, sources["NumHTTPv3Feeds"]); Assert.Equal("YesV3", sources["NuGetOrg"]); Assert.Equal(operationId, sources["ParentId"]); var page0 = events[2]; Assert.Equal("SearchPage", page0.Name); Assert.Equal("Ready", page0["LoadingStatus"]); Assert.Equal(0, page0["PageIndex"]); Assert.Equal(operationId, page0["ParentId"]); Assert.IsType <int>(page0["ResultCount"]); Assert.IsType <double>(page0["Duration"]); Assert.IsType <double>(page0["ResultsAggregationDuration"]); Assert.IsType <string>(page0["IndividualSourceDurations"]); Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page0["IndividualSourceDurations"])).Values <double>().Count()); var page1 = events[3]; Assert.Equal("SearchPage", page1.Name); Assert.Equal("Ready", page1["LoadingStatus"]); Assert.Equal(1, page1["PageIndex"]); Assert.Equal(operationId, page1["ParentId"]); Assert.IsType <int>(page1["ResultCount"]); Assert.IsType <double>(page1["Duration"]); Assert.IsType <double>(page1["ResultsAggregationDuration"]); Assert.IsType <string>(page1["IndividualSourceDurations"]); Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page1["IndividualSourceDurations"])).Values <double>().Count()); Assert.Equal(parsedOperationId, loader.State.OperationId); }
public async Task GetTotalCountAsync_WithGreaterThanOrEqualToMaxCountResults_ReturnsMaxCount() { var source1 = new PackageSource("https://dotnet.myget.org/F/nuget-volatile/api/v3/index.json", "NuGetVolatile"); var source2 = new PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org"); var sources = new List <PackageSource> { source1, source2 }; var sourceRepository = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 }); var solutionManager = new Mock <IVsSolutionManager>(); solutionManager.SetupGet(x => x.SolutionDirectory).Returns("z:\\SomeRandomPath"); var settings = new Mock <ISettings>(); var deleteOnRestartManager = new Mock <IDeleteOnRestartManager>(); AddService <IDeleteOnRestartManager>(Task.FromResult <object>(deleteOnRestartManager.Object)); AddService <IVsSolutionManager>(Task.FromResult <object>(solutionManager.Object)); AddService <ISettings>(Task.FromResult <object>(settings.Object)); AddService <ISourceRepositoryProvider>(Task.FromResult <object>(sourceRepository)); var serviceActivationOptions = default(ServiceActivationOptions); var serviceBroker = new Mock <IServiceBroker>(); var authorizationService = new AuthorizationServiceClient(Mock.Of <IAuthorizationService>()); var sharedState = new SharedServiceState(sourceRepository); var projectManagerService = new Mock <INuGetProjectManagerService>(); var installedPackages = new List <IPackageReferenceContextInfo>(); var projects = new List <IProjectContextInfo> { new ProjectContextInfo( Guid.NewGuid().ToString(), ProjectModel.ProjectStyle.PackageReference, NuGetProjectKind.PackageReference) }; projectManagerService.Setup(x => x.GetInstalledPackagesAsync( It.IsAny <IReadOnlyCollection <string> >(), It.IsAny <CancellationToken>())) .Returns(new ValueTask <IReadOnlyCollection <IPackageReferenceContextInfo> >(installedPackages)); #pragma warning disable ISB001 // Dispose of proxies serviceBroker.Setup(x => x.GetProxyAsync <INuGetProjectManagerService>( NuGetServices.ProjectManagerService, It.IsAny <ServiceActivationOptions>(), It.IsAny <CancellationToken>())) .Returns(new ValueTask <INuGetProjectManagerService>(projectManagerService.Object)); #pragma warning restore ISB001 // Dispose of proxies using (var searchService = new NuGetPackageSearchService( serviceActivationOptions, serviceBroker.Object, authorizationService, sharedState)) { const int MaxCount = 100; int totalCount = await searchService.GetTotalCountAsync( MaxCount, projects, sources.Select(s => PackageSourceContextInfo.Create(s)).ToList(), targetFrameworks : new List <string>() { "net45", "net5.0" }, new SearchFilter(includePrerelease : true), NuGet.VisualStudio.Internal.Contracts.ItemFilter.All, CancellationToken.None); Assert.Equal(MaxCount, totalCount); } }
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 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 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 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); } }