(GH-293) choco upgrade all -except="package1,package2"

src/chocolatey.tests.integration/scenarios/UpgradeScenarios.cs

@@ -2409,5 +2409,72 @@ public void should_not_have_any_packages_upgraded()
                 Results.Count().ShouldEqual(0);
             }  
         }
+
+        [Concern(typeof(ChocolateyUpgradeCommand))]
+        public class when_upgrading_all_packages_happy_path : ScenariosBase
+        {
+            public override void Context()
+            {
+                base.Context();
+                Configuration.PackageNames = Configuration.Input = "all";
+            }
+
+            public override void Because()
+            {
+                Results = Service.upgrade_run(Configuration);
+            }
+
+            [Fact]
+            public void should_report_for_all_installed_packages()
+            {
+                Results.Count().ShouldEqual(3);
+            }
+
+            [Fact]
+            public void should_upgrade_packages_with_upgrades()
+            {
+                var upgradePackageResult = Results.Where(x => x.Key == "upgradepackage").ToList();
+                upgradePackageResult.Count.ShouldEqual(1, "upgradepackage must be there once");
+                upgradePackageResult.First().Value.Version.ShouldEqual("1.1.0");
+            }
+
+            [Fact]
+            public void should_skip_packages_without_upgrades()
+            {
+                var installPackageResult = Results.Where(x => x.Key == "installpackage").ToList();
+                installPackageResult.Count.ShouldEqual(1, "installpackage must be there once");
+                installPackageResult.First().Value.Version.ShouldEqual("1.0.0");
+            }
+        }
+
+        [Concern(typeof(ChocolateyUpgradeCommand))]
+        public class when_upgrading_all_packages_with_except : ScenariosBase
+        {
+            public override void Context()
+            {
+                base.Context();
+                Configuration.PackageNames = Configuration.Input = "all";
+                Configuration.UpgradeCommand.PackageNamesToSkip = "upgradepackage,badpackage";
+            }
+
+            public override void Because()
+            {
+                Results = Service.upgrade_run(Configuration);
+            }
+
+            [Fact]
+            public void should_report_for_all_non_skipped_packages()
+            {
+                Results.Count().ShouldEqual(1);
+                Results.First().Key.ShouldEqual("installpackage");
+            }
+
+            [Fact]
+            public void should_skip_packages_in_except_list()
+            {
+                var upgradePackageResult = Results.Where(x => x.Key == "upgradepackage").ToList();
+                upgradePackageResult.Count.ShouldEqual(0, "upgradepackage should not be in the results list");
+            }
+        }
     }
 }

src/chocolatey/infrastructure.app/commands/ChocolateyUpgradeCommand.cs

@@ -94,6 +94,9 @@ public virtual void configure_argument_parser(OptionSet optionSet, ChocolateyCon
                       {
                         if (option != null) configuration.Features.CheckSumFiles = false;
                       })
+                 .Add("except=",
+                     "Except - a comma-separated list of package names that should not be upgraded when upgrading 'all'. Defaults to empty.",
+                     option => configuration.UpgradeCommand.PackageNamesToSkip = option.remove_surrounding_quotes())
                 ;
         }
 
@@ -137,6 +140,8 @@ choco upgrade notepadplusplus googlechrome atom 7zip -dvfy
     choco upgrade nodejs.install --version 0.10.35
     choco upgrade git -s ""https://somewhere/out/there""
     choco upgrade git -s ""https://somewhere/protected"" -u user -p pass
+    choco upgrade all
+    choco upgrade all --except=""skype,conemu""
 ");
 
             "chocolatey".Log().Info(ChocolateyLoggers.Important, "Options and Switches");

src/chocolatey/infrastructure.app/configuration/ChocolateyConfiguration.cs

@@ -363,6 +363,7 @@ public sealed class UpgradeCommandConfiguration
         public bool FailOnUnfound { get; set; }
         public bool FailOnNotInstalled { get; set; }
         public bool NotifyOnlyAvailableUpgrades { get; set; }
+        public string PackageNamesToSkip { get; set; }
     }
 
     [Serializable]

src/chocolatey/infrastructure.app/services/NugetService.cs

@@ -1154,13 +1154,45 @@ private void set_package_names_if_all_is_specified(ChocolateyConfiguration confi
                 var quiet = config.QuietOutput;
                 config.QuietOutput = true;
 
-                config.PackageNames = list_run(config).Select(p => p.Name).@join(ApplicationParameters.PackageNamesSeparator);
-
+                var packagesToUpdate = list_run(config).Select(p => p.Name).ToList();
+
+                if (!String.IsNullOrWhiteSpace(config.UpgradeCommand.PackageNamesToSkip))
+                {
+                    var packagesToSkip = config.UpgradeCommand.PackageNamesToSkip
+                        .Split(',')
+                        .Where(x => !String.IsNullOrWhiteSpace(x))
+                        .Select(x => x.trim_safe())
+                        .ToList();
+
+                    var unknownPackagesToSkip = packagesToSkip
+                        .Where(x => !packagesToUpdate.Contains(x, StringComparer.OrdinalIgnoreCase))
+                        .ToList();
+
+                    if (unknownPackagesToSkip.Any())
+                    {
+                        this.Log().Warn(() => "Some packages specified in the 'except' list were not found in the local packages: '{0}'".format_with(String.Join(",", unknownPackagesToSkip)));
+
+                        packagesToSkip = packagesToSkip
+                            .Where(x => !unknownPackagesToSkip.Contains(x))
+                            .ToList();
+                    }
+
+                    if (packagesToSkip.Any())
+                    {
+                        packagesToUpdate = packagesToUpdate
+                            .Where(x => !packagesToSkip.Contains(x, StringComparer.OrdinalIgnoreCase))
+                            .ToList();
+
+                        this.Log().Info("These packages will not be upgraded because they were specified in the 'except' list: {0}".format_with(String.Join(",", packagesToSkip)));
+                    }
+                }
+
                 config.QuietOutput = quiet;
                 config.Input = input;
                 config.Noop = noop;
                 config.Prerelease = pre;
                 config.Sources = sources;
+                config.PackageNames = packagesToUpdate.@join(ApplicationParameters.PackageNamesSeparator);
 
                 if (customAction != null) customAction.Invoke();
             }