Support updating all NuGet packages in a solution when using the Update-Package PowersShell cmdlet.

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

@@ -51,15 +51,25 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		protected override void ProcessRecord()
 		{
 			ThrowErrorIfProjectNotOpen();
-			if (IsPackageIdMissing) {
-				UpdateAllPackagesInProject();
+			if (IsPackageIdMissing()) {
+				if (HasProjectName()) {
+					UpdateAllPackagesInProject();
+				} else {
+					UpdateAllPackagesInSolution();
+				}
 			} else {
 				UpdatePackageInSingleProject();
 			}
 		}
 		
-		bool IsPackageIdMissing {
-			get { return Id == null; }
+		bool IsPackageIdMissing()
+		{
+			return String.IsNullOrEmpty(Id);
+		}
+		
+		bool HasProjectName()
+		{
+			return ProjectName != null;
 		}
 		
 		void UpdateAllPackagesInProject()
@@ -74,6 +84,25 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 			return updatePackageActionsFactory.CreateUpdateAllPackagesInProject(project);
 		}
 		
+		void UpdateAllPackagesInSolution()
+		{
+			IUpdatePackageActions actions = CreateUpdateAllPackagesInSolution();
+			RunActions(actions);
+		}
+		
+		IUpdatePackageActions CreateUpdateAllPackagesInSolution()
+		{
+			IPackageManagementSolution solution = ConsoleHost.Solution;
+			IPackageRepository repository = GetActivePackageRepository();
+			return updatePackageActionsFactory.CreateUpdateAllPackagesInSolution(solution, repository);
+		}
+		
+		IPackageRepository GetActivePackageRepository()
+		{
+			PackageSource packageSource = ConsoleHost.GetActivePackageSource(Source);
+			return ConsoleHost.GetPackageRepository(packageSource);
+		}
+		
 		void UpdatePackageInSingleProject()
 		{
 			IPackageManagementProject project = GetProject();

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Src/UpdatePackageCmdletTests.cs

@@ -6,6 +6,7 @@ using System.Management.Automation;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
 using NUnit.Framework;
 using PackageManagement.Cmdlets.Tests.Helpers;
 using PackageManagement.Tests.Helpers;
@@ -20,15 +21,19 @@ namespace PackageManagement.Cmdlets.Tests
 		FakePackageManagementProject fakeProject;
 		FakeUpdatePackageActionsFactory fakeUpdateActionsFactory;
 		FakeUpdatePackageActions fakeUpdateAllPackagesInProject;
+		FakePackageManagementSolution fakeSolution;
+		FakeUpdatePackageActions fakeUpdateAllPackagesInSolution;
 		
 		void CreateCmdletWithoutActiveProject()
 		{
 			cmdlet = new TestableUpdatePackageCmdlet();
 			fakeTerminatingError = cmdlet.FakeCmdletTerminatingError;
 			fakeConsoleHost = cmdlet.FakePackageManagementConsoleHost;
+			fakeSolution = fakeConsoleHost.FakeSolution;
 			fakeProject = fakeConsoleHost.FakeProject;
 			fakeUpdateActionsFactory = cmdlet.FakeUpdatePackageActionsFactory;
 			fakeUpdateAllPackagesInProject = fakeUpdateActionsFactory.FakeUpdateAllPackagesInProject;
+			fakeUpdateAllPackagesInSolution = fakeUpdateActionsFactory.FakeUpdateAllPackagesInSolution;
 		}
 				
 		FakeUpdatePackageAction UpdatePackageInSingleProjectAction {
@@ -48,6 +53,19 @@ namespace PackageManagement.Cmdlets.Tests
 			get { return GetUpdatingAllPackagesInProjectAction(1); }
 		}
 		
+		FakeUpdatePackageAction FirstUpdateActionWhenUpdatingAllPackagesInSolution {
+			get { return GetUpdatingAllPackagesInSolutionAction(0); }
+		}
+		
+		FakeUpdatePackageAction GetUpdatingAllPackagesInSolutionAction(int index)
+		{
+			return fakeUpdateActionsFactory.FakeUpdateAllPackagesInSolution.FakeActions[index];
+		}
+		
+		FakeUpdatePackageAction SecondUpdateActionWhenUpdatingAllPackagesInSolution {
+			get { return GetUpdatingAllPackagesInSolutionAction(1); }
+		}
+		
 		void CreateCmdletWithActivePackageSourceAndProject()
 		{
 			CreateCmdletWithoutActiveProject();
@@ -98,6 +116,19 @@ namespace PackageManagement.Cmdlets.Tests
 			fakeUpdateActionsFactory.FakeUpdateAllPackagesInProject.FakeActions.Add(action);
 		}
 		
+		void CreateTwoUpdateActionsWhenUpdatingAllPackagesInSolution(string packageId1, string packageId2)
+		{
+			CreateUpdateActionWhenUpdatingAllPackagesInSolution(packageId1);
+			CreateUpdateActionWhenUpdatingAllPackagesInSolution(packageId2);
+		}
+		
+		void CreateUpdateActionWhenUpdatingAllPackagesInSolution(string packageId)
+		{
+			var action = new FakeUpdatePackageAction(fakeProject);
+			action.PackageId = packageId;
+			fakeUpdateActionsFactory.FakeUpdateAllPackagesInSolution.FakeActions.Add(action);
+		}
+		
 		[Test]
 		public void ProcessRecord_NoActiveProject_ThrowsNoProjectOpenTerminatingError()
 		{
@@ -150,7 +181,7 @@ namespace PackageManagement.Cmdlets.Tests
 		}
 		
 		[Test]
-		public void ProcessRecord_PackageIdSpecified_UpdatePackageActionIsExecuted()
+		public void ProcessRecord_PackageIdAndProjectNameSpecified_UpdatePackageActionIsExecuted()
 		{
 			CreateCmdletWithActivePackageSourceAndProject();
 			SetIdParameter("Test");
@@ -239,7 +270,7 @@ namespace PackageManagement.Cmdlets.Tests
 		}
 		
 		[Test]
-		public void ProcessRecord_UpdateAllPackagesInProject_CreatesUpdateAllPackagesProject()
+		public void ProcessRecord_UpdateAllPackagesInProject_CreatesUpdateAllPackagesInProject()
 		{
 			CreateCmdletWithActivePackageSourceAndProject();
 			SetProjectNameParameter("MyProject");
@@ -250,7 +281,21 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			Assert.AreEqual(fakeProject, project);
 		}
-				
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInProjectWhenPackageIdIsEmptyString_CreatesUpdateAllPackagesInProject()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			SetProjectNameParameter("MyProject");
+			SetIdParameter(String.Empty);
+			RunCmdlet();
+			
+			IPackageManagementProject project = 
+				fakeUpdateActionsFactory.ProjectPassedToCreateUpdateAllPackagesInProject;
+			
+			Assert.AreEqual(fakeProject, project);
+		}
+		
 		[Test]
 		public void ProcessRecord_UpdateAllPackagesInProject_ProjectNameUsedToCreateProject()
 		{
@@ -325,7 +370,7 @@ namespace PackageManagement.Cmdlets.Tests
 		}
 		
 		[Test]
-		public void ProcessRecord_UpdateAllPackagesInProjectWhenOnePackageInProject_ActionsUsesCmdletAsScriptRunner()
+		public void ProcessRecord_UpdateAllPackagesInProjectWhenOnePackageInProject_ActionsUseCmdletAsScriptRunner()
 		{
 			CreateCmdletWithActivePackageSourceAndProject();
 			SetProjectNameParameter("MyProject");
@@ -336,5 +381,110 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			Assert.AreEqual(cmdlet, runner);
 		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolution_CreatesUpdateAllPackagesSolution()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			RunCmdlet();
+			
+			IPackageManagementSolution solution = 
+				fakeUpdateActionsFactory.SolutionPassedToCreateUpdateAllPackagesInSolution;
+			
+			Assert.AreEqual(fakeSolution, solution);
+		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolutionWhenSourceSpecified_PackageSourceUsedToGetRepository()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			SetSourceParameter("Test");
+			RunCmdlet();
+			
+			PackageSource packageSource = fakeConsoleHost.PackageSourcePassedToGetRepository;
+			PackageSource expectedPackageSource = fakeConsoleHost.PackageSourceToReturnFromGetActivePackageSource;
+			
+			Assert.AreEqual(expectedPackageSource, packageSource);
+		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolutionWhenSourceSpecified_SourceUsedPassedGetActvePackageSourceFromConsoleHost()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			SetSourceParameter("Test");
+			RunCmdlet();
+			
+			string packageSource = fakeConsoleHost.PackageSourcePassedToGetActivePackageSource;
+			
+			Assert.AreEqual("Test", packageSource);
+		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolution_RepositoryUsedToCreateUpdateAllPackagesInSolution()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			RunCmdlet();
+			
+			IPackageRepository repository = fakeUpdateActionsFactory.SourceRepositoryPassedToCreateUpdateAllPackagesInSolution;
+			IPackageRepository expectedRepository = fakeConsoleHost.FakePackageRepository;
+			
+			Assert.AreEqual(expectedRepository, repository);
+		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolutionWhenTwoUpdateActionsReturned_TwoUpdateActionsAreExecuted()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			CreateTwoUpdateActionsWhenUpdatingAllPackagesInSolution("PackageA", "PackageB");
+			RunCmdlet();
+			
+			bool[] executedActions = new bool[] {
+				FirstUpdateActionWhenUpdatingAllPackagesInSolution.IsExecuted,
+				SecondUpdateActionWhenUpdatingAllPackagesInSolution.IsExecuted
+			};
+			
+			bool[] expectedExecutedActions = new bool[] {
+				true,
+				true
+			};
+			
+			CollectionAssert.AreEqual(expectedExecutedActions, executedActions);
+		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolutionAndIgnoreDependenciesIsTrue_ActionDoesNotUpdateDependencies()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			CreateUpdateActionWhenUpdatingAllPackagesInSolution("PackageA");
+			EnableIgnoreDependenciesParameter();
+			RunCmdlet();
+			
+			bool update = fakeUpdateAllPackagesInSolution.UpdateDependencies;
+			
+			Assert.IsFalse(update);
+		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolutionAndIgnoreDependenciesIsFalse_ActionUpdatesDependencies()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			CreateUpdateActionWhenUpdatingAllPackagesInSolution("PackageA");
+			RunCmdlet();
+			
+			bool update = fakeUpdateAllPackagesInSolution.UpdateDependencies;
+			
+			Assert.IsTrue(update);
+		}
+		
+		[Test]
+		public void ProcessRecord_UpdateAllPackagesInSolution_ActionsUseCmdletAsScriptRunner()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			RunCmdlet();
+			
+			IPackageScriptRunner runner = fakeUpdateAllPackagesInSolution.PackageScriptRunner;
+			
+			Assert.AreEqual(cmdlet, runner);
+		}
 	}
 }

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

