Prevent a package from being uninstalled before a PowerShell script has run when uninstalling from the Add Package Reference dialog.

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

@@ -49,7 +49,7 @@
     <Compile Include="Src\ICmdletTerminatingError.cs" />
     <Compile Include="Src\InstallPackageCmdlet.cs" />
     <Compile Include="Src\InvokeInitializePackagesCmdlet.cs" />
-    <Compile Include="Src\InvokeRunPackageScriptsCmdlet.cs" />
+    <Compile Include="Src\InvokeProcessPackageActionsCmdlet.cs" />
     <Compile Include="Src\InvokeUpdateWorkingDirectoryCmdlet.cs" />
     <Compile Include="Src\ITerminatingCmdlet.cs" />
     <Compile Include="Src\OpenProjects.cs" />

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

@@ -0,0 +1,56 @@
+// 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.Management.Automation;
+using ICSharpCode.PackageManagement.Scripting;
+
+namespace ICSharpCode.PackageManagement.Cmdlets
+{
+	[Cmdlet(VerbsLifecycle.Invoke, "ProcessPackageActions", DefaultParameterSetName = ParameterAttribute.AllParameterSets)]
+	public class InvokeProcessPackageActionsCmdlet : PackageManagementCmdlet
+	{
+		PackageActionsToRun actionsToRun;
+		
+		public InvokeProcessPackageActionsCmdlet()
+			: this(
+				PackageManagementServices.PackageActionsToRun,
+				PackageManagementServices.ConsoleHost,
+				null)
+		{
+		}
+		
+		public InvokeProcessPackageActionsCmdlet(
+			PackageActionsToRun actionsToRun,
+			IPackageManagementConsoleHost consoleHost,
+			ICmdletTerminatingError terminatingError)
+			: base(consoleHost, terminatingError)
+		{
+			this.actionsToRun = actionsToRun;
+		}
+		
+		protected override void ProcessRecord()
+		{
+			ExecutePackageActions();
+		}
+		
+		void ExecutePackageActions()
+		{
+			ProcessPackageAction action = null;
+			while (GetNextAction(out action)) {
+				Execute(action);
+			}
+		}
+		
+		bool GetNextAction(out ProcessPackageAction action)
+		{
+			return actionsToRun.GetNextAction(out action);
+		}
+		
+		void Execute(ProcessPackageAction action)
+		{
+			action.PackageScriptRunner = this;
+			action.Execute();
+		}
+	}
+}

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

@@ -1,51 +0,0 @@
-// 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.Management.Automation;
-using ICSharpCode.PackageManagement.Scripting;
-
-namespace ICSharpCode.PackageManagement.Cmdlets
-{
-	[Cmdlet(VerbsLifecycle.Invoke, "RunPackageScripts", DefaultParameterSetName = ParameterAttribute.AllParameterSets)]
-	public class InvokeRunPackageScriptsCmdlet : PackageManagementCmdlet
-	{
-		PackageScriptsToRun scriptsToBeRun;
-		
-		public InvokeRunPackageScriptsCmdlet()
-			: this(
-				PackageManagementServices.PackageScriptsToRun,
-				PackageManagementServices.ConsoleHost,
-				null)
-		{
-		}
-		
-		public InvokeRunPackageScriptsCmdlet(
-			PackageScriptsToRun scriptsToBeRun,
-			IPackageManagementConsoleHost consoleHost,
-			ICmdletTerminatingError terminatingError)
-			: base(consoleHost, terminatingError)
-		{
-			this.scriptsToBeRun = scriptsToBeRun;
-		}
-		
-		protected override void ProcessRecord()
-		{
-			RunPackageScripts();
-		}
-		
-		void RunPackageScripts()
-		{
-			IPackageScript script = null;
-			while (GetNextScript(out script)) {
-				Run(script);
-			}
-		}
-		
-		bool GetNextScript(out IPackageScript script)
-		{
-			script = scriptsToBeRun.GetNextScript();
-			return script != null;
-		}
-	}
-}

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Helpers/TestableInvokeProcessPackageActionsCmdlet.cs

