Add Update All button to Manage Packages dialog.

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/InvokeProcessPackageActionsCmdlet.cs

@@ -36,18 +36,18 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		
 		void ExecutePackageActions()
 		{
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			while (GetNextAction(out action)) {
 				Execute(action);
 			}
 		}
 		
-		bool GetNextAction(out ProcessPackageAction action)
+		bool GetNextAction(out IPackageAction action)
 		{
 			return actionsToRun.GetNextAction(out action);
 		}
 		
-		void Execute(ProcessPackageAction action)
+		void Execute(IPackageAction action)
 		{
 			action.PackageScriptRunner = this;
 			action.Execute();

src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj

@@ -156,8 +156,10 @@
     <Compile Include="Src\IClassKindUpdater.cs" />
     <Compile Include="Src\IDocumentNamespaceCreator.cs" />
     <Compile Include="Src\IPackageExtensions.cs" />
+    <Compile Include="Src\IPackageAction.cs" />
     <Compile Include="Src\IProjectBuilder.cs" />
     <Compile Include="Src\IProjectContentExtensions.cs" />
+    <Compile Include="Src\IUpdatePackageSettings.cs" />
     <Compile Include="Src\IVirtualMethodUpdater.cs" />
     <Compile Include="Src\IProjectBrowserUpdater.cs" />
     <Compile Include="Src\IRefactoringDocumentView.cs" />
@@ -230,8 +232,10 @@
     <Compile Include="Src\PackageLicenseViewModel.cs" />
     <Compile Include="Src\PackageManagementServiceProvider.cs" />
     <Compile Include="Src\ProjectBuilder.cs" />
+    <Compile Include="Src\ReducedPackageOperations.cs" />
     <Compile Include="Src\ResolveFileConflictEventArgs.cs" />
     <Compile Include="Src\ServiceWithWorkbenchOwner.cs" />
+    <Compile Include="Src\UpdatePackagesAction.cs" />
     <Compile Include="Src\VirtualMethodUpdater.cs" />
     <Compile Include="Src\NewProjectsCreated.cs" />
     <Compile Include="Src\OpenMSBuildProjects.cs" />

src/AddIns/Misc/PackageManagement/Project/Src/AvailablePackagesViewModel.cs

@@ -41,11 +41,6 @@ namespace ICSharpCode.PackageManagement
 			return repository.GetPackages().Where(package => package.IsLatestVersion);
 		}
 		
-		public IQueryable<IPackage> CallGetPackagesFromPackageSource()
-		{
-			return GetPackagesFromPackageSource();
-		}
-		
 		/// <summary>
 		/// Order packages by most downloaded first.
 		/// </summary>

src/AddIns/Misc/PackageManagement/Project/Src/ConsolePackageActionRunner.cs

@@ -30,14 +30,14 @@ namespace ICSharpCode.PackageManagement
 			this.workbench = workbench;
 		}
 		
-		public void Run(ProcessPackageAction action)
+		public void Run(IPackageAction action)
 		{
-			var actions = new List<ProcessPackageAction>();
+			var actions = new List<IPackageAction>();
 			actions.Add(action);
 			Run(actions);
 		}
 		
-		public void Run(IEnumerable<ProcessPackageAction> actions)
+		public void Run(IEnumerable<IPackageAction> actions)
 		{
 			CreateConsolePadIfConsoleHostIsNotRunning();
 			AddNewActionsToRun(actions);
@@ -51,14 +51,14 @@ namespace ICSharpCode.PackageManagement
 			}
 		}
 		
-		void AddNewActionsToRun(IEnumerable<ProcessPackageAction> actions)
+		void AddNewActionsToRun(IEnumerable<IPackageAction> actions)
 		{
-			foreach (ProcessPackageAction action in actions) {
+			foreach (IPackageAction action in actions) {
 				AddNewActionToRun(action);
 			}
 		}
 		
-		void AddNewActionToRun(ProcessPackageAction action)
+		void AddNewActionToRun(IPackageAction action)
 		{
 			packageActionsToRun.AddAction(action);
 		}

src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManagementProject.cs

@@ -213,5 +213,32 @@ namespace ICSharpCode.PackageManagement.Design
 		{
 			FakeSourceRepository.AddFakePackage(packageId);
 		}
+		
+		public void UpdatePackages(UpdatePackagesAction action)
+		{
+		}
+		
+		public List<UpdatePackagesAction> UpdatePackagesActionsCreated = 
+			new List<UpdatePackagesAction>();
+		
+		public UpdatePackagesAction CreateUpdatePackagesAction()
+		{
+			var action = new UpdatePackagesAction(this);
+			UpdatePackagesActionsCreated.Add(action);
+			return action;
+		}
+		
+		public UpdatePackagesAction UpdatePackagesActionPassedToGetUpdatePackagesOperations;
+		public List<IPackage> PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations;
+		public List<PackageOperation> PackageOperationsToReturnFromGetUpdatePackagesOperations =
+			new List<PackageOperation>();
+		
+		public IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action)
+		{
+			UpdatePackagesActionPassedToGetUpdatePackagesOperations = action;
+			PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations = 
+				action.Packages.ToList();
+			return PackageOperationsToReturnFromGetUpdatePackagesOperations;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManager.cs

@@ -22,6 +22,8 @@ namespace ICSharpCode.PackageManagement.Design
 		
 		public IPackage PackagePassedToUninstallPackage;
 		
+		public UpdatePackagesAction UpdatePackagesActionsPassedToUpdatePackages;
+		
 		#pragma warning disable 67
 		public event EventHandler<PackageOperationEventArgs> PackageInstalled;
 		public event EventHandler<PackageOperationEventArgs> PackageInstalling;
@@ -158,5 +160,19 @@ namespace ICSharpCode.PackageManagement.Design
 		{
 			throw new NotImplementedException();
 		}
+		
+		public void UpdatePackages(UpdatePackagesAction updateAction)
+		{
+			UpdatePackagesActionsPassedToUpdatePackages = updateAction;
+		}
+		
+		public List<PackageOperation> PackageOperationsToReturnFromGetUpdatePackageOperations = new List<PackageOperation>();
+		public UpdatePackagesAction UpdatePackagesActionsPassedToGetUpdatePackagesOperations;
+		
+		public IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction)
+		{
+			UpdatePackagesActionsPassedToGetUpdatePackagesOperations = updateAction;
+			return PackageOperationsToReturnFromGetUpdatePackageOperations;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/Design/FakeRegisteredPackageRepositories.cs

@@ -72,7 +72,12 @@ namespace ICSharpCode.PackageManagement.Design
 		
 		public FakePackage AddFakePackageWithVersionToActiveRepository(string version)
 		{
-			var package = FakePackage.CreatePackageWithVersion("Test", version);
+			return AddFakePackageWithVersionToActiveRepository("Test", version);
+		}
+		
+		public FakePackage AddFakePackageWithVersionToActiveRepository(string id, string version)
+		{
+			var package = FakePackage.CreatePackageWithVersion(id, version);
 			FakeActiveRepository.FakePackages.Add(package);
 			return package;
 		}

src/AddIns/Misc/PackageManagement/Project/Src/IPackageAction.cs

@@ -0,0 +1,15 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement.Scripting;
+
+namespace ICSharpCode.PackageManagement
+{
+	public interface IPackageAction
+	{
+		void Execute();
+		bool HasPackageScriptsToRun();
+		IPackageScriptRunner PackageScriptRunner { get; set; }
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/IPackageActionRunner.cs

@@ -8,7 +8,7 @@ namespace ICSharpCode.PackageManagement
 {
 	public interface IPackageActionRunner
 	{
-		void Run(ProcessPackageAction action);
+		void Run(IPackageAction action);
-		void Run(IEnumerable<ProcessPackageAction> actions);
+		void Run(IEnumerable<IPackageAction> actions);
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementProject.cs

@@ -30,13 +30,16 @@ namespace ICSharpCode.PackageManagement
 		IEnumerable<IPackage> GetPackagesInReverseDependencyOrder();
 		
 		IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction);
+		IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action);
 		
 		void InstallPackage(IPackage package, InstallPackageAction installAction);
 		void UpdatePackage(IPackage package, UpdatePackageAction updateAction);
 		void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction);
+		void UpdatePackages(UpdatePackagesAction action);
 		
 		InstallPackageAction CreateInstallPackageAction();
 		UninstallPackageAction CreateUninstallPackageAction();
 		UpdatePackageAction CreateUpdatePackageAction();
+		UpdatePackagesAction CreateUpdatePackagesAction();
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/IPackageOperationResolverFactory.cs

@@ -13,5 +13,11 @@ namespace ICSharpCode.PackageManagement
 			IPackageRepository sourceRepository,
 			ILogger logger,
 			InstallPackageAction installAction);
+		
+		IPackageOperationResolver CreateUpdatePackageOperationResolver(
+			IPackageRepository localRepository,
+			IPackageRepository sourceRepository,
+			ILogger logger,
+			IUpdatePackageSettings settings);
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/IPackageViewModelFactory.cs

@@ -15,5 +15,6 @@ namespace ICSharpCode.PackageManagement
 		PackageManagementSelectedProjects SelectedProjects { get; }
 		IPackageManagementEvents PackageManagementEvents { get; }
 		IPackageActionRunner PackageActionRunner { get; }
+		ILogger Logger { get; }
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/ISharpDevelopPackageManager.cs

@@ -14,7 +14,9 @@ namespace ICSharpCode.PackageManagement
 		void InstallPackage(IPackage package, InstallPackageAction installAction);
 		void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction);
 		void UpdatePackage(IPackage package, UpdatePackageAction updateAction);
+		void UpdatePackages(UpdatePackagesAction updateAction);
 		
 		IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction);
+		IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction);
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/IUpdatePackageActions.cs

