Support updating all NuGet packages in solution from dialog

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

@@ -234,8 +234,10 @@
     <Compile Include="Src\ProjectBuilder.cs" />
     <Compile Include="Src\ReducedPackageOperations.cs" />
     <Compile Include="Src\ResolveFileConflictEventArgs.cs" />
+    <Compile Include="Src\Scripting\RunAllProjectPackageScriptsAction.cs" />
     <Compile Include="Src\ServiceWithWorkbenchOwner.cs" />
     <Compile Include="Src\UpdatePackagesAction.cs" />
+    <Compile Include="Src\UpdateSolutionPackagesAction.cs" />
     <Compile Include="Src\VirtualMethodUpdater.cs" />
     <Compile Include="Src\NewProjectsCreated.cs" />
     <Compile Include="Src\OpenMSBuildProjects.cs" />

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

@@ -229,16 +229,32 @@ namespace ICSharpCode.PackageManagement.Design
 		}
 		
 		public UpdatePackagesAction UpdatePackagesActionPassedToGetUpdatePackagesOperations;
+		public IUpdatePackageSettings SettingsPassedToGetUpdatePackagesOperations;
 		public List<IPackage> PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations;
 		public List<PackageOperation> PackageOperationsToReturnFromGetUpdatePackagesOperations =
 			new List<PackageOperation>();
 		
-		public IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action)
+		public IEnumerable<PackageOperation> GetUpdatePackagesOperations(
+			IEnumerable<IPackage> packages,
+			IUpdatePackageSettings settings)
 		{
-			UpdatePackagesActionPassedToGetUpdatePackagesOperations = action;
+			SettingsPassedToGetUpdatePackagesOperations = settings;
-			PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations = 
+			PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations = packages.ToList();
-				action.Packages.ToList();
 			return PackageOperationsToReturnFromGetUpdatePackagesOperations;
 		}
+		
+		public void RunPackageOperations(IEnumerable<PackageOperation> expectedOperations)
+		{
+		}
+		
+		public bool HasOlderPackageInstalled(IPackage package)
+		{
+			return false;
+		}
+		
+		public void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
+		{
+			throw new NotImplementedException();
+		}
 	}
 }

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using ICSharpCode.PackageManagement;
 using NuGet;
 
@@ -167,12 +168,30 @@ namespace ICSharpCode.PackageManagement.Design
 		}
 		
 		public List<PackageOperation> PackageOperationsToReturnFromGetUpdatePackageOperations = new List<PackageOperation>();
-		public UpdatePackagesAction UpdatePackagesActionsPassedToGetUpdatePackagesOperations;
+		public IUpdatePackageSettings SettingsPassedToGetUpdatePackageOperations;
+		public IEnumerable<IPackage> PackagesPassedToGetUpdatePackageOperations;
 		
-		public IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction)
+		public IEnumerable<PackageOperation> GetUpdatePackageOperations(IEnumerable<IPackage> packages, IUpdatePackageSettings settings)
 		{
-			UpdatePackagesActionsPassedToGetUpdatePackagesOperations = updateAction;
+			SettingsPassedToGetUpdatePackageOperations = settings;
+			PackagesPassedToGetUpdatePackageOperations = packages;
 			return PackageOperationsToReturnFromGetUpdatePackageOperations;
 		}
+		
+		public List<PackageOperation> PackageOperationsPassedToRunPackageOperations;
+		
+		public void RunPackageOperations(IEnumerable<PackageOperation> operations)
+		{
+			PackageOperationsPassedToRunPackageOperations = operations.ToList();
+		}
+		
+		public IPackage PackagePassedToUpdatePackageReference;
+		public IUpdatePackageSettings SettingsPassedToUpdatePackageReference;
+		
+		public void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
+		{
+			PackagePassedToUpdatePackageReference = package;
+			SettingsPassedToUpdatePackageReference = settings;
+		}
 	}
 }

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

@@ -116,5 +116,14 @@ namespace ICSharpCode.PackageManagement.Design
 		{
 			throw new NotImplementedException();
 		}
+		
+		public IPackage PackagePassedToHasOlderPackageInstalled;
+		public bool HasOlderPackageInstalledReturnValue;
+		
+		public bool HasOlderPackageInstalled(IPackage package)
+		{
+			PackagePassedToHasOlderPackageInstalled = package;
+			return HasOlderPackageInstalledReturnValue;
+		}
 	}
 }

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

@@ -25,21 +25,26 @@ namespace ICSharpCode.PackageManagement
 		
 		bool IsPackageInstalled(IPackage package);
 		bool IsPackageInstalled(string packageId);
+		bool HasOlderPackageInstalled(IPackage package);
 		
 		IQueryable<IPackage> GetPackages();
 		IEnumerable<IPackage> GetPackagesInReverseDependencyOrder();
 		
 		IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction);
-		IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action);
+		IEnumerable<PackageOperation> GetUpdatePackagesOperations(IEnumerable<IPackage> packages, IUpdatePackageSettings settings);
 		
 		void InstallPackage(IPackage package, InstallPackageAction installAction);
 		void UpdatePackage(IPackage package, UpdatePackageAction updateAction);
 		void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction);
 		void UpdatePackages(UpdatePackagesAction action);
 		
+		void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings);
+		
 		InstallPackageAction CreateInstallPackageAction();
 		UninstallPackageAction CreateUninstallPackageAction();
 		UpdatePackageAction CreateUpdatePackageAction();
 		UpdatePackagesAction CreateUpdatePackagesAction();
+		
+		void RunPackageOperations(IEnumerable<PackageOperation> expectedOperations);
 	}
 }

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

@@ -15,8 +15,11 @@ namespace ICSharpCode.PackageManagement
 		void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction);
 		void UpdatePackage(IPackage package, UpdatePackageAction updateAction);
 		void UpdatePackages(UpdatePackagesAction updateAction);
+		void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings);
 		
 		IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction);
-		IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction);
+		IEnumerable<PackageOperation> GetUpdatePackageOperations(IEnumerable<IPackage> packages, IUpdatePackageSettings settings);
+		
+		void RunPackageOperations(IEnumerable<PackageOperation> operations);
 	}
 }

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

@@ -10,5 +10,6 @@ namespace ICSharpCode.PackageManagement
 	{
 		IPackagePathResolver PathResolver { get; }
 		bool IsInstalled(string packageId);
+		bool HasOlderPackageInstalled(IPackage package);
 	}
 }

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

@@ -142,9 +142,26 @@ namespace ICSharpCode.PackageManagement
 			return new UpdatePackagesAction(this);
 		}
 		
-		public IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action)
+		public IEnumerable<PackageOperation> GetUpdatePackagesOperations(
+			IEnumerable<IPackage> packages,
+			IUpdatePackageSettings settings)
 		{
-			return packageManager.GetUpdatePackageOperations(action);
+			return packageManager.GetUpdatePackageOperations(packages, settings);
+		}
+		
+		public void RunPackageOperations(IEnumerable<PackageOperation> operations)
+		{
+			packageManager.RunPackageOperations(operations);
+		}
+		
+		public bool HasOlderPackageInstalled(IPackage package)
+		{
+			return projectManager.HasOlderPackageInstalled(package);
+		}
+		
+		public void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
+		{
+			packageManager.UpdatePackageReference(package, settings);
 		}
 	}
 }

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

