Beispiel #1
0
        public void ResolveDependenciesForUninstallPackageWithDependentAndForceReturnsPackage()
        {
            // Arrange
            var localRepository = new MockPackageRepository();

            IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
                                                             dependencies: new List <PackageDependency> {
                new PackageDependency("B")
            });

            IPackage packageB = PackageUtility.CreatePackage("B", "1.0");

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                                     new DependentsWalker(localRepository),
                                                                     NullLogger.Instance,
                                                                     removeDependencies: false,
                                                                     forceRemove: true);

            // Act
            var packages = resolver.ResolveOperations(packageB)
                           .ToDictionary(p => p.Package.Id);

            // Assert
            Assert.AreEqual(1, packages.Count);
            Assert.IsNotNull(packages["B"]);
        }
Beispiel #2
0
        public void ResolveDependenciesForUninstallDiamondDependencyGraph()
        {
            // Arrange
            var localRepository = 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");

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);
            localRepository.AddPackage(packageC);
            localRepository.AddPackage(packageD);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                                     new DependentsWalker(localRepository),
                                                                     NullLogger.Instance,
                                                                     removeDependencies: true,
                                                                     forceRemove: false);



            // Act
            var packages = resolver.ResolveOperations(packageA)
                           .ToDictionary(p => p.Package.Id);

            // Assert
            Assert.AreEqual(4, packages.Count);
            Assert.IsNotNull(packages["A"]);
            Assert.IsNotNull(packages["B"]);
            Assert.IsNotNull(packages["C"]);
            Assert.IsNotNull(packages["D"]);
        }
Beispiel #3
0
        private IEnumerable <PackageOperation> ResolveOperationsToUninstallSolutionLevelPackage(Operation operation)
        {
            IEnumerable <PackageOperation> enumerable = new UninstallWalker(this._virtualPackageRepos[operation.ProjectManager.PackageManager], new DependentsWalker(operation.ProjectManager.PackageManager.LocalRepository, null), null, NullLogger.Instance, this.RemoveDependencies, this.ForceRemove).ResolveOperations(operation.Package);

            using (IEnumerator <PackageOperation> enumerator = enumerable.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    enumerator.Current.Target = PackageOperationTarget.PackagesFolder;
                }
            }
            return(enumerable);
        }
Beispiel #4
0
        protected bool?AskRemoveDependency(
            IPackage package,
            IList <IPackageRepository> localRepositories,
            IList <FrameworkName> targetFrameworks)
        {
            Debug.Assert(localRepositories.Count == targetFrameworks.Count);

            var allOperations = new List <PackageOperation>();

            for (int i = 0; i < localRepositories.Count; i++)
            {
                var uninstallWalker = new UninstallWalker(
                    localRepositories[i],
                    new DependentsWalker(localRepositories[i], targetFrameworks[i]),
                    targetFrameworks[i],
                    logger: NullLogger.Instance,
                    removeDependencies: true,
                    forceRemove: false)
                {
                    ThrowOnConflicts = false
                };
                var operations = uninstallWalker.ResolveOperations(package);
                allOperations.AddRange(operations);
            }

            allOperations = allOperations.Reduce().ToList();

            var uninstallPackageNames = (from o in allOperations
                                         where o.Action == PackageAction.Uninstall && !PackageEqualityComparer.IdAndVersion.Equals(o.Package, package)
                                         select o.Package)
                                        .Distinct(PackageEqualityComparer.IdAndVersion)
                                        .Select(p => p.ToString())
                                        .ToList();

            bool?removeDependencies = false;

            if (uninstallPackageNames.Count > 0)
            {
                // show each dependency package on one line
                String packageNames = String.Join(Environment.NewLine, uninstallPackageNames);
                String message      = String.Format(CultureInfo.CurrentCulture, Resources.Dialog_RemoveDependencyMessage, package)
                                      + Environment.NewLine
                                      + Environment.NewLine
                                      + packageNames;

                removeDependencies = _userNotifierServices.ShowRemoveDependenciesWindow(message);
            }

            return(removeDependencies);
        }
Beispiel #5
0
        private IEnumerable <PackageOperation> ResolveOperationsToUninstallProjectLevelPackage(Operation operation)
        {
            var projectRepo     = _virtualProjectRepos[operation.ProjectManager];
            var targetFramework = operation.ProjectManager.GetTargetFrameworkForPackage(operation.Package.Id);
            var resolver        = new UninstallWalker(
                projectRepo,
                new DependentsWalker(projectRepo, targetFramework),
                targetFramework,
                NullLogger.Instance,
                RemoveDependencies,
                ForceRemove);
            var operations = resolver.ResolveOperations(operation.Package);

            return(operations);
        }
