/// <summary> /// Checks and installs nuget packages in the project /// </summary> /// <param name="packageSource">The source of the package</param> /// <param name="packageName">The name of the package to be installed</param> public async Task CheckAndInstallNuGetPackageAsync(string packageSource, string packageName) { if (PackageInstallerServices != null) { try { if (!PackageInstallerServices.IsPackageInstalled(this.Project, packageName)) { Version packageVersion = null; PackageInstaller.InstallPackage(packageSource, this.Project, packageName, packageVersion, false); await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Information, $"Nuget Package \"{packageName}\" for OData client was added.")).ConfigureAwait(false); } else { await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Information, $"Nuget Package \"{packageName}\" for OData client already installed.")).ConfigureAwait(false); } } catch (Exception ex) { await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Error, $"Nuget Package \"{packageName}\" for OData client not installed. Error: {ex.Message}.")).ConfigureAwait(false); } } else { await(this.MessageLogger?.WriteMessageAsync(LogMessageCategory.Error, $"The packages were not installed. An error occurred during the installation of packages.")).ConfigureAwait(false); } }
public ExecutionResult Install(InstallDto installOptions) { var logger = new StringLogger(); try { var packageInfo = new PackageInfo(); packageInfo.Configuration = installOptions.Configuration; packageInfo.InstallationDirectory = installOptions.Directory; packageInfo.Name = installOptions.Application; packageInfo.Version = installOptions.Version; var PackageInstaller = new PackageInstaller(); PackageInstaller.Logger = logger; PackageInstaller.Install(packageInfo, new string[] { installOptions.Repository }, installOptions.AdditionalParameters, installOptions.InstallScript, installOptions.ConfigurationFile, installOptions.ConfigurationTransform); return(new ExecutionResult() { Success = logger.Logs.All(x => !x.Error), Log = logger.Logs }); } catch (Exception e) { logger.Log(e.InnerException != null ? e.InnerException.Message : e.Message, true); return(new ExecutionResult() { Success = false, Exception = e.InnerException != null ? e.InnerException.Message : e.Message, Log = logger.Logs }); } }
public void PerformOperation_ShouldMultiplyBy2DownloadAndRemoveCallTimes_WhenInstallPassedAndDependenciesListIsNotEmpty() { var downloaderMock = new Mock <IDownloader>(); var projectMock = new Mock <IProject>(); var packageMock = new Mock <IPackage>(); var packageDependencyMock = new Mock <IPackage>(); projectMock.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>()); packageDependencyMock.Setup(x => x.Dependencies).Returns(new List <IPackage>()); packageMock.Setup(x => x.Dependencies).Returns(new List <IPackage>() { packageDependencyMock.Object }); var installer = new PackageInstaller(downloaderMock.Object, projectMock.Object); installer.Operation = Enums.InstallerOperation.Install; //Act installer.PerformOperation(packageMock.Object); //Assert downloaderMock.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2)); downloaderMock.Verify(x => x.Download(It.IsAny <string>()), Times.Exactly(4)); }
public void CallProjectRemoveMultipleTimes_WhenThereAreDependencies() { // Arrange var downloaderMock = new Mock <IDownloader>(); var projectMock = new Mock <IProject>(); var packageMock = new Mock <IPackage>(); var dependencyPackageMock = new Mock <IPackage>(); dependencyPackageMock.Setup(x => x.Dependencies.Count).Returns(0); packageMock.Setup(x => x.Dependencies.Count).Returns(1); packageMock.Setup(x => x.Dependencies).Returns(new List <IPackage>() { dependencyPackageMock.Object }); projectMock.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>() { packageMock.Object }); downloaderMock.Setup(x => x.Remove(It.IsAny <string>())); // Act var packageInstaller = new PackageInstaller(downloaderMock.Object, projectMock.Object); // Assert // 4 times as there is only one dependency downloaderMock.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2)); }
public async override Task AddNugetPackages() { await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Adding Nuget Packages"); var wcfDSInstallLocation = CodeGeneratorUtils.GetWCFDSInstallLocation(); var packageSource = Path.Combine(wcfDSInstallLocation, @"bin\NuGet"); if (Directory.Exists(packageSource)) { var files = Directory.EnumerateFiles(packageSource, "*.nupkg").ToList(); foreach (var nugetPackage in Common.Constants.V3NuGetPackages) { if (!files.Any(f => Regex.IsMatch(f, nugetPackage + @"(.\d){2,4}.nupkg"))) { packageSource = Common.Constants.NuGetOnlineRepository; } } } else { packageSource = Common.Constants.NuGetOnlineRepository; } if (!PackageInstallerServices.IsPackageInstalled(this.Project, this.ClientNuGetPackageName)) { Version packageVersion = null; PackageInstaller.InstallPackage(Common.Constants.NuGetOnlineRepository, this.Project, this.ClientNuGetPackageName, packageVersion, false); } }
private static void CheckPackage() { if (!EditorPreferences.Get($"{nameof(SDKPackageInstaller)}.Assets", false)) { EditorPreferences.Set($"{nameof(SDKPackageInstaller)}.Assets", PackageInstaller.TryInstallAssets(DefaultSdkAssets)); } }
// Internal for testing internal void AddRecipePackageAndSetTheme() { if (Recipe == null && !string.IsNullOrEmpty(RecipeName)) { KnownRecipe knownRecipe; if (KnownRecipe.Values.TryGetValue(RecipeName, out knownRecipe)) { Trace.Verbose($"Recipe {RecipeName} was in the lookup of known recipes"); // Make sure we're not ignoring packages if (!IgnoreKnownRecipePackages) { // Add the package, but only if it wasn't added manually if (!string.IsNullOrEmpty(knownRecipe.PackageId) && !PackageInstaller.ContainsPackage(knownRecipe.PackageId)) { PackageInstaller.AddPackage(knownRecipe.PackageId); } } else { Trace.Verbose("Ignoring known recipe packages"); } // Set the theme if we don't already have one if (string.IsNullOrEmpty(Theme)) { Theme = knownRecipe.DefaultTheme; } } else { Trace.Verbose($"Recipe {RecipeName} is not in the lookup of known recipes"); } } }
static UltraleapPackageInstaller() { if (!EditorPreferences.Get($"{nameof(UltraleapPackageInstaller)}", false)) { EditorPreferences.Set($"{nameof(UltraleapPackageInstaller)}", PackageInstaller.TryInstallAssets(HiddenPath, DefaultPath)); } }
public void CallDownloadFourTimesAndRemoveTwoTimes_WithOneDependencyInTheList() { // Arrange var downloaderMock = new Mock <IDownloader>(); var projectMock = new Mock <IProject>(); var packageMock = new Mock <IPackage>(); var packageDependencyMock = new Mock <IPackage>(); projectMock.Setup(p => p.PackageRepository.GetAll()).Returns(new List <IPackage>()); packageDependencyMock.Setup(p => p.Dependencies).Returns(new List <IPackage>()); packageMock.Setup(p => p.Dependencies).Returns(new List <IPackage>() { packageDependencyMock.Object }); PackageInstaller packageInstaller = new PackageInstaller(downloaderMock.Object, projectMock.Object); packageInstaller.Operation = InstallerOperation.Install; // Act packageInstaller.PerformOperation(packageMock.Object); // Assert downloaderMock.Verify(d => d.Download(It.IsAny <string>()), Times.Exactly(4)); downloaderMock.Verify(d => d.Remove(It.IsAny <string>()), Times.Exactly(2)); }
private static void CheckPackage() { if (!EditorPreferences.Get($"{nameof(LuminPackageInstaller)}.Profiles", false)) { EditorPreferences.Set($"{nameof(LuminPackageInstaller)}.Profiles", PackageInstaller.TryInstallAssets(HiddenPath, $"{DefaultPath}{Path.DirectorySeparatorChar}Profiles")); } }
public void CallTwoTimesRemoveOfDownloader_WhenThereIsOnlyOnePackageToRestoreWithOneDependencyOnTheChain() { // arrange var downloaderStub = new Mock <IDownloader>(); var projectStub = new Mock <IProject>(); downloaderStub.Setup(x => x.Remove(It.IsAny <string>())); var packageStub = new Mock <IPackage>(); var dependencyPackage = new Mock <IPackage>(); var dependenciesOfDependency = new List <IPackage>(); dependencyPackage.Setup(x => x.Dependencies).Returns(dependenciesOfDependency); var dependenciesList = new List <IPackage>() { dependencyPackage.Object }; packageStub.Setup(x => x.Dependencies).Returns(dependenciesList); projectStub.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>()); var installer = new PackageInstaller(downloaderStub.Object, projectStub.Object); installer.Operation = InstallerOperation.Install; // act installer.PerformOperation(packageStub.Object); // assert downloaderStub.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2)); }
public void ShouldShowErrorIfOneOfPackagesFail() { var callbacks = new List <string>(); var provider = new Mock <IInstallationProvider>(); provider.Setup( i => i.InstallPackage(It.IsAny <IPackageReference>(), It.IsAny <bool>(), It.IsAny <Action <string> >())) .Returns(true); provider.Setup( i => i.InstallPackage(It.Is <IPackageReference>(x => x.PackageId == "testId"), It.IsAny <bool>(), It.IsAny <Action <string> >())) .Returns(false); var references = new List <IPackageReference> { new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")), new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")), new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0")) }; var installer = new PackageInstaller(provider.Object); installer.InstallPackages(references, true, msg => callbacks.Add(msg)); provider.Verify(i => i.InstallPackage(It.IsAny <IPackageReference>(), It.IsAny <bool>(), It.IsAny <Action <string> >()), Times.Exactly(3)); callbacks.Count.ShouldEqual(1); callbacks.Count(x => x.EndsWith("unsuccessful.")).ShouldEqual(1); }
public void InstallPackageWithDependenciesCountEqualsOne_WhenPerformOperationIsCalledWithInstallOption() { // Arrange var downloaderMock = new Mock <IDownloader>(); var projectMock = new Mock <IProject>(); var packageMock = new Mock <IPackage>(); var packageDependencyMock = new Mock <IPackage>(); projectMock.Setup(x => x.PackageRepository.GetAll()).Returns(new List <IPackage>()); packageDependencyMock.SetupGet(x => x.Dependencies).Returns(new List <IPackage>()); packageMock.Setup(x => x.Dependencies).Returns(new List <IPackage>() { packageDependencyMock.Object }); var installer = new PackageInstaller(downloaderMock.Object, projectMock.Object); installer.Operation = InstallerOperation.Install; // Act installer.PerformOperation(packageMock.Object); // Assert downloaderMock.Verify(x => x.Remove(It.IsAny <string>()), Times.Exactly(2)); downloaderMock.Verify(x => x.Download(It.IsAny <string>()), Times.Exactly(4)); }
private void ThreadProc() { try { using (var installer = new PackageInstaller(SetupConfiguration, new Progress(this))) { installer.Install(); } BeginInvoke(new Action(() => MainForm.SetStep(1))); } catch (Exception ex) { BeginInvoke(new Action(() => { MessageBox.Show( this, String.Format( Labels.UnexpectedSituation, ex.Message ), Program.Configuration.Title, MessageBoxButtons.OK, MessageBoxIcon.Error ); MainForm.Dispose(); })); } }
/// ----------------------------------------------------------------------------- /// <summary> /// The InstallPackages method installs the packages /// </summary> /// ----------------------------------------------------------------------------- private void InstallPackages(ref bool clearClientCache) { //Iterate through all the Packages for (int index = 0; index <= Packages.Count - 1; index++) { PackageInstaller installer = Packages.Values[index]; //Check if package is valid if (installer.Package.IsValid) { if (installer.Package.InstallerInfo.Installed || installer.Package.InstallerInfo.RepairInstall) { clearClientCache = true; } InstallerInfo.Log.AddInfo(Util.INSTALL_Start + " - " + installer.Package.Name); installer.Install(); if (InstallerInfo.Log.Valid) { InstallerInfo.Log.AddInfo(Util.INSTALL_Success + " - " + installer.Package.Name); } else { InstallerInfo.Log.AddInfo(Util.INSTALL_Failed + " - " + installer.Package.Name); } } else { InstallerInfo.Log.AddFailure(Util.INSTALL_Aborted + " - " + installer.Package.Name); } } }
protected PackageInstaller CreatePackageInstaller(string filename) { var installer = new PackageInstaller(this.TestContext, filename); this.Installers.Push(installer); return(installer); }
private async Task AddNuGetPackagesAsync(ConnectedServiceHandlerContext context, Project currentProject, Version version) { await context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Adding Nuget Packages"); Version packageVersion = null; if (version.Major.Equals(3)) { var wcfDSInstallLocation = CodeGeneratorUtils.GetWCFDSInstallLocation(); var packageSource = Path.Combine(wcfDSInstallLocation, @"bin\NuGet"); if (Directory.Exists(packageSource)) { var files = Directory.EnumerateFiles(packageSource, "*.nupkg").ToList(); foreach (var nugetPackage in Common.Constants.V3NuGetPackages) { if (!files.Any(f => Regex.IsMatch(f, nugetPackage + @"(.\d){2,4}.nupkg"))) { packageSource = Common.Constants.NuGetOnlineRepository; } } } else { packageSource = Common.Constants.NuGetOnlineRepository; } if (!PackageInstallerServices.IsPackageInstalled(currentProject, Common.Constants.V3ClientNuGetPackage)) { PackageInstaller.InstallPackage(packageSource, currentProject, Common.Constants.V3ClientNuGetPackage, packageVersion, false); } } }
public void PerformOperation_WithInstallCommandAndEmptyDependencies_ShouldCallDownloadTwiceAndRemoveOnce() { // Arrange var downloadMock = new Mock <IDownloader>(); downloadMock.Setup(d => d.Download(It.IsAny <string>())); downloadMock.Setup(d => d.Remove(It.IsAny <string>())); var packageDependencyMock = new Mock <IPackage>(); var packageMock = new Mock <IPackage>(); packageMock.SetupGet(p => p.Name).Returns("Name"); packageMock.SetupGet(p => p.Url).Returns("URLURL"); packageMock.SetupGet(p => p.Dependencies).Returns(new HashSet <IPackage>() { }); var packageRepo = new List <IPackage>(); var projectMock = new Mock <IProject>(); projectMock.Setup(p => p.PackageRepository.GetAll()).Returns(new List <IPackage>() { packageMock.Object }); projectMock.Setup(p => p.PackageRepository.Add(It.IsAny <IPackage>())); // Act var packageInstaller = new PackageInstaller(downloadMock.Object, projectMock.Object); // Assert downloadMock.Verify(d => d.Download(It.IsAny <string>()), Times.Exactly(2)); downloadMock.Verify(d => d.Remove(It.IsAny <string>()), Times.Once); }
public ExecutionResult Update(InstallDto installOptions) { var logger = new StringLogger(); try { var files = Directory.GetFiles(installOptions.Directory, "*.nupkg"); if (files.Count() == 0) { logger.Log("No package to uninstall found, proceeding with a normal install."); } if (files.Count() >= 1) { var filename = PackageHelpers.ExtractPackageName(files.First()).Trim(); var packageInfo = new PackageInfo() { Name = filename.Substring(filename.LastIndexOf("\\") + 1), Version = PackageHelpers.ExtractPackageVersion(files.First()).Trim(), InstallationDirectory = installOptions.Directory, Configuration = installOptions.Configuration }; var packageRemover = new PackageRemover(); packageRemover.Logger = logger; var additionalParams = installOptions.AdditionalParameters; packageRemover.Remove(packageInfo, new string[] { installOptions.Directory }, additionalParams, installOptions.UninstallScript); } var packageInfo2 = new PackageInfo() { Configuration = installOptions.Configuration, InstallationDirectory = installOptions.Directory, Name = installOptions.Application, Version = installOptions.Version }; var PackageInstaller = new PackageInstaller(); PackageInstaller.Logger = logger; PackageInstaller.Install(packageInfo2, new string[] { installOptions.Repository }, installOptions.AdditionalParameters, installOptions.InstallScript, installOptions.ConfigurationFile, installOptions.ConfigurationTransform); return(new ExecutionResult() { Success = logger.Logs.All(x => !x.Error), Log = logger.Logs }); } catch (Exception e) { logger.Log(e.InnerException != null ? e.InnerException.Message : e.Message, true); return(new ExecutionResult() { Success = false, Exception = e.InnerException != null ? e.InnerException.Message : e.Message, Log = logger.Logs }); } }
public void Given_A_Valid_String_List_When_ValidateList_Then_Returns_True() { var installer = new PackageInstaller(); var result = installer.ValidateList(validPackages); result.Should().BeTrue(); }
public void Given_A_ValidPackage_List_When_ExtractDependencyOrder_Then_Returns_Install_Order_List() { var installer = new PackageInstaller(); var result = installer.ExtractDependencyOrder(validPackages); result.Should().Match("KittenService, Ice, Cyberportal, CamelCaser, Leetmeme, Fraudstream"); }
public void Given_A_Valid_String_When_ValidateInput_Then_Returns_True() { var installer = new PackageInstaller(); var result = installer.ValidateInput(simplePackages.First()); result.Should().BeTrue(); }
public void AreFilesOutOfDate_LocalLessThan_Current() { PackageInstaller pkgInstaller = new PackageInstaller(); IInstallSettings currentSettings = pkgInstaller.ReadInstallSettings(Consts.settingsXml01); string filePath = this.WriteTextToTempFile(Consts.settingsXml_Version05); bool result = pkgInstaller.AreExistingFilesOutOfDate(currentSettings, filePath); Assert.IsTrue(result); }
public string Execute([NotNull] string data, [NotNull] string fileName) { var packagePath = Upload(data, fileName); var installer = new PackageInstaller(packagePath); installer.Install(); return(string.Empty); }
public override async Task AddNugetPackages() { await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Adding Nuget Packages"); if (!PackageInstallerServices.IsPackageInstalled(this.Project, this.ClientNuGetPackageName)) { Version packageVersion = null; PackageInstaller.InstallPackage(Common.Constants.NuGetOnlineRepository, this.Project, this.ClientNuGetPackageName, packageVersion, false); } }
/// <summary> /// Initializes a new instance of the <see cref="Configurator"/> class. This overload /// allows passing in a <see cref="Preprocessor"/> that can be reused and pre-configured /// with directives not sourced from the script. /// </summary> /// <param name="engine">The engine to configure.</param> /// <param name="preprocessor">The preprocessor.</param> public Configurator(Engine engine, Preprocessor preprocessor) { _engine = engine; _preprocessor = preprocessor; _assemblyResolver = new AssemblyResolver(_scriptManager); AssemblyLoader = new AssemblyLoader(engine.FileSystem, _assemblyResolver); PackageInstaller = new PackageInstaller(engine.FileSystem, AssemblyLoader); ClassCatalog = new ClassCatalog(); engine.Namespaces.Add(typeof(ScriptBase).Namespace); }
private void InstallPackages() { System.Diagnostics.Stopwatch stopwatch = System.Diagnostics.Stopwatch.StartNew(); using (Trace.WithIndent().Information("Installing NuGet packages")) { PackageInstaller.InstallPackages(); stopwatch.Stop(); Trace.Information($"NuGet packages installed in {stopwatch.ElapsedMilliseconds} ms"); } }
private void InstallPackages(FilePath configFilePath) { Stopwatch stopwatch = Stopwatch.StartNew(); using (Trace.WithIndent().Information("Installing NuGet packages")) { PackageInstaller.InstallPackages(configFilePath); stopwatch.Stop(); Trace.Information($"NuGet packages installed in {stopwatch.ElapsedMilliseconds} ms"); } }
public Configurator(Engine engine, Preprocessor preprocessor) { _engine = engine; AssemblyLoader = new AssemblyLoader(_compilation, engine.FileSystem, engine.Assemblies, engine.Namespaces); PackageInstaller = new PackageInstaller(engine.FileSystem, AssemblyLoader); _preprocessor = preprocessor; // Add the config namespace and assembly engine.Namespaces.Add(typeof(ConfigScriptBase).Namespace); engine.Assemblies.Add(typeof(ConfigScriptBase).Assembly); }
public override async Task AddNugetPackagesAsync() { await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Adding Nuget Packages...").ConfigureAwait(false); foreach (var nugetPackage in Common.Constants.V3NuGetPackages) { await PackageInstaller.CheckAndInstallNuGetPackageAsync(Common.Constants.NuGetOnlineRepository, nugetPackage).ConfigureAwait(false); } await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Nuget Packages were installed.").ConfigureAwait(false); }
public PackageInstallerTests() { _mockLogger = new Mock<ILogger>(); _mockApp = new Mock<IApplicationEnvironment>(); _mockFileSystem = new MockFileSystem(); var applicationBasePath = @"C:\App"; _projectJsonPath = Path.Combine(applicationBasePath, "project.json"); _mockApp.Setup(app => app.ApplicationBasePath) .Returns(applicationBasePath); _packageInstaller = new PackageInstaller(_mockLogger.Object, _mockApp.Object, _mockFileSystem); }
public void ShouldNotInstallExistingPackages() { var provider = new Mock<IInstallationProvider>(); provider.Setup( i => i.IsInstalled(It.Is<IPackageReference>(x => x.PackageId == "testId"), It.IsAny<bool>())) .Returns(true); var references = new List<IPackageReference> { new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")), new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")), new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0")) }; var installer = new PackageInstaller(provider.Object); installer.InstallPackages(references); provider.Verify(i => i.InstallPackage(It.Is<IPackageReference>(x => x.PackageId == "testId"), It.IsAny<bool>(), It.IsAny<Action<string>>()), Times.Never()); }
public void ShouldThrowArgumentNullExWhenNoPackageIdsPassed() { var installer = new PackageInstaller(new Mock<IInstallationProvider>().Object); Assert.Throws<ArgumentNullException>(() => installer.InstallPackages(null)); }
public void ShouldShowSuccessIfNoneOfPackagesFail() { var callbacks = new List<string>(); var provider = new Mock<IInstallationProvider>(); provider.Setup( i => i.InstallPackage(It.IsAny<IPackageReference>(), It.IsAny<bool>(), It.IsAny<Action<string>>())) .Returns(true); var references = new List<IPackageReference> { new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")), new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")), new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0")) }; var installer = new PackageInstaller(provider.Object); installer.InstallPackages(references, true, msg => callbacks.Add(msg)); callbacks.Count.ShouldEqual(1); callbacks.Count(x => x.EndsWith("successful.")).ShouldEqual(1); }