@@ -13,16 +13,17 @@ namespace ICSharpCode.PackageManagement
 {
 	public class PackageManagementSelectedProjects
 	{
-		IPackageManagementSolution solution;
 		bool? singleProjectSelected;
 		IProject singleMSBuildProjectSelected;
 		
 		public PackageManagementSelectedProjects(IPackageManagementSolution solution)
 		{
-			this.solution = solution;
+			this.Solution = solution;
 			GetHasSingleProjectSelected();
 		}
 		
+		public IPackageManagementSolution Solution { get; private set; }
+		
 		public IEnumerable<IPackageManagementSelectedProject> GetProjects(IPackageFromRepository package)
 		{
 			if (HasSingleProjectSelected()) {
@@ -44,13 +45,13 @@ namespace ICSharpCode.PackageManagement
 		
 		void GetHasSingleProjectSelected()
 		{
-			singleMSBuildProjectSelected = solution.GetActiveMSBuildProject();
+			singleMSBuildProjectSelected = Solution.GetActiveMSBuildProject();
 			singleProjectSelected = singleMSBuildProjectSelected != null;
 		}
 		
 		IEnumerable<IProject> GetOpenProjects()
 		{
-			return solution.GetMSBuildProjects();
+			return Solution.GetMSBuildProjects();
 		}
 		
 		IPackageManagementSelectedProject GetSingleProjectSelected(IPackageFromRepository package)
@@ -60,7 +61,7 @@ namespace ICSharpCode.PackageManagement
 		
 		IPackageManagementSelectedProject CreateSelectedProject(IProject msbuildProject, IPackageFromRepository package)
 		{
-			IPackageManagementProject project = solution.GetProject(package.Repository, msbuildProject);
+			IPackageManagementProject project = Solution.GetProject(package.Repository, msbuildProject);
 			return CreateSelectedProject(project, package);
 		}
 		
@@ -88,7 +89,7 @@ namespace ICSharpCode.PackageManagement
 			if (HasSingleProjectSelected()) {
 				return false;
 			}
-			return solution.HasMultipleProjects();
+			return Solution.HasMultipleProjects();
 		}
 		
 		public string SelectionName {
@@ -110,7 +111,7 @@ namespace ICSharpCode.PackageManagement
 		
 		string GetSolutionFileNameWithoutFullPath()
 		{
-			return Path.GetFileName(solution.FileName);
+			return Path.GetFileName(Solution.FileName);
 		}
 		
 		/// <summary>
@@ -127,12 +128,12 @@ namespace ICSharpCode.PackageManagement
 		
 		public bool IsPackageInstalledInSolution(IPackage package)
 		{
-			return solution.IsPackageInstalled(package);
+			return Solution.IsPackageInstalled(package);
 		}
 		
 		public IQueryable<IPackage> GetPackagesInstalledInSolution()
 		{
-			return solution.GetPackages();
+			return Solution.GetPackages();
 		}
 		
 		public IQueryable<IPackage> GetInstalledPackages(IPackageRepository sourceRepository)
@@ -147,7 +148,7 @@ namespace ICSharpCode.PackageManagement
 		public IPackageManagementProject GetSingleProjectSelected(IPackageRepository repository)
 		{
 			if (HasSingleProjectSelected()) {
-				return solution.GetProject(repository, singleMSBuildProjectSelected);
+				return Solution.GetProject(repository, singleMSBuildProjectSelected);
 			}
 			return null;
 		}

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/RunAllProjectPackageScriptsAction.cs

@@ -0,0 +1,156 @@
+// 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.Scripting
+{
+	public class RunAllProjectPackageScriptsAction : IDisposable
+	{
+		IPackageScriptRunner scriptRunner;
+		List<IPackageManagementProject> projects;
+		IPackageScriptFactory scriptFactory;
+		
+		List<EventHandler<PackageOperationEventArgs>> packageInstalledHandlers =
+			new List<EventHandler<PackageOperationEventArgs>>();
+		
+		List<EventHandler<PackageOperationEventArgs>> packageReferenceAddedHandlers =
+			new List<EventHandler<PackageOperationEventArgs>>();
+		
+		List<EventHandler<PackageOperationEventArgs>> packageReferenceRemovedHandlers =
+			new List<EventHandler<PackageOperationEventArgs>>();
+		
+		public RunAllProjectPackageScriptsAction(
+			IPackageScriptRunner scriptRunner,
+			IEnumerable<IPackageManagementProject> projects)
+			: this(scriptRunner, projects, new PackageScriptFactory())
+		{
+		}
+		
+		public RunAllProjectPackageScriptsAction(
+			IPackageScriptRunner scriptRunner,
+			IEnumerable<IPackageManagementProject> projects,
+			IPackageScriptFactory scriptFactory)
+		{
+			this.scriptRunner = scriptRunner;
+			this.projects = projects.ToList();
+			this.scriptFactory = scriptFactory;
+			
+			RegisterEvents();
+		}
+		
+		public void Dispose()
+		{
+			IsDisposed = true;
+			UnregisterEvents();
+		}
+		
+		public bool IsDisposed { get; private set; }
+		
+		void RegisterEvents()
+		{
+			foreach (IPackageManagementProject project in projects) {
+				RegisterPackageInstalledEvent(project);
+				RegisterPackageReferenceAddedEvent(project);
+				RegisterPackageReferenceRemovedEvent(project);
+			}
+		}
+		
+		void RegisterPackageInstalledEvent(IPackageManagementProject project)
+		{
+			EventHandler<PackageOperationEventArgs> installHandler =
+				(_, e) => PackageInstalled(project, e);
+			packageInstalledHandlers.Add(installHandler);
+			project.PackageInstalled += installHandler;
+		}
+		
+		void RegisterPackageReferenceAddedEvent(IPackageManagementProject project)
+		{
+			EventHandler<PackageOperationEventArgs> referenceAddedHandler =
+				(_, e) => PackageReferenceAdded(project, e);
+			packageReferenceAddedHandlers.Add(referenceAddedHandler);
+			project.PackageReferenceAdded += referenceAddedHandler;
+		}
+		
+		void RegisterPackageReferenceRemovedEvent(IPackageManagementProject project)
+		{
+			EventHandler<PackageOperationEventArgs> referenceRemovedHandler =
+				(_, e) => PackageReferenceRemoved(project, e);
+			packageReferenceRemovedHandlers.Add(referenceRemovedHandler);
+			project.PackageReferenceRemoved += referenceRemovedHandler;
+		}
+		
+		void UnregisterEvents()
+		{
+			foreach (IPackageManagementProject project in projects) {
+				UnregisterPackageInstalledEvent(project);
+				UnregisterPackageReferenceAddedEvent(project);
+				UnregisterPackageReferenceRemovedEvent(project);
+			}
+		}
+		
+		void UnregisterPackageInstalledEvent(IPackageManagementProject project)
+		{
+			EventHandler<PackageOperationEventArgs> handler = packageInstalledHandlers.First();
+			packageInstalledHandlers.Remove(handler);
+			project.PackageInstalled -= handler;
+		}
+		
+		void UnregisterPackageReferenceAddedEvent(IPackageManagementProject project)
+		{
+			EventHandler<PackageOperationEventArgs> handler = packageReferenceAddedHandlers.First();
+			packageReferenceAddedHandlers.Remove(handler);
+			project.PackageReferenceAdded -= handler;
+		}
+		
+		void UnregisterPackageReferenceRemovedEvent(IPackageManagementProject project)
+		{
+			EventHandler<PackageOperationEventArgs> handler = packageReferenceRemovedHandlers.First();
+			packageReferenceRemovedHandlers.Remove(handler);
+			project.PackageReferenceRemoved -= handler;
+		}
+		
+		void PackageInstalled(IPackageManagementProject project, PackageOperationEventArgs e)
+		{
+			RunInitScript(project, e);
+		}
+		
+		void PackageReferenceAdded(IPackageManagementProject project, PackageOperationEventArgs e)
+		{
+			RunInstallScript(project, e);
+		}
+		
+		void PackageReferenceRemoved(IPackageManagementProject project, PackageOperationEventArgs e)
+		{
+			RunUninstallScript(project, e);
+		}
+		
+		void RunInitScript(IPackageManagementProject project, PackageOperationEventArgs e)
+		{
+			IPackageScript script = scriptFactory.CreatePackageInitializeScript(e.Package, e.InstallPath);
+			RunScript(project, script);
+		}
+		
+		void RunScript(IPackageManagementProject project, IPackageScript script)
+		{
+			script.Project = project;
+			scriptRunner.Run(script);
+		}
+		
+		void RunInstallScript(IPackageManagementProject project, PackageOperationEventArgs e)
+		{
+			IPackageScript script = scriptFactory.CreatePackageInstallScript(e.Package, e.InstallPath);
+			RunScript(project, script);
+		}
+		
+		void RunUninstallScript(IPackageManagementProject project, PackageOperationEventArgs e)
+		{
+			IPackageScript script = scriptFactory.CreatePackageUninstallScript(e.Package, e.InstallPath);
+			RunScript(project, script);
+		}
+	}
+}

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

@@ -66,9 +66,7 @@ namespace ICSharpCode.PackageManagement
 		
 		public void InstallPackage(IPackage package, InstallPackageAction installAction)
 		{
-			foreach (PackageOperation operation in installAction.Operations) {
+			RunPackageOperations(installAction.Operations);
-				Execute(operation);
-			}
 			AddPackageReference(package, installAction.IgnoreDependencies, installAction.AllowPrereleaseVersions);
 		}
 		
@@ -119,13 +117,11 @@ namespace ICSharpCode.PackageManagement
 		
 		public void UpdatePackage(IPackage package, UpdatePackageAction updateAction)
 		{
-			foreach (PackageOperation operation in updateAction.Operations) {
+			RunPackageOperations(updateAction.Operations);
-				Execute(operation);
-			}
 			UpdatePackageReference(package, updateAction);
 		}
 		
-		void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
+		public void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
 		{
 			UpdatePackageReference(package, settings.UpdateDependencies, settings.AllowPrereleaseVersions);
 		}
@@ -137,30 +133,37 @@ namespace ICSharpCode.PackageManagement
 		
 		public void UpdatePackages(UpdatePackagesAction updateAction)
 		{
-			foreach (PackageOperation operation in updateAction.Operations) {
+			RunPackageOperations(updateAction.Operations);
-				Execute(operation);
-			}
 			foreach (IPackage package in updateAction.Packages) {
 				UpdatePackageReference(package, updateAction);
 			}
 		}
 		
-		public IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction)
+		public IEnumerable<PackageOperation> GetUpdatePackageOperations(
+			IEnumerable<IPackage> packages,
+			IUpdatePackageSettings settings)
 		{
-			IPackageOperationResolver resolver = CreateUpdatePackageOperationResolver(updateAction);
+			IPackageOperationResolver resolver = CreateUpdatePackageOperationResolver(settings);
 			
-			var reducedOperations = new ReducedPackageOperations(resolver, updateAction.Packages);
+			var reducedOperations = new ReducedPackageOperations(resolver, packages);
 			reducedOperations.Reduce();
 			return reducedOperations.Operations;
 		}
 		
-		IPackageOperationResolver CreateUpdatePackageOperationResolver(UpdatePackagesAction updateAction)
+		IPackageOperationResolver CreateUpdatePackageOperationResolver(IUpdatePackageSettings settings)
 		{
 			return packageOperationResolverFactory.CreateUpdatePackageOperationResolver(
 				LocalRepository,
 				SourceRepository,
 				Logger,
-				updateAction);
+				settings);
+		}
+		
+		public void RunPackageOperations(IEnumerable<PackageOperation> operations)
+		{
+			foreach (PackageOperation operation in operations) {
+				Execute(operation);
+			}
 		}
 	}
 }

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