Beispiel #6
0
        public void ResolveDependenciesForUninstallPackageWithRemoveDependenciesSetAndForceReturnsAllDependencies()
        {
            // Arrange
            var localRepository = new MockPackageRepository();

            // A 1.0 -> [B, C]
            IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
                                                             dependencies: new List <PackageDependency> {
                new PackageDependency("B"),
                new PackageDependency("C")
            });

            IPackage packageB = PackageUtility.CreatePackage("B", "1.0");
            IPackage packageC = PackageUtility.CreatePackage("C", "1.0");

            // D -> [C]
            IPackage packageD = PackageUtility.CreatePackage("D", "1.0",
                                                             dependencies: new List <PackageDependency> {
                new PackageDependency("C"),
            });

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);
            localRepository.AddPackage(packageC);
            localRepository.AddPackage(packageD);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                                     new DependentsWalker(localRepository),
                                                                     NullLogger.Instance,
                                                                     removeDependencies: true,
                                                                     forceRemove: true);

            // Act
            var packages = resolver.ResolveOperations(packageA)
                           .ToDictionary(p => p.Package.Id);

            // Assert
            Assert.IsNotNull(packages["A"]);
            Assert.IsNotNull(packages["B"]);
            Assert.IsNotNull(packages["C"]);
        }
Beispiel #7
0
        public void UninstallPackage(IPackageDetails package)
        {
            Argument.IsNotNull(() => package);
            Argument.IsOfType(() => package, typeof(PackageDetails));

            var dependentsResolver = new DependentsWalker(_localRepository, null);

            var walker = new UninstallWalker(_localRepository, dependentsResolver, null,
                                             _logger, true, false);

            try
            {
                var nuGetPackage = ((PackageDetails)package).Package;
                walker.ResolveOperations(nuGetPackage);
                _packageManager.UninstallPackage(nuGetPackage, false, true);
            }
            catch (Exception exception)
            {
                _logger.Log(MessageLevel.Error, exception.Message);
                _packageOperationContextService.CurrentContext.CatchedExceptions.Add(exception);
            }
        }
Beispiel #8
0
        private IEnumerable <PackageOperation> ResolveOperationsToUninstallSolutionLevelPackage(Operation operation)
        {
            var repo     = _virtualPackageRepos[operation.ProjectManager.PackageManager];
            var resolver = new UninstallWalker(
                repo,
                new DependentsWalker(
                    operation.ProjectManager.PackageManager.LocalRepository,
                    targetFramework: null),
                targetFramework: null,
                logger: NullLogger.Instance,
                removeDependencies: RemoveDependencies,
                forceRemove: ForceRemove);
            var operations = resolver.ResolveOperations(operation.Package);

            // we're uninstalling solution level packages, so all target should be
            // set to PackagesFolder.
            foreach (var op in operations)
            {
                op.Target = PackageOperationTarget.PackagesFolder;
            }

            return(operations);
        }
Beispiel #9
0
        public void ResolveDependenciesForUninstallPackageWithDependentAndRemoveDependenciesThrows()
        {
            // Arrange
            var localRepository = new MockPackageRepository();

            IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
                                                             dependencies: new List <PackageDependency> {
                new PackageDependency("B")
            });

            IPackage packageB = PackageUtility.CreatePackage("B", "1.0");

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                                     new DependentsWalker(localRepository),
                                                                     NullLogger.Instance,
                                                                     removeDependencies: true,
                                                                     forceRemove: false);

            // Act & Assert
            ExceptionAssert.Throws <InvalidOperationException>(() => resolver.ResolveOperations(packageB), "Unable to uninstall 'B 1.0' because 'A 1.0' depends on it.");
        }
        protected bool? AskRemoveDependency(
            IPackage package,
            IList<IPackageRepository> localRepositories,
            IList<FrameworkName> targetFrameworks)
        {
            Debug.Assert(localRepositories.Count == targetFrameworks.Count);

            var allOperations = new List<PackageOperation>();

            for (int i = 0; i < localRepositories.Count; i++)
            {
                var uninstallWalker = new UninstallWalker(
                    localRepositories[i],
                    new DependentsWalker(localRepositories[i], targetFrameworks[i]),
                    targetFrameworks[i],
                    logger: NullLogger.Instance,
                    removeDependencies: true,
                    forceRemove: false)
                    {
                        ThrowOnConflicts = false
                    };
                var operations = uninstallWalker.ResolveOperations(package);
                allOperations.AddRange(operations);
            }

            allOperations = allOperations.Reduce().ToList();

            var uninstallPackageNames = (from o in allOperations
                                         where o.Action == PackageAction.Uninstall && !PackageEqualityComparer.IdAndVersion.Equals(o.Package, package)
                                         select o.Package)
                                         .Distinct(PackageEqualityComparer.IdAndVersion)
                                         .Select(p => p.ToString())
                                         .ToList();

            bool? removeDependencies = false;
            if (uninstallPackageNames.Count > 0)
            {
                // show each dependency package on one line
                String packageNames = String.Join(Environment.NewLine, uninstallPackageNames);
                String message = String.Format(CultureInfo.CurrentCulture, Resources.Dialog_RemoveDependencyMessage, package)
                        + Environment.NewLine
                        + Environment.NewLine
                        + packageNames;

                removeDependencies = _userNotifierServices.ShowRemoveDependenciesWindow(message);
            }

            return removeDependencies;
        }