@@ -2,33 +2,34 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Cmdlets;
 using ICSharpCode.PackageManagement.Scripting;
 using PackageManagement.Tests.Helpers;
 
 namespace PackageManagement.Cmdlets.Tests.Helpers
 {
-	public class TestableInvokeRunPackageScriptsCmdlet : InvokeRunPackageScriptsCmdlet
+	public class TestableInvokeProcessPackageActionsCmdlet : InvokeProcessPackageActionsCmdlet
 	{
 		public FakeCmdletTerminatingError FakeCmdletTerminatingError;
 		public FakePackageManagementConsoleHost FakePackageManagementConsoleHost;
-		public PackageScriptsToRun ScriptsToBeRun;
+		public PackageActionsToRun ActionsToRun;
 		
-		public TestableInvokeRunPackageScriptsCmdlet()
+		public TestableInvokeProcessPackageActionsCmdlet()
 			: this(
-				new PackageScriptsToRun(),
+				new PackageActionsToRun(),
 				new FakePackageManagementConsoleHost(),
 				new FakeCmdletTerminatingError())
 		{
 		}
 		
-		public TestableInvokeRunPackageScriptsCmdlet(
+		public TestableInvokeProcessPackageActionsCmdlet(
-			PackageScriptsToRun scriptsToBeRun,
+			PackageActionsToRun actionsToRun,
 			FakePackageManagementConsoleHost consoleHost,
 			FakeCmdletTerminatingError cmdletTerminatingError)
-			: base(scriptsToBeRun, consoleHost, cmdletTerminatingError)
+			: base(actionsToRun, consoleHost, cmdletTerminatingError)
 		{
-			this.ScriptsToBeRun = scriptsToBeRun;
+			this.ActionsToRun = actionsToRun;
 			this.FakePackageManagementConsoleHost = consoleHost;
 			this.FakeCmdletTerminatingError = cmdletTerminatingError;
 		}

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

@@ -50,7 +50,7 @@
     <Compile Include="Helpers\TestableGetProjectCmdlet.cs" />
     <Compile Include="Helpers\TestableInstallPackageCmdlet.cs" />
     <Compile Include="Helpers\TestableInvokeInitializePackagesCmdlet.cs" />
-    <Compile Include="Helpers\TestableInvokeRunPackageScriptsCmdlet.cs" />
+    <Compile Include="Helpers\TestableInvokeProcessPackageActionsCmdlet.cs" />
     <Compile Include="Helpers\TestableInvokeUpdateWorkingDirectoryCmdlet.cs" />
     <Compile Include="Helpers\TestablePackageManagementCmdlet.cs" />
     <Compile Include="Helpers\TestableUninstallPackageCmdlet.cs" />
@@ -61,7 +61,7 @@
     <Compile Include="Src\InvokeInitializePackagesCmdletTests.cs" />
     <Compile Include="Src\InstallPackageCmdletTests.cs" />
     <Compile Include="Src\CmdletTestsBase.cs" />
-    <Compile Include="Src\InvokeRunPackageScriptsCmdletTests.cs" />
+    <Compile Include="Src\InvokeProcessPackageActionsCmdletTests.cs" />
     <Compile Include="Src\InvokeUpdateWorkingDirectoryCmdletTests.cs" />
     <Compile Include="Src\PackageManagementCmdletTests.cs" />
     <Compile Include="Src\UninstallPackageCmdletTests.cs" />

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

@@ -0,0 +1,96 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NUnit.Framework;
+using PackageManagement.Cmdlets.Tests.Helpers;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests
+{
+	[TestFixture]
+	public class InvokeProcessPackageActionsCmdletTests
+	{
+		TestableInvokeProcessPackageActionsCmdlet cmdlet;
+		PackageActionsToRun actionsToRun;		
+		
+		void CreateCmdlet()
+		{
+			cmdlet = new TestableInvokeProcessPackageActionsCmdlet();
+			actionsToRun = cmdlet.ActionsToRun;
+		}
+		
+		void RunCmdlet()
+		{
+			cmdlet.CallProcessRecord();
+		}
+		
+		FakeInstallPackageAction AddInstallAction()
+		{
+			var project = new FakePackageManagementProject();
+			var action = new FakeInstallPackageAction(project);
+			actionsToRun.AddAction(action);
+			return action;
+		}
+		
+		[Test]
+		public void ProcessRecord_OnePackageActionToRun_PackageActionIsRun()
+		{
+			CreateCmdlet();
+			FakeInstallPackageAction action = AddInstallAction();
+			RunCmdlet();
+			
+			bool run = action.IsExecuteCalled;
+			
+			Assert.IsTrue(run);
+		}
+		
+		[Test]
+		public void ProcessRecord_TwoPackageActionsToRun_SecondPackageActionIsRun()
+		{
+			CreateCmdlet();
+			AddInstallAction();
+			FakeInstallPackageAction action = AddInstallAction();
+			RunCmdlet();
+			
+			bool run = action.IsExecuteCalled;
+			
+			Assert.IsTrue(run);
+		}
+		
+		[Test]
+		public void ProcessRecord_OnePackageActionToRun_PackageActionScriptRunnerIsCmdlet()
+		{
+			CreateCmdlet();
+			FakeInstallPackageAction action = AddInstallAction();
+			RunCmdlet();
+			
+			IPackageScriptRunner runner = action.PackageScriptRunner;
+			
+			Assert.AreEqual(cmdlet, runner);
+		}
+		
+		[Test]
+		public void ProcessRecord_TwoPackageActionsToRun_TwoPackageActionScriptRunnerIsCmdlet()
+		{
+			CreateCmdlet();
+			AddInstallAction();
+			FakeInstallPackageAction action = AddInstallAction();
+			RunCmdlet();
+			
+			IPackageScriptRunner runner = action.PackageScriptRunner;
+			
+			Assert.AreEqual(cmdlet, runner);
+		}
+		
+		[Test]
+		public void ProcessRecord_NoPackageActionsToRun_NullReferenceExceptionIsNotThrown()
+		{
+			CreateCmdlet();
+			Assert.DoesNotThrow(() => RunCmdlet());
+		}
+	}
+}

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

@@ -1,95 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.PackageManagement.Scripting;
-using NUnit.Framework;
-using PackageManagement.Cmdlets.Tests.Helpers;
-using PackageManagement.Tests.Helpers;
-
-namespace PackageManagement.Cmdlets.Tests
-{
-	[TestFixture]
-	public class InvokeRunPackageScriptsCmdletTests
-	{
-		TestableInvokeRunPackageScriptsCmdlet cmdlet;
-		FakeCmdletTerminatingError fakeTerminatingError;
-		PackageScriptsToRun scriptsToRun;
-		
-		void CreateCmdlet()
-		{
-			cmdlet = new TestableInvokeRunPackageScriptsCmdlet();
-			fakeTerminatingError = cmdlet.FakeCmdletTerminatingError;
-			scriptsToRun = cmdlet.ScriptsToBeRun;
-		}
-		
-		void RunCmdlet()
-		{
-			cmdlet.CallProcessRecord();
-		}
-		
-		FakePackageScript AddScript()
-		{
-			var script = new FakePackageScript();
-			scriptsToRun.AddScript(script);
-			return script;
-		}
-		
-		[Test]
-		public void ProcessRecord_OnePackageScriptToRun_PackageScriptIsRun()
-		{
-			CreateCmdlet();
-			FakePackageScript script = AddScript();
-			RunCmdlet();
-			
-			bool run = script.IsRun;
-			
-			Assert.IsTrue(run);
-		}
-		
-		[Test]
-		public void ProcessRecord_TwoPackageScriptsToRun_SecondPackageScriptIsRun()
-		{
-			CreateCmdlet();
-			AddScript();
-			FakePackageScript script = AddScript();
-			RunCmdlet();
-			
-			bool run = script.IsRun;
-			
-			Assert.IsTrue(run);
-		}
-		
-		[Test]
-		public void ProcessRecord_OnePackageScriptToRun_PackageScriptSessionIsCmdlet()
-		{
-			CreateCmdlet();
-			FakePackageScript script = AddScript();
-			RunCmdlet();
-			
-			IPackageScriptSession session = script.SessionPassedToRun;
-			
-			Assert.AreEqual(cmdlet, session);
-		}
-		
-		[Test]
-		public void ProcessRecord_TwoPackageScriptsToRun_TwoPackageScriptSessionIsCmdlet()
-		{
-			CreateCmdlet();
-			AddScript();
-			FakePackageScript script = AddScript();
-			RunCmdlet();
-			
-			IPackageScriptSession session = script.SessionPassedToRun;
-			
-			Assert.AreEqual(cmdlet, session);
-		}
-		
-		[Test]
-		public void ProcessRecord_NoPackageScriptsToRun_NullReferenceExceptionIsNotThrown()
-		{
-			CreateCmdlet();
-			Assert.DoesNotThrow(() => RunCmdlet());
-		}
-	}
-}

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

@@ -70,6 +70,7 @@
     <Compile Include="Src\AcceptLicensesEventArgs.cs" />
     <Compile Include="Src\AddPackageReferenceCommand.cs" />
     <Compile Include="Src\AggregateExceptionErrorMessage.cs" />
+    <Compile Include="Src\ConsolePackageActionRunner.cs" />
     <Compile Include="Src\Design\FakePackageManagementProject.cs" />
     <Compile Include="Src\EnvDTE\DirectoryProjectItem.cs" />
     <Compile Include="Src\EnvDTE\DirectoryProjectItems.cs" />
@@ -93,11 +94,16 @@
     <Compile Include="Src\EnvDTE\References.cs" />
     <Compile Include="Src\EnvDTE\Solution.cs" />
     <Compile Include="Src\IAddPackageReferenceView.cs" />
+    <Compile Include="Src\IPackageActionRunner.cs" />
     <Compile Include="Src\IPackageFromRepository.cs" />
     <Compile Include="Src\IPackageManagementEvents.cs" />
     <Compile Include="Src\IPackageManagementProject.cs" />
     <Compile Include="Src\IPackageManagementProjectFactory.cs" />
     <Compile Include="Src\IPackageManagementWorkbench.cs" />
+    <Compile Include="Src\PackageActionRunner.cs" />
+    <Compile Include="Src\PackageActionsToRun.cs" />
+    <Compile Include="Src\PackageFiles.cs" />
+    <Compile Include="Src\PackageFilesForOperations.cs" />
     <Compile Include="Src\PackageFromRepository.cs" />
     <Compile Include="Src\PackageManagementEvents.cs" />
     <Compile Include="Src\PackageManagementLogger.cs" />
@@ -109,6 +115,7 @@
     <Compile Include="Src\PackageOperationMessageLoggedEventArgs.cs" />
     <Compile Include="Src\PackageViewModelOperationLogger.cs" />
     <Compile Include="Src\ParentPackageOperationEventArgs.cs" />
+    <Compile Include="Src\ProcessPackageOperationsAction.cs" />
     <Compile Include="Src\ProjectBrowserRefresher.cs" />
     <Compile Include="Src\RegisteredPackageRepositories.cs" />
     <Compile Include="Src\AddPackageReferenceView.xaml.cs">
@@ -125,7 +132,7 @@
     <Compile Include="Src\Design\DesignTimePackagesViewModel.cs" />
     <Compile Include="Src\Design\FakeRegisteredPackageRepositories.cs" />
     <Compile Include="Src\Design\FakeFileSystem.cs" />
-    <Compile Include="Src\Design\FakeInstallPackageTask.cs" />
+    <Compile Include="Src\Design\FakeInstallPackageAction.cs" />
     <Compile Include="Src\Design\FakePackage.cs" />
     <Compile Include="Src\Design\FakePackageAssemblyReference.cs" />
     <Compile Include="Src\Design\FakePackageManagementProjectService.cs" />
@@ -197,13 +204,11 @@
     <Compile Include="Src\PackageManagementSolution.cs" />
     <Compile Include="Src\PackageManagementTask.cs" />
     <Compile Include="Src\PackageManagementTaskFactory.cs" />
-    <Compile Include="Src\Scripting\ConsolePackageScriptRunner.cs" />
     <Compile Include="Src\Scripting\IPackageScriptRunner.cs" />
     <Compile Include="Src\Scripting\ISolutionPackageRepository.cs" />
     <Compile Include="Src\Scripting\PackageInitializationScripts.cs" />
     <Compile Include="Src\Scripting\PackageInitializationScriptsConsole.cs" />
     <Compile Include="Src\Scripting\PackageInitializationScriptsFactory.cs" />
-    <Compile Include="Src\Scripting\PackageScriptsToRun.cs" />
     <Compile Include="Src\Scripting\PowerShellWorkingDirectory.cs" />
     <Compile Include="Src\Scripting\ResetPowerShellWorkingDirectoryOnSolutionClosed.cs" />
     <Compile Include="Src\SolutionPackageRepositoryPath.cs" />

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

@@ -22,7 +22,7 @@ namespace ICSharpCode.PackageManagement
 			IPackageManagementSolution solution,
 			IRegisteredPackageRepositories registeredPackageRepositories,
 			IPackageManagementEvents packageManagementEvents,
-			IPackageScriptRunner scriptRunner,
+			IPackageActionRunner actionRunner,
 			ILicenseAcceptanceService licenseAcceptanceService,
 			ITaskFactory taskFactory)
 		{
@@ -34,7 +34,7 @@ namespace ICSharpCode.PackageManagement
 			packageManagementEvents.PackageOperationsStarting += PackageOperationsStarting;
 			packageManagementEvents.AcceptLicenses += AcceptLicenses;
 			
-			var packageViewModelFactory = new PackageViewModelFactory(solution, packageManagementEvents, scriptRunner);
+			var packageViewModelFactory = new PackageViewModelFactory(solution, packageManagementEvents, actionRunner);
 			
 			AvailablePackagesViewModel = new AvailablePackagesViewModel(registeredPackageRepositories, packageViewModelFactory, taskFactory);
 			InstalledPackagesViewModel = new InstalledPackagesViewModel(solution, packageManagementEvents, registeredPackageRepositories, packageViewModelFactory, taskFactory);

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

@@ -0,0 +1,62 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement.Scripting;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class ConsolePackageActionRunner : IPackageActionRunner
+	{
+		IPackageManagementConsoleHost consoleHost;
+		PackageActionsToRun packageActionsToRun;
+		IPackageManagementWorkbench workbench;
+		
+		public ConsolePackageActionRunner(
+			IPackageManagementConsoleHost consoleHost,
+			PackageActionsToRun packageActionsToRun)
+			: this(consoleHost, packageActionsToRun, new PackageManagementWorkbench())
+		{
+		}
+		
+		public ConsolePackageActionRunner(
+			IPackageManagementConsoleHost consoleHost,
+			PackageActionsToRun packageActionsToRun,
+			IPackageManagementWorkbench workbench)
+		{
+			this.consoleHost = consoleHost;
+			this.packageActionsToRun = packageActionsToRun;
+			this.workbench = workbench;
+		}
+		
+		public void Run(ProcessPackageAction action)
+		{
+			CreateConsolePadIfConsoleHostIsNotRunning();
+			RunAction(action);
+		}
+		
+		void CreateConsolePadIfConsoleHostIsNotRunning()
+		{
+			if (!consoleHost.IsRunning) {
+				workbench.CreateConsolePad();
+			}
+		}
+		
+		void RunAction(ProcessPackageAction action)
+		{
+			AddNewActionToRun(action);
+			InvokeProcessPackageActionsCmdlet();
+		}
+		
+		void AddNewActionToRun(ProcessPackageAction action)
+		{
+			packageActionsToRun.AddAction(action);
+		}
+		
+		void InvokeProcessPackageActionsCmdlet()
+		{
+			string command = "Invoke-ProcessPackageActions";
+			consoleHost.ExecuteCommand(command);
+		}
+	}
+}

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

@@ -142,5 +142,12 @@ namespace ICSharpCode.PackageManagement.Design
 		}
 		
 		public bool HasDependencies { get; set; }
+		
+		public void AddFile(string fileName)
+		{
+			var file = new PhysicalPackageFile();
+			file.TargetPath = fileName;
+			FilesList.Add(file);
+		}
 	}
 }

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