@@ -318,6 +318,7 @@
     <Compile Include="Src\ThreadSafePackageManagementEvents.cs" />
     <Compile Include="Src\UninstallPackageAction.cs" />
     <Compile Include="Src\UpdateAllPackagesInProject.cs" />
+    <Compile Include="Src\UpdateAllPackagesInSolution.cs" />
     <Compile Include="Src\UpdatedPackagesViewModel.cs" />
     <Compile Include="Src\PackageViewModel.cs" />
     <Compile Include="Src\PackageViewModelFactory.cs" />

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

@@ -33,6 +33,10 @@ namespace ICSharpCode.PackageManagement.Design
 			get { return FakeUpdatePackageActionsCreated[0]; }
 		}
 		
+		public FakeUpdatePackageAction SecondFakeUpdatePackageActionCreated {
+			get { return FakeUpdatePackageActionsCreated[1]; }
+		}
+		
 		public List<FakeUpdatePackageAction> FakeUpdatePackageActionsCreated = 
 			new List<FakeUpdatePackageAction>();
 		

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

@@ -132,5 +132,31 @@ namespace ICSharpCode.PackageManagement.Design
 			FakeProjectsToReturnFromGetProject.Add(name, project);
 			return project;
 		}
+		
+		public List<FakePackage> FakePackagesInReverseDependencyOrder = 
+			new List<FakePackage>();
+		
+		public IEnumerable<IPackage> GetPackagesInReverseDependencyOrder()
+		{
+			return FakePackagesInReverseDependencyOrder;
+		}
+		
+		public List<FakePackageManagementProject> FakeProjects =
+			new List<FakePackageManagementProject>();
+		
+		public IPackageRepository SourceRepositoryPassedToGetProjects;
+		
+		public IEnumerable<IPackageManagementProject> GetProjects(IPackageRepository sourceRepository)
+		{
+			SourceRepositoryPassedToGetProjects = sourceRepository;
+			return FakeProjects;
+		}
+		
+		public FakePackageManagementProject AddFakeProject(string projectName)
+		{
+			var project = new FakePackageManagementProject(projectName);
+			FakeProjects.Add(project);
+			return project;
+		}
 	}
 }

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