@@ -21,5 +21,12 @@ namespace ICSharpCode.PackageManagement
 		{
 			return LocalRepository.Exists(packageId);
 		}
+		
+		public bool HasOlderPackageInstalled(IPackage package)
+		{
+			IPackage installedPackage = LocalRepository.FindPackage(package.Id);
+			return (installedPackage != null) &&
+				(installedPackage.Version < package.Version);
+		}
 	}
 }

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

@@ -0,0 +1,120 @@
+// 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.Scripting;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class UpdateSolutionPackagesAction : IPackageAction, IUpdatePackageSettings
+	{
+		List<IPackageFromRepository> packages = new List<IPackageFromRepository>();
+		List<PackageOperation> operations = new List<PackageOperation>();
+		List<IPackageManagementProject> projects;
+		
+		public UpdateSolutionPackagesAction(IPackageManagementSolution solution)
+		{
+			this.Solution = solution;
+			this.UpdateDependencies = true;
+		}
+		
+		public IPackageManagementSolution Solution { get; private set; }
+		public IPackageScriptRunner PackageScriptRunner { get; set; }
+		public bool UpdateDependencies { get; set; }
+		public bool AllowPrereleaseVersions { get; set; }
+		public ILogger Logger { get; set; }
+		
+		public IEnumerable<PackageOperation> Operations {
+			get { return operations; }
+		}
+		
+		public IEnumerable<IPackageFromRepository> Packages {
+			get { return packages; }
+		}
+		
+		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<IPackageFromRepository> packages)
+		{
+			this.packages.AddRange(packages);
+		}
+		
+		public void Execute()
+		{
+			if (PackageScriptRunner != null) {
+				ExecuteWithScriptRunner();
+			} else {
+				ExecuteCore();
+			}
+		}
+		
+		void ExecuteWithScriptRunner()
+		{
+			using (RunAllProjectPackageScriptsAction runScriptsAction = CreateRunPackageScriptsAction()) {
+				ExecuteCore();
+			}
+		}
+		
+		RunAllProjectPackageScriptsAction CreateRunPackageScriptsAction()
+		{
+			return CreateRunPackageScriptsAction(PackageScriptRunner, GetProjects());
+		}
+		
+		void ExecuteCore()
+		{
+			RunPackageOperations();
+			UpdatePackageReferences();
+		}
+		
+		void RunPackageOperations()
+		{
+			IPackageManagementProject project = GetProjects().First();
+			project.RunPackageOperations(operations);
+		}
+		
+		IEnumerable<IPackageManagementProject> GetProjects()
+		{
+			if (projects == null) {
+				IPackageFromRepository package = packages.First();
+				projects = Solution
+					.GetProjects(package.Repository)
+					.Select(project => {
+						project.Logger = Logger;
+						return project;
+					})
+					.ToList();
+			}
+			return projects;
+		}
+		
+		void UpdatePackageReferences()
+		{
+			foreach (IPackageManagementProject project in GetProjects()) {
+				foreach (IPackageFromRepository package in packages) {
+					if (project.HasOlderPackageInstalled(package)) {
+						project.UpdatePackageReference(package, this);
+					}
+				}
+			}
+		}
+		
+		protected virtual RunAllProjectPackageScriptsAction CreateRunPackageScriptsAction(
+			IPackageScriptRunner scriptRunner,
+			IEnumerable<IPackageManagementProject> projects)
+		{
+			return new RunAllProjectPackageScriptsAction(scriptRunner, projects);
+		}
+	}
+}

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

@@ -68,18 +68,35 @@ namespace ICSharpCode.PackageManagement
 		
 		protected override void TryUpdatingAllPackages()
 		{
-			IEnumerable<IPackageFromRepository> packages = GetPackagesFromViewModels();
+			if (selectedProjects.HasSingleProjectSelected()) {
-			IPackageRepository repository = packages.First().Repository;
+				IEnumerable<IPackageFromRepository> packages = GetPackagesFromViewModels();
-			IPackageManagementProject project = selectedProjects.GetSingleProjectSelected(repository);
+				IPackageRepository repository = packages.First().Repository;
-			project.Logger = logger;
+				IPackageManagementProject project = selectedProjects.GetSingleProjectSelected(repository);
-			
+				project.Logger = logger;
-			UpdatePackagesAction action = project.CreateUpdatePackagesAction();
+				
-			action.AddPackages(packages);
+				UpdatePackagesAction action = project.CreateUpdatePackagesAction();
-			
+				action.AddPackages(packages);
-			IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(action);
+				
-			action.AddOperations(operations);
+				IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(packages, action);
-			
+				action.AddOperations(operations);
-			ActionRunner.Run(action);
+				
+				ActionRunner.Run(action);
+			} else {
+				IEnumerable<IPackageFromRepository> packages = GetPackagesFromViewModels();
+				IPackageRepository repository = packages.First().Repository;
+				
+				var action = new UpdateSolutionPackagesAction(selectedProjects.Solution);
+				action.Logger = logger;
+				action.AddPackages(packages);
+				
+				IPackageManagementProject project = selectedProjects.Solution.GetProjects(repository).First();
+				project.Logger = logger;
+				
+				IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(packages, action);
+				action.AddOperations(operations);
+				
+				ActionRunner.Run(action);
+			}
 		}
 		
 		IEnumerable<IPackageFromRepository> GetPackagesFromViewModels()

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

@@ -134,6 +134,8 @@
     <Compile Include="Src\Helpers\TestableProjectBehaviour.cs" />
     <Compile Include="Src\Helpers\TestableSelectedProjectsForUpdatedPackages.cs" />
     <Compile Include="Src\Helpers\TestableUpdatePackagesAction.cs" />
+    <Compile Include="Src\Helpers\TestableUpdateSolutionPackagesAction.cs" />
+    <Compile Include="Src\Helpers\TestPackageHelper.cs" />
     <Compile Include="Src\Helpers\TypeParameterHelper.cs" />
     <Compile Include="Src\Helpers\UsingHelper.cs" />
     <Compile Include="Src\Helpers\UsingScopeHelper.cs" />
@@ -199,7 +201,9 @@
     <Compile Include="Src\PackageManagementServiceProviderTests.cs" />
     <Compile Include="Src\PackageViewModelOperationLoggerTests.cs" />
     <Compile Include="Src\ReducedPackageOperationsTests.cs" />
+    <Compile Include="Src\RunAllProjectPackageScriptsActionTests.cs" />
     <Compile Include="Src\UpdatePackagesActionTests.cs" />
+    <Compile Include="Src\UpdateSolutionPackagesActionTests.cs" />
     <Compile Include="Src\VirtualMethodUpdaterTests.cs" />
     <Compile Include="Src\NewProjectsCreatedTests.cs" />
     <Compile Include="Src\PackageActionRunnerTests.cs" />

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

@@ -0,0 +1,36 @@
+// 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 NuGet;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class TestPackageHelper
+	{
+		public TestPackageHelper()
+		{
+			Package = MockRepository.GenerateStub<IPackage>();
+		}
+		
+		public TestPackageHelper(string id, string version)
+			: this()
+		{
+			SetId(id);
+			SetVersion(version);
+		}
+		
+		public IPackage Package { get; set; }
+		
+		public void SetId(string id)
+		{
+			Package.Stub(p => p.Id).Return(id);
+		}
+		
+		public void SetVersion(string version)
+		{
+			Package.Stub(p => p.Version).Return(new SemanticVersion(version));
+		}
+	}
+}

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

