public R Send <T>(T content) { PackageUtility.Check(expected: typeof(R), actual: typeof(T)); return((R)(object)content); }
public void ExecuteMethodInvokeInstallScriptAndUninstallScript() { // Local repository contains Package A 1.0 and Package B // Source repository contains Package A 2.0 and Package C var packageA1 = PackageUtility.CreatePackage("A", "1.0", tools: new string[] { "uninstall.ps1" }); var packageA2 = PackageUtility.CreatePackage("A", "2.0", content: new string[] { "hello world" }, tools: new string[] { "install.ps1" }); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); // Arrange var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA1); localRepository.AddPackage(packageB); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageC); var project = new Mock <Project>(); var projectManager = CreateProjectManager(localRepository, sourceRepository); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager); packageManager.Setup(p => p.UpdatePackage( projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), true, false, It.IsAny <ILogger>())).Callback( () => { projectManager.AddPackageReference("A", new SemanticVersion("2.0"), false, false); }); var scriptExecutor = new Mock <IScriptExecutor>(); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var provider = CreateUpdatesProvider(packageManager.Object, localRepository, null, null, project.Object, scriptExecutor.Object, null, solutionManager.Object); provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0]; var extensionA = new PackageItem(provider, packageA2); ManualResetEvent manualEvent = new ManualResetEvent(false); provider.ExecuteCompletedCallback = delegate { // Assert try { scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "uninstall.ps1", packageA1, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once()); scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "install.ps1", packageA2, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once()); } finally { manualEvent.Set(); } }; // Act provider.Execute(extensionA); // do not allow the method to return manualEvent.WaitOne(); }
public void CallingEnableCurrentSolutionSetupEverythingCorrectly() { // Arrange string tempSolutionPath = CreateTempFolder(); // setup SolutionManager var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); // setup file system var fileSystem = new PhysicalFileSystem(tempSolutionPath); var fileSystemProvider = new Mock <IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath, It.IsAny <bool>())).Returns(fileSystem); var nugetFolderFileSystem = new PhysicalFileSystem(tempSolutionPath + "\\.nuget"); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath + "\\.nuget", It.IsAny <bool>())).Returns(nugetFolderFileSystem); // default app settings var defaultAppSettings = new Mock <ISettings>(); defaultAppSettings.Setup(s => s.GetValue("packageRestore", "enabled")).Returns("false"); // setup DTE var dte = new Mock <DTE>(); var projectItems = new Mock <ProjectItems>(); var solutionFolder = new Mock <Project>(); solutionFolder.Setup(s => s.Name).Returns(".nuget"); solutionFolder.SetupGet(s => s.ProjectItems).Returns(projectItems.Object); var solution = new Mock <Solution>(); solution.As <Solution2>().Setup(p => p.AddSolutionFolder(".nuget")).Returns(solutionFolder.Object); var projects = new MockProjects(new Project[0]); solution.As <Solution2>().Setup(s => s.Projects).Returns(projects); dte.SetupGet(p => p.Solution).Returns(solution.Object); // setup package repository var packageRepository = new MockPackageRepository(); packageRepository.Add(PackageUtility.CreatePackage( "NuGet.Build", version: "1.0", tools: new string[] { "NuGet.targets" }, dependencies: new PackageDependency[] { new PackageDependency("NuGet.CommandLine") })); packageRepository.Add(PackageUtility.CreatePackage( "NuGet.CommandLine", version: "1.0", tools: new string[] { "NuGet.exe" })); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(); packageRepositoryFactory.Setup(p => p.CreateRepository(NuGetConstants.DefaultFeedUrl)).Returns(packageRepository); var packageSourceProvider = new Mock <IPackageSourceProvider>(); packageSourceProvider.Setup(p => p.LoadPackageSources()).Returns(new[] { new PackageSource(NuGetConstants.DefaultFeedUrl) }); var packageRestore = CreateInstance( dte.Object, solutionManager.Object, fileSystemProvider.Object, packageRepositoryFactory.Object, packageSourceProvider: packageSourceProvider.Object, settings: defaultAppSettings.Object); // Act packageRestore.EnableCurrentSolutionForRestore(fromActivation: false); // Assert // verify that the files are copied to the .nuget sub folder under solution Assert.True(Directory.Exists(Path.Combine(tempSolutionPath, ".nuget"))); Assert.True(File.Exists(Path.Combine(tempSolutionPath, ".nuget\\NuGet.exe"))); Assert.True(File.Exists(Path.Combine(tempSolutionPath, ".nuget\\NuGet.targets"))); // verify that solution folder 'nuget' is added to solution solution.As <Solution2>().Verify(p => p.AddSolutionFolder(".nuget")); projectItems.Verify(p => p.AddFromFile(tempSolutionPath + "\\.nuget\\NuGet.exe")); projectItems.Verify(p => p.AddFromFile(tempSolutionPath + "\\.nuget\\NuGet.targets")); // verify that the Source Control mode is disabled var settings = new Settings(nugetFolderFileSystem); Assert.True(settings.IsSourceControlDisabled()); // verify that package restore consent is not set defaultAppSettings.Verify( s => s.SetValue("packageRestore", "enabled", It.Is <string>(v => v == "true" || v == "1")), Times.Never()); // clean up Directory.Delete(tempSolutionPath, recursive: true); }
private static IEnumerable <IPackage> GetPackagesWithException() { yield return(PackageUtility.CreatePackage("Baz")); throw new InvalidOperationException("Boom"); }
private async Task <bool> ProcessPackageDetailsViaStorageAsync( string packageId, string normalizedPackageVersion, PackageDetailsCatalogLeaf catalogLeaf, Dictionary <string, string> telemetryProperties, CancellationToken cancellationToken) { if (_sourceStorage == null) { return(false); } var packageFileName = PackageUtility.GetPackageFileName(packageId, normalizedPackageVersion); var sourceUri = _sourceStorage.ResolveUri(packageFileName); var sourceBlob = await _sourceStorage.GetCloudBlockBlobReferenceAsync(sourceUri); if (await sourceBlob.ExistsAsync(cancellationToken)) { // It's possible (though unlikely) that the blob may change between reads. Reading a blob with a // single GET request returns the whole blob in a consistent state, but we're reading the blob many // different times. To detect the blob changing between reads, we check the ETag again later. // If the ETag's differ, we'll fall back to using a single HTTP GET request. var token1 = await _sourceStorage.GetOptimisticConcurrencyControlTokenAsync(sourceUri, cancellationToken); telemetryProperties[TelemetryConstants.SizeInBytes] = sourceBlob.Length.ToString(); var nuspec = await GetNuspecAsync(sourceBlob, packageId, cancellationToken); if (string.IsNullOrEmpty(nuspec)) { _logger.LogWarning( "No .nuspec available for {Id}/{Version}. Falling back to HTTP processing.", packageId, normalizedPackageVersion); } else { await _dnxMaker.AddPackageAsync( _sourceStorage, nuspec, packageId, normalizedPackageVersion, catalogLeaf.IconFile, cancellationToken); var token2 = await _sourceStorage.GetOptimisticConcurrencyControlTokenAsync(sourceUri, cancellationToken); if (token1 == token2) { _logger.LogInformation("Added .nupkg and .nuspec for package {Id}/{Version}", packageId, normalizedPackageVersion); return(true); } else { _telemetryService.TrackMetric( TelemetryConstants.BlobModified, metric: 1, properties: GetTelemetryProperties(packageId, normalizedPackageVersion)); } } } else { _telemetryService.TrackMetric( TelemetryConstants.NonExistentBlob, metric: 1, properties: GetTelemetryProperties(packageId, normalizedPackageVersion)); } return(false); }
public void SearchTreeNodeHonorsTheIncludePrereleaseAttribute(bool includePrerelease, string expectedVersion) { // Arrange var packageA1 = PackageUtility.CreatePackage("packageA", "1.0"); var packageA2 = PackageUtility.CreatePackage("packageA", "2.0-alpha"); var packageC = PackageUtility.CreatePackage("packageB", "3.0.0.0-rtm"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageA1); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA2); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(localRepository); var project = new Mock <Project>(); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var provider = CreateOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, project: project.Object); provider.IncludePrerelease = includePrerelease; var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA2); firstTreeNode.Repository.AddPackage(packageA1); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); mockPackageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); var manualEvent = new ManualResetEventSlim(false); // Act 1 var treeNode = (PackagesTreeNodeBase)provider.Search("packageA"); Assert.NotNull(treeNode); Exception exception = null; treeNode.PackageLoadCompleted += (o, e) => { try { var packages = treeNode.Extensions.OfType <PackageItem>().ToList(); Assert.Equal(1, packages.Count); AssertPackage(packages[0].PackageIdentity, "packageA", expectedVersion); } catch (Exception ex) { exception = ex; } finally { manualEvent.Set(); } }; // trigger loading packages var extensions = treeNode.Extensions; // do not allow the method to return manualEvent.Wait(); if (exception != null) { throw exception; } }
public override void Execute() { if (!Package.ExecutionInfo.MakeBackup) { return; } ////////////////////////////////// // Copy files to the Backup directory String dispIconFn = null; String uninstallerPath = P.Combine(Package.ExecutionInfo.BackupDirectory.FullName, "Uninstall.exe"); String thisInstallerPath = Assembly.GetExecutingAssembly().Location; File.Copy(thisInstallerPath, uninstallerPath, true); if (!String.IsNullOrEmpty(DisplayIcon)) { FileInfo iconSrc = Package.RootDirectory.GetFile(DisplayIcon); if (iconSrc.Exists) { dispIconFn = PackageUtility.GetUnusedFileName(P.Combine(Package.ExecutionInfo.BackupDirectory.FullName, "DisplayIcon.ico")); iconSrc.CopyTo(dispIconFn); } else { Package.Log.Add(Anolis.Core.Utility.LogSeverity.Error, "Could not find DisplayIcon: " + DisplayIcon); } } ////////////////////////////////// // Add the registry key RegistryKey uninstallKey = Registry.LocalMachine.CreateSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", RegistryKeyPermissionCheck.ReadWriteSubTree); String regKeyName = "Anolis" + Package.ExecutionInfo.BackupDirectory.Name; RegistryKey prodKey = uninstallKey.CreateSubKey(regKeyName); prodKey.SetValue("DisplayName", Package.Name, RegistryValueKind.String); if (dispIconFn != null) { prodKey.SetValue("DisplayIcon", dispIconFn, RegistryValueKind.String); } prodKey.SetValue("UninstallString", uninstallerPath + " /uninstall:package.xml", RegistryValueKind.String); if (Package.Website != null) { prodKey.SetValue("HelpLink", Package.Website.OriginalString, RegistryValueKind.String); } prodKey.SetValue("Publisher", Package.Attribution, RegistryValueKind.String); prodKey.SetValue("InstallDate", DateTime.Now.ToString("yyyyMMdd"), RegistryValueKind.String); prodKey.SetValue("DisplayVersion", Package.Version.ToString(), RegistryValueKind.String); prodKey.SetValue("Version", Package.Version.Major, RegistryValueKind.DWord); // I've no idea what the convention for the 'Version' value is prodKey.SetValue("VersionMajor", Package.Version.Major, RegistryValueKind.DWord); prodKey.SetValue("VersionMinor", Package.Version.Minor, RegistryValueKind.DWord); String fullKeyPath = uninstallKey.Name + '\\' + regKeyName; Backup(Package.ExecutionInfo.BackupGroup, fullKeyPath); prodKey.Close(); uninstallKey.Close(); }
public override void Execute() { FileAssociations assoc = FileAssociations.GetAssociations(); Backup(assoc, Package.ExecutionInfo.BackupGroup); List <String> extsToDeleteOnUninstall = new List <String>(); List <String> progidsToDeleteOnUninstall = new List <String>(); List <String> iconFilesToDeleteOnUninstall = new List <String>(); DirectoryInfo iconsDir = new DirectoryInfo(PackageUtility.ResolvePath(@"%windir%\Resources\Icons")); if (!iconsDir.Exists) { iconsDir.Create(); } foreach (FileTypeSetting setting in _types) { if (!setting.TypeExt.StartsWith(".", StringComparison.Ordinal)) { Package.Log.Add(LogSeverity.Warning, "Invalid extension, must start with '.': " + setting.TypeExt); continue; } FileType targetType = null; FileExtension targetExtension = null; // get the type for this extension foreach (FileExtension ext in assoc.AllExtensions) { if (String.Equals(ext.Extension, setting.TypeExt, StringComparison.OrdinalIgnoreCase)) { targetExtension = ext; break; } } if (targetExtension == null) { // create type and extension Package.Log.Add(LogSeverity.Info, "Extension undefined: \"" + setting.TypeExt + "\". Creating FileType and FileExtension"); targetType = assoc.CreateFileType(assoc.GetUnusedProgIdForExtension(setting.TypeExt)); targetType.FriendlyName = setting.FriendlyName; targetExtension = assoc.CreateFileExtension(setting.TypeExt); targetExtension.FileType = targetType; extsToDeleteOnUninstall.Add(targetExtension.Extension); progidsToDeleteOnUninstall.Add(targetType.ProgId); } else { targetType = targetExtension.FileType; if (targetType == null) { // create the type Package.Log.Add(LogSeverity.Info, "Extension defined : \"" + setting.TypeExt + "\", but FileType undefined. Creating FileType"); String newProgid = assoc.GetUnusedProgIdForExtension(setting.TypeExt); targetType = assoc.CreateFileType(newProgid); targetType.FriendlyName = setting.FriendlyName; targetExtension.FileType = targetType; progidsToDeleteOnUninstall.Add(newProgid); } } //////////////////////// // copy the icon files to %windir%\Resources\Icons FileInfo iconFile = Package.RootDirectory.GetFile(setting.Icon); String destinationFileName = P.Combine(iconsDir.FullName, iconFile.Name); iconFile.CopyTo(destinationFileName, true); iconFilesToDeleteOnUninstall.Add(destinationFileName); targetType.DefaultIcon = destinationFileName; targetType.IsDirty = true; } assoc.CommitChanges(); BackupPart2(Package.ExecutionInfo.BackupGroup, progidsToDeleteOnUninstall, extsToDeleteOnUninstall, iconFilesToDeleteOnUninstall); }
public Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext) { var package = (Package)entity; return(PackageUtility.GetPackageUrl(package.Id, package.Version, operationContext.AbsoluteServiceUri)); }
private async Task <PackageCatalogItem> GetPackageViaStorageAsync( FeedPackageDetails packageItem, CancellationToken cancellationToken) { PackageCatalogItem item = null; var packageId = packageItem.PackageId.ToLowerInvariant(); var packageNormalizedVersion = packageItem.PackageNormalizedVersion.ToLowerInvariant(); var packageFileName = PackageUtility.GetPackageFileName(packageId, packageNormalizedVersion); var blobUri = _storage.ResolveUri(packageFileName); var blob = await _storage.GetCloudBlockBlobReferenceAsync(blobUri); if (!await blob.ExistsAsync(cancellationToken)) { _telemetryService.TrackMetric( TelemetryConstants.NonExistentBlob, metric: 1, properties: GetProperties(packageId, packageNormalizedVersion, blob)); return(item); } using (_telemetryService.TrackDuration( TelemetryConstants.PackageBlobReadSeconds, GetProperties(packageId, packageNormalizedVersion, blob: null))) { await blob.FetchAttributesAsync(cancellationToken); string packageHash = null; var etag = blob.ETag; var metadata = await blob.GetMetadataAsync(cancellationToken); if (metadata.TryGetValue(Constants.Sha512, out packageHash)) { using (var stream = await blob.GetStreamAsync(cancellationToken)) { item = Utils.CreateCatalogItem( packageItem.ContentUri.ToString(), stream, packageItem.CreatedDate, packageItem.LastEditedDate, packageItem.PublishedDate, licenseNames: null, licenseReportUrl: null, packageHash: packageHash, deprecationItem: packageItem.DeprecationInfo); if (item == null) { _logger.LogWarning("Unable to extract metadata from: {PackageDetailsContentUri}", packageItem.ContentUri); } } if (item != null) { // Since obtaining the ETag the first time, it's possible (though unlikely) that the blob may // have changed. Although reading a blob with a single GET request should return the whole // blob in a consistent state, we're reading the blob using ZipArchive and a seekable stream, // which results in many GET requests. To guard against the blob having changed since we // obtained the package hash, we check the ETag one more time. If this check fails, we'll // fallback to using a single HTTP GET request. await blob.FetchAttributesAsync(cancellationToken); if (etag != blob.ETag) { item = null; _telemetryService.TrackMetric( TelemetryConstants.BlobModified, metric: 1, properties: GetProperties(packageId, packageNormalizedVersion, blob)); } } } else { _telemetryService.TrackMetric( TelemetryConstants.NonExistentPackageHash, metric: 1, properties: GetProperties(packageId, packageNormalizedVersion, blob)); } } return(item); }
protected override Boolean PatchFile(String fileName) { List <PatchResource> patchResources = new List <PatchResource>(); foreach (PatchResourceSet set in _resourceSets) { if (EvaluatePatchResourceSet(set, fileName)) { // HACK: This just adds them together into a massive list. If the same name is mentioned it'll be overwritten several times // fortunately it isnt' very expensive as only the last "final" one counts, but could do with filtering at this stage maybe? patchResources.AddRange(set.Resources); } else { Package.Log.Add(LogSeverity.Info, "Expression evaluation non-one: " + set.Condition.ExpressionString + ", did not process " + set.Resources.Count + " resources"); } } if (patchResources.Count == 0) { Package.Log.Add(LogSeverity.Warning, "No resources to patch: " + fileName); return(false); } try { // for now, use lazy-load under all circumstances. In future analyse the Resources list to see if it's necessary or not // but the performance impact is minimal and it's the safest option, so keep it as it is using (ResourceSource source = ResourceSource.Open(fileName, false, ResourceSourceLoadMode.LazyLoadData)) { List <String> tempFiles = new List <String>(); foreach (PatchResource res in patchResources) { if (res.Source.StartsWith("comp:", StringComparison.OrdinalIgnoreCase)) { CompositedImage comp = new CompositedImage(res.Source, Package.RootDirectory); DirectoryInfo packageTempDirectory = new DirectoryInfo(P.Combine(Package.RootDirectory.FullName, "Temp")); if (!packageTempDirectory.Exists) { packageTempDirectory.Create(); } // I think not using the *.bmp extension messes up Bitmap import String tempFileName = PackageUtility.GetUnusedFileName(P.Combine(packageTempDirectory.FullName, P.GetFileName(Path) + res.Name) + ".bmp"); comp.Save(tempFileName, System.Drawing.Imaging.ImageFormat.Bmp); res.File = tempFileName; tempFiles.Add(tempFileName); } else { res.File = res.Source; } if (!File.Exists(res.File)) { Package.Log.Add(LogSeverity.Error, "Data File not found: " + res.File); continue; } ResourceTypeIdentifier typeId = ResourceTypeIdentifier.CreateFromString(res.Type, true); ResourceIdentifier nameId = ResourceIdentifier.CreateFromString(res.Name); UInt16 langId = String.IsNullOrEmpty(res.Lang) ? UInt16.MaxValue : UInt16.Parse(res.Lang, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture); if (langId == UInt16.MaxValue) // if the lang="" attribute was not specified { ResourceName name = source.GetName(typeId, nameId); if (name == null) // if the specified name does not exist { if (res.Add) { UInt16 sysLang = (UInt16)CultureInfo.InvariantCulture.LCID; ResourceData data = ResourceData.FromFileToAdd(res.File, sysLang, source); source.Add(typeId, nameId, sysLang, data); } else { // Error String sourcePath = source.Name; Anolis.Core.Source.FileResourceSource frs = source as Anolis.Core.Source.FileResourceSource; if (frs != null) { sourcePath = frs.FileInfo.FullName; } Package.Log.Add(LogSeverity.Warning, "Resource name not found: " + sourcePath + '\\' + typeId.ToString() + '\\' + nameId.FriendlyName); } } else { foreach (ResourceLang lang in name.Langs) { ResourceData data = ResourceData.FromFileToUpdate(res.File, lang); lang.SwapData(data); } } } else // if the lang="" attribute was specified { ResourceLang lang = source.GetLang(typeId, nameId, langId); if (lang == null) { ResourceData data = ResourceData.FromFileToAdd(res.File, langId, source); source.Add(typeId, nameId, langId, data); } else { ResourceData data = ResourceData.FromFileToUpdate(res.File, lang); lang.SwapData(data); } } } //foreach // note that Win32ResourceSource now recomptues the PE checksum by itself source.CommitChanges(); foreach (String tempFile in tempFiles) { File.Delete(tempFile); } return(true); } //using source } catch (AnolisException aex) { Package.Log.Add(LogSeverity.Error, "Patch Exception: " + aex.Message); if (File.Exists(fileName)) { File.Delete(fileName); } throw; } }
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; provider.SelectedNode = firstTreeNode; var manualEvent = new ManualResetEventSlim(false); provider.ExecuteCompletedCallback = delegate { // Assert packageManager.Verify(p => p.InstallPackage( projectManager1.Object, packageB.Id, packageB.Version, false, true, provider), Times.Once()); packageManager.Verify(p => p.InstallPackage( projectManager2.Object, packageB.Id, packageB.Version, false, true, provider), Times.Once()); manualEvent.Set(); }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.Wait(); }
public void SolutionInstalledProviderShowsAllVersions() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageA2 = PackageUtility.CreatePackage("A", "2.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); localRepository.AddPackage(packageA2); localRepository.AddPackage(packageB); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; provider.SelectedNode = firstTreeNode; firstTreeNode.IsSelected = true; var mre = new ManualResetEventSlim(false); firstTreeNode.PackageLoadCompleted += delegate { var allExtensions = firstTreeNode.Extensions; // Assert Assert.Equal(3, allExtensions.Count); Assert.Equal("A", allExtensions[0].Id); Assert.Equal("1.0", ((PackageItem)allExtensions[0]).Version); Assert.Equal("A", allExtensions[1].Id); Assert.Equal("2.0", ((PackageItem)allExtensions[1]).Version); Assert.Equal("B", allExtensions[2].Id); Assert.Equal("2.0", ((PackageItem)allExtensions[2]).Version); mre.Set(); }; // Act var ignore = firstTreeNode.Extensions; mre.Wait(); }
/// <summary> /// Runs candle.exe on the source files to generate a list of wixobj intermediate files. /// </summary> /// <param name="outputPane">The window to which to output build messages.</param> /// <returns><see langword="true"/> if successful; otherwise, <see langword="false"/>.</returns> private bool Compile(IVsOutputWindowPane outputPane) { Tracer.VerifyNonNullArgument(outputPane, "outputPane"); string projectRootDirectory = this.Project.RootDirectory; // Get the list of source files that should be built string[] sourceFiles = this.GetOutOfDateSourceFiles(); // If we don't have anything to compile, then just show a message indicating that if (sourceFiles.Length == 0) { this.WriteLineToOutputWindow("Compile targets are up to date."); this.WriteLineToOutputWindow(); return(true); } string[] objectFiles = this.Candle.GetOutputFiles(sourceFiles); string candleParams = this.Candle.ConstructCommandLineParameters(projectRootDirectory, sourceFiles); string toolsPath = WixPackage.Instance.Context.Settings.ToolsDirectory; // Do not quote the path here. It will be quoted in the LaunchPad string candleExePath = PackageUtility.CanonicalizeFilePath(Path.Combine(toolsPath, "candle.exe")); // See if candle exists if (!File.Exists(candleExePath)) { this.WriteLineToOutputWindow("Error: Cannot find candle.exe at '{0}'.", candleExePath); this.WriteLineToOutputWindow(); return(false); } // Create the launch pad used for compilation. LaunchPad candleLaunchPad = new LaunchPad(candleExePath, candleParams); candleLaunchPad.WorkingDirectory = projectRootDirectory; // Output the candle command line to the build output window. Tracer.WriteLineInformation(classType, "Compile", "Performing main compilation..."); this.WriteLineToOutputWindow("Performing main compilation..."); this.WriteLineToOutputWindow(candleLaunchPad.CommandLine); this.WriteLineToOutputWindow(); // Tick once and see if we should continue. if (!this.TickBuild()) { return(false); } // Make sure the output directory exists. string outputDir = this.Candle.AbsoluteOutputDirectory; if (!Directory.Exists(outputDir)) { Directory.CreateDirectory(outputDir); } // Delete the existing .wixobj files if they exist. this.CleanCompileOutput(sourceFiles); // Execute candle.exe piping the output to the output build window and the task pane. bool successful = (candleLaunchPad.ExecuteCommand(outputPane, this) == 0); // Clean up the temporary candle files after the compile has completed. this.Candle.CleanTemporaryFiles(); return(successful); }
public void ExecuteMethodDoNotCallInstallPackageIfUserDoesNotSelectAnyProject() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[0]); var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); provider.ExecuteCompletedCallback = delegate { // Assert mockPackageManager.Verify(p => p.InstallPackage( It.IsAny <IEnumerable <Project> >(), packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, provider, provider), Times.Never()); manualEvent.Set(); }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.Wait(); }
public void ExecuteAllMethodCallUpdateAllPackageOnAllProjects(bool includePrerelease) { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var packageB2 = PackageUtility.CreatePackage("B", "4.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageB2); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageB); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[] { project1, project2 }); var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); provider.IncludePrerelease = includePrerelease; var extensionTree = provider.ExtensionsTree; var extensionB2 = new PackageItem(provider, packageB2); var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); firstTreeNode.Extensions.Add(extensionB2); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception exception = null; provider.ExecuteCompletedCallback = delegate { try { // Assert Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation); mockPackageManager.Verify( p => p.UpdatePackages(true, includePrerelease, provider, provider), Times.Once()); } catch (Exception ex) { exception = ex; } finally { manualEvent.Set(); } }; // Act provider.Execute(item: null); // do not allow the method to return manualEvent.Wait(); Assert.Null(exception); }
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager(bool includePrerelease) { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(localRepository); var project = new Mock <Project>(); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var provider = CreateOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, project: project.Object); provider.IncludePrerelease = includePrerelease; var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); mockPackageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); ManualResetEvent manualEvent = new ManualResetEvent(false); provider.ExecuteCompletedCallback = delegate { // Assert Assert.Equal(RepositoryOperationNames.Install, sourceRepository.LastOperation); mockPackageManager.Verify(p => p.InstallPackage(projectManager.Object, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, includePrerelease, provider), Times.Once()); manualEvent.Set(); }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.WaitOne(); }
public void ExecuteUninstallsSolutionLevelPackageWhenUpdating() { // Arrange var packageA_10 = PackageUtility.CreatePackage("A", "1.0", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null); var packageA_12 = PackageUtility.CreatePackage("A", "1.2", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA_12); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA_10); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.IsProjectLevel(packageA_12)).Returns(false); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[0]); var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA_10); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception exception = null; provider.ExecuteCompletedCallback = delegate { try { // Assert mockPackageManager.Verify(p => p.UpdatePackage( new Project[0], packageA_12, new[] { new PackageOperation(packageA_10, PackageAction.Uninstall), new PackageOperation(packageA_12, PackageAction.Install) }, true, false, provider, provider), Times.Once()); } catch (Exception e) { exception = e; } finally { manualEvent.Set(); } }; var extensionA_12 = new PackageItem(provider, packageA_12); // Act provider.Execute(extensionA_12); // do not allow the method to return manualEvent.Wait(); Assert.Null(exception); }
public void ExecuteMethodInstallPackagesWithInitScript() { // source repo has A, B, C // solution repo has A // project repo has C // install B // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0", content: new string[] { "hello world" }, tools: new string[] { "init.ps1" }); var packageC = PackageUtility.CreatePackage("C", "3.0"); var solutionRepository = new MockPackageRepository(); solutionRepository.AddPackage(packageA); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); var localRepository = new MockPackageRepository(); localRepository.Add(packageC); var projectManager = CreateProjectManager(localRepository, solutionRepository); var project = new Mock <Project>(); project.Setup(p => p.Properties.Item("TargetFrameworkMoniker").Value).Returns(".NETFramework, Version=4.0"); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.LocalRepository).Returns(solutionRepository); packageManager.Setup(p => p.InstallPackage(projectManager, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>())). Raises(p => p.PackageInstalled += null, packageManager, new PackageOperationEventArgs(packageB, null, "")); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var provider = CreateOnlineProvider(packageManager.Object, null, null, null, project.Object, scriptExecutor.Object, solutionManager.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; ManualResetEvent manualEvent = new ManualResetEvent(false); provider.ExecuteCompletedCallback = delegate { try { // Assert // init.ps1 should be executed scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), PowerShellScripts.Init, packageB, null, null, It.IsAny <ILogger>()), Times.Once()); // InstallPackage() should get called packageManager.Verify(p => p.InstallPackage( projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>()), Times.Once()); } finally { manualEvent.Set(); } }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.WaitOne(); }
public static void MarkPackagesForReinstallationMarksPackagesProperly() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0"" targetFramework=""net30""/> <package id=""B"" version=""1.0""/> <package id=""C"" version=""1.0"" targetFramework=""net40""/> </packages>"; var fileSystem = new MockFileSystem(); fileSystem.AddFile("packages.config", config); var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config"); IList<IPackage> packagesToBeReinstalled = new List<IPackage>() { PackageUtility.CreatePackage("A", "1.0"), PackageUtility.CreatePackage("C", "1.0") }; // Act ProjectRetargetingUtility.MarkPackagesForReinstallation(packageReferenceFile, packagesToBeReinstalled); var packageReferences = packageReferenceFile.GetPackageReferences().ToList(); // Assert Assert.Equal(3, packageReferences.Count); Assert.Equal("A", packageReferences[0].Id); Assert.Equal("B", packageReferences[1].Id); Assert.Equal("C", packageReferences[2].Id); Assert.True(packageReferences[0].RequireReinstallation); Assert.False(packageReferences[1].RequireReinstallation); Assert.True(packageReferences[2].RequireReinstallation); }
private static IPackageRepositoryFactory GetFactory() { var repositoryA = new MockPackageRepository { PackageUtility.CreatePackage("Foo"), PackageUtility.CreatePackage("Baz", "0.4"), PackageUtility.CreatePackage("Baz", "0.7") }; var repositoryB = new MockPackageRepository { PackageUtility.CreatePackage("Bar", "0.5"), PackageUtility.CreatePackage("Baz", "0.8.1-alpha") }; var factory = new Mock <IPackageRepositoryFactory>(); factory.Setup(c => c.CreateRepository(It.Is <string>(f => f.Equals("Some source")))).Returns(repositoryA); factory.Setup(c => c.CreateRepository(It.Is <string>(f => f.Equals("Some other source")))).Returns(repositoryB); return(factory.Object); }
public void FallbackRepositoryUsesDependencyResolverIfPrimaryRepositoryDoesNotHaveRequiredDependency() { // Arrange IPackage packageA10 = PackageUtility.CreatePackage("M1", "1.0"), packageA11 = PackageUtility.CreatePackage("M2", "1.1"); var primaryRepository = new MockPackageRepository(); primaryRepository.AddPackage(packageA10); var dependencyResolver = new MockPackageRepository(); dependencyResolver.AddPackage(packageA11); var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver); // Act var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec { MinVersion = new SemanticVersion("1.0.1") }), false, false); // Assert Assert.Same(resolvedPackage, packageA11); }
private async Task <IEnumerable <CatalogEntry> > ProcessCatalogEntriesAsync( CollectorHttpClient client, IEnumerable <CatalogEntry> catalogEntries, CancellationToken cancellationToken) { var processedCatalogEntries = new ConcurrentBag <CatalogEntry>(); await catalogEntries.ForEachAsync(_maxConcurrentCommitItemsWithinBatch, async catalogEntry => { var packageId = catalogEntry.PackageId; var normalizedPackageVersion = catalogEntry.NormalizedPackageVersion; if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDetails.AbsoluteUri) { var telemetryProperties = GetTelemetryProperties(catalogEntry); using (_telemetryService.TrackDuration(TelemetryConstants.ProcessPackageDetailsSeconds, telemetryProperties)) { var packageFileName = PackageUtility.GetPackageFileName( packageId, normalizedPackageVersion); var sourceUri = new Uri(_contentBaseAddress, packageFileName); var destinationStorage = _storageFactory.Create(packageId); var destinationRelativeUri = DnxMaker.GetRelativeAddressNupkg( packageId, normalizedPackageVersion); var destinationUri = destinationStorage.GetUri(destinationRelativeUri); var isNupkgSynchronized = await destinationStorage.AreSynchronized(sourceUri, destinationUri); var isPackageInIndex = await _dnxMaker.HasPackageInIndexAsync( destinationStorage, packageId, normalizedPackageVersion, cancellationToken); var areRequiredPropertiesPresent = await AreRequiredPropertiesPresentAsync(destinationStorage, destinationUri); if (isNupkgSynchronized && isPackageInIndex && areRequiredPropertiesPresent) { _logger.LogInformation("No changes detected: {Id}/{Version}", packageId, normalizedPackageVersion); return; } if ((isNupkgSynchronized && areRequiredPropertiesPresent) || await ProcessPackageDetailsAsync( client, packageId, normalizedPackageVersion, sourceUri, catalogEntry.Uri, telemetryProperties, cancellationToken)) { processedCatalogEntries.Add(catalogEntry); } } } else if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDelete.AbsoluteUri) { var properties = GetTelemetryProperties(catalogEntry); using (_telemetryService.TrackDuration(TelemetryConstants.ProcessPackageDeleteSeconds, properties)) { await ProcessPackageDeleteAsync(packageId, normalizedPackageVersion, cancellationToken); processedCatalogEntries.Add(catalogEntry); } } }); return(processedCatalogEntries); }
private void SelectPackagePage_PageUnload(object sender, W3b.Wizards.PageChangeEventArgs e) { if (InstallerResources.IsCustomized && InstallerResources.CustomizedSettings.SimpleUI) { return; } if (e.PageToBeLoaded == Program.PageBMainAction) { return; } if (__embedRad.Checked) { if (__embedList.SelectedItem == null) { MessageBox.Show(this, InstallerResources.GetString("C_A_selectEmbeddedPackageFirst"), "Anolis Installer", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1); e.Cancel = true; return; } EmbeddedPackage package = __embedList.SelectedItem as EmbeddedPackage; Stream stream = PackageUtility.GetEmbeddedPackage(package); PackageInfo.Source = PackageSource.Embedded; PackageInfo.SourcePath = package.Name; PackageInfo.Archive = PackageArchive.FromStream(package.Name, PackageSubclass.LzmaTarball, stream); } else if (__packRad.Checked) { if (!File.Exists(__packFilename.Text)) { String message = String.Format(CultureInfo.InvariantCulture, InstallerResources.GetString("C_A_notFileExists"), __anopFilename.Text); MessageBox.Show(this, message, "Anolis Installer", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1); e.Cancel = true; return; } String packageName = new DirectoryInfo(Path.GetDirectoryName(__packFilename.Text)).Name; PackageInfo.Source = PackageSource.File; PackageInfo.SourcePath = __packFilename.Text; } else if (__anopRad.Checked) { if (!File.Exists(__anopFilename.Text)) { String message = String.Format(CultureInfo.InvariantCulture, InstallerResources.GetString("C_A_notFileExists"), __anopFilename.Text); MessageBox.Show(this, message, "Anolis Installer", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1); e.Cancel = true; return; } String packageName = Path.GetFileNameWithoutExtension(__anopFilename.Text); Stream stream = File.OpenRead(__anopFilename.Text); PackageInfo.Source = PackageSource.Archive; PackageInfo.SourcePath = __anopFilename.Text; PackageInfo.Archive = PackageArchive.FromStream(packageName, PackageSubclass.LzmaTarball, stream); } }
public void ExecuteAllMethodCallsUpdatePackagesMethodOnPackageManager(bool includePrerelease) { // Local repository contains Package A 1.0 and Package B // Source repository contains Package A 2.0 and Package C var packageA1 = PackageUtility.CreatePackage("A", "1.0"); var packageA2 = PackageUtility.CreatePackage("A", "2.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); // Arrange var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA1); localRepository.AddPackage(packageB); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageC); var project = new Mock <Project>(); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var mockWindowServices = new Mock <IUserNotifierServices>(); var provider = CreateUpdatesProvider(packageManager.Object, localRepository, project: project.Object, userNotifierServices: mockWindowServices.Object, solutionManager: solutionManager.Object); provider.IncludePrerelease = includePrerelease; var extensionA = new PackageItem(provider, packageA2); var extensionC = new PackageItem(provider, packageC); provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0]; var allExtensions = provider.SelectedNode.Extensions; allExtensions.Add(extensionA); allExtensions.Add(extensionC); var manualEvent = new ManualResetEvent(false); Exception exception = null; provider.ExecuteCompletedCallback = delegate { try { // Assert Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation); mockWindowServices.Verify(p => p.ShowLicenseWindow(It.IsAny <IEnumerable <IPackage> >()), Times.Never()); packageManager.Verify(p => p.UpdatePackages(projectManager.Object, true, includePrerelease, provider), Times.Once()); } catch (Exception ex) { exception = ex; } finally { manualEvent.Set(); } }; // Act provider.Execute(item: null); // do not allow the method to return manualEvent.WaitOne(); Assert.Null(exception); }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // Switches to the UI thread in order to consume some services used in command initialization await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); await RegisterVsServicesAsync(); mCommandController = new CommandController(this); CommandTestUtility.CommandController = mCommandController; var vsOutputWindow = VsServiceProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow; mOutputWindowController = new OutputWindowController(); mOutputWindowController.Initialize(this, vsOutputWindow); mRunningDocTableEvents = new RunningDocTableEvents(this); mErrorWindowController = new ErrorWindowController(this); #region Get Pointer to IVsSolutionEvents if (VsServiceProvider.TryGetService(typeof(SVsSolution), out object vsSolutionService)) { var vsSolution = vsSolutionService as IVsSolution; UnadviseSolutionEvents(vsSolution); AdviseSolutionEvents(vsSolution); } #endregion // Get the build and command events from DTE if (VsServiceProvider.TryGetService(typeof(DTE), out object dte)) { var dte2 = dte as DTE2; mBuildEvents = dte2.Events.BuildEvents; mCommandEvents = dte2.Events.CommandEvents; mDteEvents = dte2.Events.DTEEvents; } DispatcherHandler.Initialize(dte as DTE2); SettingsProvider.Initialize(this); // Detect the first install if (string.IsNullOrWhiteSpace(SettingsProvider.GeneralSettings.Version)) { ShowToolbare(); // Show the toolbar on the first install } var currentVersion = PackageUtility.GetVersion(); if (!string.IsNullOrWhiteSpace(currentVersion) && 0 > string.Compare(SettingsProvider.GeneralSettings.Version, currentVersion)) { mOutputWindowController.Clear(); mOutputWindowController.Show(); mOutputWindowController.Write($"🎉\tClang Power Tools was upgraded to v{currentVersion}\n" + $"\tCheck out what's new at http://www.clangpowertools.com/CHANGELOG"); SettingsProvider.GeneralSettings.Version = currentVersion; System.Diagnostics.Process.Start(new ProcessStartInfo("https://clangpowertools.com/blog/future-of-clang-power-tools.html")); } SettingsHandler.SaveGeneralSettings(); await mCommandController.InitializeCommandsAsync(this); mLicenseController = new LicenseController(); RegisterToEvents(); await mLicenseController.CheckLicenseAsync(); await base.InitializeAsync(cancellationToken, progress); }
public void remove(RegistryApplicationKey key, ChocolateyConfiguration config, PackageResult packageResult, string packageCacheLocation) { var userProvidedUninstallArguments = string.Empty; var userOverrideUninstallArguments = false; var package = packageResult.Package; if (package != null) { if (!PackageUtility.package_is_a_dependency(config, package.Id) || config.ApplyInstallArgumentsToDependencies) { userProvidedUninstallArguments = config.InstallArguments; userOverrideUninstallArguments = config.OverrideArguments; if (!string.IsNullOrWhiteSpace(userProvidedUninstallArguments)) { this.Log().Debug(ChocolateyLoggers.Verbose, " Using user passed {2}uninstaller args for {0}:'{1}'".format_with(package.Id, userProvidedUninstallArguments.escape_curly_braces(), userOverrideUninstallArguments ? "overriding " : string.Empty)); } } } //todo: if there is a local package, look to use it in the future if (string.IsNullOrWhiteSpace(key.UninstallString)) { this.Log().Info(" Skipping auto uninstaller - '{0}' does not have an uninstall string.".format_with(!string.IsNullOrEmpty(key.DisplayName.to_string()) ? key.DisplayName.to_string().escape_curly_braces() : "The application")); return; } this.Log().Debug(() => " Preparing uninstall key '{0}' for '{1}'".format_with(key.UninstallString.to_string().escape_curly_braces(), key.DisplayName.to_string().escape_curly_braces())); if ((!string.IsNullOrWhiteSpace(key.InstallLocation) && !_fileSystem.directory_exists(key.InstallLocation)) || !_registryService.installer_value_exists(key.KeyPath, ApplicationParameters.RegistryValueInstallLocation)) { this.Log().Info(" Skipping auto uninstaller - '{0}' appears to have been uninstalled already by other means.".format_with(!string.IsNullOrEmpty(key.DisplayName.to_string()) ? key.DisplayName.to_string().escape_curly_braces() : "The application")); this.Log().Debug(() => " Searched for install path '{0}' - found? {1}".format_with(key.InstallLocation.to_string().escape_curly_braces(), _fileSystem.directory_exists(key.InstallLocation))); this.Log().Debug(() => " Searched for registry key '{0}' value '{1}' - found? {2}".format_with(key.KeyPath.escape_curly_braces(), ApplicationParameters.RegistryValueInstallLocation, _registryService.installer_value_exists(key.KeyPath, ApplicationParameters.RegistryValueInstallLocation))); return; } // split on " /" and " -" for quite a bit more accuracy IList <string> uninstallArgsSplit = key.UninstallString.to_string().Replace(""", "\"").Replace("'", "'").Split(new[] { " /", " -" }, StringSplitOptions.RemoveEmptyEntries).ToList(); var uninstallExe = uninstallArgsSplit.DefaultIfEmpty(string.Empty).FirstOrDefault().trim_safe(); if (uninstallExe.Count(u => u == '"') > 2) { uninstallExe = uninstallExe.Split(new [] { " \"" }, StringSplitOptions.RemoveEmptyEntries).First(); } if (uninstallExe.Count(u => u == ':') > 1) { try { var firstMatch = Regex.Match(uninstallExe, @"\s+\w\:", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase); uninstallExe = uninstallExe.Substring(0, firstMatch.Index); } catch (Exception ex) { this.Log().Debug("Error splitting the uninstall string:{0} {1}".format_with(Environment.NewLine, ex.to_string())); } } var uninstallArgs = key.UninstallString.to_string().Replace(""", "\"").Replace("'", "'").Replace(uninstallExe.to_string(), string.Empty).trim_safe(); uninstallExe = uninstallExe.remove_surrounding_quotes(); this.Log().Debug(() => " Uninstaller path is '{0}'".format_with(uninstallExe)); if (uninstallExe.contains("\\") || uninstallExe.contains("/")) { if (!_fileSystem.file_exists(uninstallExe)) { this.Log().Info(" Skipping auto uninstaller - The uninstaller file no longer exists. \"{0}\"".format_with(uninstallExe)); return; } } IInstaller installer = get_installer_type(key, uninstallExe, uninstallArgs); this.Log().Debug(() => " Installer type is '{0}'".format_with(installer.GetType().Name)); if (key.InstallerType == InstallerType.Msi) { // because sometimes the key is set with /i to allow for modify :/ uninstallArgs = uninstallArgs.Replace("/I{", "/X{"); uninstallArgs = uninstallArgs.Replace("/i{", "/X{"); uninstallArgs = uninstallArgs.Replace("/I ", "/X "); uninstallArgs = uninstallArgs.Replace("/i ", "/X "); } if (!key.HasQuietUninstall) { //todo: ultimately we should merge keys uninstallArgs += " " + installer.build_uninstall_command_arguments(); } if (!string.IsNullOrWhiteSpace(userProvidedUninstallArguments)) { if (userOverrideUninstallArguments) { this.Log().Debug(() => " Replacing original uninstall arguments of '{0}' with '{1}'".format_with(uninstallArgs.escape_curly_braces(), userProvidedUninstallArguments.escape_curly_braces())); uninstallArgs = userProvidedUninstallArguments; } else { this.Log().Debug(() => " Appending original uninstall arguments with '{0}'".format_with(userProvidedUninstallArguments.escape_curly_braces())); uninstallArgs += " " + userProvidedUninstallArguments; } } this.Log().Debug(() => " Setting up uninstall logging directory at {0}".format_with(packageCacheLocation.escape_curly_braces())); _fileSystem.create_directory_if_not_exists(_fileSystem.get_directory_name(packageCacheLocation)); uninstallArgs = uninstallArgs.Replace(InstallTokens.PACKAGE_LOCATION, packageCacheLocation); uninstallArgs = uninstallArgs.Replace(InstallTokens.TEMP_LOCATION, packageCacheLocation); this.Log().Debug(() => " Args are '{0}'".format_with(uninstallArgs.escape_curly_braces())); if (!key.HasQuietUninstall && installer.GetType() == typeof(CustomInstaller)) { if (!config.Information.IsLicensedVersion) { this.Log().Warn(@" Did you know licensed versions of Chocolatey are 95% effective with Automatic Uninstaller due to licensed enhancements and Package Synchronizer? "); } var skipUninstaller = true; var timeout = config.PromptForConfirmation ? 0 : 30; var selection = InteractivePrompt.prompt_for_confirmation( "Uninstall may not be silent (could not detect). Proceed?", new[] { "yes", "no" }, defaultChoice: "no", requireAnswer: true, allowShortAnswer: true, shortPrompt: true, timeoutInSeconds: timeout ); if (selection.is_equal_to("yes")) { skipUninstaller = false; } if (skipUninstaller) { this.Log().Info(" Skipping auto uninstaller - Installer type was not detected and no silent uninstall key exists."); this.Log().Warn("If the application was not removed with a chocolateyUninstall.ps1,{0} please remove it from Programs and Features manually.".format_with(Environment.NewLine)); return; } } var exitCode = _commandExecutor.execute( uninstallExe, uninstallArgs.trim_safe(), config.CommandExecutionTimeoutSeconds, (s, e) => { if (e == null || string.IsNullOrWhiteSpace(e.Data)) { return; } this.Log().Info(() => " [AutoUninstaller] {0}".format_with(e.Data.escape_curly_braces())); }, (s, e) => { if (e == null || string.IsNullOrWhiteSpace(e.Data)) { return; } this.Log().Error(() => " [AutoUninstaller] {0}".format_with(e.Data.escape_curly_braces())); }, updateProcessPath: false); if (!installer.ValidUninstallExitCodes.Contains(exitCode)) { Environment.ExitCode = exitCode; string logMessage = " Auto uninstaller failed. Please remove machine installation manually.{0} Exit code was {1}".format_with(Environment.NewLine, exitCode); this.Log().Error(() => logMessage.escape_curly_braces()); packageResult.Messages.Add(new ResultMessage(config.Features.FailOnAutoUninstaller ? ResultType.Error : ResultType.Warn, logMessage)); } else { this.Log().Info(() => " Auto uninstaller has successfully uninstalled {0} or detected previous uninstall.".format_with(packageResult.Package.Id)); } }
public void InstallPackageInvokeInstallScript() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0", tools: new[] { "install.ps1" }); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); var fileSystem = new Mock <IVsProjectSystem>(); fileSystem.SetupGet(f => f.UniqueName).Returns("Project1"); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); projectManager1.Setup(p => p.AddPackageReference(packageB, false, false)) .Raises(p => p.PackageReferenceAdded += (o, a) => { }, new PackageOperationEventArgs(packageB, fileSystem.As <IFileSystem>().Object, "x:\\nuget")); var project1 = MockProjectUtility.CreateMockProject("Project1"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); packageManager.Setup(p => p.InstallPackage( new[] { project1 }, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>(), It.IsAny <IPackageOperationEventListener>())) .Callback( (IEnumerable <Project> projects, IPackage package, IEnumerable <PackageOperation> operations, bool ignoreDependencies, bool allowPrereleaseVersions, ILogger logger, IPackageOperationEventListener eventListener) => { eventListener.OnBeforeAddPackageReference(project1); projectManager1.Object.AddPackageReference(packageB, false, false); }); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 }); var scriptExecutor = new Mock <IScriptExecutor>(); var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, scriptExecutor: scriptExecutor.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception callbackException = null; provider.ExecuteCompletedCallback = delegate { try { // Assert scriptExecutor.Verify(p => p.Execute("x:\\nuget", "install.ps1", packageB, project1, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once()); } catch (Exception exception) { callbackException = exception; } finally { manualEvent.Set(); } }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.Wait(); if (callbackException != null) { throw callbackException; } }
public void CallingCheckForMissingPackagesRaisesThePackagesMissingStatusChangedEventWithFalseValue() { // Scenario: // Project's packages.config specifies: A[1.0], B[1.2-alpha] // The solution's packages folder contains only A[1.0], B[1.2-alpha] // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock <Project>(); // setup SolutionManager var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock <IFileSystem>(); fileSystem.Setup(p => p.DirectoryExists(".nuget")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\nuget.exe")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\nuget.targets")).Returns(true); var fileSystemProvider = new Mock <IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath, It.IsAny <bool>())).Returns(fileSystem.Object); // setup VsPackageManager var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> <package id=""B"" version=""1.2-alpha"" /> </packages>"); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, new Mock <ISharedPackageRepository>().Object); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); localRepository.AddPackage(PackageUtility.CreatePackage("B", "1.2-alpha")); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); bool?packagesMissing = null; packageRestore.PackagesMissingStatusChanged += (o, e) => { packagesMissing = e.PackagesMissing; }; // Act packageRestore.CheckForMissingPackages(); // Assert Assert.Equal(false, packagesMissing); }
private static IVsPackageManager GetPackageManager() { var fileSystem = new Mock <IFileSystem>(); var localRepo = new Mock <ISharedPackageRepository>(); var localPackages = new[] { PackageUtility.CreatePackage("P1", "0.9"), PackageUtility.CreatePackage("Pack2") }; localRepo.Setup(c => c.GetPackages()).Returns(localPackages.AsQueryable()); var remotePackages = new[] { PackageUtility.CreatePackage("P0", "1.1"), PackageUtility.CreatePackage("P1", "1.1"), PackageUtility.CreatePackage("Pack2", "1.2"), PackageUtility.CreatePackage("P3") }; var remoteRepo = new Mock <IPackageRepository>(); remoteRepo.Setup(c => c.GetPackages()).Returns(remotePackages.AsQueryable()); return(new VsPackageManager(TestUtils.GetSolutionManager(), remoteRepo.Object, new Mock <IFileSystemProvider>().Object, fileSystem.Object, localRepo.Object, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object)); }