@@ -17,6 +17,7 @@ namespace ICSharpCode.PackageManagement
 		IPackageManagementProject GetProject(PackageSource source, string projectName);
 		IPackageManagementProject GetProject(IPackageRepository sourceRepository, string projectName);
 		IPackageManagementProject GetProject(IPackageRepository sourceRepository, IProject project);
+		IEnumerable<IPackageManagementProject> GetProjects(IPackageRepository sourceRepository);
 		
 		IProject GetActiveMSBuildProject();
 		IEnumerable<IProject> GetMSBuildProjects();
@@ -24,6 +25,7 @@ namespace ICSharpCode.PackageManagement
 		
 		bool IsPackageInstalled(IPackage package);
 		IQueryable<IPackage> GetPackages();
+		IEnumerable<IPackage> GetPackagesInReverseDependencyOrder();
 		
 		bool IsOpen { get; }
 		string FileName { get; }

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

@@ -13,6 +13,7 @@ namespace ICSharpCode.PackageManagement
 	{
 		string GetInstallPath(IPackage package);
 		IEnumerable<IPackage> GetPackagesByDependencyOrder();
+		IEnumerable<IPackage> GetPackagesByReverseDependencyOrder();
 		IQueryable<IPackage> GetPackages();
 		bool IsInstalled(IPackage package);
 		

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

@@ -2,11 +2,16 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
 	public interface IUpdatePackageActionsFactory
 	{
 		IUpdatePackageActions CreateUpdateAllPackagesInProject(IPackageManagementProject project);
+		
+		IUpdatePackageActions CreateUpdateAllPackagesInSolution(
+			IPackageManagementSolution solution,
+			IPackageRepository sourceRepository);
 	}
 }

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

@@ -154,5 +154,18 @@ namespace ICSharpCode.PackageManagement
 			ISolutionPackageRepository repository = CreateSolutionPackageRepository();
 			return repository.GetPackages();
 		}
+		
+		public IEnumerable<IPackage> GetPackagesInReverseDependencyOrder()
+		{
+			ISolutionPackageRepository repository = CreateSolutionPackageRepository();
+			return repository.GetPackagesByReverseDependencyOrder();
+		}
+		
+		public IEnumerable<IPackageManagementProject> GetProjects(IPackageRepository sourceRepository)
+		{
+			foreach (MSBuildBasedProject msbuildProject in GetMSBuildProjects()) {
+				yield return projectFactory.CreateProject(sourceRepository, msbuildProject);
+			}
+		}
 	}
 }

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