@@ -0,0 +1,12 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.PackageManagement
+{
+	public interface IPackageActionRunner
+	{
+		void Run(ProcessPackageAction action);
+	}
+}

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

@@ -13,6 +13,6 @@ namespace ICSharpCode.PackageManagement
 		
 		IPackageManagementSolution Solution { get; }
 		IPackageManagementEvents PackageManagementEvents { get; }
-		IPackageScriptRunner PackageScriptRunner { get; }
+		IPackageActionRunner PackageActionRunner { get; }
 	}
 }

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

@@ -3,12 +3,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using ICSharpCode.SharpDevelop.Project;
 using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
-	public class InstallPackageAction : ProcessPackageAction
+	public class InstallPackageAction : ProcessPackageOperationsAction
 	{
 		public InstallPackageAction(
 			IPackageManagementProject project,
@@ -17,20 +18,11 @@ namespace ICSharpCode.PackageManagement
 		{
 		}
 		
-		public IEnumerable<PackageOperation> Operations { get; set; }
 		public bool IgnoreDependencies { get; set; }
 		
-		protected override void BeforeExecute()
+		protected override IEnumerable<PackageOperation> GetPackageOperations()
 		{
-			base.BeforeExecute();
+			return Project.GetInstallPackageOperations(Package, IgnoreDependencies);
-			GetPackageOperationsIfMissing();
-		}
-				
-		void GetPackageOperationsIfMissing()
-		{
-			if (Operations == null) {
-				Operations = Project.GetInstallPackageOperations(Package, IgnoreDependencies);
-			}
 		}
 		
 		protected override void ExecuteCore()

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

@@ -0,0 +1,26 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class PackageActionRunner : IPackageActionRunner
+	{
+		IPackageActionRunner consolePackageActionRunner;
+		
+		public PackageActionRunner(IPackageActionRunner consolePackageActionRunner)
+		{
+			this.consolePackageActionRunner = consolePackageActionRunner;
+		}
+		
+		public void Run(ProcessPackageAction action)
+		{
+			if (action.HasPackageScriptsToRun()) {
+				consolePackageActionRunner.Run(action);
+			} else {
+				action.Execute();
+			}
+		}
+	}
+}

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

@@ -0,0 +1,23 @@
+// 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.Concurrent;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class PackageActionsToRun
+	{
+		ConcurrentQueue<ProcessPackageAction> actions = new ConcurrentQueue<ProcessPackageAction>();
+		
+		public bool GetNextAction(out ProcessPackageAction action)
+		{
+			return actions.TryDequeue(out action);
+		}
+		
+		public void AddAction(ProcessPackageAction action)
+		{
+			actions.Enqueue(action);
+		}
+	}
+}

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