@@ -0,0 +1,39 @@
+// 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 ICSharpCode.PackageManagement.Scripting;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class TestableUpdateSolutionPackagesAction : UpdateSolutionPackagesAction
+	{
+		public bool IsRunPackageScriptsActionCreated;
+		public IPackageScriptRunner ScriptRunnerPassedToCreateRunPackageScriptsAction;
+		public List<IPackageManagementProject> ProjectsPassedToCreateRunPackageScriptsAction;
+		public RunAllProjectPackageScriptsAction RunPackageScriptsAction;
+		
+		public TestableUpdateSolutionPackagesAction(IPackageManagementSolution solution)
+			: base(solution)
+		{
+		}
+		
+		protected override RunAllProjectPackageScriptsAction CreateRunPackageScriptsAction(
+			IPackageScriptRunner scriptRunner,
+			IEnumerable<IPackageManagementProject> projects)
+		{
+			IsRunPackageScriptsActionCreated = true;
+			ScriptRunnerPassedToCreateRunPackageScriptsAction = scriptRunner;
+			ProjectsPassedToCreateRunPackageScriptsAction = projects.ToList();
+			RunPackageScriptsAction = base.CreateRunPackageScriptsAction(scriptRunner, projects);
+			return RunPackageScriptsAction;
+		}
+		
+		public bool IsRunPackageScriptsActionDisposed {
+			get { return RunPackageScriptsAction.IsDisposed; }
+		}
+	}
+}

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

@@ -662,10 +662,13 @@ namespace PackageManagement.Tests
 		{
 			CreateProject();
 			CreateUpdatePackagesAction();
+			var expectedPackages = new FakePackage[] { new FakePackage("Test") };
+			updatePackagesAction.AddPackages(expectedPackages);
 			
-			project.GetUpdatePackagesOperations(updatePackagesAction);
+			project.GetUpdatePackagesOperations(updatePackagesAction.Packages, updatePackagesAction);
 			
-			Assert.AreEqual(updatePackagesAction, fakePackageManager.UpdatePackagesActionsPassedToGetUpdatePackagesOperations);
+			Assert.AreEqual(updatePackagesAction, fakePackageManager.SettingsPassedToGetUpdatePackageOperations);
+			Assert.AreEqual(expectedPackages, fakePackageManager.PackagesPassedToGetUpdatePackageOperations);
 		}
 		
 		[Test]
@@ -676,9 +679,70 @@ namespace PackageManagement.Tests
 			List<PackageOperation> expectedOperations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
 			fakePackageManager.PackageOperationsToReturnFromGetUpdatePackageOperations = expectedOperations;
 			
-			IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(updatePackagesAction);
+			IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(updatePackagesAction.Packages, updatePackagesAction);
 			
 			CollectionAssert.AreEqual(expectedOperations, operations);
 		}
+		
+		[Test]
+		public void RunPackageOperations_OneOperation_PackageOperationsRunByPackageManager()
+		{
+			CreateProject();
+			CreateUpdatePackagesAction();
+			List<PackageOperation> expectedOperations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
+			
+			project.RunPackageOperations(expectedOperations);
+			
+			CollectionAssert.AreEqual(expectedOperations, fakePackageManager.PackageOperationsPassedToRunPackageOperations);
+		}
+		
+		[Test]
+		public void HasOlderPackageInstalled_TestPackage_PackagePassedToProjectManager()
+		{
+			CreateProject();
+			CreateUpdatePackagesAction();
+			var expectedPackage = new FakePackage("Test");
+			
+			project.HasOlderPackageInstalled(expectedPackage);
+			
+			Assert.AreEqual(expectedPackage, fakeProjectManager.PackagePassedToHasOlderPackageInstalled);
+		}
+		
+		[Test]
+		public void HasOlderPackageInstalled_PackageIsInstalled_ReturnsTrue()
+		{
+			CreateProject();
+			fakeProjectManager.HasOlderPackageInstalledReturnValue = true;
+			var package = new FakePackage("Test");
+			
+			bool installed = project.HasOlderPackageInstalled(package);
+			
+			Assert.IsTrue(installed);
+		}
+		
+		[Test]
+		public void HasOlderPackageInstalled_PackageIsNotInstalled_ReturnsFalse()
+		{
+			CreateProject();
+			fakeProjectManager.HasOlderPackageInstalledReturnValue = false;
+			var package = new FakePackage("Test");
+			
+			bool installed = project.HasOlderPackageInstalled(package);
+			
+			Assert.IsFalse(installed);
+		}
+		
+		[Test]
+		public void UpdatePackageReference_PackageAndUpdateActionPassed_BothPassedToPackageManager()
+		{
+			CreateProject();
+			CreateUpdatePackagesAction();
+			var package = new FakePackage("Test");
+			
+			project.UpdatePackageReference(package, updatePackagesAction);
+			
+			Assert.AreEqual(package, fakePackageManager.PackagePassedToUpdatePackageReference);
+			Assert.AreEqual(updatePackagesAction, fakePackageManager.SettingsPassedToUpdatePackageReference);
+		}
 	}
 }

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

@@ -8,6 +8,7 @@ using System.Linq;
 using ICSharpCode.PackageManagement;
 using NuGet;
 using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
 using Rhino.Mocks;
 
 namespace PackageManagement.Tests
@@ -36,10 +37,7 @@ namespace PackageManagement.Tests
 		
 		IPackage CreatePackage(string id, string version)
 		{
-			IPackage package = MockRepository.GenerateStub<IPackage>();
+			return new TestPackageHelper(id, version).Package;
-			package.Stub(p => p.Id).Return(id);
-			package.Stub(p => p.Version).Return(new SemanticVersion(version));
-			return package;
 		}
 		
 		PackageOperation AddInstallOperationForPackage(IPackage package)

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