@@ -27,5 +27,7 @@ namespace ICSharpCode.PackageManagement.Scripting
 		IPackageManagementProject GetProject(string packageSource, string projectName);
 		IPackageManagementProject GetProject(IPackageRepository sourceRepository, string projectName);
 		PackageSource GetActivePackageSource(string source);
+		
+		IPackageRepository GetPackageRepository(PackageSource packageSource);
 	}
 }

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

@@ -250,5 +250,10 @@ namespace ICSharpCode.PackageManagement.Scripting
 		{
 			ScriptingConsole.SendLine(command);
 		}
+		
+		public IPackageRepository GetPackageRepository(PackageSource packageSource)
+		{
+			return registeredRepositories.CreateRepository(packageSource);
+		}
 	}
 }

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

@@ -71,5 +71,10 @@ namespace ICSharpCode.PackageManagement.Scripting
 				"The Package Management Console requires Windows PowerShell 2.0.\r\n" +
 				"PowerShell 2.0 can be downloaded from http://support.microsoft.com/kb/968929";
 		}
+		
+		public IPackageRepository GetPackageRepository(PackageSource packageSource)
+		{
+			return null;
+		}
 	}
 }

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

@@ -76,6 +76,11 @@ namespace ICSharpCode.PackageManagement
 			return packageSorter.GetPackagesByDependencyOrder(repository);
 		}
 		
+		public IEnumerable<IPackage> GetPackagesByReverseDependencyOrder()
+		{
+			return GetPackagesByDependencyOrder().Reverse();
+		}
+		
 		public bool IsInstalled(IPackage package)
 		{
 			return repository.Exists(package);

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

@@ -0,0 +1,65 @@
+// 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 UpdateAllPackagesInSolution : IUpdatePackageActions
+	{
+		IPackageManagementSolution solution;
+		IPackageRepository sourceRepository;
+		List<IPackageManagementProject> projects;
+		
+		public UpdateAllPackagesInSolution(
+			IPackageManagementSolution solution,
+			IPackageRepository sourceRepository)
+		{
+			this.solution = solution;
+			this.sourceRepository = sourceRepository;
+		}
+		
+		public bool UpdateDependencies { get; set; }
+		public IPackageScriptRunner PackageScriptRunner { get; set; }
+		
+		public IEnumerable<UpdatePackageAction> CreateActions()
+		{
+			GetProjects();
+			foreach (IPackage package in GetPackages()) {
+				foreach (IPackageManagementProject project in projects) {
+					yield return CreateAction(project, package);
+				}
+			}
+		}
+		
+		void GetProjects()
+		{
+			projects = new List<IPackageManagementProject>();
+			projects.AddRange(solution.GetProjects(sourceRepository));
+		}
+		
+		IEnumerable<IPackage> GetPackages()
+		{
+			return solution.GetPackagesInReverseDependencyOrder();
+		}
+		
+		UpdatePackageAction CreateAction(IPackageManagementProject project, IPackage package)
+		{
+			UpdatePackageAction action = project.CreateUpdatePackageAction();
+			SetUpdateActionParameters(action, package);
+			return action;
+		}
+		
+		void SetUpdateActionParameters(UpdatePackageAction action, IPackage package)
+		{
+			action.PackageId = package.Id;
+			action.PackageScriptRunner = PackageScriptRunner;
+			action.UpdateIfPackageDoesNotExistInProject = false;
+			action.UpdateDependencies = UpdateDependencies;
+		}
+	}
+}

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

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
@@ -11,5 +12,12 @@ namespace ICSharpCode.PackageManagement
 		{
 			return new UpdateAllPackagesInProject(project);
 		}
+		
+		public IUpdatePackageActions CreateUpdateAllPackagesInSolution(
+			IPackageManagementSolution solution,
+			IPackageRepository sourceRepository)
+		{
+			return new UpdateAllPackagesInSolution(solution, sourceRepository);
+		}
 	}
 }

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

@@ -246,6 +246,7 @@
     <Compile Include="Src\ThreadSafePackageManagementEventsTests.cs" />
     <Compile Include="Src\UninstallPackageActionTests.cs" />
     <Compile Include="Src\UpdateAllPackagesInProjectTests.cs" />
+    <Compile Include="Src\UpdateAllPackagesInSolutionTests.cs" />
     <Compile Include="Src\UpdatedPackagesViewModelTests.cs" />
     <Compile Include="Src\PackageViewModelTests.cs" />
     <Compile Include="Src\PagesTests.cs" />

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

@@ -118,5 +118,16 @@ namespace PackageManagement.Tests.Helpers
 		{
 			CommandsExecuted.Add(command);
 		}