@@ -0,0 +1,83 @@
+// 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.IO;
+using System.Linq;
+
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class PackageFiles
+	{
+		IEnumerable<IPackageFile> files;
+		
+		public PackageFiles(IPackage package)
+			: this(package.GetFiles())
+		{
+		}
+		
+		public PackageFiles(IEnumerable<IPackageFile> files)
+		{
+			this.files = files;
+		}
+		
+		public bool HasAnyPackageScripts()
+		{
+			foreach (string fileName in GetFileNames()) {
+				if (IsPackageScriptFile(fileName)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		IEnumerable<string> GetFileNames()
+		{
+			foreach (IPackageFile file in files) {
+				string fileName = Path.GetFileName(file.Path);
+				yield return fileName;
+			}
+		}
+		
+		public bool HasUninstallPackageScript()
+		{
+			foreach (string fileName in GetFileNames()) {
+				if (IsPackageUninstallScriptFile(fileName)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		bool IsPackageScriptFile(string fileName)
+		{
+			return
+				IsPackageInitializationScriptFile(fileName) ||
+				IsPackageInstallScriptFile(fileName) ||
+				IsPackageUninstallScriptFile(fileName);
+		}
+		
+		bool IsPackageInitializationScriptFile(string fileName)
+		{
+			return IsCaseInsensitiveMatch(fileName, "init.ps1");
+		}
+		
+		bool IsPackageInstallScriptFile(string fileName)
+		{
+			return IsCaseInsensitiveMatch(fileName, "install.ps1");
+		}
+		
+		bool IsPackageUninstallScriptFile(string fileName)
+		{
+			return IsCaseInsensitiveMatch(fileName, "uninstall.ps1");
+		}
+		
+		bool IsCaseInsensitiveMatch(string a, string b)
+		{
+			return String.Equals(a, b, StringComparison.InvariantCultureIgnoreCase);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/PackageFilesForOperations.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 System.Collections.Generic;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class PackageFilesForOperations
+	{
+		IEnumerable<PackageOperation> operations;
+		
+		public PackageFilesForOperations(IEnumerable<PackageOperation> operations)
+		{
+			this.operations = operations;
+		}
+		
+		public bool HasAnyPackageScripts()
+		{
+			foreach (PackageFiles files in GetPackageFilesForEachOperation()) {
+				if (files.HasAnyPackageScripts()) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		IEnumerable<PackageFiles> GetPackageFilesForEachOperation()
+		{
+			foreach (PackageOperation operation in operations) {
+				yield return new PackageFiles(operation.Package);
+			}
+		}
+	}
+}

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

@@ -18,8 +18,8 @@ namespace ICSharpCode.PackageManagement
 		static readonly PackageManagementOutputMessagesView outputMessagesView;
 		static readonly RunPackageInitializationScriptsOnSolutionOpen runPackageInitializationScripts;
 		static readonly ResetPowerShellWorkingDirectoryOnSolutionClosed resetPowerShellWorkingDirectory;
-		static readonly PackageScriptsToRun packageScriptsToRun = new PackageScriptsToRun();
+		static readonly PackageActionsToRun packageActionsToRun = new PackageActionsToRun();
-		static readonly ConsolePackageScriptRunner consolePackageScriptRunner;
+		static readonly PackageActionRunner packageActionRunner;
 		
 		static PackageManagementServices()
 		{
@@ -31,7 +31,8 @@ namespace ICSharpCode.PackageManagement
 			projectBrowserRefresher = new ProjectBrowserRefresher(projectService, packageManagementEvents);
 			runPackageInitializationScripts = new RunPackageInitializationScriptsOnSolutionOpen(projectService);
 			resetPowerShellWorkingDirectory = new ResetPowerShellWorkingDirectoryOnSolutionClosed(projectService, consoleHost);
-			consolePackageScriptRunner = new ConsolePackageScriptRunner(consoleHost, packageScriptsToRun);
+			var consolePackageActionRunner = new ConsolePackageActionRunner(consoleHost, packageActionsToRun);
+			packageActionRunner = new PackageActionRunner(consolePackageActionRunner);
 		}
 		
 		public static PackageManagementOptions Options {
@@ -62,12 +63,12 @@ namespace ICSharpCode.PackageManagement
 			get { return projectService; }
 		}
 		
-		public static PackageScriptsToRun PackageScriptsToRun {
+		public static PackageActionsToRun PackageActionsToRun {
-			get { return packageScriptsToRun; }
+			get { return packageActionsToRun; }
 		}
 		
-		public static IPackageScriptRunner ConsolePackageScriptRunner {
+		public static IPackageActionRunner PackageActionRunner {
-			get { return consolePackageScriptRunner; }
+			get { return packageActionRunner; }
 		}
 	}
 }

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

@@ -32,7 +32,7 @@ namespace ICSharpCode.PackageManagement
 					solution,
 					registeredPackageRepositories,
 					PackageManagementServices.PackageManagementEvents,
-					PackageManagementServices.ConsolePackageScriptRunner,
+					PackageManagementServices.PackageActionRunner,
 					new LicenseAcceptanceService(),
 					new PackageManagementTaskFactory());
 		}

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

@@ -21,19 +21,19 @@ namespace ICSharpCode.PackageManagement
 		IPackageFromRepository package;
 		IEnumerable<PackageOperation> packageOperations = new PackageOperation[0];
 		PackageViewModelOperationLogger logger;
-		IPackageScriptRunner scriptRunner;
+		IPackageActionRunner actionRunner;
 		
 		public PackageViewModel(
 			IPackageFromRepository package,
 			IPackageManagementSolution solution,
 			IPackageManagementEvents packageManagementEvents,
-			IPackageScriptRunner scriptRunner,
+			IPackageActionRunner actionRunner,
 			ILogger logger)
 		{
 			this.package = package;
 			this.solution = solution;
 			this.packageManagementEvents = packageManagementEvents;
-			this.scriptRunner = scriptRunner;
+			this.actionRunner = actionRunner;
 			this.logger = CreateLogger(logger);
 			
 			CreateCommands();
@@ -233,16 +233,21 @@ namespace ICSharpCode.PackageManagement
 			OnPropertyChanged(model => model.IsAdded);
 		}
 		
-		protected virtual void InstallPackage(
+		void InstallPackage(
 			IPackageFromRepository package,
 			IEnumerable<PackageOperation> packageOperations)
 		{
 			IPackageManagementProject project = solution.GetActiveProject(package.Repository);
-			InstallPackageAction action = project.CreateInstallPackageAction();
+			ProcessPackageOperationsAction action = CreateInstallPackageAction(project);
 			action.Package = package;
 			action.Operations = packageOperations;
-			action.PackageScriptRunner = scriptRunner;
+			actionRunner.Run(action);
-			action.Execute();
+		}
+		
+		protected virtual ProcessPackageOperationsAction CreateInstallPackageAction(
+			IPackageManagementProject project)
+		{
+			return project.CreateInstallPackageAction();
 		}
 		
 		void ReportError(Exception ex)
@@ -271,8 +276,7 @@ namespace ICSharpCode.PackageManagement
 				IPackageManagementProject project = solution.GetActiveProject(package.Repository);
 				UninstallPackageAction action = project.CreateUninstallPackageAction();
 				action.Package = package;
-				action.PackageScriptRunner = scriptRunner;
+				actionRunner.Run(action);
-				action.Execute();
 			} catch (Exception ex) {
 				ReportError(ex);
 				logger.LogError(ex);

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

@@ -13,18 +13,18 @@ namespace ICSharpCode.PackageManagement
 			: this(
 				packageViewModelFactory.Solution,
 				packageViewModelFactory.PackageManagementEvents,
-				packageViewModelFactory.PackageScriptRunner)
+				packageViewModelFactory.PackageActionRunner)
 		{
 		}
 		
 		public PackageViewModelFactory(
 			IPackageManagementSolution solution,
 			IPackageManagementEvents packageManagementEvents,
-			IPackageScriptRunner scriptRunner)
+			IPackageActionRunner actionRunner)
 		{
 			this.Solution = solution;
 			this.PackageManagementEvents = packageManagementEvents;
-			this.PackageScriptRunner = scriptRunner;
+			this.PackageActionRunner = actionRunner;
 			this.Logger = new PackageManagementLogger(packageManagementEvents);
 		}
 		
@@ -34,13 +34,13 @@ namespace ICSharpCode.PackageManagement
 				package,
 				Solution,
 				PackageManagementEvents,
-				PackageScriptRunner,
+				PackageActionRunner,
 				Logger);
 		}
 		
 		public IPackageManagementSolution Solution { get; private set; }
 		public IPackageManagementEvents PackageManagementEvents { get; private set; }
 		public ILogger Logger { get; private set; }
-		public IPackageScriptRunner PackageScriptRunner { get; private set; }
+		public IPackageActionRunner PackageActionRunner { get; private set; }
 	}
 }

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

@@ -27,6 +27,11 @@ namespace ICSharpCode.PackageManagement
 		public string PackageId { get; set; }
 		public IPackageScriptRunner PackageScriptRunner { get; set; }
 		
+		public virtual bool HasPackageScriptsToRun()
+		{
+			return false;
+		}
+		
 		protected void OnParentPackageInstalled()
 		{
 			packageManagementEvents.OnParentPackageInstalled(Package);

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

@@ -0,0 +1,45 @@
+// 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 NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public abstract class ProcessPackageOperationsAction : ProcessPackageAction
+	{
+		public ProcessPackageOperationsAction(
+			IPackageManagementProject project,
+			IPackageManagementEvents packageManagementEvents)
+			: base(project, packageManagementEvents)
+		{
+		}
+		
+		public IEnumerable<PackageOperation> Operations { get; set; }
+
+		public override bool HasPackageScriptsToRun()
+		{
+			var files = new PackageFilesForOperations(Operations);
+			return files.HasAnyPackageScripts();
+		}
+		
+		protected override void BeforeExecute()
+		{
+			base.BeforeExecute();
+			GetPackageOperationsIfMissing();
+		}
+				
+		void GetPackageOperationsIfMissing()
+		{
+			if (Operations == null) {
+				Operations = GetPackageOperations();
+			}
+		}
+		
+		protected virtual IEnumerable<PackageOperation> GetPackageOperations()
+		{
+			return null;
+		}
+	}
+}

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

@@ -1,63 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-
-namespace ICSharpCode.PackageManagement.Scripting
-{
-	public class ConsolePackageScriptRunner : IPackageScriptRunner
-	{
-		IPackageManagementConsoleHost consoleHost;
-		PackageScriptsToRun packageScriptsToRun;
-		IPackageManagementWorkbench workbench;
-		
-		public ConsolePackageScriptRunner(
-			IPackageManagementConsoleHost consoleHost,
-			PackageScriptsToRun packageScriptsToRun)
-			: this( consoleHost, packageScriptsToRun, new PackageManagementWorkbench())
-		{
-		}
-		
-		public ConsolePackageScriptRunner(
-			IPackageManagementConsoleHost consoleHost,
-			PackageScriptsToRun packageScriptsToRun,
-			IPackageManagementWorkbench workbench)
-		{
-			this.consoleHost = consoleHost;
-			this.packageScriptsToRun = packageScriptsToRun;
-			this.workbench = workbench;
-		}
-		
-		public void Run(IPackageScript script)
-		{
-			if (script.Exists()) {
-				CreateConsolePadIfConsoleHostIsNotRunning();
-				RunScriptThatExists(script);
-			}
-		}
-		
-		void CreateConsolePadIfConsoleHostIsNotRunning()
-		{
-			if (!consoleHost.IsRunning) {
-				workbench.CreateConsolePad();
-			}
-		}
-		
-		void RunScriptThatExists(IPackageScript script)
-		{
-			AddNewScriptToRun(script);
-			InvokeRunPackageScriptsCmdlet();
-		}
-		
-		void AddNewScriptToRun(IPackageScript script)
-		{
-			packageScriptsToRun.AddScript(script);
-		}
-		
-		void InvokeRunPackageScriptsCmdlet()
-		{
-			string command = "Invoke-RunPackageScripts";
-			consoleHost.ExecuteCommand(command);
-		}
-	}
-}

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

@@ -1,32 +0,0 @@
-// 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.Concurrent;
-
-namespace ICSharpCode.PackageManagement.Scripting
-{
-	public class PackageScriptsToRun
-	{
-		ConcurrentQueue<IPackageScript> scripts = new ConcurrentQueue<IPackageScript>();
-		
-		public IPackageScript GetNextScript()
-		{
-			IPackageScript script = null;
-			if (GetNextScript(out script)) {
-				return script;
-			}
-			return null;
-		}
-		
-		public bool GetNextScript(out IPackageScript script)
-		{
-			return scripts.TryDequeue(out script);
-		}
-		
-		public void AddScript(IPackageScript script)
-		{
-			scripts.Enqueue(script);
-		}
-	}
-}

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

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.IO;
 using ICSharpCode.SharpDevelop.Project;
 using NuGet;
 
@@ -29,5 +30,11 @@ namespace ICSharpCode.PackageManagement
 			Project.UninstallPackage(Package, ForceRemove, RemoveDependencies);
 			OnParentPackageUninstalled();
 		}
+		
+		public override bool HasPackageScriptsToRun()
+		{
+			var files = new PackageFiles(Package);
+			return files.HasUninstallPackageScript();
+		}
 	}
 }

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

@@ -7,7 +7,7 @@ using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
-	public class UpdatePackageAction : ProcessPackageAction
+	public class UpdatePackageAction : ProcessPackageOperationsAction
 	{
 		public UpdatePackageAction(
 			IPackageManagementProject project,
@@ -17,20 +17,11 @@ namespace ICSharpCode.PackageManagement
 			UpdateDependencies = true;
 		}
 		
-		public IEnumerable<PackageOperation> Operations { get; set; }
 		public bool UpdateDependencies { get; set; }
 		
-		protected override void BeforeExecute()
+		protected override IEnumerable<PackageOperation> GetPackageOperations()
 		{
-			base.BeforeExecute();
+			return Project.GetInstallPackageOperations(Package, !UpdateDependencies);
-			GetPackageOperationsIfMissing();
-		}
-				
-		void GetPackageOperationsIfMissing()
-		{
-			if (Operations == null) {
-				Operations = Project.GetInstallPackageOperations(Package, !UpdateDependencies);
-			}
 		}
 		
 		protected override void ExecuteCore()

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

@@ -10,31 +10,20 @@ namespace ICSharpCode.PackageManagement
 {
 	public class UpdatedPackageViewModel : PackageViewModel
 	{
-		IPackageManagementSolution solution;
-		IPackageScriptRunner scriptRunner;
-		
 		public UpdatedPackageViewModel(
 			IPackageFromRepository package,
 			IPackageManagementSolution solution,
 			IPackageManagementEvents packageManagementEvents,
-			IPackageScriptRunner scriptRunner,
+			IPackageActionRunner actionRunner,
 			ILogger logger)
-			: base(package, solution, packageManagementEvents, scriptRunner, logger)
+			: base(package, solution, packageManagementEvents, actionRunner, logger)
 		{
-			this.solution = solution;
-			this.scriptRunner = scriptRunner;
 		}
 		
-		protected override void InstallPackage(
+		protected override ProcessPackageOperationsAction CreateInstallPackageAction(
-			IPackageFromRepository package,
+			IPackageManagementProject project)
-			IEnumerable<PackageOperation> packageOperations)
 		{
-			IPackageManagementProject project = solution.GetActiveProject(package.Repository);
+			return project.CreateUpdatePackageAction();
-			UpdatePackageAction action = project.CreateUpdatePackageAction();
-			action.Package = package;
-			action.Operations = packageOperations;
-			action.PackageScriptRunner = scriptRunner;
-			action.Execute();
 		}
 	}
 }

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

@@ -19,7 +19,7 @@ namespace ICSharpCode.PackageManagement
 				package,
 				Solution,
 				PackageManagementEvents,
-				PackageScriptRunner,
+				PackageActionRunner,
 				Logger);
 		}
 	}

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