@@ -0,0 +1,339 @@
+// 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;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+using Rhino.Mocks;
+using Rhino.Mocks.Constraints;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class RunAllProjectPackageScriptsActionTests
+	{
+		RunAllProjectPackageScriptsAction action;
+		List<IPackageManagementProject> projects;
+		IPackageScriptRunner scriptRunner;
+		IPackageScriptFactory scriptFactory;
+		
+		[SetUp]
+		public void Init()
+		{
+			CreateProjectsList();
+		}
+		
+		void CreateProjectsList()
+		{
+			projects = new List<IPackageManagementProject>();
+		}
+		
+		void CreateAction()
+		{
+			scriptRunner = MockRepository.GenerateStub<IPackageScriptRunner>();
+			scriptFactory = MockRepository.GenerateStub<IPackageScriptFactory>();
+			action = new RunAllProjectPackageScriptsAction(scriptRunner, projects, scriptFactory);
+		}
+		
+		IPackageManagementProject AddProject()
+		{
+			IPackageManagementProject project = MockRepository.GenerateStub<IPackageManagementProject>();
+			projects.Add(project);
+			return project;
+		}
+		
+		PackageOperationEventArgs CreatePackageOperationEventArgs()
+		{
+			IPackage package = CreatePackage();
+			return CreatePackageOperationEventArgs(package);
+		}
+		
+		IPackage CreatePackage()
+		{
+			return new TestPackageHelper("Test", "1.0").Package;
+		}
+		
+		PackageOperationEventArgs CreatePackageOperationEventArgs(
+			IPackage package,
+			string installPath = @"d:\projects\myproject\packages\test")
+		{
+			return new PackageOperationEventArgs(package, null, installPath);
+		}
+		
+		void FirePackageInstalledEvent(IPackageManagementProject project, PackageOperationEventArgs eventArgs)
+		{
+			project.Raise(p => p.PackageInstalled += null, null, eventArgs);
+		}
+		
+		void FirePackageReferenceAddedEvent(IPackageManagementProject project, PackageOperationEventArgs eventArgs)
+		{
+			project.Raise(p => p.PackageReferenceAdded += null, null, eventArgs);
+		}
+		
+		void FirePackageReferenceRemovedEvent(IPackageManagementProject project, PackageOperationEventArgs eventArgs)
+		{
+			project.Raise(p => p.PackageReferenceRemoved += null, null, eventArgs);
+		}
+		
+		IPackageScript CreatePackageScript()
+		{
+			return MockRepository.GenerateStub<IPackageScript>();
+		}
+		
+		void SetInitScriptToReturnFromScriptFactory(IPackageScript initScript)
+		{
+			scriptFactory.Stub(factory => factory.CreatePackageInitializeScript(
+				Arg<IPackage>.Is.Anything,
+				Arg<string>.Is.Anything))
+				.Return(initScript);
+		}
+		
+		void SetInstallScriptToReturnFromScriptFactory(IPackageScript installScript)
+		{
+			scriptFactory.Stub(factory => factory.CreatePackageInstallScript(
+				Arg<IPackage>.Is.Anything,
+				Arg<string>.Is.Anything))
+				.Return(installScript);
+		}
+		
+		void SetUninstallScriptToReturnFromScriptFactory(IPackageScript uninstallScript)
+		{
+			scriptFactory.Stub(factory => factory.CreatePackageUninstallScript(
+				Arg<IPackage>.Is.Anything,
+				Arg<string>.Is.Anything))
+				.Return(uninstallScript);
+		}
+		
+		[Test]
+		public void Constructor_OneProjectAndOnePackageIsInstalled_PackageInitializeScriptCreated()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript initScript = CreatePackageScript();
+			SetInitScriptToReturnFromScriptFactory(initScript);
+			IPackage package = CreatePackage();
+			string installPath = @"d:\projects\MyProject\packages\foo";
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs(package, installPath);
+			
+			FirePackageInstalledEvent(project, eventArgs);
+			
+			scriptFactory.AssertWasCalled(factory => factory.CreatePackageInitializeScript(package, installPath));
+		}
+		
+		[Test]
+		public void Constructor_OneProjectAndOnePackageIsInstalled_PackageInitializeScriptIsRun()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript initScript = CreatePackageScript();
+			SetInitScriptToReturnFromScriptFactory(initScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageInstalledEvent(project, eventArgs);
+			
+			scriptRunner.AssertWasCalled(runner => runner.Run(initScript));
+		}
+		
+		[Test]
+		public void Constructor_OneProjectAndOnePackageIsInstalled_ProjectSetForPackageScript()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript initScript = CreatePackageScript();
+			SetInitScriptToReturnFromScriptFactory(initScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageInstalledEvent(project, eventArgs);
+			
+			Assert.AreEqual(project, initScript.Project);
+		}
+		
+		[Test]
+		public void Constructor_TwoProjectsAndPackageIsInstalledForSecondProject_PackageInitializeScriptIsRun()
+		{
+			IPackageManagementProject project1 = AddProject();
+			IPackageManagementProject project2 = AddProject();
+			CreateAction();
+			IPackageScript initScript = CreatePackageScript();
+			SetInitScriptToReturnFromScriptFactory(initScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageInstalledEvent(project2, eventArgs);
+			
+			scriptRunner.AssertWasCalled(runner => runner.Run(initScript));
+		}
+		
+		[Test]
+		public void Constructor_TwoProjectsAndPackageIsInstalledForSecondProject_SecondProjectSetForPackageScript()
+		{
+			IPackageManagementProject project1 = AddProject();
+			IPackageManagementProject project2 = AddProject();
+			CreateAction();
+			IPackageScript initScript = CreatePackageScript();
+			SetInitScriptToReturnFromScriptFactory(initScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageInstalledEvent(project2, eventArgs);
+			
+			Assert.AreEqual(project2, initScript.Project);
+		}
+		
+		[Test]
+		public void Dispose_OneProjectAndOnePackageIsInstalledAfterScriptsActionIsDisposed_PackageInitializeScriptIsNotRun()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript initScript = CreatePackageScript();
+			SetInitScriptToReturnFromScriptFactory(initScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			action.Dispose();
+			FirePackageInstalledEvent(project, eventArgs);
+			
+			scriptRunner.AssertWasNotCalled(runner => runner.Run(Arg<IPackageScript>.Is.Anything));
+		}
+		
+		[Test]
+		public void Dispose_TwoProjectsAndOnePackageIsInstalledForSecondProjectAfterScriptsActionIsDisposed_PackageInitializeScriptIsNotRun()
+		{
+			IPackageManagementProject project1 = AddProject();
+			IPackageManagementProject project2 = AddProject();
+			CreateAction();
+			IPackageScript initScript = CreatePackageScript();
+			SetInitScriptToReturnFromScriptFactory(initScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			action.Dispose();
+			FirePackageInstalledEvent(project2, eventArgs);
+			
+			scriptRunner.AssertWasNotCalled(runner => runner.Run(Arg<IPackageScript>.Is.Anything));
+		}
+		
+		[Test]
+		public void Constructor_OneProjectAndPackageReferencedAddedToProject_PackageInstallScriptCreated()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript installScript = CreatePackageScript();
+			SetInstallScriptToReturnFromScriptFactory(installScript);
+			IPackage package = CreatePackage();
+			string installPath = @"d:\projects\MyProject\packages\foo";
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs(package, installPath);
+			
+			FirePackageReferenceAddedEvent(project, eventArgs);
+			
+			scriptFactory.AssertWasCalled(factory => factory.CreatePackageInstallScript(package, installPath));
+		}
+		
+		[Test]
+		public void Constructor_TwoProjectsAndPackageReferencedAddedToSecondProject_PackageInstallScriptIsRun()
+		{
+			IPackageManagementProject project1 = AddProject();
+			IPackageManagementProject project2 = AddProject();
+			CreateAction();
+			IPackageScript installScript = CreatePackageScript();
+			SetInstallScriptToReturnFromScriptFactory(installScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageReferenceAddedEvent(project2, eventArgs);
+			
+			scriptRunner.AssertWasCalled(runner => runner.Run(installScript));
+		}
+		
+		[Test]
+		public void Constructor_TwoProjectsAndPackageReferencedIsAddedForSecondProject_SecondProjectSetForPackageScript()
+		{
+			IPackageManagementProject project1 = AddProject();
+			IPackageManagementProject project2 = AddProject();
+			CreateAction();
+			IPackageScript installScript = CreatePackageScript();
+			SetInstallScriptToReturnFromScriptFactory(installScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageReferenceAddedEvent(project2, eventArgs);
+			
+			Assert.AreEqual(project2, installScript.Project);
+		}
+		
+		[Test]
+		public void Dispose_OneProjectAndPackageReferencedAddedToProjectAfterActionIsDisposed_PackageInstallScriptIsNotRun()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript installScript = CreatePackageScript();
+			SetInstallScriptToReturnFromScriptFactory(installScript);
+			IPackage package = CreatePackage();
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			action.Dispose();
+			FirePackageReferenceAddedEvent(project, eventArgs);
+			
+			scriptRunner.AssertWasNotCalled(runner => runner.Run(installScript));
+		}
+		
+		[Test]
+		public void Constructor_OneProjectAndPackageReferencedRemovedFromProject_PackageUninstallScriptCreated()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript uninstallScript = CreatePackageScript();
+			SetUninstallScriptToReturnFromScriptFactory(uninstallScript);
+			IPackage package = CreatePackage();
+			string installPath = @"d:\projects\MyProject\packages\foo";
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs(package, installPath);
+			
+			FirePackageReferenceRemovedEvent(project, eventArgs);
+			
+			scriptFactory.AssertWasCalled(factory => factory.CreatePackageUninstallScript(package, installPath));
+		}
+		
+		[Test]
+		public void Constructor_TwoProjectsAndPackageReferencedRemovedFromSecondProject_PackageUninstallScriptIsRun()
+		{
+			IPackageManagementProject project1 = AddProject();
+			IPackageManagementProject project2 = AddProject();
+			CreateAction();
+			IPackageScript uninstallScript = CreatePackageScript();
+			SetUninstallScriptToReturnFromScriptFactory(uninstallScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageReferenceRemovedEvent(project2, eventArgs);
+			
+			scriptRunner.AssertWasCalled(runner => runner.Run(uninstallScript));
+		}
+		
+		[Test]
+		public void Constructor_TwoProjectsAndPackageReferencedIsRemovedFromSecondProject_SecondProjectSetForPackageScript()
+		{
+			IPackageManagementProject project1 = AddProject();
+			IPackageManagementProject project2 = AddProject();
+			CreateAction();
+			IPackageScript uninstallScript = CreatePackageScript();
+			SetUninstallScriptToReturnFromScriptFactory(uninstallScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			FirePackageReferenceRemovedEvent(project2, eventArgs);
+			
+			Assert.AreEqual(project2, uninstallScript.Project);
+		}
+		
+		[Test]
+		public void Dispose_OneProjectAndPackageReferencedRemovedFromProjectAfterActionIsDisposed_PackageUninstallScriptIsNotRun()
+		{
+			IPackageManagementProject project = AddProject();
+			CreateAction();
+			IPackageScript uninstallScript = CreatePackageScript();
+			SetUninstallScriptToReturnFromScriptFactory(uninstallScript);
+			PackageOperationEventArgs eventArgs = CreatePackageOperationEventArgs();
+			
+			action.Dispose();
+			FirePackageReferenceRemovedEvent(project, eventArgs);
+			
+			scriptRunner.AssertWasNotCalled(runner => runner.Run(uninstallScript));
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Scripting/RunPackageScriptsActionTests.cs

@@ -18,7 +18,7 @@ namespace PackageManagement.Tests.Scripting
 		FakePackageManagementProject fakeProject;
 		FakePackageScriptFactory fakeScriptFactory;
 		FakePackageScriptRunner fakeScriptRunner;
-			
+		
 		void CreateAction()
 		{
 			fakeProject = new FakePackageManagementProject();

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

@@ -885,7 +885,7 @@ namespace PackageManagement.Tests
 			FakePackage package = CreateFakePackage("Test", "1.1");
 			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
 			
-			packageManager.GetUpdatePackageOperations(updateAction);
+			packageManager.GetUpdatePackageOperations(updateAction.Packages, updateAction);
 			
 			ILogger expectedLogger = packageManager.Logger;
 			ILogger actualLogger = fakePackageOperationResolverFactory.LoggerPassedToCreateUpdatePackageOperationResolver;
@@ -899,7 +899,7 @@ namespace PackageManagement.Tests
 			FakePackage package = CreateFakePackage("Test", "1.1");
 			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
 			
-			packageManager.GetUpdatePackageOperations(updateAction);
+			packageManager.GetUpdatePackageOperations(updateAction.Packages, updateAction);
 			
 			IPackageRepository expectedRepository = packageManager.LocalRepository;
 			IPackageRepository actualRepository = fakePackageOperationResolverFactory.LocalRepositoryPassedToCreateUpdatePackageOperationsResolver;
@@ -913,7 +913,7 @@ namespace PackageManagement.Tests
 			FakePackage package = CreateFakePackage("Test", "1.1");
 			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
 			
-			packageManager.GetUpdatePackageOperations(updateAction);
+			packageManager.GetUpdatePackageOperations(updateAction.Packages, updateAction);
 			
 			IPackageRepository expectedRepository = packageManager.SourceRepository;
 			IPackageRepository actualRepository = fakePackageOperationResolverFactory.SourceRepositoryPassedToCreateUpdatePackageOperationsResolver;
@@ -927,7 +927,7 @@ namespace PackageManagement.Tests
 			FakePackage package = CreateFakePackage("Test", "1.1");
 			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
 			
-			packageManager.GetUpdatePackageOperations(updateAction);
+			packageManager.GetUpdatePackageOperations(updateAction.Packages, updateAction);
 			
 			IUpdatePackageSettings settings = fakePackageOperationResolverFactory.SettingsPassedToCreatePackageOperationResolver;
 			Assert.AreEqual(updateAction, settings);
@@ -944,11 +944,29 @@ namespace PackageManagement.Tests
 			PackageOperation operation2 = AddInstallOperationForPackage(package2);
 			UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package1, package2);
 			
-			List<PackageOperation> operations = packageManager.GetUpdatePackageOperations(updateAction).ToList();
+			List<PackageOperation> operations = packageManager.GetUpdatePackageOperations(updateAction.Packages, updateAction).ToList();
 			
 			Assert.AreEqual(2, operations.Count());
 			Assert.Contains(operation1, operations);
 			Assert.Contains(operation2, operations);
 		}
+		
+		[Test]
+		public void RunPackageOperations_TwoPackageOperations_BothPackagesInOperationsAddedToSharedRepository()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			PackageOperation operation1 = CreateOneInstallPackageOperation("First", "1.0");
+			PackageOperation operation2 = CreateOneInstallPackageOperation("Second", "1.0");
+			var operations = new PackageOperation[] { operation1, operation2 };
+			var expectedPackages = new FakePackage[] {
+				operation1.Package as FakePackage,
+				operation2.Package as FakePackage
+			};
+			
+			packageManager.RunPackageOperations(operations);
+			
+			PackageCollectionAssert.AreEqual(expectedPackages, fakeSolutionSharedRepository.PackagesAdded);
+		}
 	}
 }

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

@@ -3,6 +3,7 @@
 
 using System;
 using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Design;
 using NUnit.Framework;
 using PackageManagement.Tests.Helpers;
 
@@ -23,6 +24,11 @@ namespace PackageManagement.Tests
 			projectManager.AddFakePackageToProjectLocalRepository(packageId, version);
 		}
 		