+		
+		public FakePackageRepository FakePackageRepository = 
+			new FakePackageRepository();
+		
+		public PackageSource PackageSourcePassedToGetRepository;
+		
+		public IPackageRepository GetPackageRepository(PackageSource packageSource)
+		{
+			PackageSourcePassedToGetRepository = packageSource;
+			return FakePackageRepository;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementProjectFactory.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 ICSharpCode.SharpDevelop.Project;
@@ -11,15 +12,35 @@ namespace PackageManagement.Tests.Helpers
 {
 	public class FakePackageManagementProjectFactory : IPackageManagementProjectFactory
 	{
-		public FakePackageManagementProject FakeProject = new FakePackageManagementProject();
-		public IPackageRepository RepositoryPassedToCreateProject;
-		public MSBuildBasedProject ProjectPassedToCreateProject;
+		public List<FakePackageManagementProject> FakeProjectsCreated = 
+			new List<FakePackageManagementProject>();
+		
+		public FakePackageManagementProject FirstFakeProjectCreated {
+			get { return FakeProjectsCreated[0]; }
+		}
+		
+		public IPackageRepository FirstRepositoryPassedToCreateProject {
+			get { return RepositoriesPassedToCreateProject[0]; }
+		}
+		
+		public List<IPackageRepository> RepositoriesPassedToCreateProject = 
+			new List<IPackageRepository>();
+		
+		public MSBuildBasedProject FirstProjectPassedToCreateProject {
+			get { return ProjectsPassedToCreateProject[0]; }
+		}
+		
+		public List<MSBuildBasedProject> ProjectsPassedToCreateProject  =
+			new List<MSBuildBasedProject>();
 		
 		public IPackageManagementProject CreateProject(IPackageRepository sourceRepository, MSBuildBasedProject project)
 		{
-			RepositoryPassedToCreateProject = sourceRepository;
-			ProjectPassedToCreateProject = project;
-			return FakeProject;
+			RepositoriesPassedToCreateProject.Add(sourceRepository);
+			ProjectsPassedToCreateProject.Add(project);
+			
+			var fakeProject = new FakePackageManagementProject();
+			FakeProjectsCreated.Add(fakeProject);
+			return fakeProject;
 		}
 	}
 }

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

@@ -35,6 +35,13 @@ namespace PackageManagement.Tests.Helpers
 			return FakePackages;
 		}
 		
+		public List<FakePackage> FakePackagesByReverseDependencyOrder = new List<FakePackage>();
+		
+		public IEnumerable<IPackage> GetPackagesByReverseDependencyOrder()
+		{
+			return FakePackagesByReverseDependencyOrder;
+		}
+		
 		public bool IsInstalled(IPackage package)
 		{
 			return FakeSharedRepository.FakePackages.Exists(p => p == package);

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

@@ -3,6 +3,7 @@
 
 using System;
 using ICSharpCode.PackageManagement;
+using NuGet;
 
 namespace PackageManagement.Tests.Helpers
 {
@@ -10,6 +11,7 @@ namespace PackageManagement.Tests.Helpers
 	{
 		public FakeUpdatePackageActions FakeUpdateAllPackagesInProject = 
 			new FakeUpdatePackageActions();
+		
 		public IPackageManagementProject ProjectPassedToCreateUpdateAllPackagesInProject;
 		
 		public IUpdatePackageActions CreateUpdateAllPackagesInProject(IPackageManagementProject project)
@@ -17,5 +19,20 @@ namespace PackageManagement.Tests.Helpers
 			ProjectPassedToCreateUpdateAllPackagesInProject = project;
 			return FakeUpdateAllPackagesInProject;
 		}
+		
+		public FakeUpdatePackageActions FakeUpdateAllPackagesInSolution = 
+			new FakeUpdatePackageActions();
+		
+		public IPackageManagementSolution SolutionPassedToCreateUpdateAllPackagesInSolution;
+		public IPackageRepository SourceRepositoryPassedToCreateUpdateAllPackagesInSolution;
+		
+		public IUpdatePackageActions CreateUpdateAllPackagesInSolution(
+			IPackageManagementSolution solution,
+			IPackageRepository sourceRepository)
+		{
+			SolutionPassedToCreateUpdateAllPackagesInSolution = solution;
+			SourceRepositoryPassedToCreateUpdateAllPackagesInSolution = sourceRepository;
+			return FakeUpdateAllPackagesInSolution;
+		}
 	}
 }

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

@@ -65,13 +65,20 @@ namespace PackageManagement.Tests
 			return project;
 		}
 		
+		FakePackage AddPackageInReverseDependencyOrderToSolution(string packageId)
+		{
+			var package = new FakePackage(packageId);
+			fakeSolutionPackageRepository.FakePackagesByReverseDependencyOrder.Add(package);
+			return package;
+		}
+		
 		[Test]
 		public void GetActiveProject_ProjectIsSelected_CreatesProjectUsingCurrentProjectSelectedInSharpDevelop()
 		{
 			CreateSolution();
 			
 			IPackageManagementProject activeProject = solution.GetActiveProject();
-			IProject actualProject = fakeProjectFactory.ProjectPassedToCreateProject;
+			IProject actualProject = fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(testProject, actualProject);
 		}
@@ -83,7 +90,7 @@ namespace PackageManagement.Tests
 			
 			IPackageManagementProject activeProject = solution.GetActiveProject();
 			
-			IPackageRepository repository = fakeProjectFactory.RepositoryPassedToCreateProject;
+			IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 			IPackageRepository expectedRepository = fakeRegisteredPackageRepositories.ActiveRepository;
 			
 			Assert.AreEqual(expectedRepository, repository);