@@ -70,6 +70,7 @@
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Src\AddPackageReferenceCommandTests.cs" />
+    <Compile Include="Src\ConsolePackageActionRunnerTests.cs" />
     <Compile Include="Src\EnvDTE\DTETests.cs" />
     <Compile Include="Src\EnvDTE\ItemOperationsTests.cs" />
     <Compile Include="Src\EnvDTE\ProjectItemPropertyTests.cs" />
@@ -83,6 +84,7 @@
     <Compile Include="Src\Helpers\ExceptionThrowingRegisteredPackageRepositories.cs" />
     <Compile Include="Src\Helpers\FakeAddPackageReferenceView.cs" />
     <Compile Include="Src\Helpers\FakeLogger.cs" />
+    <Compile Include="Src\Helpers\FakePackageActionRunner.cs" />
     <Compile Include="Src\Helpers\FakePackageInitializationScriptsInSolution.cs" />
     <Compile Include="Src\Helpers\FakePackageInitializationScriptsInSolutionFactory.cs" />
     <Compile Include="Src\Helpers\FakePackageManagementEvents.cs" />
@@ -100,6 +102,9 @@
     <Compile Include="Src\Helpers\ProjectItemCollectionAssert.cs" />
     <Compile Include="Src\Helpers\TestableAddPackageReferenceCommand.cs" />
     <Compile Include="Src\Helpers\TestableDTEProject.cs" />
+    <Compile Include="Src\PackageActionRunnerTests.cs" />
+    <Compile Include="Src\PackageActionsToRunTests.cs" />
+    <Compile Include="Src\PackageFilesTests.cs" />
     <Compile Include="Src\PackageFromRepositoryTests.cs" />
     <Compile Include="Src\PackageManagementEventsTests.cs" />
     <Compile Include="Src\PackageManagementLoggerTests.cs" />
@@ -177,10 +182,8 @@
     <Compile Include="Src\PackageManagementOutputMessagesViewTests.cs" />
     <Compile Include="Src\PackageManagementSolutionTests.cs" />
     <Compile Include="Src\PackageRepositoryCacheTests.cs" />
-    <Compile Include="Src\Scripting\ConsolePackageScriptRunnerTests.cs" />
     <Compile Include="Src\Scripting\PackageInitializationScriptsConsoleTests.cs" />
     <Compile Include="Src\Scripting\PackageInitializationScriptsTests.cs" />
-    <Compile Include="Src\Scripting\PackageScriptsToRunTests.cs" />
     <Compile Include="Src\Scripting\PowerShellWorkingDirectoryTests.cs" />
     <Compile Include="Src\Scripting\ResetPowerShellWorkingDirectoryOnSolutionClosedTests.cs" />
     <Compile Include="Src\SolutionPackageRepositoryPathTests.cs" />

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

@@ -22,7 +22,7 @@ namespace PackageManagement.Tests
 		FakeRegisteredPackageRepositories fakeRegisteredPackageRepositories;
 		FakeTaskFactory taskFactory;
 		List<FakePackage> packagesPassedToOnAcceptLicenses;
-		FakePackageScriptRunner fakeScriptRunner;
+		FakePackageActionRunner fakeActionRunner;
 		
 		void CreateSolution()
 		{
@@ -41,12 +41,12 @@ namespace PackageManagement.Tests
 			taskFactory = new FakeTaskFactory();
 			packageManagementEvents = new PackageManagementEvents();
 			fakeLicenseAcceptanceSevice = new FakeLicenseAcceptanceService();
-			fakeScriptRunner = new FakePackageScriptRunner();
+			fakeActionRunner = new FakePackageActionRunner();
 			viewModel = new AddPackageReferenceViewModel(
 				solution,
 				fakeRegisteredPackageRepositories,
 				packageManagementEvents,
-				fakeScriptRunner,
+				fakeActionRunner,
 				fakeLicenseAcceptanceSevice,
 				taskFactory);
 			taskFactory.ExecuteAllFakeTasks();

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

@@ -0,0 +1,126 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using ICSharpCode.Scripting.Tests.Utils;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class ConsolePackageActionRunnerTests
+	{
+		ConsolePackageActionRunner runner;
+		PackageActionsToRun actionsToRun;
+		FakePackageManagementConsoleHost fakeConsoleHost;
+		FakeScriptingConsole fakeScriptingConsole;
+		FakePackageManagementWorkbench fakeWorkbench;
+		
+		void CreateRunner()
+		{
+			actionsToRun = new PackageActionsToRun();
+			fakeConsoleHost = new FakePackageManagementConsoleHost();
+			fakeScriptingConsole = new FakeScriptingConsole();
+			fakeConsoleHost.ScriptingConsole = fakeScriptingConsole;
+			fakeWorkbench = new FakePackageManagementWorkbench();
+			runner = new ConsolePackageActionRunner(fakeConsoleHost, actionsToRun, fakeWorkbench);
+		}
+		
+		FakeInstallPackageAction CreateInstallAction()
+		{
+			var project = new FakePackageManagementProject();
+			var action = new FakeInstallPackageAction(project);
+			action.Operations = new PackageOperation[0];
+			return action;
+		}
+		
+		FakeInstallPackageAction RunInstallActionWithNoOperations()
+		{
+			FakeInstallPackageAction action = CreateInstallAction();
+			runner.Run(action);
+			return action;
+		}
+		
+		FakeInstallPackageAction RunInstallActionWithOneOperation()
+		{
+			var operations = new PackageOperation[] {
+				new PackageOperation(new FakePackage(), PackageAction.Install)
+			};
+			FakeInstallPackageAction action = CreateInstallAction();			
+			action.Operations = operations;
+			runner.Run(action);
+			return action;
+		}
+		
+		void ConsoleHostIsRunning()
+		{
+			fakeConsoleHost.IsRunning = true;
+		}
+		
+		void ConsoleHostIsNotRunning()
+		{
+			fakeConsoleHost.IsRunning = false;
+		}
+		
+		ProcessPackageAction GetNextActionToRun()
+		{
+			ProcessPackageAction action = null;
+			actionsToRun.GetNextAction(out action);
+			return action;
+		}
+		
+		[Test]
+		public void Run_ConsoleHostIsRunning_ActionAddedToPackageActionsToBeRun()
+		{
+			CreateRunner();
+			ConsoleHostIsRunning();
+			FakeInstallPackageAction expectedAction = RunInstallActionWithOneOperation();
+			
+			ProcessPackageAction actionAdded = GetNextActionToRun();
+			
+			Assert.AreEqual(expectedAction, actionAdded);
+		}
+		
+		[Test]
+		public void Run_ConsoleHostIsRunning_CommandPassedToConsoleHostToProcessPackageActions()
+		{
+			CreateRunner();
+			ConsoleHostIsRunning();
+			RunInstallActionWithOneOperation();
+			
+			string command = fakeConsoleHost.FirstCommandExecuted;
+			string expectedCommand = "Invoke-ProcessPackageActions";
+			
+			Assert.AreEqual(expectedCommand, command);
+		}
+		
+		[Test]
+		public void Run_ConsoleHostIsNotRunning_ConsolePadIsCreated()
+		{
+			CreateRunner();
+			ConsoleHostIsNotRunning();
+			RunInstallActionWithOneOperation();
+			
+			bool created = fakeWorkbench.IsCreateConsolePadCalled;
+			
+			Assert.IsTrue(created);
+		}
+		
+		[Test]
+		public void Run_ConsoleHostIsRunning_ConsolePadIsNotCreated()
+		{
+			CreateRunner();
+			ConsoleHostIsRunning();
+			RunInstallActionWithOneOperation();
+			
+			bool created = fakeWorkbench.IsCreateConsolePadCalled;
+			
+			Assert.IsFalse(created);
+		}
+	}
+}

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

@@ -0,0 +1,18 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FakePackageActionRunner : IPackageActionRunner
+	{
+		public ProcessPackageAction ActionPassedToRun;
+		
+		public void Run(ProcessPackageAction action)
+		{
+			ActionPassedToRun = action;
+		}
+	}
+}

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

@@ -14,7 +14,7 @@ namespace PackageManagement.Tests.Helpers
 		public FakePackageManagementSolution FakeSolution = new FakePackageManagementSolution();
 		public FakePackageManagementEvents FakePackageManagementEvents = new FakePackageManagementEvents();
 		public FakeLogger FakeLogger = new FakeLogger();
-		public FakePackageScriptRunner FakeScriptRunner = new FakePackageScriptRunner();
+		public FakePackageActionRunner FakeActionRunner = new FakePackageActionRunner();
 		
 		public PackageViewModel CreatePackageViewModel(IPackageFromRepository package)
 		{
@@ -22,7 +22,7 @@ namespace PackageManagement.Tests.Helpers
 				package,
 				FakeSolution,
 				FakePackageManagementEvents,
-				FakeScriptRunner,
+				FakeActionRunner,
 				FakeLogger);
 		}
 		
@@ -34,8 +34,8 @@ namespace PackageManagement.Tests.Helpers
 			get { return FakePackageManagementEvents; }
 		}
 		
-		public IPackageScriptRunner PackageScriptRunner {
+		public IPackageActionRunner PackageActionRunner {
-			get { return FakeScriptRunner; }
+			get { return FakeActionRunner; }
 		}
 	}
 }

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

@@ -14,14 +14,14 @@ namespace PackageManagement.Tests.Helpers
 		public FakePackageManagementEvents FakePackageManagementEvents;
 		public FakePackage FakePackage;
 		public FakeLogger FakeLogger;