+		FakePackage CreatePackage(string packageId, string version)
+		{
+			return FakePackage.CreatePackageWithVersion(packageId, version);
+		}
+		
 		[Test]
 		public void IsInstalled_PackageIdPassedThatDoesNotExistInProjectLocalRepository_ReturnsFalse()
 		{
@@ -43,5 +49,40 @@ namespace PackageManagement.Tests
 			
 			Assert.IsTrue(installed);
 		}
+		
+		[Test]
+		public void HasOlderPackageInstalled_ProjectLocalRepositoryDoesNotHavePackage_ReturnsFalse()
+		{
+			CreateProjectManager();
+			FakePackage package = CreatePackage("Test", "1.0");
+			
+			bool installed = projectManager.HasOlderPackageInstalled(package);
+			
+			Assert.IsFalse(installed);
+		}
+		
+		[Test]
+		public void HasOlderPackageInstalled_ProjectLocalRepositoryHasOlderPackage_ReturnsTrue()
+		{
+			CreateProjectManager();
+			projectManager.AddFakePackageToProjectLocalRepository("Test", "1.0");
+			FakePackage package = CreatePackage("Test", "1.1");
+			
+			bool installed = projectManager.HasOlderPackageInstalled(package);
+			
+			Assert.IsTrue(installed);
+		}
+		
+		[Test]
+		public void HasOlderPackageInstalled_ProjectLocalRepositoryHasSamePackageVersion_ReturnsFalse()
+		{
+			CreateProjectManager();
+			projectManager.AddFakePackageToProjectLocalRepository("Test", "1.1");
+			FakePackage package = CreatePackage("Test", "1.1");
+			
+			bool installed = projectManager.HasOlderPackageInstalled(package);
+			
+			Assert.IsFalse(installed);
+		}
 	}
 }

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

@@ -19,7 +19,7 @@ namespace PackageManagement.Tests
 		
 		void CreateAction()
 		{
-			CreateProject();
+			CreateSolution();
 			action = new TestableUpdatePackagesAction(project);
 		}
 		
@@ -29,7 +29,7 @@ namespace PackageManagement.Tests
 			action.AddOperations(operations);
 		}
 		
-		void CreateProject()
+		void CreateSolution()
 		{
 			project = MockRepository.GenerateStub<IPackageManagementProject>();
 		}
@@ -150,7 +150,7 @@ namespace PackageManagement.Tests
 		}
 		
 		[Test]