@@ -95,7 +102,7 @@ namespace PackageManagement.Tests
 			CreateSolution();
 			
 			IPackageManagementProject activeProject = solution.GetActiveProject();
-			IPackageManagementProject expectedProject = fakeProjectFactory.FakeProject;
+			IPackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 			
 			Assert.AreEqual(expectedProject, activeProject);
 		}
@@ -107,7 +114,7 @@ namespace PackageManagement.Tests
 			var expectedRepository = new FakePackageRepository();
 			solution.GetActiveProject(expectedRepository);
 			
-			IPackageRepository repository = fakeProjectFactory.RepositoryPassedToCreateProject;
+			IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 			
 			Assert.AreEqual(expectedRepository, repository);
 		}
@@ -122,7 +129,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetActiveProject(expectedRepository);
 			
-			MSBuildBasedProject project = fakeProjectFactory.ProjectPassedToCreateProject;
+			MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -134,7 +141,7 @@ namespace PackageManagement.Tests
 			var expectedRepository = new FakePackageRepository();
 			IPackageManagementProject project = solution.GetActiveProject(expectedRepository);
 			
-			FakePackageManagementProject expectedProject = fakeProjectFactory.FakeProject;
+			FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -148,7 +155,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetProject(source, "Test");
 			
-			MSBuildBasedProject project = fakeProjectFactory.ProjectPassedToCreateProject;
+			MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -162,7 +169,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetProject(source, "TEST");
 			
-			MSBuildBasedProject project = fakeProjectFactory.ProjectPassedToCreateProject;
+			MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -175,7 +182,7 @@ namespace PackageManagement.Tests
 			var source = new PackageSource("http://sharpdevelop.net");
 			IPackageManagementProject project = solution.GetProject(source, "Test");
 			
-			FakePackageManagementProject expectedProject = fakeProjectFactory.FakeProject;
+			FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -202,7 +209,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetProject(repository, "Test");
 			
-			MSBuildBasedProject project = fakeProjectFactory.ProjectPassedToCreateProject;
+			MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -216,7 +223,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetProject(repository, expectedProject);
 			
-			MSBuildBasedProject project = fakeProjectFactory.ProjectPassedToCreateProject;
+			MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -230,7 +237,7 @@ namespace PackageManagement.Tests
 			
 			IPackageManagementProject project = solution.GetProject(repository, msbuildProject);
 			
-			FakePackageManagementProject expectedProject = fakeProjectFactory.FakeProject;
+			FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -244,7 +251,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetProject(expectedRepository, expectedProject);
 			
-			IPackageRepository repository = fakeProjectFactory.RepositoryPassedToCreateProject;
+			IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 			
 			Assert.AreEqual(expectedRepository, repository);
 		}
@@ -258,7 +265,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetProject(repository, "TEST");
 			
-			MSBuildBasedProject project = fakeProjectFactory.ProjectPassedToCreateProject;
+			MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -272,7 +279,7 @@ namespace PackageManagement.Tests
 			
 			IPackageManagementProject project = solution.GetProject(repository, "Test");
 			
-			FakePackageManagementProject expectedProject = fakeProjectFactory.FakeProject;
+			FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 			
 			Assert.AreEqual(expectedProject, project);
 		}
@@ -286,7 +293,7 @@ namespace PackageManagement.Tests
 			
 			solution.GetProject(expectedRepository, "Test");
 			
-			IPackageRepository actualRepository = fakeProjectFactory.RepositoryPassedToCreateProject;
+			IPackageRepository actualRepository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 			
 			Assert.AreEqual(expectedRepository, actualRepository);
 		}
@@ -454,5 +461,83 @@ namespace PackageManagement.Tests
 			
 			PackageCollectionAssert.AreEqual(expectedPackages, packages);
 		}
+		
+		[Test]
+		public void GetPackagesInReverseDependencyOrder_TwoPackages_ReturnsPackagesFromSolutionLocalRepositoryInCorrectOrder()
+		{
+			CreateSolution();
+			FakePackage packageA = AddPackageInReverseDependencyOrderToSolution("A");
+			FakePackage packageB = AddPackageInReverseDependencyOrderToSolution("A");
+			
+			packageB.DependenciesList.Add(new PackageDependency("A"));
+			
+			var expectedPackages = new FakePackage[] {
+				packageB,
+				packageA
+			};
+			
+			IEnumerable<IPackage> packages = solution.GetPackagesInReverseDependencyOrder();
+			
+			PackageCollectionAssert.AreEqual(expectedPackages, packages);
+		}
+		
+		[Test]
+		public void GetProjects_SolutionHasOneProject_ReturnsOneProject()
+		{
+			CreateSolution();
+			AddProjectToOpenProjects("MyProject");
+			var repository = new FakePackageRepository();
+			List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
+			
+			Assert.AreEqual(1, projects.Count);
+		}
+		
+		[Test]
+		public void GetProjects_SolutionHasOneProject_RepositoryUsedToCreateProject()
+		{
+			CreateSolution();
+			AddProjectToOpenProjects("MyProject");
+			var expectedRepository = new FakePackageRepository();
+			List<IPackageManagementProject> projects = solution.GetProjects(expectedRepository).ToList();
+			
+			IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
+			
+			Assert.AreEqual(expectedRepository, repository);
+		}
+		
+		[Test]
+		public void GetProjects_SolutionHasOneProject_MSBuildProjectUsedToCreateProject()
+		{
+			CreateSolution();
+			TestableProject expectedProject = AddProjectToOpenProjects("MyProject");
+			var repository = new FakePackageRepository();
+			List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
+			
+			MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
+			
+			Assert.AreEqual(expectedProject, project);
+		}
+		
+		[Test]
+		public void GetProjects_SolutionHasNoProjects_ReturnsNoProjects()
+		{
+			CreateSolution();
+			var repository = new FakePackageRepository();
+			List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
+			
+			Assert.AreEqual(0, projects.Count);
+		}
+		
+		[Test]
+		public void GetProjects_SolutionHasTwoProjects_ReturnsTwoProjects()
+		{
+			CreateSolution();
+			AddProjectToOpenProjects("One");
+			AddProjectToOpenProjects("Two");
+			var repository = new FakePackageRepository();
+			List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
+			
+			Assert.AreEqual(2, projects.Count);
+		}
 	}
 }

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

