Add cmdlet to run a set of package scripts inside the PowerShell console.

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

@@ -49,6 +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\InvokeUpdateWorkingDirectoryCmdlet.cs" />
     <Compile Include="Src\ITerminatingCmdlet.cs" />
     <Compile Include="Src\OpenProjects.cs" />

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

@@ -0,0 +1,51 @@
+// 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/Project/Src/PackageManagementCmdlet.cs

@@ -99,7 +99,9 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		
 		public void Run(IPackageScript script)
 		{
-			script.Execute(this);
+			if (script.Exists()) {
+				script.Execute(this);
+			}
 		}
 	}
 }

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

@@ -0,0 +1,41 @@
+// 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.Cmdlets;
+using ICSharpCode.PackageManagement.Scripting;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests.Helpers
+{
+	public class TestableInvokeRunPackageScriptsCmdlet : InvokeRunPackageScriptsCmdlet
+	{
+		public FakeCmdletTerminatingError FakeCmdletTerminatingError;
+		public FakePackageManagementConsoleHost FakePackageManagementConsoleHost;
+		public PackageScriptsToRun ScriptsToBeRun;
+		
+		public TestableInvokeRunPackageScriptsCmdlet()
+			: this(
+				new PackageScriptsToRun(),
+				new FakePackageManagementConsoleHost(),
+				new FakeCmdletTerminatingError())
+		{
+		}
+		
+		public TestableInvokeRunPackageScriptsCmdlet(
+			PackageScriptsToRun scriptsToBeRun,
+			FakePackageManagementConsoleHost consoleHost,
+			FakeCmdletTerminatingError cmdletTerminatingError)
+			: base(scriptsToBeRun, consoleHost, cmdletTerminatingError)
+		{
+			this.ScriptsToBeRun = scriptsToBeRun;
+			this.FakePackageManagementConsoleHost = consoleHost;
+			this.FakeCmdletTerminatingError = cmdletTerminatingError;
+		}
+		
+		public void CallProcessRecord()
+		{
+			base.ProcessRecord();
+		}
+	}
+}

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

@@ -50,6 +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\TestableInvokeUpdateWorkingDirectoryCmdlet.cs" />
     <Compile Include="Helpers\TestablePackageManagementCmdlet.cs" />
     <Compile Include="Helpers\TestableUninstallPackageCmdlet.cs" />
@@ -60,6 +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\InvokeUpdateWorkingDirectoryCmdletTests.cs" />
     <Compile Include="Src\PackageManagementCmdletTests.cs" />
     <Compile Include="Src\UninstallPackageCmdletTests.cs" />

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

@@ -0,0 +1,95 @@
+// 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 executed = script.IsExecuted;
+			
+			Assert.IsTrue(executed);
+		}
+		
+		[Test]
+		public void ProcessRecord_TwoPackageScriptsToRun_SecondPackageScriptIsRun()
+		{
+			CreateCmdlet();
+			AddScript();
+			FakePackageScript script = AddScript();
+			RunCmdlet();
+			
+			bool executed = script.IsExecuted;
+			
+			Assert.IsTrue(executed);
+		}
+		
+		[Test]
+		public void ProcessRecord_OnePackageScriptToRun_PackageScriptSessionIsCmdlet()
+		{
+			CreateCmdlet();
+			FakePackageScript script = AddScript();
+			RunCmdlet();
+			
+			IPackageScriptSession session = script.SessionPassedToExecute;
+			
+			Assert.AreEqual(cmdlet, session);
+		}
+		
+		[Test]
+		public void ProcessRecord_TwoPackageScriptsToRun_TwoPackageScriptSessionIsCmdlet()
+		{
+			CreateCmdlet();
+			AddScript();
+			FakePackageScript script = AddScript();
+			RunCmdlet();
+			
+			IPackageScriptSession session = script.SessionPassedToExecute;
+			
+			Assert.AreEqual(cmdlet, session);
+		}
+		
+		[Test]
+		public void ProcessRecord_NoPackageScriptsToRun_NullReferenceExceptionIsNotThrown()
+		{
+			CreateCmdlet();
+			Assert.DoesNotThrow(() => RunCmdlet());
+		}
+	}
+}

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

@@ -124,5 +124,19 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			Assert.AreEqual(cmdlet, session);
 		}
+		
+		[Test]
+		public void Run_PackageScriptDoesNotExist_ScriptIsNotRun()
+		{
+			CreateCmdlet();
+			
+			var script = new FakePackageScript();
+			script.ExistsReturnValue = false;
+			cmdlet.Run(script);
+			
+			bool executed = script.IsExecuted;
+			
+			Assert.IsFalse(executed);
+		}
 	}
 }

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

@@ -200,6 +200,7 @@
     <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/PackageManagementServices.cs

@@ -18,6 +18,7 @@ namespace ICSharpCode.PackageManagement
 		static readonly PackageManagementOutputMessagesView outputMessagesView;
 		static readonly RunPackageInitializationScriptsOnSolutionOpen runPackageInitializationScripts;
 		static readonly ResetPowerShellWorkingDirectoryOnSolutionClosed resetPowerShellWorkingDirectory;
+		static readonly PackageScriptsToRun packageScriptsToRun = new PackageScriptsToRun();
 		
 		static PackageManagementServices()
 		{
@@ -58,5 +59,9 @@ namespace ICSharpCode.PackageManagement
 		public static IPackageManagementProjectService ProjectService {
 			get { return projectService; }
 		}
+		
+		public static PackageScriptsToRun PackageScriptsToRun {
+			get { return packageScriptsToRun; }
+		}
 	}
 }

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

@@ -0,0 +1,32 @@
+// 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/Test/PackageManagement.Tests.csproj

@@ -178,6 +178,7 @@
     <Compile Include="Src\PackageRepositoryCacheTests.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/Scripting/PackageScriptsToRunTests.cs

@@ -0,0 +1,156 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using 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);
+		}
+	}
+}