Beispiel #11
0
        public void ResolveDependenciesForUninstallPackageWithDependentAndForceReturnsPackage()
        {
            // Arrange
            var localRepository = new MockPackageRepository();

            IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
                                                            dependencies: new List<PackageDependency> {
                                                                    new PackageDependency("B")
                                                                });

            IPackage packageB = PackageUtility.CreatePackage("B", "1.0");

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                               new DependentsWalker(localRepository),
                                                               NullLogger.Instance,
                                                               removeDependencies: false,
                                                               forceRemove: true);

            // Act
            var packages = resolver.ResolveOperations(packageB)
                             .ToDictionary(p => p.Package.Id);

            // Assert
            Assert.Equal(1, packages.Count);
            Assert.NotNull(packages["B"]);
        }
Beispiel #12
0
        protected bool? AskRemoveDependencyAndCheckUninstallPSScript(IPackage package, bool checkDependents)
        {
            if (checkDependents)
            {
                // check if there is any other package depends on this package.
                // if there is, throw to cancel the uninstallation
                var dependentsWalker = new DependentsWalker(LocalRepository);
                IList<IPackage> dependents = dependentsWalker.GetDependents(package).ToList();
                if (dependents.Count > 0)
                {
                    ShowProgressWindow();
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            Resources.PackageHasDependents,
                            package.GetFullName(),
                            String.Join(", ", dependents.Select(d => d.GetFullName()))
                        )
                    );
                }
            }

            var uninstallWalker = new UninstallWalker(
                LocalRepository,
                new DependentsWalker(LocalRepository),
                logger: NullLogger.Instance,
                removeDependencies: true,
                forceRemove: false)
                {
                    ThrowOnConflicts = false
                };
            IList<PackageOperation> operations = uninstallWalker.ResolveOperations(package).ToList();

            var uninstallPackageNames = (from o in operations
                                         where o.Action == PackageAction.Uninstall && !PackageEqualityComparer.IdAndVersion.Equals(o.Package, package)
                                         select o.Package.ToString()).ToList();

            bool? removeDependencies = false;
            if (uninstallPackageNames.Count > 0)
            {
                // show each dependency package on one line
                String packageNames = String.Join(Environment.NewLine, uninstallPackageNames);
                String message = String.Format(CultureInfo.CurrentCulture, Resources.Dialog_RemoveDependencyMessage, package)
                        + Environment.NewLine
                        + Environment.NewLine
                        + packageNames;

                removeDependencies = _userNotifierServices.ShowRemoveDependenciesWindow(message);
            }
            if (removeDependencies == null)
            {
                return removeDependencies;
            }

            bool hasScriptPackages;
            if (removeDependencies == true)
            {
                // if user wants to remove dependencies, we need to check all of them for PS scripts
                var scriptPackages = from o in operations
                                     where o.Package.HasPowerShellScript()
                                     select o.Package;
                hasScriptPackages = scriptPackages.Any();
            }
            else
            {
                // otherwise, just check the to-be-uninstalled package
                hasScriptPackages = package.HasPowerShellScript(new string[] { PowerShellScripts.Uninstall });
            }

            if (hasScriptPackages)
            {
                if (!RegistryHelper.CheckIfPowerShell2Installed())
                {
                    throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript);
                }
            }

            return removeDependencies;
        }