@@ -66,7 +66,7 @@ namespace PackageManagement.Tests
 			InstallPackages();
 			
 			MSBuildBasedProject projectUsedToCreatePackageManagementProject
-				= fakeProjectFactory.ProjectPassedToCreateProject;
+				= fakeProjectFactory.FirstProjectPassedToCreateProject;
 			
 			Assert.AreEqual(project, projectUsedToCreatePackageManagementProject);
 		}
@@ -78,7 +78,7 @@ namespace PackageManagement.Tests
 			AddPackageReference("PackageId", "1.3.4.5");
 			InstallPackages();
 			
-			IPackageRepository repository = fakeProjectFactory.RepositoryPassedToCreateProject;
+			IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 			IPackageRepository expectedRepository = fakeRepositoryCache.FakeAggregateRepository;
 			
 			Assert.AreEqual(expectedRepository, repository);		

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

@@ -623,5 +623,29 @@ namespace PackageManagement.Tests.Scripting
 			
 			Assert.AreEqual(expectedText, text);
 		}
+		
+		[Test]
+		public void GetPackageRepository_PackageSourceSpecified_ReturnsPackageRepositoryFromRegisteredRepositories()
+		{
+			CreateHost();
+			
+			var packageSource = new PackageSource("Test");
+			IPackageRepository repository = host.GetPackageRepository(packageSource);
+			FakePackageRepository expectedRepository = fakeRegisteredPackageRepositories.FakePackageRepository;
+			
+			Assert.AreEqual(expectedRepository, repository);
+		}
+		
+		[Test]
+		public void GetPackageRepository_PackageSourceSpecified_PackagSourceUsedToGetRepository()
+		{
+			CreateHost();
+			
+			var expectedPackageSource = new PackageSource("Test");
+			IPackageRepository repository = host.GetPackageRepository(expectedPackageSource);
+			PackageSource packageSource = fakeRegisteredPackageRepositories.PackageSourcePassedToCreateRepository;
+			
+			Assert.AreEqual(expectedPackageSource, packageSource);
+		}
 	}
 }

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

@@ -150,6 +150,25 @@ namespace PackageManagement.Tests
 			Assert.AreEqual(expectedPackages, actualPackages);
 		}
 		