-		public FakePackageScriptRunner FakeScriptRunner;
+		public FakePackageActionRunner FakeActionRunner;
 		
 		public TestablePackageViewModel(FakePackageManagementSolution solution)
 			: this(
 				new FakePackage(),
 				solution,
 				new FakePackageManagementEvents(),
-				new FakePackageScriptRunner(),
+				new FakePackageActionRunner(),
 				new FakeLogger())
 		{
 		}
@@ -30,19 +30,19 @@ namespace PackageManagement.Tests.Helpers
 			FakePackage package,
 			FakePackageManagementSolution solution,
 			FakePackageManagementEvents packageManagementEvents,
-			FakePackageScriptRunner scriptRunner,
+			FakePackageActionRunner actionRunner,
 			FakeLogger logger)
 			: base(
 				package,
 				solution,
 				packageManagementEvents,
-				scriptRunner,
+				actionRunner,
 				logger)
 		{
 			this.FakePackage = package;
 			this.FakeSolution = solution;
 			this.FakePackageManagementEvents = packageManagementEvents;
-			this.FakeScriptRunner = scriptRunner;
+			this.FakeActionRunner = actionRunner;
 			this.FakeLogger = logger;
 		}
 		

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

@@ -16,7 +16,7 @@ namespace PackageManagement.Tests.Helpers
 		public FakePackage FakePackage;
 		public FakeLogger FakeLogger;
 		public ILogger LoggerUsedWhenCreatingPackageResolver;
-		public FakePackageScriptRunner FakeScriptRunner;
+		public FakePackageActionRunner FakeActionRunner;
 		
 		public TestableUpdatedPackageViewModel()
 			: this(new FakePackageManagementSolution())
@@ -28,7 +28,7 @@ namespace PackageManagement.Tests.Helpers
 				new FakePackage(),
 				solution,
 				new FakePackageManagementEvents(),
-				new FakePackageScriptRunner(),
+				new FakePackageActionRunner(),
 				new FakeLogger())
 		{		
 		}
@@ -37,18 +37,18 @@ namespace PackageManagement.Tests.Helpers
 			FakePackage package,
 			FakePackageManagementSolution solution,
 			FakePackageManagementEvents packageManagementEvents,
-			FakePackageScriptRunner scriptRunner,
+			FakePackageActionRunner actionRunner,
 			FakeLogger logger)
 			: base(
 				package,
 				solution,
 				packageManagementEvents,
-				scriptRunner,
+				actionRunner,
 				logger)
 		{
 			this.FakePackage = package;
 			this.FakeSolution = solution;
-			this.FakeScriptRunner = scriptRunner;
+			this.FakeActionRunner = actionRunner;
 			this.FakeLogger = logger;
 		}
 	}

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

@@ -32,6 +32,18 @@ namespace PackageManagement.Tests
 			return fakeProject.FakeSourceRepository.AddFakePackage(packageId);
 		}
 		