Beispiel #13
0
        protected bool?AskRemoveDependencyAndCheckUninstallPSScript(
            IPackage package,
            IList <IPackageRepository> localRepositories,
            IList <FrameworkName> targetFrameworks)
        {
            Debug.Assert(localRepositories.Count == targetFrameworks.Count);

            var allOperations = new List <PackageOperation>();

            for (int i = 0; i < localRepositories.Count; i++)
            {
                var uninstallWalker = new UninstallWalker(
                    localRepositories[i],
                    new DependentsWalker(localRepositories[i], targetFrameworks[i]),
                    targetFrameworks[i],
                    logger: NullLogger.Instance,
                    removeDependencies: true,
                    forceRemove: false)
                {
                    ThrowOnConflicts = false
                };
                var operations = uninstallWalker.ResolveOperations(package);
                allOperations.AddRange(operations);
            }

            allOperations = allOperations.Reduce().ToList();

            var uninstallPackageNames = (from o in allOperations
                                         where o.Action == PackageAction.Uninstall && !PackageEqualityComparer.IdAndVersion.Equals(o.Package, package)
                                         select o.Package)
                                        .Distinct(PackageEqualityComparer.IdAndVersion)
                                        .Select(p => p.ToString())
                                        .ToList();

            bool?removeDependencies = false;

            if (uninstallPackageNames.Count > 0)
            {
                // show each dependency package on one line
                String packageNames = String.Join(Environment.NewLine, uninstallPackageNames);
                String message      = String.Format(CultureInfo.CurrentCulture, Resources.Dialog_RemoveDependencyMessage, package)
                                      + Environment.NewLine
                                      + Environment.NewLine
                                      + packageNames;

                removeDependencies = _userNotifierServices.ShowRemoveDependenciesWindow(message);
            }

            if (removeDependencies == null)
            {
                return(removeDependencies);
            }

            bool hasScriptPackages;

            if (removeDependencies == true)
            {
                // if user wants to remove dependencies, we need to check all of them for PS scripts
                var scriptPackages = from o in allOperations
                                     where o.Package.HasPowerShellScript()
                                     select o.Package;
                hasScriptPackages = scriptPackages.Any();
            }
            else
            {
                // otherwise, just check the to-be-uninstalled package
                hasScriptPackages = package.HasPowerShellScript(new string[] { PowerShellScripts.Uninstall });
            }

            if (hasScriptPackages)
            {
                if (!RegistryHelper.CheckIfPowerShell2Installed())
                {
                    throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript);
                }
            }

            return(removeDependencies);
        }
Beispiel #14
0
        protected bool? AskRemoveDependencyAndCheckUninstallPSScript(
            IPackage package,
            IList<IPackageRepository> localRepositories,
            IList<FrameworkName> targetFrameworks)
        {
            Debug.Assert(localRepositories.Count == targetFrameworks.Count);

            var allOperations = new List<PackageOperation>();

            for (int i = 0; i < localRepositories.Count; i++)
            {
                var uninstallWalker = new UninstallWalker(
                    localRepositories[i],
                    new DependentsWalker(localRepositories[i], targetFrameworks[i]),
                    targetFrameworks[i],
                    logger: NullLogger.Instance,
                    removeDependencies: true,
                    forceRemove: false)
                    {
                        ThrowOnConflicts = false
                    };
                var operations = uninstallWalker.ResolveOperations(package);
                allOperations.AddRange(operations);
            }

            allOperations = allOperations.Reduce().ToList();

            var uninstallPackageNames = (from o in allOperations
                                         where o.Action == PackageAction.Uninstall && !PackageEqualityComparer.IdAndVersion.Equals(o.Package, package)
                                         select o.Package)
                                         .Distinct(PackageEqualityComparer.IdAndVersion)
                                         .Select(p => p.ToString())
                                         .ToList();

            bool? removeDependencies = false;
            if (uninstallPackageNames.Count > 0)
            {
                // show each dependency package on one line
                String packageNames = String.Join(Environment.NewLine, uninstallPackageNames);
                String message = String.Format(CultureInfo.CurrentCulture, Resources.Dialog_RemoveDependencyMessage, package)
                        + Environment.NewLine
                        + Environment.NewLine
                        + packageNames;

                removeDependencies = _userNotifierServices.ShowRemoveDependenciesWindow(message);
            }

            if (removeDependencies == null)
            {
                return removeDependencies;
            }

            bool hasScriptPackages;
            if (removeDependencies == true)
            {
                // if user wants to remove dependencies, we need to check all of them for PS scripts
                var scriptPackages = from o in allOperations
                                     where o.Package.HasPowerShellScript()
                                     select o.Package;
                hasScriptPackages = scriptPackages.Any();
            }
            else
            {
                // otherwise, just check the to-be-uninstalled package
                hasScriptPackages = package.HasPowerShellScript(new string[] { PowerShellScripts.Uninstall });
            }

            if (hasScriptPackages)
            {
                if (!RegistryHelper.CheckIfPowerShell2Installed())
                {
                    throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript);
                }
            }

            return removeDependencies;
        }