+		[Test]
+		public void GetPackagesByReverseDependencyOrder_TwoPackagesInSharedRepositorySecondPackageDependsOnFirst_ReturnsSecondPackageFirst()
+		{
+			CreateSolution(@"d:\projects\myproject\myproject.sln");
+			CreateRepository(solution);
+			FakePackage firstPackage = AddPackageToSharedRepository("First");
+			FakePackage secondPackage = AddPackageToSharedRepository("Second");
+			secondPackage.AddDependency("First");
+						
+			List<IPackage> actualPackages = repository.GetPackagesByReverseDependencyOrder().ToList();
+			
+			var expectedPackages = new IPackage[] {
+				secondPackage,
+				firstPackage
+			};
+			
+			Assert.AreEqual(expectedPackages, actualPackages);
+		}
+		
 		[Test]
 		public void IsInstalled_PackageIsInSharedRepository_ReturnsTrue()
 		{

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

@@ -0,0 +1,223 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class UpdateAllPackagesInSolutionTests
+	{
+		UpdateAllPackagesInSolution updateAllPackagesInSolution;
+		FakePackageManagementSolution fakeSolution;
+		List<UpdatePackageAction> updateActions;
+		FakePackageRepository fakeSourceRepository;
+		
+		void CreateUpdateAllPackagesInSolution()
+		{
+			fakeSolution = new FakePackageManagementSolution();
+			fakeSourceRepository = new FakePackageRepository();
+			updateAllPackagesInSolution = new UpdateAllPackagesInSolution(fakeSolution, fakeSourceRepository);
+		}
+		
+		void AddPackageToSolution(string packageId)
+		{
+			var package = new FakePackage(packageId, "1.0");
+			fakeSolution.FakePackagesInReverseDependencyOrder.Add(package);
+		}
+		
+		FakePackageManagementProject AddProjectToSolution(string projectName)
+		{
+			return fakeSolution.AddFakeProject(projectName);
+		}
+		
+		void CallCreateActions()
+		{
+			IEnumerable<UpdatePackageAction> actions = updateAllPackagesInSolution.CreateActions();
+			updateActions = actions.ToList();
+		}
+		
+		UpdatePackageAction FirstUpdateAction {
+			get { return updateActions[0]; }
+		}
+		
+		FakePackageManagementProject FirstProjectInSolution {
+			get { return fakeSolution.FakeProjects[0]; }
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithOneProject_ReturnsOneAction()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test");
+			CallCreateActions();
+			
+			Assert.AreEqual(1, updateActions.Count);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithOneProject_UpdateActionCreatedFromProject()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test");
+			CallCreateActions();
+			
+			UpdatePackageAction action = FirstUpdateAction;
+			UpdatePackageAction expectedAction = FirstProjectInSolution.FirstFakeUpdatePackageActionCreated;
+			
+			Assert.AreEqual(expectedAction, action);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithOneProject_UpdateActionCreatedUsingSourceRepositoryPassedInConstructor()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test");
+			CallCreateActions();
+			
+			IPackageRepository repository = fakeSolution.SourceRepositoryPassedToGetProjects;
+			FakePackageRepository expectedRepository = fakeSourceRepository;
+			
+			Assert.AreEqual(expectedRepository, repository);
+		}
+		
+		[Test]
+		public void CreateActions_NoPackagesInSolution_NoActionsReturned()
+		{
+			CreateUpdateAllPackagesInSolution();
+			CallCreateActions();
+			
+			Assert.AreEqual(0, updateActions.Count);
+		}
+		
+		[Test]
+		public void CreateActions_TwoPackagesInSolutionWithOneProject_ReturnsTwoActions()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test1");
+			AddPackageToSolution("Test2");
+			CallCreateActions();
+			
+			Assert.AreEqual(2, updateActions.Count);
+		}
+		
+		[Test]
+		public void CreateActions_TwoPackagesInSolutionWithOneProject_ReturnsTwoActionsWithPackageIdsForTwoPackages()
+		{
+			CreateUpdateAllPackagesInSolution();
+			FakePackageManagementProject project = AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test1");
+			AddPackageToSolution("Test2");
+			CallCreateActions();
+			
+			string[] packageIds = new string[] {
+				project.FirstFakeUpdatePackageActionCreated.PackageId,
+				project.SecondFakeUpdatePackageActionCreated.PackageId
+			};
+			
+			string [] expectedPackageIds = new string[] {
+				"Test1",
+				"Test2"
+			};
+			
+			Assert.AreEqual(expectedPackageIds, packageIds);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithTwoProjects_ReturnsTwoActions()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject1");
+			AddProjectToSolution("MyProject2");
+			AddPackageToSolution("Test");
+			CallCreateActions();
+			
+			Assert.AreEqual(2, updateActions.Count);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithTwoProjects_ReturnsTwoActionsCreatedFromProjects()
+		{
+			CreateUpdateAllPackagesInSolution();
+			FakePackageManagementProject project1 = AddProjectToSolution("MyProject1");
+			FakePackageManagementProject project2 = AddProjectToSolution("MyProject2");
+			AddPackageToSolution("Test");
+			CallCreateActions();
+			
+			var expectedActions = new UpdatePackageAction[] {
+				project1.FirstFakeUpdatePackageActionCreated,
+				project2.FirstFakeUpdatePackageActionCreated
+			};
+			
+			Assert.AreEqual(expectedActions, updateActions);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithOneProjectAndScriptRunnerIsSet_UpdateActionUsesSameScriptRunner()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test");
+			var expectedRunner = new FakePackageScriptRunner();
+			updateAllPackagesInSolution.PackageScriptRunner = expectedRunner;
+			CallCreateActions();
+			
+			IPackageScriptRunner runner = FirstUpdateAction.PackageScriptRunner;
+			
+			Assert.AreEqual(expectedRunner, runner);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithOneProject_UpdateActionDoesNotUpdatePackageIfProjectDoesNotHavePackage()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test");
+			CallCreateActions();
+			
+			bool updateIfPackageDoesNotExist = FirstUpdateAction.UpdateIfPackageDoesNotExistInProject;
+			
+			Assert.IsFalse(updateIfPackageDoesNotExist);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithOneProjectAndUpdateDependenciesIsFalse_UpdateActionDoesNotUpdateDependencies()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test");
+			updateAllPackagesInSolution.UpdateDependencies = false;
+			CallCreateActions();
+			
+			bool updateDependencies = FirstUpdateAction.UpdateDependencies;
+			
+			Assert.IsFalse(updateDependencies);
+		}
+		
+		[Test]
+		public void CreateActions_OnePackageInSolutionWithOneProjectAndUpdateDependenciesIsTrue_UpdateActionDoesUpdateDependencies()
+		{
+			CreateUpdateAllPackagesInSolution();
+			AddProjectToSolution("MyProject");
+			AddPackageToSolution("Test");
+			updateAllPackagesInSolution.UpdateDependencies = true;
+			CallCreateActions();
+			
+			bool updateDependencies = FirstUpdateAction.UpdateDependencies;
+			
+			Assert.IsTrue(updateDependencies);
+		}
+	}
+}