-		public void Execute_NullPackageScriptRunner_PackagesAreUpdated()
+		public void Execute_PackageScriptRunnerSet_PackagesAreUpdated()
 		{
 			CreateAction();
 			PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");

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

@@ -0,0 +1,311 @@
+// 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;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class UpdateSolutionPackagesActionTests
+	{
+		TestableUpdateSolutionPackagesAction action;
+		IPackageManagementSolution solution;
+		List<IPackageManagementProject> projects;
+		IPackageRepository sourceRepository;
+		
+		void CreateAction()
+		{
+			CreateSolution();
+			action = new TestableUpdateSolutionPackagesAction(solution);
+		}
+		
+		void CreateActionWithOperations(params PackageOperation[] operations)
+		{
+			CreateAction();
+			action.AddOperations(operations);
+		}
+		
+		void CreateSolution()
+		{
+			projects = new List<IPackageManagementProject>();
+			sourceRepository = MockRepository.GenerateStub<IPackageRepository>();
+			
+			solution = MockRepository.GenerateStub<IPackageManagementSolution>();
+			solution
+				.Stub(s => s.GetProjects(sourceRepository))
+				.Return(projects);
+		}
+		
+		IPackageFromRepository CreatePackage(string packageId, string version)
+		{
+			var package = MockRepository.GenerateStub<IPackageFromRepository>();
+			package.Stub(p => p.Id).Return(packageId);
+			package.Stub(p => p.Version).Return(new SemanticVersion(version));
+			package.Stub(p => p.Repository).Return(sourceRepository);
+			return package;
+		}
+		
+		void ProjectHasOlderVersionOfPackage(IPackageManagementProject project, IPackageFromRepository package)
+		{
+			project.Stub(p => p.HasOlderPackageInstalled(package)).Return(true);
+		}
+		
+		PackageOperation CreateInstallOperationWithFile(string fileName)
+		{
+			return PackageOperationHelper.CreateInstallOperationWithFile(fileName);
+		}
+		
+		IPackageScriptRunner CreatePackageScriptRunner()
+		{
+			return MockRepository.GenerateStub<IPackageScriptRunner>();
+		}
+		
+		IPackageManagementProject AddProjectToSolution()
+		{
+			IPackageManagementProject project = MockRepository.GenerateStub<IPackageManagementProject>();
+			projects.Add(project);
+			return project;
+		}
+		
+		IPackageFromRepository AddPackageToAction(string packageId, string version)
+		{
+			IPackageFromRepository package = CreatePackage(packageId, version);
+			action.AddPackages(new IPackageFromRepository[] { package });
+			return package;
+		}
+		
+		[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_OneProjectThatHasOlderVersionOfPackageBeingUpdated_PackageOperationsAreRun()
+		{
+			PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
+			CreateActionWithOperations(operation);
+			IPackageFromRepository package = AddPackageToAction("Test", "1.0");
+			IPackageManagementProject project = AddProjectToSolution();
+			var expectedOperations = new PackageOperation[] { operation };
+			
+			action.Execute();
+			
+			project.AssertWasCalled(p => p.RunPackageOperations(expectedOperations));
+		}
+		
+		[Test]
+		public void Execute_OneProjectThatHasOlderVersionOfPackageBeingUpdated_PackageReferenceUpdatedInProject()
+		{
+			CreateAction();
+			IPackageFromRepository package = AddPackageToAction("Test", "1.0");
+			IPackageManagementProject project = AddProjectToSolution();
+			ProjectHasOlderVersionOfPackage(project, package);
+			
+			action.Execute();
+			
+			project.AssertWasCalled(p => p.UpdatePackageReference(package, action));
+		}
+		
+		[Test]
+		public void Execute_OneProjectThatHasOlderVersionsOfTwoPackagesBeingUpdated_PackageReferenceUpdatedInProjectForBothPackages()
+		{
+			CreateAction();
+			IPackageFromRepository package1 = AddPackageToAction("A", "1.0");
+			IPackageFromRepository package2 = AddPackageToAction("B", "1.0");
+			IPackageManagementProject project = AddProjectToSolution();
+			ProjectHasOlderVersionOfPackage(project, package1);
+			ProjectHasOlderVersionOfPackage(project, package2);
+			
+			action.Execute();
+			
+			project.AssertWasCalled(p => p.UpdatePackageReference(package1, action));
+			project.AssertWasCalled(p => p.UpdatePackageReference(package2, action));
+		}
+		
+		[Test]
+		public void Execute_TwoProjectsThatHaveOlderVersionsOfPackageBeingUpdated_PackageReferenceUpdatedInBothProjects()
+		{
+			CreateAction();
+			IPackageFromRepository package = AddPackageToAction("A", "1.0");
+			IPackageManagementProject project1 = AddProjectToSolution();
+			IPackageManagementProject project2 = AddProjectToSolution();
+			ProjectHasOlderVersionOfPackage(project1, package);
+			ProjectHasOlderVersionOfPackage(project2, package);
+			
+			action.Execute();
+			
+			project1.AssertWasCalled(p => p.UpdatePackageReference(package, action));
+			project2.AssertWasCalled(p => p.UpdatePackageReference(package, action));
+		}
+		
+		[Test]
+		public void Execute_TwoProjectsAndOnlyOneHasOlderVersionsOfPackageBeingUpdated_PackageReferenceUpdatedInOnlyOneProject()
+		{
+			CreateAction();
+			IPackageFromRepository package = AddPackageToAction("A", "1.0");
+			IPackageManagementProject project1 = AddProjectToSolution();
+			IPackageManagementProject project2 = AddProjectToSolution();
+			ProjectHasOlderVersionOfPackage(project2, package);
+			
+			action.Execute();
+			
+			project1.AssertWasNotCalled(p => p.UpdatePackageReference(package, action));
+			project2.AssertWasCalled(p => p.UpdatePackageReference(package, action));
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingPackageScriptRunner()
+		{
+			CreateAction();
+			IPackageScriptRunner expectedRunner = CreatePackageScriptRunner();
+			action.PackageScriptRunner = expectedRunner;
+			AddPackageToAction("Test", "1.0");
+			AddProjectToSolution();
+			
+			action.Execute();
+			
+			IPackageScriptRunner actualRunner = action.ScriptRunnerPassedToCreateRunPackageScriptsAction;
+			Assert.AreEqual(expectedRunner, actualRunner);
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingProjects()
+		{
+			CreateAction();
+			AddPackageToAction("Test", "1.0");
+			IPackageManagementProject project1 = AddProjectToSolution();
+			IPackageManagementProject project2 = AddProjectToSolution();
+			var expectedProjects = new IPackageManagementProject[] {
+				project1,
+				project2
+			};
+			action.PackageScriptRunner = CreatePackageScriptRunner();
+			
+			action.Execute();
+			
+			Assert.AreEqual(expectedProjects, action.ProjectsPassedToCreateRunPackageScriptsAction);
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionIsDisposed()
+		{
+			CreateAction();
+			AddPackageToAction("Test", "1.0");
+			AddProjectToSolution();
+			action.PackageScriptRunner = CreatePackageScriptRunner();
+			
+			action.Execute();
+			
+			Assert.IsTrue(action.IsRunPackageScriptsActionDisposed);
+		}
+		
+		[Test]
+		public void Execute_NullPackageScriptRunner_RunPackageScriptsActionIsNotCreated()
+		{
+			CreateAction();
+			AddPackageToAction("Test", "1.0");
+			AddProjectToSolution();
+			action.PackageScriptRunner = null;
+			
+			action.Execute();
+			
+			Assert.IsFalse(action.IsRunPackageScriptsActionCreated);
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_PackageReferenceUpdatedInProject()
+		{
+			CreateAction();
+			IPackageFromRepository package = AddPackageToAction("Test", "1.0");
+			IPackageManagementProject project = AddProjectToSolution();
+			ProjectHasOlderVersionOfPackage(project, package);
+			action.PackageScriptRunner = CreatePackageScriptRunner();
+			
+			action.Execute();
+			
+			project.AssertWasCalled(p => p.UpdatePackageReference(package, action));
+		}
+		
+		[Test]
+		public void Execute_PackageScriptRunnerSet_ProjectsFromSolutionReadOnlyOnce()
+		{
+			CreateAction();
+			IPackageFromRepository package = AddPackageToAction("Test", "1.0");
+			IPackageManagementProject project = AddProjectToSolution();
+			ProjectHasOlderVersionOfPackage(project, package);
+			action.PackageScriptRunner = CreatePackageScriptRunner();
+			
+			action.Execute();
+			
+			solution.AssertWasCalled(
+				s => s.GetProjects(sourceRepository),
+				setupConstraint => setupConstraint.Repeat.Once());
+		}
+		
+		[Test]
+		public void Execute_NullPackageScriptRunner_ProjectsFromSolutionReadOnlyOnce()
+		{
+			CreateAction();
+			IPackageFromRepository package = AddPackageToAction("Test", "1.0");
+			IPackageManagementProject project = AddProjectToSolution();
+			ProjectHasOlderVersionOfPackage(project, package);
+			action.PackageScriptRunner = null;
+			
+			action.Execute();
+			
+			solution.AssertWasCalled(
+				s => s.GetProjects(sourceRepository),
+				setupConstraint => setupConstraint.Repeat.Once());
+		}
+		
+		[Test]
+		public void Execute_TwoProjectsBeingUpdated_LoggerSetOnBothProjects()
+		{
+			CreateAction();
+			ILogger logger = MockRepository.GenerateStub<ILogger>();
+			action.Logger = logger;
+			IPackageFromRepository package = AddPackageToAction("A", "1.0");
+			IPackageManagementProject project1 = AddProjectToSolution();
+			IPackageManagementProject project2 = AddProjectToSolution();
+			
+			action.Execute();
+			
+			Assert.AreEqual(logger, project1.Logger);
+			Assert.AreEqual(logger, project2.Logger);
+		}
+	}
+}

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

@@ -123,19 +123,15 @@ namespace PackageManagement.Tests
 			return package;
 		}
 		
-		FakePackage AddPackageToActiveRepository(string version)
-		{
-			return AddPackageToActiveRepository("Test", version);
-		}
-		
 		FakePackage AddPackageToActiveRepository(string id, string version)
 		{
 			return registeredPackageRepositories.AddFakePackageWithVersionToActiveRepository(id, version);
 		}
 		
-		FakePackage AddPackageToSolution(string version)
+		FakePackage AddPackageToSolution(string id, string version)
 		{
 			FakePackage package = FakePackage.CreatePackageWithVersion(version);
+			package.Id = id;
 			solution.FakeInstalledPackages.Add(package);
 			return package;
 		}
@@ -170,6 +166,13 @@ namespace PackageManagement.Tests
 				.ActionPassedToRun as UpdatePackagesAction;
 		}
 		
+		UpdateSolutionPackagesAction GetUpdateSolutionPackagesActionRun()
+		{
+			return packageViewModelFactory
+				.FakeActionRunner
+				.ActionPassedToRun as UpdateSolutionPackagesAction;
+		}
+		
 		void RunUpdateAllPackagesCommand()
 		{
 			viewModel.UpdateAllPackagesCommand.Execute(null);
@@ -185,12 +188,27 @@ namespace PackageManagement.Tests
 			CompleteReadPackagesTask();
 		}
 		
+		void ViewModelHasTwoPackagesInSolutionThatCanBeUpdatedAfterReadingPackages()
+		{
+			AddPackageToSolution("First", "1.0.0.0");
+			AddPackageToActiveRepository("First", "1.1.0.0");
+			AddPackageToSolution("Second", "1.0.0.0");
+			AddPackageToActiveRepository("Second", "1.1.0.0");
+			viewModel.ReadPackages();
+			CompleteReadPackagesTask();
+		}
+		
+		FakePackageManagementProject AddProjectToSolution()
+		{
+			return solution.AddFakeProject("MyProject");
+		}
+		
 		[Test]
 		public void ReadPackages_OneNewerPackageVersionAvailable_NewerPackageVersionDisplayed()
 		{
 			CreateViewModel();
-			AddPackageToLocalRepository("1.0.0.0");
+			AddPackageToLocalRepository("Test", "1.0.0.0");
-			FakePackage newerPackage = AddPackageToActiveRepository("1.1.0.0");
+			FakePackage newerPackage = AddPackageToActiveRepository("Test", "1.1.0.0");
 			
 			viewModel.ReadPackages();
 			CompleteReadPackagesTask();
@@ -206,9 +224,9 @@ namespace PackageManagement.Tests
 		public void ReadPackages_TwoPackagesInSourceRepositoryAndOneNewerPackageVersionAvailable_NewerPackageVersionDisplayed()
 		{
 			CreateViewModel();
-			AddPackageToLocalRepository("1.0.0.0");
+			AddPackageToLocalRepository("Test", "1.0.0.0");
-			AddPackageToActiveRepository("1.0.0.0");
+			AddPackageToActiveRepository("Test", "1.0.0.0");
-			FakePackage newerPackage = AddPackageToActiveRepository("1.1.0.0");
+			FakePackage newerPackage = AddPackageToActiveRepository("Test", "1.1.0.0");
 			
 			viewModel.ReadPackages();
 			CompleteReadPackagesTask();
@@ -224,8 +242,8 @@ namespace PackageManagement.Tests
 		public void ReadPackages_OneNewerPackageVersionAvailable_ProjectNotCreatedByBackgroundThread()
 		{
 			CreateViewModel();
-			AddPackageToLocalRepository("1.0.0.0");
+			AddPackageToLocalRepository("Test", "1.0.0.0");
-			FakePackage newerPackage = AddPackageToActiveRepository("1.1.0.0");
+			FakePackage newerPackage = AddPackageToActiveRepository("Test", "1.1.0.0");
 			
 			viewModel.ReadPackages();
 			
@@ -254,8 +272,8 @@ namespace PackageManagement.Tests
 			CreateSolution();
 			NoProjectsSelected();
 			CreateViewModel(solution);
-			AddPackageToSolution("1.0.0.0");
+			AddPackageToSolution("Test", "1.0.0.0");
-			FakePackage newerPackage = AddPackageToActiveRepository("1.1.0.0");
+			FakePackage newerPackage = AddPackageToActiveRepository("Test", "1.1.0.0");
 			
 			viewModel.ReadPackages();
 			CompleteReadPackagesTask();
@@ -273,8 +291,8 @@ namespace PackageManagement.Tests
 			CreateSolution();
 			NoProjectsSelected();
 			CreateViewModel(solution);
-			AddPackageToSolution("1.0.0.0");
+			AddPackageToSolution("Test", "1.0.0.0");
-			FakePackage newerPackage = AddPackageToActiveRepository("1.1.0.0");
+			FakePackage newerPackage = AddPackageToActiveRepository("Test", "1.1.0.0");
 			
 			viewModel.ReadPackages();
 			CompleteReadPackagesTask();
@@ -297,9 +315,8 @@ namespace PackageManagement.Tests
 		public void ReadPackages_PrereleasePackageVersionAvailable_NoUpdatesFound()
 		{
 			CreateViewModel();
-			
+			AddPackageToLocalRepository("Test", "1.0.0");
-			AddPackageToLocalRepository("1.0.0");
+			FakePackage newerPackage = AddPackageToActiveRepository("Test", "1.1.0-alpha");
-			FakePackage newerPackage = AddPackageToActiveRepository("1.1.0-alpha");
 			
 			viewModel.ReadPackages();
 			CompleteReadPackagesTask();
@@ -474,7 +491,8 @@ namespace PackageManagement.Tests
 			
 			UpdatePackagesAction action = GetUpdatePackagesActionRun();
 			FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
-			Assert.AreEqual(action, project.UpdatePackagesActionPassedToGetUpdatePackagesOperations);
+			Assert.AreEqual(action, project.SettingsPassedToGetUpdatePackagesOperations);
+			Assert.AreEqual(action.Packages, project.PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations);
 		}
 		
 		[Test]
@@ -504,5 +522,132 @@ namespace PackageManagement.Tests
 			
 			CollectionAssert.AreEqual(expectedPackages, project.PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations);
 		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_TwoProjectsAndPackagesUpdatedForSolution_UpdateAllPackagesInSolutionActionIsRun()
+		{
+			CreateSolution();
+			NoProjectsSelected();
+			FakePackageManagementProject project1 = AddProjectToSolution();
+			FakePackageManagementProject project2 = AddProjectToSolution();
+			CreateViewModel(solution);
+			ViewModelHasTwoPackagesInSolutionThatCanBeUpdatedAfterReadingPackages();
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdateSolutionPackagesAction action = GetUpdateSolutionPackagesActionRun();
+			Assert.IsNotNull(action);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_TwoProjectsAndPackagesUpdatedForSolution_UpdateAllPackagesInSolutionActionRunHasSolutionSet()
+		{
+			CreateSolution();
+			NoProjectsSelected();
+			FakePackageManagementProject project1 = AddProjectToSolution();
+			FakePackageManagementProject project2 = AddProjectToSolution();
+			CreateViewModel(solution);
+			ViewModelHasTwoPackagesInSolutionThatCanBeUpdatedAfterReadingPackages();
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdateSolutionPackagesAction action = GetUpdateSolutionPackagesActionRun();
+			Assert.AreEqual(solution, action.Solution);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_TwoProjectsAndPackagesUpdatedForSolution_UpdateAllPackagesInSolutionActionRunHasTwoPackages()
+		{
+			CreateSolution();
+			NoProjectsSelected();
+			FakePackageManagementProject project1 = AddProjectToSolution();
+			FakePackageManagementProject project2 = AddProjectToSolution();
+			CreateViewModel(solution);
+			AddPackageToSolution("First", "1.0.0.0");
+			FakePackage firstUpdatedPackage = AddPackageToActiveRepository("First", "1.1.0.0");
+			AddPackageToSolution("Second", "1.0.0.0");
+			FakePackage secondUpdatedPackage = AddPackageToActiveRepository("Second", "1.1.0.0");
+			viewModel.ReadPackages();
+			CompleteReadPackagesTask();
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdateSolutionPackagesAction action = GetUpdateSolutionPackagesActionRun();
+			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_TwoProjectsAndPackagesUpdatedForSolution_ActionHasPackageOperations()
+		{
+			CreateSolution();
+			NoProjectsSelected();
+			FakePackageManagementProject project1 = AddProjectToSolution();
+			FakePackageManagementProject project2 = AddProjectToSolution();
+			CreateViewModel(solution);
+			ViewModelHasTwoPackagesInSolutionThatCanBeUpdatedAfterReadingPackages();
+			List<PackageOperation> operations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
+			project1.PackageOperationsToReturnFromGetUpdatePackagesOperations = operations;
+			
+			RunUpdateAllPackagesCommand();
+			
+			UpdateSolutionPackagesAction action = GetUpdateSolutionPackagesActionRun();
+			CollectionAssert.AreEqual(operations, action.Operations);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_TwoProjectsAndPackagesUpdatedForSolution_PackageOperationsDeterminedFromConfiguredPackageRepository()
+		{
+			CreateSolution();
+			NoProjectsSelected();
+			FakePackageManagementProject project1 = AddProjectToSolution();
+			FakePackageManagementProject project2 = AddProjectToSolution();
+			CreateViewModel(solution);
+			ViewModelHasTwoPackagesInSolutionThatCanBeUpdatedAfterReadingPackages();
+			List<PackageOperation> operations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
+			project1.PackageOperationsToReturnFromGetUpdatePackagesOperations = operations;
+			IPackageFromRepository package = viewModel.PackageViewModels[0].GetPackage() as IPackageFromRepository;
+			
+			RunUpdateAllPackagesCommand();
+			
+			Assert.AreEqual(package.Repository, solution.SourceRepositoryPassedToGetProjects);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_TwoProjectsAndPackagesUpdatedForSolution_LoggerSetWhenResolvingPackageOperations()
+		{
+			CreateSolution();
+			NoProjectsSelected();
+			FakePackageManagementProject project1 = AddProjectToSolution();
+			FakePackageManagementProject project2 = AddProjectToSolution();
+			CreateViewModel(solution);
+			ViewModelHasTwoPackagesInSolutionThatCanBeUpdatedAfterReadingPackages();
+			
+			RunUpdateAllPackagesCommand();
+			
+			ILogger expectedLogger = updatedPackageViewModelFactory.Logger;
+			ILogger actualLogger = project1.Logger;
+			Assert.AreEqual(expectedLogger, actualLogger);
+		}
+		
+		[Test]
+		public void UpdateAllPackagesCommand_TwoProjectsAndPackagesUpdatedForSolution_LoggerSetOnUpdateSolutionPackagesAction()
+		{
+			CreateSolution();
+			NoProjectsSelected();
+			FakePackageManagementProject project1 = AddProjectToSolution();
+			FakePackageManagementProject project2 = AddProjectToSolution();
+			CreateViewModel(solution);
+			ViewModelHasTwoPackagesInSolutionThatCanBeUpdatedAfterReadingPackages();
+			
+			RunUpdateAllPackagesCommand();
+			
+			ILogger expectedLogger = updatedPackageViewModelFactory.Logger;
+			UpdateSolutionPackagesAction action = GetUpdateSolutionPackagesActionRun();
+			Assert.AreEqual(expectedLogger, action.Logger);
+		}
 	}
 }