+		void AddInstallOperationWithFile(string fileName)
+		{
+			var package = new FakePackage();
+			package.AddFile(fileName);
+			
+			var operation = new PackageOperation(package, PackageAction.Install);
+			var operations = new List<PackageOperation>();
+			operations.Add(operation);
+			
+			action.Operations = operations;
+		}
+		
 		[Test]
 		public void Execute_PackageIsSet_InstallsPackageIntoProject()
 		{
@@ -173,5 +185,60 @@ namespace PackageManagement.Tests
 			
 			Assert.AreEqual(package, actualPackage);
 		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasInitPowerShellScript_ReturnsTrue()
+		{
+			CreateAction();
+			AddInstallOperationWithFile(@"tools\init.ps1");
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(hasPackageScripts);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasNoFiles_ReturnsFalse()
+		{
+			CreateAction();
+			action.Operations = new List<PackageOperation>();
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsFalse(hasPackageScripts);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasInitPowerShellScriptInUpperCase_ReturnsTrue()
+		{
+			CreateAction();
+			AddInstallOperationWithFile(@"tools\INIT.PS1");
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(hasPackageScripts);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasInstallPowerShellScriptInUpperCase_ReturnsTrue()
+		{
+			CreateAction();
+			AddInstallOperationWithFile(@"tools\INSTALL.PS1");
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(hasPackageScripts);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasUninstallPowerShellScriptInUpperCase_ReturnsTrue()
+		{
+			CreateAction();
+			AddInstallOperationWithFile(@"tools\UNINSTALL.PS1");
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(hasPackageScripts);
+		}
 	}
 }

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

@@ -0,0 +1,89 @@
+// 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.Design;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class PackageActionRunnerTests
+	{
+		FakePackageActionRunner fakeConsoleActionRunner;
+		PackageActionRunner runner;
+		FakeInstallPackageAction fakeAction;
+		
+		void CreateRunner()
+		{
+			fakeConsoleActionRunner = new FakePackageActionRunner();
+			runner = new PackageActionRunner(fakeConsoleActionRunner);	
+		}
+		
+		void CreateInstallActionWithNoPowerShellScripts()
+		{
+			var fakeProject = new FakePackageManagementProject();
+			fakeAction = new FakeInstallPackageAction(fakeProject);
+			fakeAction.Operations = new PackageOperation[0];
+		}
+		
+		void CreateInstallActionWithOnePowerShellScript()
+		{
+			CreateInstallActionWithNoPowerShellScripts();
+			
+			var package = new FakePackage();
+			package.AddFile(@"tools\init.ps1");
+			
+			var operation = new PackageOperation(package, PackageAction.Install);
+			var operations = new List<PackageOperation>();
+			operations.Add(operation);
+			
+			fakeAction.Operations = operations;
+		}
+		
+		void Run()
+		{
+			runner.Run(fakeAction);
+		}
+		
+		[Test]
+		public void Run_InstallActionHasNoPowerShellScripts_ActionIsExecutedDirectly()
+		{
+			CreateRunner();
+			CreateInstallActionWithNoPowerShellScripts();
+			Run();
+			
+			bool executed = fakeAction.IsExecuteCalled;
+			
+			Assert.IsTrue(executed);
+		}
+		
+		[Test]
+		public void Run_InstallActionHasOnePowerShellScript_ActionIsPassedToConsoleToRun()
+		{
+			CreateRunner();
+			CreateInstallActionWithOnePowerShellScript();
+			Run();
+			
+			ProcessPackageAction action = fakeConsoleActionRunner.ActionPassedToRun;
+			
+			Assert.AreEqual(fakeAction, action);
+		}
+		
+		[Test]
+		public void Run_InstallActionHasOnePowerShellScript_ActionIsNotExecutedDirectly()
+		{
+			CreateRunner();
+			CreateInstallActionWithOnePowerShellScript();
+			Run();
+			
+			bool executed = fakeAction.IsExecuteCalled;
+			
+			Assert.IsFalse(executed);
+		}
+	}
+}

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

@@ -0,0 +1,117 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class PackageActionsToRunTests
+	{
+		PackageActionsToRun actions;
+		
+		void CreateActions()
+		{
+			actions = new PackageActionsToRun();
+		}
+		
+		InstallPackageAction AddAction()
+		{
+			var project = new FakePackageManagementProject();
+			var events = new FakePackageManagementEvents();
+			var action = new InstallPackageAction(project, events);
+			actions.AddAction(action);
+			return action;
+		}
+		
+		[Test]
+		public void GetNextAction_NewInstance_ReturnsFalse()
+		{
+			CreateActions();
+			ProcessPackageAction action = null;
+			bool result = actions.GetNextAction(out action);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void GetNextAction_OneActionAdded_ReturnsActionInOutParameter()
+		{
+			CreateActions();
+			ProcessPackageAction expectedAction = AddAction();
+			
+			ProcessPackageAction action = null;
+			actions.GetNextAction(out action);
+			
+			Assert.AreEqual(expectedAction, action);
+		}
+		
+		[Test]
+		public void GetNextAction_OneActionAdded_ReturnsTrue()
+		{
+			CreateActions();
+			ProcessPackageAction expectedAction = AddAction();
+			
+			ProcessPackageAction action = null;
+			bool result = actions.GetNextAction(out action);
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsNullActionInOutParameterOnSecondCall()
+		{
+			CreateActions();
+			ProcessPackageAction expectedAction = AddAction();
+			ProcessPackageAction action = null;
+			actions.GetNextAction(out action);
+			actions.GetNextAction(out action);
+			
+			Assert.IsNull(action);
+		}
+		
+		[Test]
+		public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsFalseOnSecondCall()
+		{
+			CreateActions();
+			ProcessPackageAction expectedAction = AddAction();
+			
+			ProcessPackageAction action = null;
+			actions.GetNextAction(out action);
+			bool result = actions.GetNextAction(out action);
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void GetNextAction_CalledTwiceWithTwoActionsAdded_ReturnsSecondActionAddedInOutParameter()
+		{
+			CreateActions();
+			AddAction();
+			ProcessPackageAction expectedAction = AddAction();
+			ProcessPackageAction action = null;
+			actions.GetNextAction(out action);
+			actions.GetNextAction(out action);
+			
+			Assert.AreEqual(expectedAction, action);
+		}
+		
+		[Test]
+		public void GetNextAction_CalledTwiceWithTwoActionsAdded_ReturnsTrueOnSecondCall()
+		{
+			CreateActions();
+			AddAction();
+			ProcessPackageAction expectedAction = AddAction();
+			ProcessPackageAction action = null;
+			actions.GetNextAction(out action);
+			bool result = actions.GetNextAction(out action);
+			
+			Assert.IsTrue(result);
+		}
+	}
+}

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

@@ -0,0 +1,148 @@
+// 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.Design;
+using NuGet;
+using NUnit.Framework;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class PackageFilesTests
+	{
+		PackageFiles packageFiles;
+		
+		void CreatePackageFiles(FakePackage package)
+		{
+			packageFiles = new PackageFiles(package);
+		}
+		
+		void CreatePackageFilesWithOneFile(string fileName)
+		{
+			var package = new FakePackage();
+			package.AddFile(fileName);
+			CreatePackageFiles(package);
+		}
+		
+		void CreatePackageFilesWithTwoFiles(string fileName1, string fileName2)
+		{
+			var package = new FakePackage();
+			package.AddFile(fileName1);
+			package.AddFile(fileName2);
+			CreatePackageFiles(package);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOnePowerShellInitScript_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"tools\init.ps1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOneCSharpFile_ReturnsFalse()
+		{
+			CreatePackageFilesWithOneFile(@"src\test.cs");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsFalse(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOnePowerShellInitScriptWithDifferentParentFolder_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"parentfolder\init.ps1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOnePowerShellInitScriptInUpperCase_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"tools\INIT.PS1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOnePowerShellInstallScript_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"tools\install.ps1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOnePowerShellInstallScriptInUpperCase_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"tools\INSTALL.PS1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOnePowerShellUninstallScript_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"tools\uninstall.ps1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_HasOnePowerShellUninstallScriptInUpperCase_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"tools\UNINSTALL.PS1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasAnyPackageScripts_SecondFileIsPowerShellInitScript_ReturnsTrue()
+		{
+			CreatePackageFilesWithTwoFiles(@"src\test.cs", @"tools\init.ps1");
+			
+			bool hasScripts = packageFiles.HasAnyPackageScripts();
+			
+			Assert.IsTrue(hasScripts);
+		}
+		
+		[Test]
+		public void HasUninstallPackageScript_HasOnePowerShellUninstallScript_ReturnsTrue()
+		{
+			CreatePackageFilesWithOneFile(@"tools\uninstall.ps1");
+			
+			bool hasScript = packageFiles.HasUninstallPackageScript();
+			
+			Assert.IsTrue(hasScript);
+		}
+		
+		[Test]
+		public void HasUninstallPackageScript_HasOneCSharpFile_ReturnsFalse()
+		{
+			CreatePackageFilesWithOneFile(@"tools\test.cs");
+			
+			bool hasScript = packageFiles.HasUninstallPackageScript();
+			
+			Assert.IsFalse(hasScript);
+		}
+	}
+}

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

@@ -23,7 +23,7 @@ namespace PackageManagement.Tests
 		FakeInstallPackageAction fakeInstallPackageAction;
 		FakeUninstallPackageAction fakeUninstallPackageAction;
 		FakeLogger fakeLogger;
-		FakePackageScriptRunner fakeScriptRunner;
+		FakePackageActionRunner fakeActionRunner;
 		
 		void CreateViewModel()
 		{
@@ -53,7 +53,7 @@ namespace PackageManagement.Tests
 			fakeLogger = viewModel.FakeLogger;
 			fakeInstallPackageAction = solution.FakeProject.FakeInstallPackageAction;
 			fakeUninstallPackageAction = solution.FakeProject.FakeUninstallPackageAction;
-			fakeScriptRunner = viewModel.FakeScriptRunner;
+			fakeActionRunner = viewModel.FakeActionRunner;
 		}
 
 		[Test]
@@ -86,7 +86,9 @@ namespace PackageManagement.Tests
 			
 			viewModel.AddPackage();
 			
-			Assert.IsTrue(fakeInstallPackageAction.IsExecuteCalled);
+			ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
+			
+			Assert.AreEqual(fakeInstallPackageAction, actionExecuted);
 		}
 		
 		[Test]
@@ -571,19 +573,6 @@ namespace PackageManagement.Tests
 			Assert.AreEqual(expectedPackage, actualPackage);
 		}
 		
-		[Test]
-		public void AddPackage_PackagesInstalledSuccessfully_ScriptRunnerUsedWhenInstallingPackage()
-		{
-			CreateViewModel();
-			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
-			viewModel.AddPackage();
-			
-			IPackageScriptRunner scriptRunner = fakeInstallPackageAction.PackageScriptRunner;
-			FakePackageScriptRunner expectedScriptRunner = fakeScriptRunner;
-			
-			Assert.AreEqual(expectedScriptRunner, scriptRunner);
-		}
-		
 		[Test]
 		public void AddPackage_PackagesInstalledSuccessfully_PackageDependenciesNotIgnoredWhenCheckingForPackageOperations()
 		{
@@ -605,20 +594,9 @@ namespace PackageManagement.Tests
 			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.RemovePackage();
 			
-			Assert.IsTrue(fakeUninstallPackageAction.IsExecuted);
+			ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
-		}
-		
-		[Test]
-		public void RemovePackage_PackageRemovedSuccessfully_PackageScriptRunnerIsUsedWhenUninstalling()
-		{
-			CreateViewModel();
-			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
-			viewModel.RemovePackage();
-			
-			IPackageScriptRunner scriptRunner = fakeUninstallPackageAction.PackageScriptRunner;
-			FakePackageScriptRunner expectedScriptRunner = fakeScriptRunner;
 			
-			Assert.AreEqual(expectedScriptRunner, scriptRunner);
+			Assert.AreEqual(fakeUninstallPackageAction, actionExecuted);
 		}
 	}
 }

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

@@ -1,152 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.PackageManagement.Scripting;
-using ICSharpCode.Scripting.Tests.Utils;
-using NUnit.Framework;
-using PackageManagement.Tests.Helpers;
-
-namespace PackageManagement.Tests.Scripting
-{
-	[TestFixture]
-	public class ConsolePackageScriptRunnerTests
-	{
-		ConsolePackageScriptRunner runner;
-		PackageScriptsToRun packageScriptsToRun;
-		FakePackageManagementConsoleHost fakeConsoleHost;
-		FakeScriptingConsole fakeScriptingConsole;
-		FakePackageManagementWorkbench fakeWorkbench;
-		
-		void CreateRunner()
-		{
-			packageScriptsToRun = new PackageScriptsToRun();
-			fakeConsoleHost = new FakePackageManagementConsoleHost();
-			fakeScriptingConsole = new FakeScriptingConsole();
-			fakeConsoleHost.ScriptingConsole = fakeScriptingConsole;
-			fakeWorkbench = new FakePackageManagementWorkbench();
-			runner = new ConsolePackageScriptRunner(fakeConsoleHost, packageScriptsToRun, fakeWorkbench);
-		}
-		
-		FakePackageScript RunScriptThatExists()
-		{
-			var script = new FakePackageScript();
-			script.ExistsReturnValue = true;
-			return RunScript(script);
-		}
-		
-		FakePackageScript RunScriptThatDoesNotExist()
-		{
-			var script = new FakePackageScript();
-			script.ExistsReturnValue = false;
-			return RunScript(script);
-		}
-		
-		FakePackageScript RunScript(FakePackageScript script)
-		{
-			runner.Run(script);
-			return script;
-		}
-		
-		void ConsoleHostIsRunning()
-		{
-			fakeConsoleHost.IsRunning = true;
-		}
-		
-		void ConsoleHostIsNotRunning()
-		{
-			fakeConsoleHost.IsRunning = false;
-		}
-		
-		IPackageScript GetNextScriptToBeRun()
-		{
-			return packageScriptsToRun.GetNextScript();
-		}
-		
-		[Test]
-		public void Run_ConsoleHostIsRunningAndScriptExists_ScriptAddedToPackageScriptsToBeRun()
-		{
-			CreateRunner();
-			ConsoleHostIsRunning();
-			FakePackageScript expectedScript = RunScriptThatExists();
-			
-			IPackageScript scriptAdded = GetNextScriptToBeRun();
-			
-			Assert.AreEqual(expectedScript, scriptAdded);
-		}
-		
-		[Test]
-		public void Run_ConsoleHostIsRunningAndScriptDoesNotExist_ScriptIsNotAddedToPackageScriptsToBeRun()
-		{
-			CreateRunner();
-			ConsoleHostIsRunning();
-			FakePackageScript script = RunScriptThatDoesNotExist();
-			script.ExistsReturnValue = false;
-			
-			IPackageScript scriptAdded = GetNextScriptToBeRun();
-			
-			Assert.IsNull(scriptAdded);
-		}
-		
-		[Test]
-		public void Run_ConsoleHostIsRunningAndScriptExists_CommandPassedToConsoleHostToRunPackageScripts()
-		{
-			CreateRunner();
-			ConsoleHostIsRunning();
-			RunScriptThatExists();
-			
-			string command = fakeConsoleHost.FirstCommandExecuted;
-			string expectedCommand = "Invoke-RunPackageScripts";
-			
-			Assert.AreEqual(expectedCommand, command);
-		}
-		
-		[Test]
-		public void Run_ConsoleHostIsRunningAndScriptDoesNotExist_CommandIsNotPassedToConsoleHostToRunPackageScripts()
-		{
-			CreateRunner();
-			ConsoleHostIsRunning();
-			RunScriptThatDoesNotExist();
-			
-			int count = fakeConsoleHost.CommandsExecuted.Count;
-			
-			Assert.AreEqual(0, count);
-		}
-		
-		[Test]
-		public void Run_ConsoleHostIsNotRunningAndScriptExists_ConsolePadIsCreated()
-		{
-			CreateRunner();
-			ConsoleHostIsNotRunning();
-			RunScriptThatExists();
-			
-			bool created = fakeWorkbench.IsCreateConsolePadCalled;
-			
-			Assert.IsTrue(created);
-		}
-		
-		[Test]
-		public void Run_ConsoleHostIsNotRunningAndScriptDoesNotExist_ConsolePadIsNotCreated()
-		{
-			CreateRunner();
-			ConsoleHostIsNotRunning();
-			RunScriptThatDoesNotExist();
-			
-			bool created = fakeWorkbench.IsCreateConsolePadCalled;
-			
-			Assert.IsFalse(created);
-		}
-		
-		[Test]
-		public void Run_ConsoleHostIsRunningAndScriptExists_ConsolePadIsNotCreated()
-		{
-			CreateRunner();
-			ConsoleHostIsRunning();
-			RunScriptThatExists();
-			
-			bool created = fakeWorkbench.IsCreateConsolePadCalled;
-			
-			Assert.IsFalse(created);
-		}
-	}
-}

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

@@ -1,156 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.PackageManagement.Scripting;
-using NUnit.Framework;
-using PackageManagement.Tests.Helpers;
-
-namespace PackageManagement.Tests.Scripting
-{
-	[TestFixture]
-	public class PackageScriptsToRunTests
-	{
-		PackageScriptsToRun scriptsToRun;
-		
-		void CreateScriptsToBeRun()
-		{
-			scriptsToRun = new PackageScriptsToRun();
-		}
-		
-		FakePackageScript AddScript()
-		{
-			var script = new FakePackageScript();
-			scriptsToRun.AddScript(script);
-			return script;
-		}
-		
-		[Test]
-		public void GetNextScript_NewInstance_ReturnsNull()
-		{
-			CreateScriptsToBeRun();
-			IPackageScript script = scriptsToRun.GetNextScript();
-			
-			Assert.IsNull(script);
-		}
-		
-		[Test]
-		public void GetNextScript_NewInstance_ReturnsFalse()
-		{
-			CreateScriptsToBeRun();
-			IPackageScript script = null;
-			bool result = scriptsToRun.GetNextScript(out script);
-			
-			Assert.IsFalse(result);
-		}
-		
-		[Test]
-		public void GetNextScript_OneScriptAdded_ReturnsScript()
-		{
-			CreateScriptsToBeRun();
-			FakePackageScript expectedScript = AddScript();
-			
-			IPackageScript script = scriptsToRun.GetNextScript();
-			
-			Assert.AreEqual(expectedScript, script);
-		}
-		
-		[Test]
-		public void GetNextScript_OneScriptAdded_ReturnsScriptInOutParameter()
-		{
-			CreateScriptsToBeRun();
-			FakePackageScript expectedScript = AddScript();
-			
-			IPackageScript script = null;
-			scriptsToRun.GetNextScript(out script);
-			
-			Assert.AreEqual(expectedScript, script);
-		}
-		
-		[Test]
-		public void GetNextScript_OneScriptAdded_ReturnsTrue()
-		{
-			CreateScriptsToBeRun();
-			FakePackageScript expectedScript = AddScript();
-			
-			IPackageScript script = null;
-			bool result = scriptsToRun.GetNextScript(out script);
-			
-			Assert.IsTrue(result);
-		}
-		
-		[Test]
-		public void GetNextScript_CalledTwiceWithOneScriptAdded_ReturnsNullOnSecondCall()
-		{
-			CreateScriptsToBeRun();
-			FakePackageScript expectedScript = AddScript();
-			scriptsToRun.GetNextScript();
-			IPackageScript script = scriptsToRun.GetNextScript();
-			
-			Assert.IsNull(script);
-		}
-		
-		[Test]
-		public void GetNextScript_CalledTwiceWithOneScriptAdded_ReturnsNullScriptInOutParameterOnSecondCall()
-		{
-			CreateScriptsToBeRun();
-			FakePackageScript expectedScript = AddScript();
-			scriptsToRun.GetNextScript();
-			IPackageScript script = null;
-			scriptsToRun.GetNextScript(out script);
-			
-			Assert.IsNull(script);
-		}
-		
-		[Test]
-		public void GetNextScript_CalledTwiceWithOneScriptAdded_ReturnsFalseOnSecondCall()
-		{
-			CreateScriptsToBeRun();
-			FakePackageScript expectedScript = AddScript();
-			scriptsToRun.GetNextScript();
-			
-			IPackageScript script = null;
-			bool result = scriptsToRun.GetNextScript(out script);
-			
-			Assert.IsFalse(result);
-		}
-		
-		[Test]
-		public void GetNextScript_CalledTwiceWithTwoScriptsAdded_ReturnsSecondScriptAdded()
-		{
-			CreateScriptsToBeRun();
-			AddScript();
-			FakePackageScript expectedScript = AddScript();
-			scriptsToRun.GetNextScript();
-			IPackageScript script = scriptsToRun.GetNextScript();
-			
-			Assert.AreEqual(expectedScript, script);
-		}
-		
-		[Test]
-		public void GetNextScript_CalledTwiceWithTwoScriptsAdded_ReturnsSecondScriptAddedInOutParameter()
-		{
-			CreateScriptsToBeRun();
-			AddScript();
-			FakePackageScript expectedScript = AddScript();
-			scriptsToRun.GetNextScript();
-			IPackageScript script = null;
-			scriptsToRun.GetNextScript(out script);
-			
-			Assert.AreEqual(expectedScript, script);
-		}
-		
-		[Test]
-		public void GetNextScript_CalledTwiceWithTwoScriptsAdded_ReturnsTrueOnSecondCall()
-		{
-			CreateScriptsToBeRun();
-			AddScript();
-			FakePackageScript expectedScript = AddScript();
-			scriptsToRun.GetNextScript();
-			IPackageScript script = null;
-			bool result = scriptsToRun.GetNextScript(out script);
-			
-			Assert.IsTrue(result);
-		}
-	}
-}

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

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using NuGet;
@@ -31,6 +32,14 @@ namespace PackageManagement.Tests
 			return fakeProject.FakeSourceRepository.AddFakePackage(packageId);
 		}
 		
+		void AddFileToPackageBeingUninstalled(string fileName)
+		{
+			var package = new FakePackage();
+			package.AddFile(fileName);
+			
+			action.Package = package;
+		}
+		
 		[Test]
 		public void Execute_PackageObjectPassed_UninstallsPackageFromProject()
 		{
@@ -171,5 +180,38 @@ namespace PackageManagement.Tests
 			CreateAction();
 			Assert.IsFalse(action.RemoveDependencies);
 		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasUninstallPowerShellScript_ReturnsTrue()
+		{
+			CreateAction();
+			AddFileToPackageBeingUninstalled(@"tools\uninstall.ps1");
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(hasPackageScripts);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasNoFiles_ReturnsFalse()
+		{
+			CreateAction();
+			action.Package = new FakePackage();
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsFalse(hasPackageScripts);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasUninstallPowerShellScriptInUpperCase_ReturnsTrue()
+		{
+			CreateAction();
+			AddFileToPackageBeingUninstalled(@"tools\UNINSTALL.PS1");
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(hasPackageScripts);
+		}
 	}
 }

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

@@ -2,8 +2,10 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
+using NuGet;
 using NUnit.Framework;
 using PackageManagement.Tests.Helpers;
 
@@ -25,6 +27,18 @@ namespace PackageManagement.Tests
 			updatePackageHelper = new UpdatePackageHelper(action);
 		}
 		
+		void AddInstallOperationWithFile(string fileName)
+		{
+			var package = new FakePackage();
+			package.AddFile(fileName);
+			
+			var operation = new PackageOperation(package, PackageAction.Install);
+			var operations = new List<PackageOperation>();
+			operations.Add(operation);
+			
+			action.Operations = operations;
+		}
+		
 		[Test]
 		public void Execute_PackageAndRepositoryPassed_PackageIsUpdated()
 		{
@@ -179,5 +193,27 @@ namespace PackageManagement.Tests
 			
 			Assert.IsNull(actualPackage);
 		}
+	
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasInitPowerShellScript_ReturnsTrue()
+		{
+			CreateSolution();
+			AddInstallOperationWithFile(@"tools\init.ps1");
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsTrue(hasPackageScripts);
+		}
+		
+		[Test]
+		public void HasPackageScriptsToRun_OnePackageInOperationsHasNoFiles_ReturnsFalse()
+		{
+			CreateSolution();
+			action.Operations = new List<PackageOperation>();
+			
+			bool hasPackageScripts = action.HasPackageScriptsToRun();
+			
+			Assert.IsFalse(hasPackageScripts);
+		}		
 	}
 }

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

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using ICSharpCode.PackageManagement.Scripting;
 using NUnit.Framework;