Beispiel #15
0
        public void ResolveDependenciesForUninstallDiamondDependencyGraph()
        {
            // Arrange
            var localRepository = 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");

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);
            localRepository.AddPackage(packageC);
            localRepository.AddPackage(packageD);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                               new DependentsWalker(localRepository),
                                                               NullLogger.Instance,
                                                               removeDependencies: true,
                                                               forceRemove: false);



            // Act
            var packages = resolver.ResolveOperations(packageA)
                                   .ToDictionary(p => p.Package.Id);

            // Assert
            Assert.Equal(4, packages.Count);
            Assert.NotNull(packages["A"]);
            Assert.NotNull(packages["B"]);
            Assert.NotNull(packages["C"]);
            Assert.NotNull(packages["D"]);
        }
Beispiel #16
0
        public void ResolveDependenciesForUninstallPackageWithDependentAndRemoveDependenciesThrows()
        {
            // Arrange
            var localRepository = new MockPackageRepository();

            IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
                                                            dependencies: new List<PackageDependency> {
                                                                    new PackageDependency("B")
                                                                });

            IPackage packageB = PackageUtility.CreatePackage("B", "1.0");

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                               new DependentsWalker(localRepository),
                                                               NullLogger.Instance,
                                                               removeDependencies: true,
                                                               forceRemove: false);

            // Act & Assert
            ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(packageB), "Unable to uninstall 'B 1.0' because 'A 1.0' depends on it.");
        }
Beispiel #17
0
 private IEnumerable<PackageOperation> ResolveOperationsToUninstallProjectLevelPackage(Operation operation)
 {
     var projectRepo = _virtualProjectRepos[operation.ProjectManager];
     var targetFramework = operation.ProjectManager.GetTargetFrameworkForPackage(operation.Package.Id);
     var resolver = new UninstallWalker(
         projectRepo,
         new DependentsWalker(projectRepo, targetFramework),
         targetFramework,
         NullLogger.Instance,
         RemoveDependencies,
         ForceRemove);
     var operations = resolver.ResolveOperations(operation.Package);
     return operations;
 }
Beispiel #18
0
        public void ResolveDependenciesForUninstallPackageWithRemoveDependenciesSetAndForceReturnsAllDependencies()
        {
            // Arrange
            var localRepository = new MockPackageRepository();

            // A 1.0 -> [B, C]
            IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
                                                            dependencies: new List<PackageDependency> {
                                                                    new PackageDependency("B"),
                                                                    new PackageDependency("C")
                                                            });

            IPackage packageB = PackageUtility.CreatePackage("B", "1.0");
            IPackage packageC = PackageUtility.CreatePackage("C", "1.0");

            // D -> [C]
            IPackage packageD = PackageUtility.CreatePackage("D", "1.0",
                                                            dependencies: new List<PackageDependency> {
                                                                new PackageDependency("C"),
                                                            });

            localRepository.AddPackage(packageA);
            localRepository.AddPackage(packageB);
            localRepository.AddPackage(packageC);
            localRepository.AddPackage(packageD);

            IPackageOperationResolver resolver = new UninstallWalker(localRepository,
                                                               new DependentsWalker(localRepository),
                                                               NullLogger.Instance,
                                                               removeDependencies: true,
                                                               forceRemove: true);

            // Act
            var packages = resolver.ResolveOperations(packageA)
                                   .ToDictionary(p => p.Package.Id);

            // Assert            
            Assert.NotNull(packages["A"]);
            Assert.NotNull(packages["B"]);
            Assert.NotNull(packages["C"]);
        }
Beispiel #19
0
        private IEnumerable<PackageOperation> ResolveOperationsToUninstallSolutionLevelPackage(Operation operation)
        {
            var repo = _virtualPackageRepos[operation.ProjectManager.PackageManager];
            var resolver = new UninstallWalker(
                repo,
                new DependentsWalker(
                    operation.ProjectManager.PackageManager.LocalRepository,
                    targetFramework: null),
                targetFramework: null,
                logger: NullLogger.Instance,
                removeDependencies: RemoveDependencies,
                forceRemove: ForceRemove);
            var operations = resolver.ResolveOperations(operation.Package);

            // we're uninstalling solution level packages, so all target should be
            // set to PackagesFolder.
            foreach (var op in operations)
            {
                op.Target = PackageOperationTarget.PackagesFolder;
            }

            return operations;
        }