public void ResolveDependenciesForInstallPackageResolvesDependencyUsingDependencyProvider() { // Arrange IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }); IPackage packageB = PackageUtility.CreatePackage("B"); var repository = new Mock<PackageRepositoryBase>(); repository.Setup(c => c.GetPackages()).Returns(new[] { packageA }.AsQueryable()); var dependencyProvider = repository.As<IDependencyResolver>(); dependencyProvider.Setup(c => c.ResolveDependency(It.Is<PackageDependency>(p => p.Id == "B"), It.IsAny<IPackageConstraintProvider>(), false, true, DependencyVersion.Lowest)) .Returns(packageB).Verifiable(); var localRepository = new MockPackageRepository(); IPackageOperationResolver resolver = new InstallWalker(localRepository, repository.Object, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act var operations = resolver.ResolveOperations(packageA).ToList(); // Assert Assert.Equal(2, operations.Count); Assert.Equal(PackageAction.Install, operations.First().Action); Assert.Equal(packageB, operations.First().Package); Assert.Equal(PackageAction.Install, operations.Last().Action); Assert.Equal(packageA, operations.Last().Package); dependencyProvider.Verify(); }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList <PackageOperation> allOperations, out IList <IPackage> packagesByDependencyOrder) { allOperations = new List <PackageOperation>(); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease); if (_project.SupportsINuGetProjectSystem()) { packagesByDependencyOrder = allPackages.ToList(); foreach (var package in allPackages) { allOperations.Add(new PackageOperation(package, PackageAction.Install)); } } else { var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, dependencyVersion: activePackageManager.DependencyVersion); allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder); } return(ShowLicenseAgreement(activePackageManager, allOperations)); }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out List <PackageOperation> allOperations) { allOperations = new List <PackageOperation>(); var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease); foreach (var package in allPackages) { if (allOperations.FindIndex( operation => operation.Action == PackageAction.Install && operation.Package.Id == package.Id && operation.Package.Version == package.Version) == -1) { var operations = installWalker.ResolveOperations(package); allOperations.AddRange(operations); } } allOperations = (List <PackageOperation>)allOperations.Reduce(); return(ShowLicenseAgreement(activePackageManager, allOperations)); }
public void ResolveDependenciesForInstallCircularReferenceThrows() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List <PackageDependency> { new PackageDependency("B") }); IPackage packageB = PackageUtility.CreatePackage("B", "1.0", dependencies: new List <PackageDependency> { new PackageDependency("A") }); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Circular dependency detected 'A 1.0 => B 1.0 => A 1.0'."); }
public IEnumerable <IPackage> GetPackagesToBeInstalledForUpdateAll() { InstallWalker walker = new InstallWalker( _webProjectManager.LocalRepository, _webProjectManager.SourceRepository, TargetFramework, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); var packagesToUpdate = GetPackagesWithUpdates(); var allOperations = new List <PackageOperation>(); foreach (IPackage package in packagesToUpdate) { if (!allOperations.Any(operation => operation.Action == PackageAction.Install && operation.Package.Id == package.Id && operation.Package.Version == package.Version)) { var operations = walker.ResolveOperations(package); allOperations.AddRange(operations); } } return((from operation in allOperations where operation.Action == PackageAction.Install select operation.Package).Distinct()); }
public IEnumerable <IPackage> GetSourcePackageDependencies(IPackage package) { InstallWalker walker = new InstallWalker(localRepository: LocalRepository, sourceRepository: SourceRepository, logger: NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false, targetFramework: null); IEnumerable <PackageOperation> operations = walker.ResolveOperations(package); return(operations.Where(operation => operation.Action == PackageAction.Install).Select(operation => operation.Package)); }
public void ResolveDependencyForInstallPackageWithDependencyThatDoesntMeetExactVersionThrows() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List <PackageDependency> { PackageDependency.CreateDependency("B", "[1.5]") }); sourceRepository.AddPackage(packageA); IPackage packageB = PackageUtility.CreatePackage("B", "1.4"); sourceRepository.AddPackage(packageB); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Unable to resolve dependency 'B (= 1.5)'."); }
protected bool ShowLicenseAgreement( IPackage package, IVsPackageManager packageManager, IEnumerable <Project> projects, out IList <PackageOperation> operations) { var allOperations = new List <PackageOperation>(); foreach (Project project in projects) { var walker = new InstallWalker( packageManager.GetProjectManager(project).LocalRepository, packageManager.SourceRepository, project.GetTargetFrameworkName(), this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, dependencyVersion: packageManager.DependencyVersion); allOperations.AddRange(walker.ResolveOperations(package)); } operations = allOperations.Reduce(); return(ShowLicenseAgreement(packageManager, operations)); }
protected void CheckInstallPSScripts( IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository, FrameworkName targetFramework, bool includePrerelease, out IList <PackageOperation> operations) { // Review: Is there any way the user could get into a position that we would need to allow pre release versions here? var walker = new InstallWalker( localRepository, sourceRepository, targetFramework, this, ignoreDependencies: false, allowPrereleaseVersions: includePrerelease); operations = walker.ResolveOperations(package).ToList(); var scriptPackages = from o in operations where o.Package.HasPowerShellScript() select o.Package; if (scriptPackages.Any()) { if (!RegistryHelper.CheckIfPowerShell2Installed()) { throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript); } } }
void WalkPackage(IPackage package) { var localRepository = new FakePackageRepository(); var sourceRepository = new FakePackageRepository(); var walker = new InstallWalker(localRepository, sourceRepository, null, NullLogger.Instance, true, false, DependencyVersion.Lowest); walker.Walk(package); }
private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository) { InstallWalker walker = new InstallWalker(localRepository: localRepository, sourceRepository: sourceRepository, logger: NullLogger.Instance, ignoreDependencies: false); IEnumerable <PackageOperation> operations = walker.ResolveOperations(package); return(from operation in operations where operation.Action == PackageAction.Install select operation.Package); }
/// <summary> /// Gets the package dependencies. /// </summary> /// <param name="package">The package.</param> /// <param name="localRepository">The local repository.</param> /// <param name="sourceRepository">The source repository.</param> /// <returns></returns> private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository) { InstallWalker walker = new InstallWalker(localRepository: localRepository, sourceRepository: sourceRepository, targetFramework: null, logger: NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false, dependencyVersion: DependencyVersion.Highest); IEnumerable <PackageOperation> operations = walker.ResolveOperations(package); return(from operation in operations where operation.Action == PackageAction.Install select operation.Package); }
protected override bool ExecuteCore(PackageItem item) { var activePackageManager = GetActivePackageManager(); Debug.Assert(activePackageManager != null); var walker = new InstallWalker( ProjectManager.LocalRepository, activePackageManager.SourceRepository, this, ignoreDependencies: false); IList <PackageOperation> operations = walker.ResolveOperations(item.PackageIdentity).ToList(); IList <IPackage> scriptPackages = (from o in operations where o.Package.HasPowerShellScript() select o.Package).ToList(); if (scriptPackages.Count > 0) { if (!RegistryHelper.CheckIfPowerShell2Installed()) { throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript); } } IEnumerable <IPackage> licensePackages = from o in operations where o.Action == PackageAction.Install && o.Package.RequireLicenseAcceptance && !activePackageManager.LocalRepository.Exists(o.Package) select o.Package; // display license window if necessary if (licensePackages.Any()) { // hide the progress window if we are going to show license window HideProgressWindow(); bool accepted = _licenseWindowOpener.ShowLicenseWindow(licensePackages); if (!accepted) { return(false); } ShowProgressWindow(); } try { RegisterPackageOperationEvents(activePackageManager); ExecuteCommand(item, activePackageManager, operations); } finally { UnregisterPackageOperationEvents(activePackageManager); } return(true); }
public void ResolveDependenciesForInstallDiamondDependencyGraph() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); // A -> [B, C] // B -> [D] // C -> [D] // A // / \ // B C // \ / // D IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List <PackageDependency> { new PackageDependency("B"), new PackageDependency("C") }); IPackage packageB = PackageUtility.CreatePackage("B", "1.0", dependencies: new List <PackageDependency> { new PackageDependency("D") }); IPackage packageC = PackageUtility.CreatePackage("C", "1.0", dependencies: new List <PackageDependency> { new PackageDependency("D") }); IPackage packageD = PackageUtility.CreatePackage("D", "1.0"); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageD); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false); // Act var packages = resolver.ResolveOperations(packageA).ToList(); // Assert var dict = packages.ToDictionary(p => p.Package.Id); Assert.AreEqual(4, packages.Count); Assert.IsNotNull(dict["A"]); Assert.IsNotNull(dict["B"]); Assert.IsNotNull(dict["C"]); Assert.IsNotNull(dict["D"]); }
private IEnumerable <PackageOperation> ResolveOperationsToInstallSolutionLevelPackage(Operation operation) { IEnumerable <PackageOperation> enumerable = new InstallWalker(this._virtualPackageRepos[operation.ProjectManager.PackageManager], operation.ProjectManager.PackageManager.DependencyResolver, null, this.Logger, this.IgnoreDependencies, this.AllowPrereleaseVersions, this.DependencyVersion).ResolveOperations(operation.Package); using (IEnumerator <PackageOperation> enumerator = enumerable.GetEnumerator()) { while (enumerator.MoveNext()) { enumerator.Current.Target = PackageOperationTarget.PackagesFolder; } } return(enumerable); }
public void ResolveOperationsForInstallSameDependencyAtDifferentLevelsInGraph() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); // A1 -> B1, C1 IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List <PackageDependency> { PackageDependency.CreateDependency("B", "1.0"), PackageDependency.CreateDependency("C", "1.0") }); // B1 IPackage packageB = PackageUtility.CreatePackage("B", "1.0"); // C1 -> B1, D1 IPackage packageC = PackageUtility.CreatePackage("C", "1.0", dependencies: new List <PackageDependency> { PackageDependency.CreateDependency("B", "1.0"), PackageDependency.CreateDependency("D", "1.0") }); // D1 -> B1 IPackage packageD = PackageUtility.CreatePackage("D", "1.0", dependencies: new List <PackageDependency> { PackageDependency.CreateDependency("B", "1.0") }); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageD); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false); // Act & Assert var packages = resolver.ResolveOperations(packageA).ToList(); Assert.AreEqual(4, packages.Count); Assert.AreEqual("B", packages[0].Package.Id); Assert.AreEqual("D", packages[1].Package.Id); Assert.AreEqual("C", packages[2].Package.Id); Assert.AreEqual("A", packages[3].Package.Id); }
private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository) { var walker = new InstallWalker( localRepository, sourceRepository, new FrameworkName(".NET Framework, Version=4.0"), NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: true); return(from operation in walker.ResolveOperations(package) where operation.Action == PackageAction.Install select operation.Package); }
private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository) { IPackageRepository repository = localRepository; IPackageRepository repository2 = sourceRepository; ILogger instance = NullLogger.Instance; bool ignoreDependencies = false; var walker = new InstallWalker(repository, repository2, new FrameworkName(".NETFramework", new Version("4.0")), instance, ignoreDependencies, true); return(walker.ResolveOperations(package).Where <PackageOperation>(delegate(PackageOperation operation) { return (operation.Action == PackageAction.Install); }).Select <PackageOperation, IPackage>(delegate(PackageOperation operation) { return operation.Package; })); }
protected bool ShowLicenseAgreement( IPackage package, IVsPackageManager packageManager, FrameworkName targetFramework, out IList <PackageOperation> operations) { var walker = new InstallWalker( LocalRepository, packageManager.SourceRepository, targetFramework, this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); operations = walker.ResolveOperations(package).ToList(); return(ShowLicenseAgreement(packageManager, operations)); }
public void ResolveDependenciesForInstallPackageWithUnknownDependencyThrows() { // Arrange IPackage package = PackageUtility.CreatePackage("A", "1.0", dependencies: new List <PackageDependency> { new PackageDependency("B") }); IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(), new MockPackageRepository(), NullLogger.Instance, ignoreDependencies: false); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>(() => resolver.ResolveOperations(package), "Unable to resolve dependency 'B'."); }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList <PackageOperation> allOperations, out IList <IPackage> packagesByDependencyOrder) { allOperations = new List <PackageOperation>(); var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease); allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder); return(ShowLicenseAgreement(activePackageManager, allOperations)); }
public IEnumerable <IPackage> FindDependenciesToBeInstalled(IPackage package) { // We don't currently sync the set of dependencies/packates to be installed // with the target framework of the user's site. We'd need to supply a framework // version here to add that feature. InstallWalker walker = new InstallWalker( _webProjectManager.LocalRepository, _webProjectManager.SourceRepository, TargetFramework, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); IEnumerable <PackageOperation> operations = walker.ResolveOperations(package); return(from operation in operations where operation.Package != package && operation.Action == PackageAction.Install select operation.Package); }
public void ResolveDependenciesForInstallPackageWithUnknownDependencyThrows() { // Arrange IPackage package = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }); IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(), new MockPackageRepository(), NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act & Assert ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(package), "Unable to resolve dependency 'B'."); }
public ReinstallPackageOperations GetReinstallPackageOperations(IEnumerable <IPackage> packages) { var installWalker = new InstallWalker( LocalRepository, SourceRepository, ProjectManager.Project.TargetFramework, ProjectManager.Logger, ignoreDependencies: true, allowPrereleaseVersions: false, dependencyVersion: DependencyVersion.Lowest); IList <IPackage> packagesInDependencyOrder; IList <PackageOperation> operations = installWalker.ResolveOperations( packages, out packagesInDependencyOrder, allowPrereleaseVersionsBasedOnPackage: true); return(new ReinstallPackageOperations(operations, packagesInDependencyOrder)); }
public void InstallWalkerResolvesLowestMajorAndMinorVersionButHighestBuildAndRevisionForDependencies() { // Arrange // A 1.0 -> B 1.0 // B 1.0 -> C 1.1 // C 1.1 -> D 1.0 var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") }); var repository = new MockPackageRepository() { PackageUtility.CreatePackage("B", "2.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.0.1"), A10, PackageUtility.CreatePackage("D", "2.0"), PackageUtility.CreatePackage("C", "1.1.3", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("C", "1.1.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("C", "1.5.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("B", "1.0.9", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.1", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }) }; IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(), repository, NullLogger.Instance, ignoreDependencies: false); // Act var packages = resolver.ResolveOperations(A10).ToList(); // Assert Assert.AreEqual(4, packages.Count); Assert.AreEqual("D", packages[0].Package.Id); Assert.AreEqual(new Version("2.0"), packages[0].Package.Version); Assert.AreEqual("C", packages[1].Package.Id); Assert.AreEqual(new Version("1.1.3"), packages[1].Package.Version); Assert.AreEqual("B", packages[2].Package.Id); Assert.AreEqual(new Version("1.0.9"), packages[2].Package.Version); Assert.AreEqual("A", packages[3].Package.Id); Assert.AreEqual(new Version("1.0"), packages[3].Package.Version); }
public void InstallPackage(IPackageDetails package, bool allowedPrerelease) { Argument.IsNotNull(() => package); Argument.IsOfType(() => package, typeof(PackageDetails)); var repository = _packageOperationContextService.CurrentContext.Repository; var sourceRepository = _repositoryCacheService.GetNuGetRepository(repository); var walker = new InstallWalker(_localRepository, sourceRepository, null, _logger, false, allowedPrerelease, DependencyVersion); try { var nuGetPackage = ((PackageDetails)package).Package; var operations = walker.ResolveOperations(nuGetPackage); _packageManager.InstallPackage(nuGetPackage, false, allowedPrerelease, false); } catch (Exception exception) { _logger.Log(MessageLevel.Error, exception.Message); _packageOperationContextService.CurrentContext.CatchedExceptions.Add(exception); } }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager) { var allOperations = new List <PackageOperation>(); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease).ToList(); foreach (var package in allPackages) { var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); var operations = installWalker.ResolveOperations(package); allOperations.AddRange(operations); } return(ShowLicenseAgreement(activePackageManager, allOperations.Reduce())); }
private IEnumerable <PackageOperation> ResolveOperationsToInstallSolutionLevelPackage(Operation operation) { var repo = _virtualPackageRepos[operation.ProjectManager.PackageManager]; var installWalker = new InstallWalker( repo, operation.ProjectManager.PackageManager.DependencyResolver, targetFramework: null, logger: Logger, ignoreDependencies: IgnoreDependencies, allowPrereleaseVersions: AllowPrereleaseVersions, dependencyVersion: DependencyVersion); var operations = installWalker.ResolveOperations(operation.Package); // we're installing solution level packages, so all target should be // set to PackagesFolder. foreach (var op in operations) { op.Target = PackageOperationTarget.PackagesFolder; } return(operations); }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList<PackageOperation> allOperations, out IList<IPackage> packagesByDependencyOrder) { allOperations = new List<PackageOperation>(); var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, dependencyVersion: activePackageManager.DependencyVersion); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease); allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder); return ShowLicenseAgreement(activePackageManager, allOperations); }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList<PackageOperation> allOperations, out IList<IPackage> packagesByDependencyOrder) { allOperations = new List<PackageOperation>(); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease); if (_project.SupportsINuGetProjectSystem()) { packagesByDependencyOrder = allPackages.ToList(); foreach (var package in allPackages) { allOperations.Add(new PackageOperation(package, PackageAction.Install)); } } else { var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, dependencyVersion: activePackageManager.DependencyVersion); allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder); } return ShowLicenseAgreement(activePackageManager, allOperations); }
protected bool ShowLicenseAgreement( IPackage package, IVsPackageManager packageManager, IEnumerable<Project> projects, out IList<PackageOperation> operations) { var allOperations = new List<PackageOperation>(); foreach (Project project in projects) { var walker = new InstallWalker( packageManager.GetProjectManager(project).LocalRepository, packageManager.SourceRepository, project.GetTargetFrameworkName(), this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, dependencyVersion: packageManager.DependencyVersion); allOperations.AddRange(walker.ResolveOperations(package)); } operations = allOperations.Reduce(); return ShowLicenseAgreement(packageManager, operations); }
public void ResolveOperationsForInstallSameDependencyAtDifferentLevelsInGraph() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); // A1 -> B1, C1 IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "1.0"), PackageDependency.CreateDependency("C", "1.0") }); // B1 IPackage packageB = PackageUtility.CreatePackage("B", "1.0"); // C1 -> B1, D1 IPackage packageC = PackageUtility.CreatePackage("C", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "1.0"), PackageDependency.CreateDependency("D", "1.0") }); // D1 -> B1 IPackage packageD = PackageUtility.CreatePackage("D", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "1.0") }); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageD); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act & Assert var packages = resolver.ResolveOperations(packageA).ToList(); Assert.Equal(4, packages.Count); Assert.Equal("B", packages[0].Package.Id); Assert.Equal("D", packages[1].Package.Id); Assert.Equal("C", packages[2].Package.Id); Assert.Equal("A", packages[3].Package.Id); }
public void ResolvingDependencyForUpdateThatHasAnUnsatisfiedConstraint() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); var constraintProvider = new Mock<IPackageConstraintProvider>(); constraintProvider.Setup(m => m.GetConstraint("B")).Returns(VersionUtility.ParseVersionSpec("[1.4]")); constraintProvider.Setup(m => m.Source).Returns("foo"); IPackage A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "1.5") }); IPackage A20 = PackageUtility.CreatePackage("A", "2.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "2.0") }); IPackage B15 = PackageUtility.CreatePackage("B", "1.5"); IPackage B20 = PackageUtility.CreatePackage("B", "2.0"); localRepository.Add(A10); localRepository.Add(B15); sourceRepository.AddPackage(A10); sourceRepository.AddPackage(A20); sourceRepository.AddPackage(B15); sourceRepository.AddPackage(B20); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, constraintProvider.Object, null, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act & Assert ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(A20), "Unable to resolve dependency 'B (\u2265 2.0)'.'B' has an additional constraint (= 1.4) defined in foo."); }
public void ResolveDependencyForInstallCircularReferenceWithDifferentVersionOfPackageReferenceThrows() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); IPackage packageA10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }); IPackage packageA15 = PackageUtility.CreatePackage("A", "1.5", dependencies: new List<PackageDependency> { new PackageDependency("B") }); IPackage packageB10 = PackageUtility.CreatePackage("B", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("A", "[1.5]") }); sourceRepository.AddPackage(packageA10); sourceRepository.AddPackage(packageA15); sourceRepository.AddPackage(packageB10); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act & Assert ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(packageA10), "Circular dependency detected 'A 1.0 => B 1.0 => A 1.5'."); }
public void ResolveDependenciesForInstallDiamondDependencyGraph() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); // A -> [B, C] // B -> [D] // C -> [D] // A // / \ // B C // \ / // D IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B"), new PackageDependency("C") }); IPackage packageB = PackageUtility.CreatePackage("B", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("D") }); IPackage packageC = PackageUtility.CreatePackage("C", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("D") }); IPackage packageD = PackageUtility.CreatePackage("D", "1.0"); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageD); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act var packages = resolver.ResolveOperations(packageA).ToList(); // Assert var dict = packages.ToDictionary(p => p.Package.Id); Assert.Equal(4, packages.Count); Assert.NotNull(dict["A"]); Assert.NotNull(dict["B"]); Assert.NotNull(dict["C"]); Assert.NotNull(dict["D"]); }
// Reinstall all packages in the specified project public void ReinstallPackages( IProjectManager projectManager, bool updateDependencies, bool allowPrereleaseVersions, ILogger logger) { //1) Call UninstallPackagesForReinstall(IProjectManager, Empty Dictionary, out packagesUninstalledForReinstallation) //2) Call InstallWalker.ResolveOperations(packagesInSourceRepository, out IList<IPackage> packagesByDependencyOrder) //3) Call ExecuteOperationsWithPackage( call projectManager.AddPackageReference(IPackage, ..., ...) HashSet<IPackage> packagesToBeReinstalled; UninstallPackagesForReinstall(projectManager, updateDependencies, logger, new Dictionary<PackageName, IPackage>(), out packagesToBeReinstalled); // NOTE THAT allowPrereleaseVersions should be true for pre-release packages alone, even if the user did not specify it // since we are trying to reinstall packages here. However, ResolveOperations below will take care of this problem via allowPrereleaseVersionsBasedOnPackage parameter var installWalker = new InstallWalker(projectManager.LocalRepository, SourceRepository, projectManager.Project.TargetFramework, logger ?? NullLogger.Instance, ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions, dependencyVersion: DependencyVersion); IList<IPackage> packagesUninstalledInDependencyOrder; var operations = installWalker.ResolveOperations(packagesToBeReinstalled, out packagesUninstalledInDependencyOrder, allowPrereleaseVersionsBasedOnPackage: true); ExecuteOperationsWithPackage( projectManager, null, operations, () => { foreach (var package in packagesUninstalledInDependencyOrder) { AddPackageReference(projectManager, package, ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions || !package.IsReleaseVersion()); } }, logger); }
protected void CheckInstallPSScripts( IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository, FrameworkName targetFramework, bool includePrerelease, out IList<PackageOperation> operations) { // Review: Is there any way the user could get into a position that we would need to allow pre release versions here? var walker = new InstallWalker( localRepository, sourceRepository, targetFramework, this, ignoreDependencies: false, allowPrereleaseVersions: includePrerelease); operations = walker.ResolveOperations(package).ToList(); var scriptPackages = from o in operations where o.Package.HasPowerShellScript() select o.Package; if (scriptPackages.Any()) { if (!RegistryHelper.CheckIfPowerShell2Installed()) { throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript); } } }
protected override bool ExecuteCore(PackageItem item) { var activePackageManager = GetActivePackageManager(); Debug.Assert(activePackageManager != null); var walker = new InstallWalker( ProjectManager.LocalRepository, activePackageManager.SourceRepository, this, ignoreDependencies: false); IList<PackageOperation> operations = walker.ResolveOperations(item.PackageIdentity).ToList(); IList<IPackage> scriptPackages = (from o in operations where o.Package.HasPowerShellScript() select o.Package).ToList(); if (scriptPackages.Count > 0) { if (!RegistryHelper.CheckIfPowerShell2Installed()) { throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript); } } IEnumerable<IPackage> licensePackages = from o in operations where o.Action == PackageAction.Install && o.Package.RequireLicenseAcceptance && !activePackageManager.LocalRepository.Exists(o.Package) select o.Package; // display license window if necessary if (licensePackages.Any()) { // hide the progress window if we are going to show license window HideProgressWindow(); bool accepted = _licenseWindowOpener.ShowLicenseWindow(licensePackages); if (!accepted) { return false; } ShowProgressWindow(); } try { RegisterPackageOperationEvents(activePackageManager); ExecuteCommand(item, activePackageManager, operations); } finally { UnregisterPackageOperationEvents(activePackageManager); } return true; }
public void UpdatePackagesEndToEndWhereNewerVersionPackageDoesNotHaveDependencyLikeOlderVersion() { // Arrange var localRepository = new MockSharedPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var A1 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello1" }, dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") }); var A2 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello2" }, dependencies: new[] { PackageDependency.CreateDependency("C", "1.0") }); var B1 = PackageUtility.CreatePackage("B", "1.0", new[] { "world1" }); var B2 = PackageUtility.CreatePackage("B", "2.0", new[] { "world2" }); var C1 = PackageUtility.CreatePackage("C", "1.0", new[] { "galaxy1" }); var C2 = PackageUtility.CreatePackage("C", "2.0", new[] { "galaxy2" }); sourceRepository.AddPackage(A1); sourceRepository.AddPackage(A2); sourceRepository.AddPackage(B1); sourceRepository.AddPackage(B2); sourceRepository.AddPackage(C1); sourceRepository.AddPackage(C2); localRepository.AddPackage(A1); localRepository.AddPackage(B1); localRepository.AddPackage(C1); projectRepository.Add(A1); projectRepository.Add(B1); projectRepository.Add(C1); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository); var installWalker = new InstallWalker( localRepository, sourceRepository, null, logger: NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: true); IList<IPackage> updatePackagesByDependencyOrder; var updatePackages = new List<IPackage> { A2, B2, C2 }; var operationsForShowingLicense = installWalker.ResolveOperations(updatePackages, out updatePackagesByDependencyOrder); // Act packageManager.UpdatePackages(projectManager, updatePackagesByDependencyOrder, operationsForShowingLicense, updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert // NOTE THAT BELOW, there is no uninstall operation for B1 but only for C1. Because A2 depends on C1 only where A1 depends on B1 only // And, the operations are resolved for A2 NOT A1 Assert.True(operationsForShowingLicense.Count == 4); Assert.True(operationsForShowingLicense[0].Package == A2 && operationsForShowingLicense[0].Action == PackageAction.Install); Assert.True(operationsForShowingLicense[1].Package == B2 && operationsForShowingLicense[1].Action == PackageAction.Install); Assert.True(operationsForShowingLicense[2].Package == C1 && operationsForShowingLicense[2].Action == PackageAction.Uninstall); Assert.True(operationsForShowingLicense[3].Package == C2 && operationsForShowingLicense[3].Action == PackageAction.Install); Assert.True(updatePackagesByDependencyOrder.Count == 3); Assert.True(updatePackagesByDependencyOrder[0] == C2); Assert.True(updatePackagesByDependencyOrder[1] == A2); Assert.True(updatePackagesByDependencyOrder[2] == B2); Assert.True(localRepository.Exists("A", new SemanticVersion("2.0"))); Assert.False(localRepository.Exists("A", new SemanticVersion("1.0"))); Assert.True(localRepository.Exists("B", new SemanticVersion("2.0"))); Assert.False(localRepository.Exists("B", new SemanticVersion("1.0"))); Assert.True(localRepository.Exists("C", new SemanticVersion("2.0"))); Assert.False(localRepository.Exists("C", new SemanticVersion("1.0"))); Assert.True(projectRepository.Exists("A", new SemanticVersion("2.0"))); Assert.True(projectRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectRepository.Exists("C", new SemanticVersion("2.0"))); }
private IEnumerable<PackageOperation> ResolveOperationsToInstallSolutionLevelPackage(Operation operation) { var repo = _virtualPackageRepos[operation.ProjectManager.PackageManager]; var installWalker = new InstallWalker( repo, operation.ProjectManager.PackageManager.DependencyResolver, targetFramework: null, logger: Logger, ignoreDependencies: IgnoreDependencies, allowPrereleaseVersions: AllowPrereleaseVersions, dependencyVersion: DependencyVersion); var operations = installWalker.ResolveOperations(operation.Package); // we're installing solution level packages, so all target should be // set to PackagesFolder. foreach (var op in operations) { op.Target = PackageOperationTarget.PackagesFolder; } return operations; }
protected bool ShowLicenseAgreement( IPackage package, IVsPackageManager packageManager, FrameworkName targetFramework, out IList<PackageOperation> operations) { var walker = new InstallWalker( LocalRepository, packageManager.SourceRepository, targetFramework, this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease, dependencyVersion: packageManager.DependencyVersion); operations = walker.ResolveOperations(package).ToList(); return ShowLicenseAgreement(packageManager, operations); }
public void InstallWalkerResolvesLowestMajorAndMinorHighestPatchVersionOfListedPackagesForDependencies() { // Arrange // A 1.0 -> B 1.0 // B 1.0 -> C 1.1 // C 1.1 -> D 1.0 var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") }); var repository = new MockPackageRepository() { PackageUtility.CreatePackage("B", "2.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }, listed: false), PackageUtility.CreatePackage("B", "1.0.1"), A10, PackageUtility.CreatePackage("D", "2.0"), PackageUtility.CreatePackage("C", "1.1.3", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("C", "1.1.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }, listed: false), PackageUtility.CreatePackage("C", "1.5.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("B", "1.0.9", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.1", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }) }; IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(), repository, constraintProvider: null, logger: NullLogger.Instance, targetFramework: null, ignoreDependencies: false, allowPrereleaseVersions: false) { DependencyVersion = DependencyVersion.HighestPatch }; // Act var packages = resolver.ResolveOperations(A10).ToList(); // Assert Assert.Equal(4, packages.Count); Assert.Equal("D", packages[0].Package.Id); Assert.Equal(new SemanticVersion("2.0"), packages[0].Package.Version); Assert.Equal("C", packages[1].Package.Id); Assert.Equal(new SemanticVersion("1.1.3"), packages[1].Package.Version); Assert.Equal("B", packages[2].Package.Id); Assert.Equal(new SemanticVersion("1.0.9"), packages[2].Package.Version); Assert.Equal("A", packages[3].Package.Id); Assert.Equal(new SemanticVersion("1.0"), packages[3].Package.Version); }
public void ResolveOperationsForPackagesWherePackagesOrderIsDifferentFromItsDependencyOrder() { // Arrange // A 1.0 -> B 1.0 to 1.5 // A 2.0 -> B 1.8 // B 1.0 // B 2.0 // C 1.0 // C 2.0 var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "[1.0, 1.5]") }); var A20 = PackageUtility.CreatePackage("A", "2.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.8") }); var B10 = PackageUtility.CreatePackage("B", "1.0"); var B20 = PackageUtility.CreatePackage("B", "2.0"); var C10 = PackageUtility.CreatePackage("C", "1.0"); var C20 = PackageUtility.CreatePackage("C", "2.0"); var sourceRepository = new MockPackageRepository() { A10, A20, B10, B20, C10, C20, }; var localRepository = new MockPackageRepository() { A10, B10, C10 }; var resolver = new InstallWalker(localRepository, sourceRepository, constraintProvider: NullConstraintProvider.Instance, logger: NullLogger.Instance, targetFramework: null, ignoreDependencies: false, allowPrereleaseVersions: false); var updatePackages = new List<IPackage> { A20, B20, C20 }; IList<IPackage> allUpdatePackagesByDependencyOrder; // Act var operations = resolver.ResolveOperations(updatePackages, out allUpdatePackagesByDependencyOrder); // Assert Assert.True(operations.Count == 3); Assert.True(operations[0].Package == B20 && operations[0].Action == PackageAction.Install); Assert.True(operations[1].Package == A20 && operations[1].Action == PackageAction.Install); Assert.True(operations[2].Package == C20 && operations[2].Action == PackageAction.Install); Assert.True(allUpdatePackagesByDependencyOrder[0] == B20); Assert.True(allUpdatePackagesByDependencyOrder[1] == A20); Assert.True(allUpdatePackagesByDependencyOrder[2] == C20); }
// Reinstall all packages in all projects public void ReinstallPackages( bool updateDependencies, bool allowPrereleaseVersions, ILogger logger, IPackageOperationEventListener eventListener) { //1) Reinstall solution packages first //2) On Each Project, call UninstallAllPackages(IProjectManager, Dictionary<Tuple<string, SemanticVersion>, bool>, out packagesInSourceRepository). And, create a dictionary <projectManager, packages> //3) Append all packagesInSourceRepository into allPackagesInSourceRepository //4) Call InstallWalker.ResolveOperations(allPackagesInSourceRepository, out IList<IPackage> packagesByDependencyOrder) //5) Call for each entry in Dictionary<projectManager, packages> // InitializeLogger, RunSolutionAction( call projectManager.AddPackageReference(IPackage, ..., ...) // Change it to array so that the enumeration is not modified during enumeration to reinstall solution packages var packages = LocalRepository.GetPackages().ToArray(); foreach (var package in packages) { if (!IsProjectLevel(package)) { ReinstallSolutionPackage(package, updateDependencies, allowPrereleaseVersions, logger); } } // Now, take care of project-level packages var packagesInProject = new Dictionary<IProjectManager, HashSet<IPackage>>(); var verifiedPackagesInSourceRepository = new Dictionary<PackageName, IPackage>(); HashSet<IPackage> allPackagesToBeReinstalled = new HashSet<IPackage>(); // first uninstall all the packages from each project RunActionOnProjects( _solutionManager.GetProjects(), project => { IProjectManager projectManager = GetProjectManager(project); HashSet<IPackage> packagesToBeReinstalled; UninstallPackagesForReinstall(projectManager, updateDependencies, logger, verifiedPackagesInSourceRepository, out packagesToBeReinstalled); Debug.Assert(!packagesInProject.ContainsKey(projectManager)); packagesInProject[projectManager] = packagesToBeReinstalled; allPackagesToBeReinstalled.AddRange(packagesToBeReinstalled); }, logger, eventListener ?? NullPackageOperationEventListener.Instance); // NOTE THAT allowPrereleaseVersions should be true for pre-release packages alone, even if the user did not specify it // since we are trying to reinstall packages here. However, ResolveOperations below will take care of this problem via allowPrereleaseVersionsBasedOnPackage parameter var installWalker = new InstallWalker(LocalRepository, SourceRepository, null, logger ?? NullLogger.Instance, ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions, dependencyVersion: DependencyVersion); IList<IPackage> packagesUninstalledInDependencyOrder; var operations = installWalker.ResolveOperations(allPackagesToBeReinstalled, out packagesUninstalledInDependencyOrder, allowPrereleaseVersionsBasedOnPackage: true); ExecuteOperationsWithPackage( _solutionManager.GetProjects(), null, operations, projectManager => { foreach (var package in packagesUninstalledInDependencyOrder) { HashSet<IPackage> packagesToBeReinstalled; if (packagesInProject.TryGetValue(projectManager, out packagesToBeReinstalled) && packagesToBeReinstalled.Contains(package)) { AddPackageReference(projectManager, package, ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions || !package.IsReleaseVersion()); } } }, logger, eventListener); }
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferntVersionOfSamePackage() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); // A -> [B, C] // B -> [D >= 1, E >= 2] // C -> [D >= 2, E >= 1] // A // / \ // B C // | \ | \ // D1 E2 D2 E1 IPackage packageA = PackageUtility.CreateProjectLevelPackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B"), new PackageDependency("C") }); IPackage packageB = PackageUtility.CreateProjectLevelPackage("B", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("D", "1.0"), PackageDependency.CreateDependency("E", "2.0") }); IPackage packageC = PackageUtility.CreateProjectLevelPackage("C", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("D", "2.0"), PackageDependency.CreateDependency("E", "1.0") }); IPackage packageD10 = PackageUtility.CreateProjectLevelPackage("D", "1.0"); IPackage packageD20 = PackageUtility.CreateProjectLevelPackage("D", "2.0"); IPackage packageE10 = PackageUtility.CreateProjectLevelPackage("E", "1.0"); IPackage packageE20 = PackageUtility.CreateProjectLevelPackage("E", "2.0"); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageD20); sourceRepository.AddPackage(packageD10); sourceRepository.AddPackage(packageE20); sourceRepository.AddPackage(packageE10); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act var operations = resolver.ResolveOperations(packageA).ToList(); var projectOperations = resolver.ResolveOperations(packageA).ToList(); // Assert Assert.Equal(5, operations.Count); Assert.Equal("E", operations[0].Package.Id); Assert.Equal(new SemanticVersion("2.0"), operations[0].Package.Version); Assert.Equal("B", operations[1].Package.Id); Assert.Equal("D", operations[2].Package.Id); Assert.Equal(new SemanticVersion("2.0"), operations[2].Package.Version); Assert.Equal("C", operations[3].Package.Id); Assert.Equal("A", operations[4].Package.Id); Assert.Equal(5, projectOperations.Count); Assert.Equal("E", projectOperations[0].Package.Id); Assert.Equal(new SemanticVersion("2.0"), projectOperations[0].Package.Version); Assert.Equal("B", projectOperations[1].Package.Id); Assert.Equal("D", projectOperations[2].Package.Id); Assert.Equal(new SemanticVersion("2.0"), projectOperations[2].Package.Version); Assert.Equal("C", projectOperations[3].Package.Id); Assert.Equal("A", projectOperations[4].Package.Id); }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out List<PackageOperation> allOperations) { allOperations = new List<PackageOperation>(); var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease); foreach (var package in allPackages) { if (allOperations.FindIndex( operation => operation.Action == PackageAction.Install && operation.Package.Id == package.Id && operation.Package.Version == package.Version) == -1) { var operations = installWalker.ResolveOperations(package); allOperations.AddRange(operations); } } allOperations = (List<PackageOperation>)allOperations.Reduce(); return ShowLicenseAgreement(activePackageManager, allOperations); }
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager) { var allOperations = new List<PackageOperation>(); var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease).ToList(); foreach (var package in allPackages) { var installWalker = new InstallWalker( LocalRepository, activePackageManager.SourceRepository, _project.GetTargetFrameworkName(), logger: this, ignoreDependencies: false, allowPrereleaseVersions: IncludePrerelease); var operations = installWalker.ResolveOperations(package); allOperations.AddRange(operations); } return ShowLicenseAgreement(activePackageManager, allOperations.Reduce()); }
public void InstallWalkerResolvesLowestMajorAndMinorVersionButHighestBuildAndRevisionForDependencies() { // Arrange // A 1.0 -> B 1.0 // B 1.0 -> C 1.1 // C 1.1 -> D 1.0 var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") }); var repository = new MockPackageRepository() { PackageUtility.CreatePackage("B", "2.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.0.1"), A10, PackageUtility.CreatePackage("D", "2.0"), PackageUtility.CreatePackage("C", "1.1.3", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("C", "1.1.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("C", "1.5.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }), PackageUtility.CreatePackage("B", "1.0.9", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }), PackageUtility.CreatePackage("B", "1.1", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }) }; IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(), repository, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act var packages = resolver.ResolveOperations(A10).ToList(); // Assert Assert.Equal(4, packages.Count); Assert.Equal("D", packages[0].Package.Id); Assert.Equal(new SemanticVersion("2.0"), packages[0].Package.Version); Assert.Equal("C", packages[1].Package.Id); Assert.Equal(new SemanticVersion("1.1.3"), packages[1].Package.Version); Assert.Equal("B", packages[2].Package.Id); Assert.Equal(new SemanticVersion("1.0.9"), packages[2].Package.Version); Assert.Equal("A", packages[3].Package.Id); Assert.Equal(new SemanticVersion("1.0"), packages[3].Package.Version); }
public void ResolveDependencyForInstallPackageWithDependencyThatDoesntMeetExactVersionThrows() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "[1.5]") }); sourceRepository.AddPackage(packageA); IPackage packageB = PackageUtility.CreatePackage("B", "1.4"); sourceRepository.AddPackage(packageB); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act & Assert ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Unable to resolve dependency 'B (= 1.5)'."); }
public void ResolveDependenciesForInstallPackageResolvesDependencyWithConstraintsUsingDependencyResolver() { // Arrange var packageDependency = new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.1") }); IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { packageDependency }); IPackage packageB10 = PackageUtility.CreatePackage("B", "1.0"); IPackage packageB12 = PackageUtility.CreatePackage("B", "1.2"); var repository = new Mock<PackageRepositoryBase>(MockBehavior.Strict); repository.Setup(c => c.GetPackages()).Returns(new[] { packageA }.AsQueryable()); var dependencyProvider = repository.As<IDependencyResolver>(); dependencyProvider.Setup(c => c.ResolveDependency(packageDependency, It.IsAny<IPackageConstraintProvider>(), false, true)) .Returns(packageB12).Verifiable(); var localRepository = new MockPackageRepository(); IPackageOperationResolver resolver = new InstallWalker(localRepository, repository.Object, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act var operations = resolver.ResolveOperations(packageA).ToList(); // Assert Assert.Equal(2, operations.Count); Assert.Equal(PackageAction.Install, operations.First().Action); Assert.Equal(packageB12, operations.First().Package); Assert.Equal(PackageAction.Install, operations.Last().Action); Assert.Equal(packageA, operations.Last().Package); dependencyProvider.Verify(); }
public void ResolveDependenciesForInstallCircularReferenceThrows() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }); IPackage packageB = PackageUtility.CreatePackage("B", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("A") }); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); IPackageOperationResolver resolver = new InstallWalker( localRepository, new DependencyResolverFromRepo(sourceRepository), NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false, dependencyVersion: DependencyVersion.Lowest); // Act & Assert ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Circular dependency detected 'A 1.0 => B 1.0 => A 1.0'."); }
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferntVersionOfSamePackage() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); // A -> [B, C] // B -> [D >= 1, E >= 2] // C -> [D >= 2, E >= 1] // A // / \ // B C // | \ | \ // D1 E2 D2 E1 IPackage packageA = PackageUtility.CreateProjectLevelPackage("A", "1.0", dependencies: new List <PackageDependency> { new PackageDependency("B"), new PackageDependency("C") }); IPackage packageB = PackageUtility.CreateProjectLevelPackage("B", "1.0", dependencies: new List <PackageDependency> { PackageDependency.CreateDependency("D", "1.0"), PackageDependency.CreateDependency("E", "2.0") }); IPackage packageC = PackageUtility.CreateProjectLevelPackage("C", "1.0", dependencies: new List <PackageDependency> { PackageDependency.CreateDependency("D", "2.0"), PackageDependency.CreateDependency("E", "1.0") }); IPackage packageD10 = PackageUtility.CreateProjectLevelPackage("D", "1.0"); IPackage packageD20 = PackageUtility.CreateProjectLevelPackage("D", "2.0"); IPackage packageE10 = PackageUtility.CreateProjectLevelPackage("E", "1.0"); IPackage packageE20 = PackageUtility.CreateProjectLevelPackage("E", "2.0"); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageD20); sourceRepository.AddPackage(packageD10); sourceRepository.AddPackage(packageE20); sourceRepository.AddPackage(packageE10); IPackageOperationResolver projectResolver = new ProjectInstallWalker(localRepository, sourceRepository, new DependentsWalker(localRepository), NullLogger.Instance, ignoreDependencies: false); IPackageOperationResolver resolver = new InstallWalker(localRepository, sourceRepository, NullLogger.Instance, ignoreDependencies: false); // Act var operations = resolver.ResolveOperations(packageA).ToList(); var projectOperations = resolver.ResolveOperations(packageA).ToList(); // Assert Assert.AreEqual(5, operations.Count); Assert.AreEqual("E", operations[0].Package.Id); Assert.AreEqual(new Version("2.0"), operations[0].Package.Version); Assert.AreEqual("B", operations[1].Package.Id); Assert.AreEqual("D", operations[2].Package.Id); Assert.AreEqual(new Version("2.0"), operations[2].Package.Version); Assert.AreEqual("C", operations[3].Package.Id); Assert.AreEqual("A", operations[4].Package.Id); Assert.AreEqual(5, projectOperations.Count); Assert.AreEqual("E", projectOperations[0].Package.Id); Assert.AreEqual(new Version("2.0"), projectOperations[0].Package.Version); Assert.AreEqual("B", projectOperations[1].Package.Id); Assert.AreEqual("D", projectOperations[2].Package.Id); Assert.AreEqual(new Version("2.0"), projectOperations[2].Package.Version); Assert.AreEqual("C", projectOperations[3].Package.Id); Assert.AreEqual("A", projectOperations[4].Package.Id); }