@@ -7,10 +7,8 @@ using ICSharpCode.PackageManagement.Scripting;
 
 namespace ICSharpCode.PackageManagement
 {
-	public interface IUpdatePackageActions
+	public interface IUpdatePackageActions : IUpdatePackageSettings
 	{
-		bool UpdateDependencies { get; set; }
-		bool AllowPrereleaseVersions { get; set; }
 		IPackageScriptRunner PackageScriptRunner { get; set; }
 		
 		IEnumerable<UpdatePackageAction> CreateActions();

src/AddIns/Misc/PackageManagement/Project/Src/IUpdatePackageSettings.cs

@@ -0,0 +1,13 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.PackageManagement
+{
+	public interface IUpdatePackageSettings
+	{
+		bool UpdateDependencies { get; set; }
+		bool AllowPrereleaseVersions { get; set; }
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/PackageActionRunner.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.PackageManagement
 			this.powerShellDetection = powerShellDetection;
 		}
 		
-		public void Run(IEnumerable<ProcessPackageAction> actions)
+		public void Run(IEnumerable<IPackageAction> actions)
 		{
 			if (ShouldRunActionsInConsole(actions)) {
 				consolePackageActionRunner.Run(actions);
@@ -42,9 +42,9 @@ namespace ICSharpCode.PackageManagement
 			}
 		}
 		
-		bool ShouldRunActionsInConsole(IEnumerable<ProcessPackageAction> actions)
+		bool ShouldRunActionsInConsole(IEnumerable<IPackageAction> actions)
 		{
-			foreach (ProcessPackageAction action in actions) {
+			foreach (IPackageAction action in actions) {
 				if (ShouldRunActionInConsole(action)) {
 					return true;
 				}
@@ -52,7 +52,7 @@ namespace ICSharpCode.PackageManagement
 			return false;
 		}
 		
-		public void Run(ProcessPackageAction action)
+		public void Run(IPackageAction action)
 		{
 			if (ShouldRunActionInConsole(action)) {
 				consolePackageActionRunner.Run(action);
@@ -61,7 +61,7 @@ namespace ICSharpCode.PackageManagement
 			}
 		}
 		
-		bool ShouldRunActionInConsole(ProcessPackageAction action)
+		bool ShouldRunActionInConsole(IPackageAction action)
 		{
 			if (action.HasPackageScriptsToRun()) {
 				if (powerShellDetection.IsPowerShell2Installed()) {

src/AddIns/Misc/PackageManagement/Project/Src/PackageActionsToRun.cs

@@ -8,14 +8,14 @@ namespace ICSharpCode.PackageManagement
 {
 	public class PackageActionsToRun
 	{
-		ConcurrentQueue<ProcessPackageAction> actions = new ConcurrentQueue<ProcessPackageAction>();
+		ConcurrentQueue<IPackageAction> actions = new ConcurrentQueue<IPackageAction>();
 		
-		public bool GetNextAction(out ProcessPackageAction action)
+		public bool GetNextAction(out IPackageAction action)
 		{
 			return actions.TryDequeue(out action);
 		}
 		
-		public void AddAction(ProcessPackageAction action)
+		public void AddAction(IPackageAction action)
 		{
 			actions.Enqueue(action);
 		}

src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementProject.cs

@@ -131,5 +131,20 @@ namespace ICSharpCode.PackageManagement
 				.GetPackagesByDependencyOrder(projectManager.LocalRepository)
 				.Reverse();
 		}
+		
+		public void UpdatePackages(UpdatePackagesAction updateAction)
+		{
+			packageManager.UpdatePackages(updateAction);
+		}
+		
+		public UpdatePackagesAction CreateUpdatePackagesAction()
+		{
+			return new UpdatePackagesAction(this);
+		}
+		
+		public IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action)
+		{
+			return packageManager.GetUpdatePackageOperations(action);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/PackageOperationsResolverFactory.cs

@@ -22,5 +22,16 @@ namespace ICSharpCode.PackageManagement
 				installAction.IgnoreDependencies,
 				installAction.AllowPrereleaseVersions);
 		}
+		
+		public IPackageOperationResolver CreateUpdatePackageOperationResolver(IPackageRepository localRepository, IPackageRepository sourceRepository, ILogger logger, IUpdatePackageSettings settings)
+		{
+			return new InstallWalker(
+				localRepository,
+				sourceRepository,
+				null,
+				logger,
+				!settings.UpdateDependencies,
+				settings.AllowPrereleaseVersions);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/PackagesView.xaml

@@ -1,4 +1,4 @@
-<UserControl
+<UserControl
 	x:Class="ICSharpCode.PackageManagement.PackagesView"
 	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 	xmlns:core="http://icsharpcode.net/sharpdevelop/core"
@@ -306,6 +306,7 @@
 		<Grid
 			Grid.Column="2">
 			<Grid.RowDefinitions>
+				<RowDefinition Height="Auto"/>
 				<RowDefinition Height="Auto"/>
 				<RowDefinition />
 			</Grid.RowDefinitions>
@@ -352,6 +353,12 @@
 							Width="16"/>
 					</Hyperlink>
 				</TextBlock>
+				<Button
+					Grid.Row="2"
+					Grid.Column="1"
+					Visibility="{Binding Path=IsUpdateAllPackagesEnabled, Converter={StaticResource BoolToVisibility}}"
+					Content="Update All"
+					Command="{Binding UpdateAllPackagesCommand}"/>
 			</Grid>
 			<ContentControl
 				Grid.Row="1"

src/AddIns/Misc/PackageManagement/Project/Src/PackagesViewModel.cs

@@ -44,12 +44,14 @@ namespace ICSharpCode.PackageManagement
 			ShowPreviousPageCommand = new DelegateCommand(param => ShowPreviousPage());
 			ShowPageCommand = new DelegateCommand(param => ExecuteShowPageCommand(param));
 			SearchCommand = new DelegateCommand(param => Search());
+			UpdateAllPackagesCommand = new DelegateCommand(param => UpdateAllPackages());
 		}
 		
 		public ICommand ShowNextPageCommand { get; private set; }
 		public ICommand ShowPreviousPageCommand { get; private set; }
 		public ICommand ShowPageCommand { get; private set; }
 		public ICommand SearchCommand { get; private set; }
+		public ICommand UpdateAllPackagesCommand { get; private set; }
 		
 		public void Dispose()
 		{
@@ -361,5 +363,45 @@ namespace ICSharpCode.PackageManagement
 				}
 			}
 		}
+		
+		public bool ShowUpdateAllPackages { get; set; }
+		
+		public bool IsUpdateAllPackagesEnabled {
+			get {
+				return ShowUpdateAllPackages && (TotalItems > 1);
+			}
+		}
+		
+		void UpdateAllPackages()
+		{
+			try {
+				TryUpdatingAllPackages();
+			} catch (Exception ex) {
+				ReportError(ex);
+				LogError(ex);
+			}
+		}
+		
+		void LogError(Exception ex)
+		{
+			packageViewModelFactory
+				.Logger
+				.Log(MessageLevel.Error, ex.ToString());
+		}
+		
+		void ReportError(Exception ex)
+		{
+			packageViewModelFactory
+				.PackageManagementEvents
+				.OnPackageOperationError(ex);
+		}
+		
+		protected virtual void TryUpdatingAllPackages()
+		{
+		}
+		
+		protected IPackageActionRunner ActionRunner {
+			get { return packageViewModelFactory.PackageActionRunner; }
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/ProcessPackageAction.cs

@@ -8,7 +8,7 @@ using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
-	public abstract class ProcessPackageAction
+	public abstract class ProcessPackageAction : IPackageAction
 	{
 		IPackageManagementEvents packageManagementEvents;
 		

src/AddIns/Misc/PackageManagement/Project/Src/ReducedPackageOperations.cs

@@ -0,0 +1,52 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class ReducedPackageOperations
+	{
+		IPackageOperationResolver resolver;
+		IList<PackageOperation> operations;
+		IEnumerable<IPackage> packages;
+		
+		public ReducedPackageOperations(IPackageOperationResolver resolver, IEnumerable<IPackage> packages)
+		{
+			this.resolver = resolver;
+			this.packages = packages;
+			this.operations = new List<PackageOperation>();
+		}
+		
+		public IEnumerable<PackageOperation> Operations {
+			get { return operations; }
+		}
+		
+		public void Reduce()
+		{
+			foreach (IPackage package in packages) {
+				if (!InstallOperationExists(package)) {
+					operations.AddRange(resolver.ResolveOperations(package));
+				}
+			}
+			
+			operations = operations.Reduce();
+		}
+		
+		bool InstallOperationExists(IPackage package)
+		{
+			var installOperation = new PackageOperation(package, PackageAction.Install);
+			return operations.Any(operation => IsMatch(installOperation, operation));
+		}
+		
+		bool IsMatch(PackageOperation x, PackageOperation y)
+		{
+			return (x.Package.Id == y.Package.Id) &&
+				(x.Package.Version == y.Package.Version) &&
+				(x.Action == y.Action);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/SharpDevelopPackageManager.cs

@@ -125,9 +125,42 @@ namespace ICSharpCode.PackageManagement
 			UpdatePackageReference(package, updateAction);
 		}
 		
-		void UpdatePackageReference(IPackage package, UpdatePackageAction updateAction)
+		void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
 		{
-			ProjectManager.UpdatePackageReference(package.Id, package.Version, updateAction.UpdateDependencies, updateAction.AllowPrereleaseVersions);		
+			UpdatePackageReference(package, settings.UpdateDependencies, settings.AllowPrereleaseVersions);
+		}
+		
+		void UpdatePackageReference(IPackage package, bool updateDependencies, bool allowPrereleaseVersions)
+		{
+			ProjectManager.UpdatePackageReference(package.Id, package.Version, updateDependencies, allowPrereleaseVersions);
+		}
+		
+		public void UpdatePackages(UpdatePackagesAction updateAction)
+		{
+			foreach (PackageOperation operation in updateAction.Operations) {
+				Execute(operation);
+			}
+			foreach (IPackage package in updateAction.Packages) {
+				UpdatePackageReference(package, updateAction);
+			}
+		}
+		
+		public IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction)
+		{
+			IPackageOperationResolver resolver = CreateUpdatePackageOperationResolver(updateAction);
+			
+			var reducedOperations = new ReducedPackageOperations(resolver, updateAction.Packages);
+			reducedOperations.Reduce();
+			return reducedOperations.Operations;
+		}
+		
+		IPackageOperationResolver CreateUpdatePackageOperationResolver(UpdatePackagesAction updateAction)
+		{
+			return packageOperationResolverFactory.CreateUpdatePackageOperationResolver(
+				LocalRepository,
+				SourceRepository,
+				Logger,
+				updateAction);
 		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackageAction.cs

@@ -7,7 +7,7 @@ using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
-	public class UpdatePackageAction : ProcessPackageOperationsAction
+	public class UpdatePackageAction : ProcessPackageOperationsAction, IUpdatePackageSettings
 	{
 		public UpdatePackageAction(
 			IPackageManagementProject project,

src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackagesAction.cs

@@ -0,0 +1,85 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class UpdatePackagesAction : IPackageAction, IUpdatePackageSettings
+	{
+		List<IPackage> packages = new List<IPackage>();
+		List<PackageOperation> operations = new List<PackageOperation>();
+		
+		public UpdatePackagesAction(IPackageManagementProject project)
+		{
+			Project = project;
+			UpdateDependencies = true;
+		}
+		
+		public IPackageScriptRunner PackageScriptRunner { get; set; }
+		public IPackageManagementProject Project { get; private set; }
+		
+		public IEnumerable<IPackage> Packages {
+			get { return packages; }
+		}
+		
+		public IEnumerable<PackageOperation> Operations {
+			get { return operations; }
+		}
+		
+		public bool UpdateDependencies { get; set; }
+		public bool AllowPrereleaseVersions { get; set; }
+		
+		public bool HasPackageScriptsToRun()
+		{
+			var files = new PackageFilesForOperations(Operations);
+			return files.HasAnyPackageScripts();
+		}
+		
+		public void AddOperations(IEnumerable<PackageOperation> operations)
+		{
+			this.operations.AddRange(operations);
+		}
+		
+		public void AddPackages(IEnumerable<IPackage> packages)
+		{
+			this.packages.AddRange(packages);
+		}
+		
+		public void Execute()
+		{
+			if (PackageScriptRunner != null) {
+				ExecuteWithScriptRunner();
+			} else {
+				ExecuteCore();
+			}
+		}
+		
+		protected virtual void ExecuteCore()
+		{
+			Project.UpdatePackages(this);
+		}
+		
+		void ExecuteWithScriptRunner()
+		{
+			using (RunPackageScriptsAction runScriptsAction = CreateRunPackageScriptsAction()) {
+				ExecuteCore();
+			}
+		}
+		
+		RunPackageScriptsAction CreateRunPackageScriptsAction()
+		{
+			return CreateRunPackageScriptsAction(PackageScriptRunner, Project);
+		}
+		
+		protected virtual RunPackageScriptsAction CreateRunPackageScriptsAction(
+			IPackageScriptRunner scriptRunner,
+			IPackageManagementProject project)
+		{
+			return new RunPackageScriptsAction(scriptRunner, project);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/UpdatedPackagesViewModel.cs

@@ -14,6 +14,7 @@ namespace ICSharpCode.PackageManagement
 		PackageManagementSelectedProjects selectedProjects;
 		UpdatedPackages updatedPackages;
 		string errorMessage = String.Empty;
+		ILogger logger;
 		
 		public UpdatedPackagesViewModel(
 			IPackageManagementSolution solution,
@@ -26,7 +27,9 @@ namespace ICSharpCode.PackageManagement
 				taskFactory)
 		{
 			this.selectedProjects = new PackageManagementSelectedProjects(solution);
+			this.logger = packageViewModelFactory.Logger;
 			ShowPackageSources = true;
+			ShowUpdateAllPackages = true;
 		}
 		
 		protected override void UpdateRepositoryBeforeReadPackagesTaskStarts()
@@ -62,5 +65,26 @@ namespace ICSharpCode.PackageManagement
 		{
 			return updatedPackages.GetUpdatedPackages().AsQueryable();
 		}
+		
+		protected override void TryUpdatingAllPackages()
+		{
+			IEnumerable<IPackageFromRepository> packages = GetPackagesFromViewModels();
+			IPackageRepository repository = packages.First().Repository;
+			IPackageManagementProject project = selectedProjects.GetSingleProjectSelected(repository);
+			project.Logger = logger;
+			
+			UpdatePackagesAction action = project.CreateUpdatePackagesAction();
+			action.AddPackages(packages);
+			
+			IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(action);
+			action.AddOperations(operations);
+			
+			ActionRunner.Run(action);
+		}
+		
+		IEnumerable<IPackageFromRepository> GetPackagesFromViewModels()
+		{
+			return PackageViewModels.Select(viewModel => viewModel.GetPackage() as IPackageFromRepository);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj

@@ -112,6 +112,7 @@
     <Compile Include="Src\Helpers\ClassHelper.cs" />
     <Compile Include="Src\Helpers\CodeElementsExtensions.cs" />
     <Compile Include="Src\Helpers\CompilationUnitHelper.cs" />
+    <Compile Include="Src\Helpers\ExceptionThrowingPackageActionRunner.cs" />
     <Compile Include="Src\Helpers\FakeCodeGenerator.cs" />
     <Compile Include="Src\Helpers\FieldHelper.cs" />
     <Compile Include="Src\Helpers\FakeSelectProjectsService.cs" />
@@ -120,6 +121,7 @@
     <Compile Include="Src\Helpers\FakeUpdatePackageActionsFactory.cs" />
     <Compile Include="Src\Helpers\MethodHelper.cs" />
     <Compile Include="Src\Helpers\MethodOrPropertyHelper.cs" />
+    <Compile Include="Src\Helpers\PackageOperationHelper.cs" />
     <Compile Include="Src\Helpers\ParameterHelper.cs" />
     <Compile Include="Src\Helpers\ProjectContentHelper.cs" />
     <Compile Include="Src\Helpers\PropertiesHelper.cs" />
@@ -131,6 +133,7 @@
     <Compile Include="Src\Helpers\TestablePackageFromRepository.cs" />
     <Compile Include="Src\Helpers\TestableProjectBehaviour.cs" />
     <Compile Include="Src\Helpers\TestableSelectedProjectsForUpdatedPackages.cs" />
+    <Compile Include="Src\Helpers\TestableUpdatePackagesAction.cs" />
     <Compile Include="Src\Helpers\TypeParameterHelper.cs" />
     <Compile Include="Src\Helpers\UsingHelper.cs" />
     <Compile Include="Src\Helpers\UsingScopeHelper.cs" />
@@ -195,6 +198,8 @@
     <Compile Include="Src\OpenMSBuildProjectsTests.cs" />
     <Compile Include="Src\PackageManagementServiceProviderTests.cs" />
     <Compile Include="Src\PackageViewModelOperationLoggerTests.cs" />
+    <Compile Include="Src\ReducedPackageOperationsTests.cs" />
+    <Compile Include="Src\UpdatePackagesActionTests.cs" />
     <Compile Include="Src\VirtualMethodUpdaterTests.cs" />
     <Compile Include="Src\NewProjectsCreatedTests.cs" />
     <Compile Include="Src\PackageActionRunnerTests.cs" />

src/AddIns/Misc/PackageManagement/Test/Src/AvailablePackagesViewModelTests.cs

@@ -455,5 +455,23 @@ namespace PackageManagement.Tests
 			Assert.IsFalse(containsDisabledPackageSource);
 			Assert.IsTrue(containsEnabledPackageSource);
 		}
+		
+		[Test]
+		public void IsInstallAllPackagesEnabled_RepositoryHasTwoPackages_ReturnsFalse()
+		{
+			CreateViewModel();
+			var package1 = new FakePackage("Test", "0.1.0.0");
+			var package2 = new FakePackage("Test", "0.2.0.0");
+			var packages = new FakePackage[] {
+				package1, package2
+			};
+			registeredPackageRepositories.FakeActiveRepository.FakePackages.AddRange(packages);
+			viewModel.ReadPackages();
+			CompleteReadPackagesTask();
+			
+			bool enabled = viewModel.IsUpdateAllPackagesEnabled;
+			
+			Assert.IsFalse(enabled);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/ConsolePackageActionRunnerTests.cs

@@ -78,17 +78,17 @@ namespace PackageManagement.Tests
 			fakeConsoleHost.IsRunning = false;
 		}
 		
-		ProcessPackageAction GetNextActionToRun()
+		IPackageAction GetNextActionToRun()
 		{
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			actionsToRun.GetNextAction(out action);
 			return action;
 		}
 		
-		List<ProcessPackageAction> GetNextActionsToRun()
+		List<IPackageAction> GetNextActionsToRun()
 		{
-			var actions = new List<ProcessPackageAction>();
+			var actions = new List<IPackageAction>();
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			while (actionsToRun.GetNextAction(out action)) {
 				actions.Add(action);
 			}
@@ -102,7 +102,7 @@ namespace PackageManagement.Tests
 			ConsoleHostIsRunning();
 			FakeInstallPackageAction expectedAction = RunInstallActionWithOneOperation();
 			
-			ProcessPackageAction actionAdded = GetNextActionToRun();
+			IPackageAction actionAdded = GetNextActionToRun();
 			
 			Assert.AreEqual(expectedAction, actionAdded);
 		}
@@ -188,7 +188,7 @@ namespace PackageManagement.Tests
 			ConsoleHostIsRunning();
 			List<FakeInstallPackageAction> expectedActions = RunTwoInstallActionsWithOneOperation();
 			
-			List<ProcessPackageAction> actionsAdded = GetNextActionsToRun();
+			List<IPackageAction> actionsAdded = GetNextActionsToRun();
 			
 			CollectionAssert.AreEqual(expectedActions, actionsAdded);
 		}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ExceptionThrowingPackageActionRunner.cs

@@ -0,0 +1,19 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class ExceptionThrowingPackageActionRunner : FakePackageActionRunner
+	{
+		public Exception ExceptionToThrow = new Exception("test");
+		
+		public override void Run(IPackageAction action)
+		{
+			base.Run(action);
+			throw ExceptionToThrow;
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageActionRunner.cs

@@ -9,30 +9,30 @@ namespace PackageManagement.Tests.Helpers
 {
 	public class FakePackageActionRunner : IPackageActionRunner
 	{
-		public ProcessPackageAction ActionPassedToRun;
+		public IPackageAction ActionPassedToRun;
 		public bool IsRunCalled;
 		
-		public void Run(ProcessPackageAction action)
+		public virtual void Run(IPackageAction action)
 		{
 			IsRunCalled = true;
 			ActionPassedToRun = action;
 			ActionsPassedToRun.Add(action);
 		}
 		
-		public List<ProcessPackageAction> ActionsPassedToRun = 
+		public List<IPackageAction> ActionsPassedToRun = 
-			new List<ProcessPackageAction>();
+			new List<IPackageAction>();
 		
-		public void Run(IEnumerable<ProcessPackageAction> actions)
+		public void Run(IEnumerable<IPackageAction> actions)
 		{
 			IsRunCalled = true;
 			ActionsRunInOneCall = actions;
 		}
 		
-		public IEnumerable<ProcessPackageAction> ActionsRunInOneCall;
+		public IEnumerable<IPackageAction> ActionsRunInOneCall;
 		
-		public List<ProcessPackageAction> GetActionsRunInOneCallAsList()
+		public List<IPackageAction> GetActionsRunInOneCallAsList()
 		{
-			return new List<ProcessPackageAction>(ActionsRunInOneCall);
+			return new List<IPackageAction>(ActionsRunInOneCall);
 		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageOperationResolverFactory.cs

@@ -30,5 +30,25 @@ namespace PackageManagement.Tests.Helpers
 			
 			return FakeInstallPackageOperationResolver;
 		}
+		
+		public IPackageRepository LocalRepositoryPassedToCreateUpdatePackageOperationsResolver;
+		public IPackageRepository SourceRepositoryPassedToCreateUpdatePackageOperationsResolver;
+		public IPackageOperationResolver UpdatePackageOperationsResolver = new FakePackageOperationResolver();
+		public ILogger LoggerPassedToCreateUpdatePackageOperationResolver;
+		public IUpdatePackageSettings SettingsPassedToCreatePackageOperationResolver;
+		
+		public IPackageOperationResolver CreateUpdatePackageOperationResolver(
+			IPackageRepository localRepository,
+			IPackageRepository sourceRepository,
+			ILogger logger,
+			IUpdatePackageSettings settings)
+		{
+			LocalRepositoryPassedToCreateUpdatePackageOperationsResolver = localRepository;
+			SourceRepositoryPassedToCreateUpdatePackageOperationsResolver = sourceRepository;
+			LoggerPassedToCreateUpdatePackageOperationResolver = logger;
+			SettingsPassedToCreatePackageOperationResolver = settings;
+			
+			return UpdatePackageOperationsResolver;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageViewModelFactory.cs

@@ -16,13 +16,9 @@ namespace PackageManagement.Tests.Helpers
 		public FakeLogger FakeLogger = new FakeLogger();
 		public FakePackageActionRunner FakeActionRunner = new FakePackageActionRunner();
 		
-		public FakePackageViewModelFactory()
-		{
-			SelectedProjects = new PackageManagementSelectedProjects(FakeSolution);
-		}
-		
 		public PackageViewModel CreatePackageViewModel(IPackageFromRepository package)
 		{
+			SelectedProjects = new PackageManagementSelectedProjects(FakeSolution);
 			return new PackageViewModel(
 				package,
 				SelectedProjects,
@@ -44,5 +40,9 @@ namespace PackageManagement.Tests.Helpers
 		public IPackageActionRunner PackageActionRunner {
 			get { return FakeActionRunner; }
 		}
+		
+		public ILogger Logger {
+			get { return FakeLogger; }
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PackageOperationHelper.cs

@@ -0,0 +1,29 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.PackageManagement.Design;
+using NuGet;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public static class PackageOperationHelper
+	{
+		public static PackageOperation CreateInstallOperationWithFile(string fileName)
+		{
+			var package = new FakePackage();
+			package.AddFile(fileName);
+			
+			return new PackageOperation(package, PackageAction.Install);
+		}
+		
+		public static List<PackageOperation> CreateListWithOneInstallOperationWithFile(string fileName)
+		{
+			PackageOperation operation = CreateInstallOperationWithFile(fileName);
+			var operations = new List<PackageOperation>();
+			operations.Add(operation);
+			return operations;
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableProcessPackageAction.cs

@@ -53,5 +53,12 @@ namespace PackageManagement.Tests.Helpers
 		public bool IsRunPackageScriptsActionDisposed {
 			get { return RunPackageScriptsAction.IsDisposed; }
 		}
+		
+		public bool IsExecuteCoreCalled { get; set; }
+		
+		protected override void ExecuteCore()
+		{
+			IsExecuteCoreCalled = true;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableProjectManager.cs

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using NuGet;
@@ -21,6 +22,7 @@ namespace PackageManagement.Tests.Helpers
 		public IPackage PackagePassedToUpdatePackageReference;
 		public bool UpdateDependenciesPassedToUpdatePackageReference;
 		public bool AllowPrereleaseVersionsPassedToUpdatePackageReference;
+		public List<IPackage> PackagesPassedToUpdatePackageReference = new List<IPackage>();
 		
 		public FakePackageRepository FakeLocalRepository {
 			get { return LocalRepository as FakePackageRepository; }
@@ -67,6 +69,8 @@ namespace PackageManagement.Tests.Helpers
 			PackagePassedToUpdatePackageReference = package;
 			UpdateDependenciesPassedToUpdatePackageReference = updateDependencies;
 			AllowPrereleaseVersionsPassedToUpdatePackageReference = allowPrereleaseVersions;
+			
+			PackagesPassedToUpdatePackageReference.Add(package);
 		}
 		
 		public FakePackage AddFakePackageToProjectLocalRepository(string packageId, string version)

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableUpdatePackagesAction.cs

@@ -0,0 +1,37 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Scripting;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class TestableUpdatePackagesAction : UpdatePackagesAction
+	{
+		public bool IsRunPackageScriptsActionCreated;
+		public IPackageScriptRunner ScriptRunnerPassedToCreateRunPackageScriptsAction;
+		public IPackageManagementProject ProjectPassedToCreateRunPackageScriptsAction;
+		public RunPackageScriptsAction RunPackageScriptsAction;
+		
+		public TestableUpdatePackagesAction(IPackageManagementProject project)
+			: base(project)
+		{
+		}
+		
+		protected override RunPackageScriptsAction CreateRunPackageScriptsAction(
+			IPackageScriptRunner scriptRunner,
+			IPackageManagementProject project)
+		{
+			IsRunPackageScriptsActionCreated = true;
+			ScriptRunnerPassedToCreateRunPackageScriptsAction = scriptRunner;
+			ProjectPassedToCreateRunPackageScriptsAction = project;
+			RunPackageScriptsAction = base.CreateRunPackageScriptsAction(scriptRunner, project);
+			return RunPackageScriptsAction;
+		}
+		
+		public bool IsRunPackageScriptsActionDisposed {
+			get { return RunPackageScriptsAction.IsDisposed; }
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/InstallPackageActionTests.cs

@@ -34,14 +34,8 @@ namespace PackageManagement.Tests
 		
 		void AddInstallOperationWithFile(string fileName)
 		{
-			var package = new FakePackage();
+			action.Operations =
-			package.AddFile(fileName);
+				PackageOperationHelper.CreateListWithOneInstallOperationWithFile(fileName);
-			
-			var operation = new PackageOperation(package, PackageAction.Install);
-			var operations = new List<PackageOperation>();
-			operations.Add(operation);
-			
-			action.Operations = operations;
 		}
 		
 		[Test]

src/AddIns/Misc/PackageManagement/Test/Src/InstalledPackageViewModelTests.cs

@@ -235,7 +235,7 @@ namespace PackageManagement.Tests
 			viewModel.FakePackageManagementEvents.ProjectsToSelect.Add("UnknownProject");
 			viewModel.ManagePackage();
 			
-			List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
+			List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
 			var firstAction = actions[0] as UninstallPackageAction;
 			var secondAction = actions[1] as UninstallPackageAction;
 			

src/AddIns/Misc/PackageManagement/Test/Src/PackageActionRunnerTests.cs

@@ -42,14 +42,8 @@ namespace PackageManagement.Tests
 		{
 			CreateInstallActionWithNoPowerShellScripts();
 			
-			var package = new FakePackage();
+			fakeAction.Operations =
-			package.AddFile(@"tools\init.ps1");
+				PackageOperationHelper.CreateListWithOneInstallOperationWithFile(@"tools\init.ps1");
-			
-			var operation = new PackageOperation(package, PackageAction.Install);
-			var operations = new List<PackageOperation>();
-			operations.Add(operation);
-			
-			fakeAction.Operations = operations;
 			fakeActions.Add(fakeAction);
 		}
 		
@@ -83,7 +77,7 @@ namespace PackageManagement.Tests
 			powerShellDetection.IsPowerShell2InstalledReturnValue = true;
 			Run();
 			
-			ProcessPackageAction action = fakeConsoleActionRunner.ActionPassedToRun;
+			IPackageAction action = fakeConsoleActionRunner.ActionPassedToRun;
 			
 			Assert.AreEqual(fakeAction, action);
 		}
@@ -155,7 +149,7 @@ namespace PackageManagement.Tests
 			powerShellDetection.IsPowerShell2InstalledReturnValue = true;
 			RunMultipleActions();
 			
-			IEnumerable<ProcessPackageAction> actions = fakeConsoleActionRunner.ActionsRunInOneCall;
+			IEnumerable<IPackageAction> actions = fakeConsoleActionRunner.ActionsRunInOneCall;
 			
 			CollectionAssert.AreEqual(fakeActions, actions);
 		}

src/AddIns/Misc/PackageManagement/Test/Src/PackageActionsToRunTests.cs

@@ -33,7 +33,7 @@ namespace PackageManagement.Tests
 		public void GetNextAction_NewInstance_ReturnsFalse()
 		{
 			CreateActions();
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			bool result = actions.GetNextAction(out action);
 			
 			Assert.IsFalse(result);
@@ -45,7 +45,7 @@ namespace PackageManagement.Tests
 			CreateActions();
 			ProcessPackageAction expectedAction = AddAction();
 			
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			actions.GetNextAction(out action);
 			
 			Assert.AreEqual(expectedAction, action);
@@ -57,7 +57,7 @@ namespace PackageManagement.Tests
 			CreateActions();
 			ProcessPackageAction expectedAction = AddAction();
 			
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			bool result = actions.GetNextAction(out action);
 			
 			Assert.IsTrue(result);
@@ -67,8 +67,8 @@ namespace PackageManagement.Tests
 		public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsNullActionInOutParameterOnSecondCall()
 		{
 			CreateActions();
-			ProcessPackageAction expectedAction = AddAction();
+			IPackageAction expectedAction = AddAction();
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			actions.GetNextAction(out action);
 			actions.GetNextAction(out action);
 			
@@ -79,9 +79,9 @@ namespace PackageManagement.Tests
 		public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsFalseOnSecondCall()
 		{
 			CreateActions();
-			ProcessPackageAction expectedAction = AddAction();
+			IPackageAction expectedAction = AddAction();
 			
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			actions.GetNextAction(out action);
 			bool result = actions.GetNextAction(out action);
 			
@@ -93,8 +93,8 @@ namespace PackageManagement.Tests
 		{
 			CreateActions();
 			AddAction();
-			ProcessPackageAction expectedAction = AddAction();
+			IPackageAction expectedAction = AddAction();
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			actions.GetNextAction(out action);
 			actions.GetNextAction(out action);
 			
@@ -106,8 +106,8 @@ namespace PackageManagement.Tests
 		{
 			CreateActions();
 			AddAction();
-			ProcessPackageAction expectedAction = AddAction();
+			IPackageAction expectedAction = AddAction();
-			ProcessPackageAction action = null;
+			IPackageAction action = null;
 			actions.GetNextAction(out action);
 			bool result = actions.GetNextAction(out action);
 			

src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementProjectTests.cs

@@ -28,6 +28,7 @@ namespace PackageManagement.Tests
 		FakeInstallPackageAction fakeInstallAction;
 		FakeUninstallPackageAction fakeUninstallAction;
 		FakeUpdatePackageAction fakeUpdateAction;
+		UpdatePackagesAction updatePackagesAction;
 		
 		void CreateProject()
 		{
@@ -63,6 +64,11 @@ namespace PackageManagement.Tests
 			return fakeUpdateAction;
 		}
 		
+		void CreateUpdatePackagesAction()
+		{
+			updatePackagesAction = new UpdatePackagesAction(project);
+		}
+		
 		[Test]
 		public void IsInstalled_PackageIsInstalled_ReturnsTrue()
 		{
@@ -639,5 +645,40 @@ namespace PackageManagement.Tests
 			
 			Assert.IsFalse(fakePackageManager.AllowPrereleaseVersionsPassedToInstallPackage);
 		}
+		
+		[Test]
+		public void UpdatePackages_ActionHasOperationsAndPackages_ActionPassedToPackageManager()
+		{
+			CreateProject();
+			CreateUpdatePackagesAction();
+			
+			project.UpdatePackages(updatePackagesAction);
+			
+			Assert.AreEqual(updatePackagesAction, fakePackageManager.UpdatePackagesActionsPassedToUpdatePackages);
+		}
+		
+		[Test]
+		public void GetUpdatePackagesOperations_ActionPassed_ActionPassedToPackageManager()
+		{
+			CreateProject();
+			CreateUpdatePackagesAction();
+			
+			project.GetUpdatePackagesOperations(updatePackagesAction);
+			
+			Assert.AreEqual(updatePackagesAction, fakePackageManager.UpdatePackagesActionsPassedToGetUpdatePackagesOperations);
+		}
+		
+		[Test]
+		public void GetUpdatePackagesOperations_ActionPassed_PackageOperationsReturned()
+		{
+			CreateProject();
+			CreateUpdatePackagesAction();
+			List<PackageOperation> expectedOperations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
+			fakePackageManager.PackageOperationsToReturnFromGetUpdatePackageOperations = expectedOperations;
+			
+			IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(updatePackagesAction);
+			
+			CollectionAssert.AreEqual(expectedOperations, operations);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/PackageReferenceInstallerTests.cs

@@ -49,7 +49,7 @@ namespace PackageManagement.Tests
 			AddPackageReference("PackageId", "1.3.4.5");
 			InstallPackages();
 			
-			var actions = new List<ProcessPackageAction>(fakeActionRunner.ActionsRunInOneCall);
+			var actions = new List<IPackageAction>(fakeActionRunner.ActionsRunInOneCall);
 			var action = actions[0] as InstallPackageAction;
 			
 			var expectedVersion = new SemanticVersion("1.3.4.5");

src/AddIns/Misc/PackageManagement/Test/Src/PackageViewModelTests.cs

@@ -177,7 +177,7 @@ namespace PackageManagement.Tests
 			
 			viewModel.AddPackage();
 			
-			ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
+			IPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
 			
 			Assert.AreEqual(fakeInstallPackageAction, actionExecuted);
 		}
@@ -739,7 +739,7 @@ namespace PackageManagement.Tests
 			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.RemovePackage();
 			
-			ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
+			IPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
 			
 			Assert.AreEqual(fakeUninstallPackageAction, actionExecuted);
 		}
@@ -902,7 +902,7 @@ namespace PackageManagement.Tests
 			
 			viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 			
-			List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
+			List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
 			InstallPackageAction action = actions[0] as InstallPackageAction;
 			
 			Assert.AreEqual(1, actions.Count);
@@ -1111,7 +1111,7 @@ namespace PackageManagement.Tests
 			viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 			
 			InstallPackageAction expectedAction = FirstFakeSelectedProject.FakeInstallPackageAction;
-			List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
+			List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
 			InstallPackageAction action = actions[0] as InstallPackageAction;
 			
 			Assert.AreEqual(1, actions.Count);
@@ -1224,12 +1224,12 @@ namespace PackageManagement.Tests
 			CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 			UserAcceptsProjectSelection();
 			fakePackageManagementEvents.ProjectsToSelect.Add("Project A");
+			
 			viewModel.ManagePackage();
 			
-			List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
+			List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
-			ProcessPackageAction action = actions[0];
+			var action = actions[0] as ProcessPackageAction;
 			FakePackageManagementProject expectedProject = fakeSolution.FakeProjectsToReturnFromGetProject["Project A"];
-			
 			Assert.AreEqual(expectedProject, action.Project);
 		}
 		

src/AddIns/Misc/PackageManagement/Test/Src/ProcessPackageActionTests.cs

@@ -67,7 +67,7 @@ namespace PackageManagement.Tests
 		}
 		
 		[Test]
-		public void Execute_MethodCalled_RunPackageScriptsActionCreatedUsingPackageScriptRunner()
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingPackageScriptRunner()
 		{
 			CreateAction();
 			var expectedRunner = new FakePackageScriptRunner();
@@ -80,7 +80,7 @@ namespace PackageManagement.Tests
 		}
 		
 		[Test]
-		public void Execute_MethodCalled_RunPackageScriptsActionCreatedUsingProject()
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingProject()
 		{
 			CreateAction();
 			var expectedProject = new FakePackageManagementProject();
@@ -88,13 +88,13 @@ namespace PackageManagement.Tests
 			action.PackageScriptRunner = new FakePackageScriptRunner();
 			action.Execute();
 			
-			var actualProject = action.ProjectPassedToCreateRunPackageScriptsAction;
+			IPackageManagementProject actualProject = action.ProjectPassedToCreateRunPackageScriptsAction;
 			
 			Assert.AreEqual(expectedProject, actualProject);
 		}
 		
 		[Test]
-		public void Execute_MethodCalled_RunPackageScriptsActionIsDisposed()
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionIsDisposed()
 		{
 			CreateAction();
 			action.PackageScriptRunner = new FakePackageScriptRunner();
@@ -104,12 +104,25 @@ namespace PackageManagement.Tests
 		}
 		
 		[Test]
-		public void Execute_NullSession_RunPackageScriptsActionIsNotCreated()
+		public void Execute_NullPackageScriptRunner_RunPackageScriptsActionIsNotCreated()
 		{
 			CreateAction();
+			action.PackageScriptRunner = null;
+			
 			action.Execute();
 			
 			Assert.IsFalse(action.IsRunPackageScriptsActionCreated);
 		}
+		
+		[Test]
+		public void Execute_NullPackageScriptRunner_ActionIsExecuted()
+		{
+			CreateAction();
+			action.PackageScriptRunner = new FakePackageScriptRunner();
+			
+			action.Execute();
+			
+			Assert.IsTrue(action.IsExecuteCoreCalled);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/ReducedPackageOperationsTests.cs

@@ -0,0 +1,170 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using ICSharpCode.PackageManagement;
+using NuGet;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class ReducedPackageOperationsTests
+	{
+		ReducedPackageOperations reducedPackageOperations;
+		IPackageOperationResolver fakePackageOperationResolver;
+		List<IPackage> packages;
+		
+		void CreateReducedPackageOperations()
+		{
+			packages = new List<IPackage>();
+			fakePackageOperationResolver = MockRepository.GenerateStub<IPackageOperationResolver>();
+			reducedPackageOperations = new ReducedPackageOperations(fakePackageOperationResolver, packages);
+		}
+		
+		IPackage AddPackage(string id, string version)
+		{
+			IPackage package = CreatePackage(id, version);
+			packages.Add(package);
+			
+			return package;
+		}
+		
+		IPackage CreatePackage(string id, string version)
+		{
+			IPackage package = MockRepository.GenerateStub<IPackage>();
+			package.Stub(p => p.Id).Return(id);
+			package.Stub(p => p.Version).Return(new SemanticVersion(version));
+			return package;
+		}
+		
+		PackageOperation AddInstallOperationForPackage(IPackage package)
+		{
+			var operation = new PackageOperation(package, PackageAction.Install);
+			AddInstallOperationsForPackage(package, operation);
+			return operation;
+		}
+		
+		void AddInstallOperationsForPackage(IPackage package, params PackageOperation[] operations)
+		{
+			fakePackageOperationResolver
+				.Stub(resolver => resolver.ResolveOperations(package))
+				.Return(operations);
+		}
+		
+		PackageOperation CreatePackageOperation(string id, string version, PackageAction action)
+		{
+			IPackage package = CreatePackage(id, version);
+			return new PackageOperation(package, action);
+		}
+		
+		void AssertReducedOperationsContains(PackageOperation operation)
+		{
+			Assert.Contains(operation, reducedPackageOperations.Operations.ToList());
+		}
+		
+		[Test]
+		public void Reduce_OnePackage_ReturnsPackageOperationsFromResolverForPackage()
+		{
+			CreateReducedPackageOperations();
+			IPackage package = AddPackage("Test", "1.0");
+			PackageOperation operation = AddInstallOperationForPackage(package);
+			
+			reducedPackageOperations.Reduce();
+			
+			Assert.AreEqual(1, reducedPackageOperations.Operations.Count());
+			Assert.AreEqual(operation, reducedPackageOperations.Operations.First());
+		}
+		
+		[Test]
+		public void Reduce_TwoPackages_ReturnsPackageOperationsForBothPackages()
+		{
+			CreateReducedPackageOperations();
+			IPackage package1 = AddPackage("Test", "1.0");
+			IPackage package2 = AddPackage("Test2", "1.0");
+			PackageOperation operation1 = AddInstallOperationForPackage(package1);
+			PackageOperation operation2 = AddInstallOperationForPackage(package2);
+			
+			reducedPackageOperations.Reduce();
+			
+			Assert.AreEqual(2, reducedPackageOperations.Operations.Count());
+			AssertReducedOperationsContains(operation1);
+			AssertReducedOperationsContains(operation2);
+		}
+		
+		[Test]
+		public void Reduce_OncePackageOperationInstallsPackageWhilstOneUninstallsSamePackage_PackageOperationNotIncludedInReducedSet()
+		{
+			CreateReducedPackageOperations();
+			IPackage package = AddPackage("Test", "1.0");
+			PackageOperation installOperation = CreatePackageOperation("Foo", "1.0", PackageAction.Install);
+			PackageOperation uninstallOperation = CreatePackageOperation("Foo", "1.0", PackageAction.Uninstall);
+			AddInstallOperationsForPackage(package, installOperation, uninstallOperation);
+			
+			reducedPackageOperations.Reduce();
+			
+			Assert.AreEqual(0, reducedPackageOperations.Operations.Count());
+		}
+		
+		[Test]
+		public void Reduce_OnePackageOperationMatchesPackageBeingInstalled_ReturnsOnlyOnePackageInstallOperationForThisPackage()
+		{
+			CreateReducedPackageOperations();
+			IPackage package1 = AddPackage("Test", "1.0");
+			IPackage package2 = AddPackage("Test2", "1.0");
+			PackageOperation operation1a = CreatePackageOperation("Test", "1.0", PackageAction.Install);
+			PackageOperation operation1b = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
+			PackageOperation operation2 = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
+			AddInstallOperationsForPackage(package1, operation1a, operation1b);
+			AddInstallOperationsForPackage(package2, operation2);
+			
+			reducedPackageOperations.Reduce();
+			
+			PackageOperation operation = reducedPackageOperations
+				.Operations
+				.SingleOrDefault(o => o.Package.Id == "Test2");
+			Assert.AreEqual(2, reducedPackageOperations.Operations.Count());
+		}
+		
+		[Test]
+		public void Reduce_OnePackageOperationMatchesPackageBeingInstalledOnlyById_MatchingPackageOperationByIdIncludedInSet()
+		{
+			CreateReducedPackageOperations();
+			IPackage package1 = AddPackage("Test", "1.0");
+			IPackage package2 = AddPackage("Test2", "1.0");
+			PackageOperation operation1a = CreatePackageOperation("Test", "1.0", PackageAction.Install);
+			PackageOperation operation1b = CreatePackageOperation("Test2", "1.1", PackageAction.Install);
+			PackageOperation operation2 = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
+			AddInstallOperationsForPackage(package1, operation1a, operation1b);
+			AddInstallOperationsForPackage(package2, operation2);
+			
+			reducedPackageOperations.Reduce();
+			
+			Assert.AreEqual(3, reducedPackageOperations.Operations.Count());
+		}
+		
+		[Test]
+		public void Reduce_OnePackageOperationMatchesPackageBeingInstalledByIdAndVersionButOneIsInstallAndOneIsUninstall_BothOperationsNotIncludedInSet()
+		{
+			CreateReducedPackageOperations();
+			IPackage package1 = AddPackage("Test", "1.0");
+			IPackage package2 = AddPackage("Test2", "1.0");
+			PackageOperation operation1a = CreatePackageOperation("Test", "1.0", PackageAction.Install);
+			PackageOperation operation1b = CreatePackageOperation("Test2", "1.0", PackageAction.Uninstall);
+			PackageOperation operation2 = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
+			AddInstallOperationsForPackage(package1, operation1a, operation1b);
+			AddInstallOperationsForPackage(package2, operation2);
+			
+			reducedPackageOperations.Reduce();
+			
+			PackageOperation operation = reducedPackageOperations
+				.Operations
+				.SingleOrDefault(o => o.Package.Id == "Test");
+			Assert.AreEqual(1, reducedPackageOperations.Operations.Count());
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/SharpDevelopPackageManagerTests.cs

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using ICSharpCode.Core;
 using ICSharpCode.PackageManagement;
@@ -10,6 +11,7 @@ using ICSharpCode.SharpDevelop.Project;
 using NuGet;
 using NUnit.Framework;
 using PackageManagement.Tests.Helpers;
+using Rhino.Mocks;
 
 namespace PackageManagement.Tests
 {
@@ -26,6 +28,7 @@ namespace PackageManagement.Tests
 		TestableProjectManager testableProjectManager;
 		FakeFileSystem fakeFileSystem;
 		FakePackageOperationResolverFactory fakePackageOperationResolverFactory;
+		IPackageOperationResolver fakePackageOperationResolver;
 		
 		void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper)
 		{
@@ -76,9 +79,9 @@ namespace PackageManagement.Tests
 			packageManager.ProjectManager = testableProjectManager;
 		}
 		
-		FakePackage CreateFakePackage()
+		FakePackage CreateFakePackage(string id = "Test", string version = "1.0.0.0")
 		{
-			return new FakePackage("Test", "1.0.0.0");
+			return new FakePackage(id, version);
 		}
 		
 		FakePackage InstallPackage()
@@ -192,11 +195,9 @@ namespace PackageManagement.Tests
 			return package;
 		}
 		
-		PackageOperation CreateOneInstallPackageOperation()
+		PackageOperation CreateOneInstallPackageOperation(string id = "PackageToInstall", string version = "1.0")
 		{
-			FakePackage package = CreateFakePackage();
+			FakePackage package = CreateFakePackage(id, version);
-			package.Id = "PackageToInstall";
-			
 			return new PackageOperation(package, PackageAction.Install);
 		}
 		
@@ -270,6 +271,45 @@ namespace PackageManagement.Tests
 			return package;
 		}
 		
+		UpdatePackagesAction CreateUpdatePackagesAction()
+		{
+			return new UpdatePackagesAction(new FakePackageManagementProject());
+		}
+		
+		UpdatePackagesAction CreateUpdatePackagesActionWithPackages(params IPackage[] packages)
+		{
+			UpdatePackagesAction action = CreateUpdatePackagesAction();
+			action.AddPackages(packages);
+			return action;
+		}
+		
+		UpdatePackagesAction CreateUpdatePackagesActionWithOperations(params PackageOperation[] operations)
+		{
+			UpdatePackagesAction action = CreateUpdatePackagesAction();
+			action.AddOperations(operations);
+			return action;
+		}
+		
+		PackageOperation AddInstallOperationForPackage(IPackage package)
+		{
+			var operation = new PackageOperation(package, PackageAction.Install);
+			AddInstallOperationsForPackage(package, operation);
+			return operation;
+		}
+		
+		void AddInstallOperationsForPackage(IPackage package, params PackageOperation[] operations)
+		{
+			fakePackageOperationResolver
+				.Stub(resolver => resolver.ResolveOperations(package))
+				.Return(operations);
+		}
+		
+		void CreateFakePackageResolverForUpdatePackageOperations()
+		{
+			fakePackageOperationResolver = MockRepository.GenerateStub<IPackageOperationResolver>();
+			fakePackageOperationResolverFactory.UpdatePackageOperationsResolver = fakePackageOperationResolver;
+		}
+		
 		[Test]
 		public void ProjectManager_InstanceCreated_SourceRepositoryIsSharedRepositoryPassedToPackageManager()
 		{
@@ -735,5 +775,180 @@ namespace PackageManagement.Tests
 			
 			Assert.IsFalse(testableProjectManager.UpdateDependenciesPassedToUpdatePackageReference);
 		}
+		
+		[Test]
+		public void UpdatePackages_OnePackage_PackageReferencedIsAddedToProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
+			
+			packageManager.UpdatePackages(action);
+			
+			Assert.AreEqual(package, testableProjectManager.PackagePassedToUpdatePackageReference);
+		}
+		
+		[Test]
+		public void UpdatePackages_TwoPackages_PackageReferencedIsAddedToProjectForBothPackages()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			FakePackage package1 = CreateFakePackage("First", "1.1");
+			FakePackage package2 = CreateFakePackage("Second", "2.0");
+			var expectedPackages = new FakePackage[] { package1, package2 };
+			UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(expectedPackages);
+			
+			packageManager.UpdatePackages(action);
+			
+			PackageCollectionAssert.AreEqual(expectedPackages, testableProjectManager.PackagesPassedToUpdatePackageReference);
+		}
+		
+		[Test]
+		public void UpdatePackages_UpdateDependenciesIsTrue_UpdateDependenciesPassedToProjectManager()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
+			action.UpdateDependencies = true;
+			
+			packageManager.UpdatePackages(action);
+			
+			Assert.IsTrue(testableProjectManager.UpdateDependenciesPassedToUpdatePackageReference);
+		}
+		
+		[Test]
+		public void UpdatePackages_UpdateDependenciesIsFalse_UpdateDependenciesPassedToProjectManager()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
+			action.UpdateDependencies = false;
+			
+			packageManager.UpdatePackages(action);
+			
+			Assert.IsFalse(testableProjectManager.UpdateDependenciesPassedToUpdatePackageReference);
+		}
+		
+		[Test]
+		public void UpdatePackages_AllowPrereleaseVersionsIsTrue_AllowPrereleaseVersionsPassedToProjectManager()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
+			action.AllowPrereleaseVersions = true;
+			
+			packageManager.UpdatePackages(action);
+			
+			Assert.IsTrue(testableProjectManager.AllowPrereleaseVersionsPassedToUpdatePackageReference);
+		}
+		
+		[Test]
+		public void UpdatePackages_AllowPrereleaseVersionsIsFalse_AllowPrereleaseVersionsPassedToProjectManager()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
+			action.AllowPrereleaseVersions = false;
+			
+			packageManager.UpdatePackages(action);
+			
+			Assert.IsFalse(testableProjectManager.AllowPrereleaseVersionsPassedToUpdatePackageReference);
+		}
+		
+		[Test]
+		public void UpdatePackages_TwoPackageOperations_BothPackagesInOperationsAddedToSharedRepository()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			PackageOperation operation1 = CreateOneInstallPackageOperation("First", "1.0");
+			PackageOperation operation2 = CreateOneInstallPackageOperation("Second", "1.0");
+			UpdatePackagesAction action = CreateUpdatePackagesActionWithOperations(operation1, operation2);
+			var expectedPackages = new FakePackage[] {
+				operation1.Package as FakePackage,
+				operation2.Package as FakePackage
+			};
+			
+			packageManager.UpdatePackages(action);
+			
+			PackageCollectionAssert.AreEqual(expectedPackages, fakeSolutionSharedRepository.PackagesAdded);
+		}
+		
+		[Test]
+		public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesLoggerWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
+			
+			packageManager.GetUpdatePackageOperations(updateAction);
+			
+			ILogger expectedLogger = packageManager.Logger;
+			ILogger actualLogger = fakePackageOperationResolverFactory.LoggerPassedToCreateUpdatePackageOperationResolver;
+			Assert.AreEqual(expectedLogger, actualLogger);
+		}
+		
+		[Test]
+		public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesLocalRepositoryWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
+			
+			packageManager.GetUpdatePackageOperations(updateAction);
+			
+			IPackageRepository expectedRepository = packageManager.LocalRepository;
+			IPackageRepository actualRepository = fakePackageOperationResolverFactory.LocalRepositoryPassedToCreateUpdatePackageOperationsResolver;
+			Assert.AreEqual(expectedRepository, actualRepository);
+		}
+		
+		[Test]
+		public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesSourceRepositoryWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
+			
+			packageManager.GetUpdatePackageOperations(updateAction);
+			
+			IPackageRepository expectedRepository = packageManager.SourceRepository;
+			IPackageRepository actualRepository = fakePackageOperationResolverFactory.SourceRepositoryPassedToCreateUpdatePackageOperationsResolver;
+			Assert.AreEqual(expectedRepository, actualRepository);
+		}
+		
+		[Test]
+		public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesUpdatePackageSettingsWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			FakePackage package = CreateFakePackage("Test", "1.1");
+			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
+			
+			packageManager.GetUpdatePackageOperations(updateAction);
+			
+			IUpdatePackageSettings settings = fakePackageOperationResolverFactory.SettingsPassedToCreatePackageOperationResolver;
+			Assert.AreEqual(updateAction, settings);
+		}
+		
+		[Test]
+		public void GetUpdatePackageOperations_TwoPackages_ReturnsPackageOperationsForBothPackages()
+		{
+			CreatePackageManager();
+			CreateFakePackageResolverForUpdatePackageOperations();
+			IPackage package1 = CreateFakePackage("Test", "1.0");
+			IPackage package2 = CreateFakePackage("Test2", "1.0");
+			PackageOperation operation1 = AddInstallOperationForPackage(package1);
+			PackageOperation operation2 = AddInstallOperationForPackage(package2);
+			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package1, package2);
+			
+			List<PackageOperation> operations = packageManager.GetUpdatePackageOperations(updateAction).ToList();
+			
+			Assert.AreEqual(2, operations.Count());
+			Assert.Contains(operation1, operations);
+			Assert.Contains(operation2, operations);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/UpdatePackagesActionTests.cs

@@ -0,0 +1,165 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class UpdatePackagesActionTests
+	{
+		TestableUpdatePackagesAction action;
+		IPackageManagementProject project;
+		
+		void CreateAction()
+		{
+			CreateProject();
+			action = new TestableUpdatePackagesAction(project);
+		}
+		
+		void CreateActionWithOperations(params PackageOperation[] operations)
+		{
+			CreateAction();
+			action.AddOperations(operations);
+		}
+		
+		void CreateProject()
+		{
+			project = MockRepository.GenerateStub<IPackageManagementProject>();
+		}
+		
+		IPackage CreatePackage()
+		{
+			return MockRepository.GenerateStub<IPackage>();
+		}
+		
+		PackageOperation CreateInstallOperationWithFile(string fileName)
+		{
+			return PackageOperationHelper.CreateInstallOperationWithFile(fileName);
+		}
+		
+		IPackageScriptRunner CreatePackageScriptRunner()
+		{
+			return MockRepository.GenerateStub<IPackageScriptRunner>();
+		}
+		
+		[Test]
+		public void UpdateDependencies_DefaultValue_IsTrue()
+		{
+			CreateActionWithOperations();
+			
+			bool result = action.UpdateDependencies;
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_PackageHasInitPowerShellScript_ReturnsTrue()
+		{
+			PackageOperation operation = CreateInstallOperationWithFile(@"tools\install.ps1");
+			CreateActionWithOperations(operation);
+			
+			bool result = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_PackageHasOneTextFile_ReturnsFalse()
+		{
+			PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
+			CreateActionWithOperations(operation);
+			
+			bool result = action.HasPackageScriptsToRun();
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void Execute_UpdatePackagesAction_PackagesUpdatedUsingProject()
+		{
+			CreateAction();
+			
+			action.Execute();
+			
+			project.AssertWasCalled(p => p.UpdatePackages(action));
+		}
+		
+		[Test]
+		public void Execute_UpdatePackagesActionWithOnePackageOperation_PackagesUpdatedUsingProject()
+		{
+			PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
+			CreateActionWithOperations(operation);
+			
+			action.Execute();
+			
+			project.AssertWasCalled(p => p.UpdatePackages(action));
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingPackageScriptRunner()
+		{
+			CreateAction();
+			IPackageScriptRunner expectedRunner = CreatePackageScriptRunner();
+			action.PackageScriptRunner = expectedRunner;
+			
+			action.Execute();
+			
+			IPackageScriptRunner actualRunner = action.ScriptRunnerPassedToCreateRunPackageScriptsAction;
+			Assert.AreEqual(expectedRunner, actualRunner);
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingProject()
+		{
+			CreateAction();
+			action.PackageScriptRunner = CreatePackageScriptRunner();
+			
+			action.Execute();
+			
+			IPackageManagementProject actualProject = action.ProjectPassedToCreateRunPackageScriptsAction;
+			Assert.AreEqual(project, actualProject);
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionIsDisposed()
+		{
+			CreateAction();
+			action.PackageScriptRunner = CreatePackageScriptRunner();
+			
+			action.Execute();
+			
+			Assert.IsTrue(action.IsRunPackageScriptsActionDisposed);
+		}
+		
+		[Test]
+		public void Execute_NullPackageScriptRunner_RunPackageScriptsActionIsNotCreated()
+		{
+			CreateAction();
+			action.PackageScriptRunner = null;
+			
+			action.Execute();
+			
+			Assert.IsFalse(action.IsRunPackageScriptsActionCreated);
+		}
+		
+		[Test]
+		public void Execute_NullPackageScriptRunner_PackagesAreUpdated()
+		{
+			CreateAction();
+			PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
+			CreateActionWithOperations(operation);
+			action.PackageScriptRunner = CreatePackageScriptRunner();
+			
+			action.Execute();
+			
+			project.AssertWasCalled(p => p.UpdatePackages(action));
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/UpdatedPackageViewModelTests.cs

@@ -39,7 +39,6 @@ namespace PackageManagement.Tests
 			get { return fakeProject.FirstFakeUpdatePackageActionCreated; }
 		}
 		
-		
 		void CreateFakeSolution()
 		{
 			fakeSolution = new FakePackageManagementSolution();
@@ -106,7 +105,7 @@ namespace PackageManagement.Tests
 			CreateViewModel();
 			viewModel.AddPackage();
 			
-			ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
+			IPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
 
 			Assert.AreEqual(FirstUpdatePackageActionCreated, actionExecuted);
 		}
@@ -120,7 +119,7 @@ namespace PackageManagement.Tests
 			viewModel.ManagePackage();
 			
 			FakePackage expectedPackage = viewModel.FakePackage;
-			List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
+			List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
 			var updatePackageAction = actions[0] as UpdatePackageAction;
 			IPackage actualPackage = updatePackageAction.Package;
 			

src/AddIns/Misc/PackageManagement/Test/Src/UpdatedPackagesViewModelTests.cs

@@ -2,6 +2,9 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
+
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using NuGet;
@@ -18,6 +21,9 @@ namespace PackageManagement.Tests
 		FakeTaskFactory taskFactory;
 		FakeRegisteredPackageRepositories registeredPackageRepositories;
 		ExceptionThrowingPackageManagementSolution exceptionThrowingSolution;
+		FakePackageViewModelFactory packageViewModelFactory;
+		FakePackageManagementEvents fakePackageManagementEvents;
+		UpdatedPackageViewModelFactory updatedPackageViewModelFactory;
 		
 		void CreateViewModel()
 		{
@@ -42,11 +48,40 @@ namespace PackageManagement.Tests
 			CreateViewModel(solution, registeredPackageRepositories);
 		}
 		
+		void CreateViewModel(FakePackageActionRunner actionRunner)
+		{
+			CreateSolution();
+			CreateRegisteredPackageRepositories();
+			CreateViewModel(solution, registeredPackageRepositories, actionRunner);
+		}
+		
 		void CreateViewModel(FakePackageManagementSolution solution, FakeRegisteredPackageRepositories registeredPackageRepositories)
+		{
+			packageViewModelFactory = new FakePackageViewModelFactory { FakeSolution = solution };
+			CreateViewModel(solution, registeredPackageRepositories, packageViewModelFactory);
+		}
+		
+		void CreateViewModel(
+			FakePackageManagementSolution solution,
+			FakeRegisteredPackageRepositories registeredPackageRepositories,
+			FakePackageActionRunner actionRunner)
+		{
+			packageViewModelFactory = new FakePackageViewModelFactory {
+				FakeSolution = solution,
+				FakeActionRunner = actionRunner
+			};
+			CreateViewModel(solution, registeredPackageRepositories, packageViewModelFactory);
+		}
+		
+		void CreateViewModel(
+			FakePackageManagementSolution solution,
+			FakeRegisteredPackageRepositories registeredPackageRepositories,
+			FakePackageViewModelFactory packageViewModelFactory)
 		{
 			taskFactory = new FakeTaskFactory();
-			var packageViewModelFactory = new FakePackageViewModelFactory();
+			this.packageViewModelFactory = packageViewModelFactory;
-			var updatedPackageViewModelFactory = new UpdatedPackageViewModelFactory(packageViewModelFactory);
+			fakePackageManagementEvents = packageViewModelFactory.FakePackageManagementEvents;
+			updatedPackageViewModelFactory = new UpdatedPackageViewModelFactory(packageViewModelFactory);
 			viewModel = new UpdatedPackagesViewModel(
 				solution,
 				registeredPackageRepositories,
@@ -78,14 +113,24 @@ namespace PackageManagement.Tests
 
 		FakePackage AddPackageToLocalRepository(string version)
 		{
-			FakePackage package = FakePackage.CreatePackageWithVersion(version);
+			return AddPackageToLocalRepository("Test", version);
+		}
+		
+		FakePackage AddPackageToLocalRepository(string id, string version)
+		{
+			FakePackage package = FakePackage.CreatePackageWithVersion(id, version);
 			solution.FakeProjectToReturnFromGetProject.FakePackages.Add(package);
 			return package;
 		}
 		
 		FakePackage AddPackageToActiveRepository(string version)
 		{
-			return registeredPackageRepositories.AddFakePackageWithVersionToActiveRepository(version);
+			return AddPackageToActiveRepository("Test", version);
+		}
+		
+		FakePackage AddPackageToActiveRepository(string id, string version)
+		{
+			return registeredPackageRepositories.AddFakePackageWithVersionToActiveRepository(id, version);
 		}
 		
 		FakePackage AddPackageToSolution(string version)
@@ -118,6 +163,28 @@ namespace PackageManagement.Tests
 			registeredPackageRepositories.AddPackageSources(sources);
 		}
 		
+		UpdatePackagesAction GetUpdatePackagesActionRun()
+		{
+			return packageViewModelFactory
+				.FakeActionRunner
+				.ActionPassedToRun as UpdatePackagesAction;
+		}
+		
+		void RunUpdateAllPackagesCommand()
+		{
+			viewModel.UpdateAllPackagesCommand.Execute(null);
+		}
+		
+		void ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages()
+		{
+			AddPackageToLocalRepository("First", "1.0.0.0");
+			AddPackageToActiveRepository("First", "1.1.0.0");
+			AddPackageToLocalRepository("Second", "1.0.0.0");
+			AddPackageToActiveRepository("Second", "1.1.0.0");
+			viewModel.ReadPackages();
+			CompleteReadPackagesTask();
+		}
+		
 		[Test]
 		public void ReadPackages_OneNewerPackageVersionAvailable_NewerPackageVersionDisplayed()
 		{
@@ -259,5 +326,183 @@ namespace PackageManagement.Tests
 			
 			Assert.IsTrue(viewModel.ShowPackageSources);
 		}
+		
+		[Test]
+		public void ShowUpdateAllPackages_DefaultValue_ReturnsTrue()
+		{
+			CreateViewModel();
+			
+			bool result = viewModel.ShowUpdateAllPackages;
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void IsUpdateAllPackagesEnabled_NoPackages_ReturnsFalse()
+		{
+			CreateViewModel();
+			
+			bool enabled = viewModel.IsUpdateAllPackagesEnabled;
+			
+			Assert.IsFalse(enabled);
+		}
+		
+		[Test]
+		public void IsUpdateAllPackagesEnabled_TwoNewerPackagesAvailable_ReturnsTrue()
+		{
+			CreateViewModel();
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			
+			bool enabled = viewModel.IsUpdateAllPackagesEnabled;
+			
+			Assert.IsTrue(enabled);
+		}
+		
+		[Test]
+		public void IsUpdateAllPackagesEnabled_OneNewerPackageAvailable_ReturnsFalse()
+		{
+			CreateViewModel();
+			AddPackageToLocalRepository("First", "1.0.0.0");
+			AddPackageToActiveRepository("First", "1.1.0.0");
+			viewModel.ReadPackages();
+			CompleteReadPackagesTask();
+			
+			bool enabled = viewModel.IsUpdateAllPackagesEnabled;
+			
+			Assert.IsFalse(enabled);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_TwoPackagesToBeUpdated_BothPackagesUpdated()
+		{
+			CreateViewModel();
+			AddPackageToLocalRepository("First", "1.0.0.0");
+			FakePackage firstUpdatedPackage = AddPackageToActiveRepository("First", "1.1.0.0");
+			AddPackageToLocalRepository("Second", "1.0.0.0");
+			FakePackage secondUpdatedPackage = AddPackageToActiveRepository("Second", "1.1.0.0");
+			viewModel.ReadPackages();
+			CompleteReadPackagesTask();
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdatePackagesAction action = GetUpdatePackagesActionRun();
+			IPackage firstPackage = action.Packages.FirstOrDefault(p => p.Id == "First");
+			IPackage secondPackage = action.Packages.FirstOrDefault(p => p.Id == "Second");
+			Assert.AreEqual(firstUpdatedPackage, firstPackage);
+			Assert.AreEqual(secondUpdatedPackage, secondPackage);
+			Assert.AreEqual(2, action.Packages.Count());
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_ExceptionThrownWhenUpdatingAllPackages_ExceptionReported()
+		{
+			var actionRunner =  new ExceptionThrowingPackageActionRunner();
+			CreateViewModel(actionRunner);
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			var exception = new Exception("test");
+			actionRunner.ExceptionToThrow = exception;
+			
+			RunUpdateAllPackagesCommand();
+			
+			Assert.AreEqual(exception, packageViewModelFactory.FakePackageManagementEvents.ExceptionPassedToOnPackageOperationError);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_ExceptionThrownWhenUpdatingAllPackages_ExceptionLogged()
+		{
+			var actionRunner =  new ExceptionThrowingPackageActionRunner();
+			CreateViewModel(actionRunner);
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			var exception = new Exception("Exception error message");
+			actionRunner.ExceptionToThrow = exception;
+			
+			RunUpdateAllPackagesCommand();
+			
+			string actualMessage = fakePackageManagementEvents.FormattedStringPassedToOnPackageOperationMessageLogged;
+			bool containsExceptionErrorMessage = actualMessage.Contains("Exception error message");
+			Assert.IsTrue(containsExceptionErrorMessage, actualMessage);
+			Assert.AreEqual(MessageLevel.Error, fakePackageManagementEvents.MessageLevelPassedToOnPackageOperationMessageLogged);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_PackagesUpdated_ProjectCreatedUsingSourcePackageRepository()
+		{
+			CreateViewModel();
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			var package = viewModel.PackageViewModels[0].GetPackage() as IPackageFromRepository;
+			solution.RepositoryPassedToGetProject = null;
+			
+			RunUpdateAllPackagesCommand();
+			
+			Assert.AreEqual(package.Repository, solution.RepositoryPassedToGetProject);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_PackagesUpdated_UpdatePackagesActionCreatedFromProject()
+		{
+			CreateViewModel();
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdatePackagesAction action = GetUpdatePackagesActionRun();
+			FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
+			UpdatePackagesAction expectedAction = project.UpdatePackagesActionsCreated.FirstOrDefault();
+			Assert.AreEqual(expectedAction, action);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_CheckLoggerUsed_PackageViewModelLoggerUsedWhenResolvingPackageOperations()
+		{
+			CreateViewModel();
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			
+			RunUpdateAllPackagesCommand();
+			
+			ILogger expectedLogger = updatedPackageViewModelFactory.Logger;
+			ILogger actualLogger = solution.FakeProjectToReturnFromGetProject.Logger;
+			Assert.AreEqual(expectedLogger, actualLogger);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_PackageOperations_CreatedFromProjectUsingPackagesAndUpdatePackagesAction()
+		{
+			CreateViewModel();
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdatePackagesAction action = GetUpdatePackagesActionRun();
+			FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
+			Assert.AreEqual(action, project.UpdatePackagesActionPassedToGetUpdatePackagesOperations);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_PackageOperations_ActionHasPackageOperationsReturnedFromProject()
+		{
+			CreateViewModel();
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
+			List<PackageOperation> operations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
+			project.PackageOperationsToReturnFromGetUpdatePackagesOperations = operations;
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdatePackagesAction action = GetUpdatePackagesActionRun();
+			CollectionAssert.AreEqual(operations, action.Operations);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_PackageOperations_PackagesUsedToDeterminePackageOperations()
+		{
+			CreateViewModel();
+			ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
+			FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
+			List<FakePackage> expectedPackages = registeredPackageRepositories.FakeActiveRepository.FakePackages;
+			
+			RunUpdateAllPackagesCommand();
+			
+			CollectionAssert.AreEqual(expectedPackages, project.PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations);
+		}
 	}
 }