@@ -16,7 +17,7 @@ namespace PackageManagement.Tests
 		FakePackageManagementSolution fakeSolution;
 		FakePackageManagementProject fakeProject;
 		FakeUpdatePackageAction updatePackageAction;
-		FakePackageScriptRunner fakeScriptRunner;
+		FakePackageActionRunner fakeActionRunner;
 		
 		void CreateViewModel()
 		{
@@ -24,7 +25,7 @@ namespace PackageManagement.Tests
 			fakeSolution = viewModel.FakeSolution;
 			fakeProject = fakeSolution.FakeProject;
 			updatePackageAction = fakeProject.FakeUpdatePackageAction;
-			fakeScriptRunner = viewModel.FakeScriptRunner;
+			fakeActionRunner = viewModel.FakeActionRunner;
 		}
 		
 		[Test]
@@ -66,19 +67,9 @@ namespace PackageManagement.Tests
 			CreateViewModel();
 			viewModel.AddPackage();
 			
-			Assert.IsTrue(updatePackageAction.IsExecuted);
+			ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
-		}
-		
-		[Test]
-		public void AddPackage_PackageAddedSuccessfully_PackageScriptRunnerIsUsedWhenUpdatingPackages()
-		{
-			CreateViewModel();
-			viewModel.AddPackage();
-			
-			IPackageScriptRunner scriptRunner = updatePackageAction.PackageScriptRunner;
-			FakePackageScriptRunner expectedScriptRunner = fakeScriptRunner;
 
-			Assert.AreEqual(expectedScriptRunner, scriptRunner);
+			Assert.AreEqual(updatePackageAction, actionExecuted);
 		}
 	}
 }