Add support for running PowerShell scripts in NuGet packages.

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

@@ -49,17 +49,23 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		
 		void InstallPackage()
 		{
-			InstallPackageAction action = CreateInstallPackageTask();
+			IPackageManagementProject project = GetProject();
+			InstallPackageAction action = CreateInstallPackageTask(project);
 			action.Execute();
 		}
 		
-		InstallPackageAction CreateInstallPackageTask()
+		IPackageManagementProject GetProject()
+		{
+			return ConsoleHost.GetProject(Source, ProjectName);
+		}
+		
+		InstallPackageAction CreateInstallPackageTask(IPackageManagementProject project)
 		{
-			IPackageManagementProject project = ConsoleHost.GetProject(Source, ProjectName);
 			InstallPackageAction action = project.CreateInstallPackageAction();
 			action.PackageId = Id;
 			action.PackageVersion = Version;
 			action.IgnoreDependencies = IgnoreDependencies.IsPresent;
+			action.PackageScriptSession = this;
 			return action;
 		}
 	}

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

@@ -9,8 +9,10 @@ using NuGet;
 
 namespace ICSharpCode.PackageManagement.Cmdlets
 {
-	public abstract class PackageManagementCmdlet : PSCmdlet, ITerminatingCmdlet
+	public abstract class PackageManagementCmdlet : PSCmdlet, ITerminatingCmdlet, IPackageScriptSession
 	{
+		static readonly string EnvironmentPathVariableName = "env:path";
+		
 		IPackageManagementConsoleHost consoleHost;
 		ICmdletTerminatingError terminatingError;
 		
@@ -50,5 +52,45 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		{
 			TerminatingError.ThrowNoProjectOpenError();
 		}
+		
+		public void SetEnvironmentPath(string path)
+		{
+			SetSessionVariable(EnvironmentPathVariableName, path);
+		}
+		
+		protected virtual void SetSessionVariable(string name, object value)
+		{
+			SessionState.PSVariable.Set(name, value);
+		}
+		
+		public string GetEnvironmentPath()
+		{
+			return (string)GetSessionVariable(EnvironmentPathVariableName);
+		}
+		
+		protected virtual object GetSessionVariable(string name)
+		{
+			return GetVariableValue(name);
+		}
+		
+		public void AddVariable(string name, object value)
+		{
+			SetSessionVariable(name, value);
+		}
+		
+		public void RemoveVariable(string name)
+		{
+			RemoveSessionVariable(name);
+		}
+		
+		protected virtual void RemoveSessionVariable(string name)
+		{
+			SessionState.PSVariable.Remove(name);
+		}
+		
+		public void InvokeScript(string script)
+		{
+			InvokeCommand.InvokeScript(script);
+		}
 	}
 }

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

@@ -49,19 +49,25 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		
 		void UninstallPackage()
 		{
-			UninstallPackageAction action = CreateUninstallPackageAction();
+			IPackageManagementProject project = GetProject();
+			UninstallPackageAction action = CreateUninstallPackageAction(project);
 			action.Execute();
 		}
 		
-		UninstallPackageAction CreateUninstallPackageAction()
+		IPackageManagementProject GetProject()
 		{
 			string source = null; 
-			IPackageManagementProject project = ConsoleHost.GetProject(source, ProjectName);
+			return ConsoleHost.GetProject(source, ProjectName);
+		}
+		
+		UninstallPackageAction CreateUninstallPackageAction(IPackageManagementProject project)
+		{
 			UninstallPackageAction action = project.CreateUninstallPackageAction();
 			action.PackageId = Id;
 			action.PackageVersion = Version;
 			action.ForceRemove = Force.IsPresent;
 			action.RemoveDependencies = RemoveDependencies.IsPresent;
+			action.PackageScriptSession = this;
 			
 			return action;
 		}

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

@@ -49,17 +49,23 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		
 		void UpdatePackage()
 		{
-			UpdatePackageAction action = CreateUpdatePackageAction();
+			IPackageManagementProject project = GetProject();
+			UpdatePackageAction action = CreateUpdatePackageAction(project);
 			action.Execute();
 		}
 		
-		UpdatePackageAction CreateUpdatePackageAction()
+		IPackageManagementProject GetProject()
+		{
+			return ConsoleHost.GetProject(Source, ProjectName);
+		}
+		
+		UpdatePackageAction CreateUpdatePackageAction(IPackageManagementProject project)
 		{
-			IPackageManagementProject project = ConsoleHost.GetProject(Source, ProjectName);
 			UpdatePackageAction action = project.CreateUpdatePackageAction();
 			action.PackageId = Id;
 			action.PackageVersion = Version;
 			action.UpdateDependencies = !IgnoreDependencies.IsPresent;
+			action.PackageScriptSession = this;
 			return action;
 		}
 	}

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

@@ -10,6 +10,11 @@ namespace PackageManagement.Cmdlets.Tests.Helpers
 {
 	public class TestablePackageManagementCmdlet : PackageManagementCmdlet
 	{
+		public TestablePackageManagementCmdlet()
+			: this(new FakeCmdletTerminatingError())
+		{
+		}
+		
 		public TestablePackageManagementCmdlet(FakeCmdletTerminatingError terminatingError)
 			: base(
 				new FakePackageManagementConsoleHost(),
@@ -22,5 +27,30 @@ namespace PackageManagement.Cmdlets.Tests.Helpers
 		{
 			base.ThrowProjectNotOpenTerminatingError();
 		}
+		
+		public object GetSessionVariableReturnValue;
+		public string NamePassedToGetSessionVariable;
+		
+		protected override object GetSessionVariable(string name)
+		{
+			NamePassedToGetSessionVariable = name;
+			return GetSessionVariableReturnValue;
+		}
+		
+		public object ValuePassedToSetSessionVariable;
+		public string NamePassedToSetSessionVariable;
+		
+		protected override void SetSessionVariable(string name, object value)
+		{
+			NamePassedToSetSessionVariable = name;
+			ValuePassedToSetSessionVariable = value;
+		}
+		
+		public string NamePassedToRemoveVariable;
+		
+		protected override void RemoveSessionVariable(string name)
+		{
+			NamePassedToRemoveVariable = name;
+		}
 	}
 }

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

@@ -19,7 +19,7 @@ namespace PackageManagement.Cmdlets.Tests
 		TestableInstallPackageCmdlet cmdlet;
 		FakeCmdletTerminatingError fakeTerminatingError;
 		FakePackageManagementProject fakeProject;
-		FakeInstallPackageAction fakeInstallPackageTask;
+		FakeInstallPackageAction fakeInstallPackageAction;
 		
 		void CreateCmdletWithoutActiveProject()
 		{
@@ -27,7 +27,7 @@ namespace PackageManagement.Cmdlets.Tests
 			fakeTerminatingError = cmdlet.FakeCmdletTerminatingError;
 			fakeConsoleHost = cmdlet.FakePackageManagementConsoleHost;
 			fakeProject = fakeConsoleHost.FakeProject;
-			fakeInstallPackageTask = fakeProject.FakeInstallPackageAction;
+			fakeInstallPackageAction = fakeProject.FakeInstallPackageAction;
 		}
 				
 		void CreateCmdletWithActivePackageSourceAndProject()
@@ -97,7 +97,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetIdParameter("Test");
 			RunCmdlet();
 			
-			var actualPackageId = fakeInstallPackageTask.PackageId;
+			var actualPackageId = fakeInstallPackageAction.PackageId;
 			
 			Assert.AreEqual("Test", actualPackageId);
 		}
@@ -111,7 +111,7 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableIgnoreDependenciesParameter();
 			RunCmdlet();
 			
-			bool result = fakeInstallPackageTask.IgnoreDependencies;
+			bool result = fakeInstallPackageAction.IgnoreDependencies;
 			
 			Assert.IsTrue(result);
 		}
@@ -124,7 +124,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetIdParameter("Test");
 			RunCmdlet();
 			
-			bool result = fakeInstallPackageTask.IgnoreDependencies;
+			bool result = fakeInstallPackageAction.IgnoreDependencies;
 			
 			Assert.IsFalse(result);
 		}
@@ -154,7 +154,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetVersionParameter(version);
 			RunCmdlet();
 			
-			var actualVersion = fakeInstallPackageTask.PackageVersion;
+			var actualVersion = fakeInstallPackageAction.PackageVersion;
 			
 			Assert.AreEqual(version, actualVersion);
 		}
@@ -167,7 +167,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetIdParameter("Test");
 			RunCmdlet();
 			
-			var actualVersion = fakeInstallPackageTask.PackageVersion;
+			var actualVersion = fakeInstallPackageAction.PackageVersion;
 			
 			Assert.IsNull(actualVersion);
 		}
@@ -210,9 +210,23 @@ namespace PackageManagement.Cmdlets.Tests
 			SetIdParameter("Test");
 			RunCmdlet();
 			
-			bool result = fakeInstallPackageTask.IsExecuteCalled;
+			bool result = fakeInstallPackageAction.IsExecuteCalled;
 			
 			Assert.IsTrue(result);
 		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_CmdletUsedAsScriptSession()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddDefaultProjectToConsoleHost();
+			var packageSource = AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			var actualSession = fakeInstallPackageAction.PackageScriptSession;
+			
+			Assert.AreEqual(cmdlet, actualSession);
+		}
 	}
 }

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

@@ -17,6 +17,11 @@ namespace PackageManagement.Cmdlets.Tests
 			cmdlet = new TestablePackageManagementCmdlet(null);
 		}
 		
+		void CreateCmdlet()
+		{
+			cmdlet = new TestablePackageManagementCmdlet();
+		}
+		
 		[Test]
 		public void ThrowProjectNotOpenTerminatingError_TerminatingErrorIsNull_NullReferenceExceptionIsNotThrown()
 		{
@@ -24,5 +29,85 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			Assert.DoesNotThrow(() => cmdlet.CallThrowProjectNotOpenTerminatingError());
 		}
+		
+		[Test]
+		public void GetEnvironmentPath_MethodCalled_ReturnsEnvPathFromSessionState()
+		{
+			CreateCmdlet();
+			object expectedPath = "Test";
+			cmdlet.GetSessionVariableReturnValue = expectedPath;
+			
+			object path = cmdlet.GetEnvironmentPath();
+			
+			Assert.AreEqual(expectedPath, path);
+		}
+		
+		[Test]
+		public void GetEnvironmentPath_MethodCalled_EnvPathVariableRetrievedFromSessionState()
+		{
+			CreateCmdlet();
+			cmdlet.GetSessionVariableReturnValue = "Test";
+			
+			cmdlet.GetEnvironmentPath();
+			
+			string variableName = cmdlet.NamePassedToGetSessionVariable;
+			
+			Assert.AreEqual("env:path", variableName);
+		}
+		
+		[Test]
+		public void SetEnvironmentPath_PathSet_EnvPathVariableUpdated()
+		{
+			CreateCmdlet();
+			cmdlet.SetEnvironmentPath("Test");
+			
+			string variableName = cmdlet.NamePassedToSetSessionVariable;
+			
+			Assert.AreEqual("env:path", variableName);
+		}
+		
+		[Test]
+		public void SetEnvironmentPath_PathSet_EnvPathUpdated()
+		{
+			CreateCmdlet();
+			cmdlet.SetEnvironmentPath("Test");
+			
+			object path = cmdlet.ValuePassedToSetSessionVariable;
+			
+			Assert.AreEqual("Test", path);
+		}
+		
+		[Test]
+		public void AddVariable_NameAndValuePassed_VariableWithNameIsUpdated()
+		{
+			CreateCmdlet();
+			cmdlet.AddVariable("Test", "Value");
+			
+			string variableName = cmdlet.NamePassedToSetSessionVariable;
+			
+			Assert.AreEqual("Test", variableName);
+		}
+		
+		[Test]
+		public void AddVariable_NameAndValuePassed_VariableValueUpdated()
+		{
+			CreateCmdlet();
+			cmdlet.AddVariable("Test", "Value");
+			
+			object value = cmdlet.ValuePassedToSetSessionVariable;
+			
+			Assert.AreEqual("Value", value);
+		}
+		
+		[Test]
+		public void RemoveVariable_NamePassed_VariableRemoved()
+		{
+			CreateCmdlet();
+			cmdlet.RemoveVariable("Test");
+			
+			string name = cmdlet.NamePassedToRemoveVariable;
+			
+			Assert.AreEqual("Test", name);
+		}
 	}
 }

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

@@ -221,5 +221,19 @@ namespace PackageManagement.Cmdlets.Tests
 						
 			Assert.IsTrue(uninstallPackageAction.IsExecuted);
 		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_CmdletUsedAsScriptSession()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddDefaultProjectToConsoleHost();
+			var packageSource = AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			var actualSession = uninstallPackageAction.PackageScriptSession;
+						
+			Assert.AreEqual(cmdlet, actualSession);
+		}
 	}
 }

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

@@ -217,7 +217,7 @@ namespace PackageManagement.Cmdlets.Tests
 		{
 			CreateCmdletWithoutActiveProject();
 			AddDefaultProjectToConsoleHost();
-			var packageSource = AddPackageSourceToConsoleHost();
+			AddPackageSourceToConsoleHost();
 			SetIdParameter("Test");
 			RunCmdlet();
 			
@@ -225,5 +225,19 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			Assert.IsTrue(executed);
 		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_CmdletUsedAsScriptSession()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddDefaultProjectToConsoleHost();
+			AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			var actualSession = fakeUpdatePackageAction.PackageScriptSession;
+			
+			Assert.AreEqual(cmdlet, actualSession);
+		}
 	}
 }

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

@@ -58,6 +58,7 @@
     <Folder Include="Resources" />
     <Folder Include="Src" />
     <Folder Include="Src\Design" />
+    <Folder Include="Src\EnvDTE" />
     <Folder Include="Src\Scripting" />
   </ItemGroup>
   <ItemGroup>
@@ -167,7 +168,22 @@
     </Compile>
     <Compile Include="Src\PackagesViewModel.cs" />
     <Compile Include="Src\ProcessPackageAction.cs" />
+    <Compile Include="Src\Scripting\IPackageScript.cs" />
+    <Compile Include="Src\Scripting\IPackageScriptFactory.cs" />
+    <Compile Include="Src\Scripting\IPackageScriptSession.cs" />
+    <Compile Include="Src\Scripting\PackageInitializeScript.cs" />
+    <Compile Include="Src\Scripting\PackageInitializeScriptFileName.cs" />
+    <Compile Include="Src\Scripting\PackageInstallScript.cs" />
+    <Compile Include="Src\Scripting\PackageInstallScriptFileName.cs" />
+    <Compile Include="Src\Scripting\PackageScript.cs" />
+    <Compile Include="Src\Scripting\PackageScriptFactory.cs" />
+    <Compile Include="Src\Scripting\PackageScriptFileName.cs" />
+    <Compile Include="Src\Scripting\PackageUninstallScript.cs" />
+    <Compile Include="Src\Scripting\PackageUninstallScriptFileName.cs" />
     <Compile Include="Src\Scripting\PowerShellHostRawUserInterface.cs" />
+    <Compile Include="Src\Scripting\PowerShellSessionEnvironmentPath.cs" />
+    <Compile Include="Src\EnvDTE\Project.cs" />
+    <Compile Include="Src\Scripting\RunPackageScriptsAction.cs" />
     <Compile Include="Src\UninstallPackageAction.cs" />
     <Compile Include="Src\UpdatedPackagesViewModel.cs" />
     <Compile Include="Src\PackageViewModel.cs" />

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

@@ -12,16 +12,15 @@ namespace ICSharpCode.PackageManagement.Design
 	public class FakeFileSystem : IFileSystem
 	{
 		public bool FileExistsReturnValue;
+		public string PathPassedToFileExists;
 		public string FileToReturnFromOpenFile;
 		public string PathToReturnFromGetFullPath;
+		public bool DirectoryExistsReturnValue;
+		public string PathPassedToDirectoryExists;
 		
 		public ILogger Logger { get; set; }
 		
-		public string Root {
-			get {
-				throw new NotImplementedException();
-			}
-		}
+		public string Root { get; set; }
 		
 		public void DeleteDirectory(string path, bool recursive)
 		{
@@ -55,12 +54,14 @@ namespace ICSharpCode.PackageManagement.Design
 		
 		public bool FileExists(string path)
 		{
+			PathPassedToFileExists = path;
 			return FileExistsReturnValue;
 		}
 		
 		public bool DirectoryExists(string path)
 		{
-			throw new NotImplementedException();
+			PathPassedToDirectoryExists = path;
+			return DirectoryExistsReturnValue;
 		}
 		
 		public void AddFile(string path, Stream stream)

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

@@ -7,8 +7,8 @@ namespace ICSharpCode.PackageManagement.Design
 {
 	public class FakeInstallPackageAction : InstallPackageAction
 	{
-		public FakeInstallPackageAction()
-			: base((IPackageManagementProject)null, null)
+		public FakeInstallPackageAction(IPackageManagementProject project)
+			: base(project, null)
 		{
 		}
 		

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

@@ -6,12 +6,24 @@ using System.Collections.Generic;
 using System.Linq;
 
 using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.EnvDTE;
 using NuGet;
 
 namespace ICSharpCode.PackageManagement.Design
 {
 	public class FakePackageManagementProject : IPackageManagementProject
 	{
+		public FakePackageManagementProject()
+		{
+			FakeInstallPackageAction = new FakeInstallPackageAction(this);
+			FakeUninstallPackageAction = new FakeUninstallPackageAction(this);
+			FakeUpdatePackageAction = new FakeUpdatePackageAction(this);
+		}
+		
+		public FakeInstallPackageAction FakeInstallPackageAction;
+		public FakeUpdatePackageAction FakeUpdatePackageAction;
+		public FakeUninstallPackageAction FakeUninstallPackageAction;
+		
 		public bool IsInstalledReturnValue;
 		public IPackage PackagePassedToIsInstalled;
 		
@@ -87,25 +99,62 @@ namespace ICSharpCode.PackageManagement.Design
 			UpdateDependenciesPassedToUpdatePackage = updateDependencies;
 		}
 		
-		public FakeInstallPackageAction FakeInstallPackageAction = new FakeInstallPackageAction();
-		
 		public virtual InstallPackageAction CreateInstallPackageAction()
 		{
 			return FakeInstallPackageAction;
 		}
 		
-		public FakeUninstallPackageAction FakeUninstallPackageAction = new FakeUninstallPackageAction();
-		
 		public virtual UninstallPackageAction CreateUninstallPackageAction()
 		{
 			return FakeUninstallPackageAction;
 		}
-		
-		public FakeUpdatePackageAction FakeUpdatePackageAction = new FakeUpdatePackageAction();
-		
+				
 		public UpdatePackageAction CreateUpdatePackageAction()
 		{
 			return FakeUpdatePackageAction;
 		}
+		
+		public event EventHandler<PackageOperationEventArgs> PackageInstalled;
+		
+		public void FirePackageInstalledEvent(PackageOperationEventArgs e)
+		{
+			if (PackageInstalled != null) {
+				PackageInstalled(this, e);
+			}
+		}
+		
+		public event EventHandler<PackageOperationEventArgs> PackageUninstalled;
+		
+		public void FirePackageUninstalledEvent(PackageOperationEventArgs e)
+		{
+			if (PackageUninstalled != null) {
+				PackageUninstalled(this, e);
+			}
+		}
+		
+		public event EventHandler<PackageOperationEventArgs> PackageReferenceAdded;
+		
+		public void FirePackageReferenceAddedEvent(PackageOperationEventArgs e)
+		{
+			if (PackageReferenceAdded != null) {
+				PackageReferenceAdded(this, e);
+			}
+		}
+		
+		public event EventHandler<PackageOperationEventArgs> PackageReferenceRemoved;
+		
+		public void FirePackageReferenceRemovedEvent(PackageOperationEventArgs e)
+		{
+			if (PackageReferenceRemoved != null) {
+				PackageReferenceRemoved(this, e);
+			}
+		}
+		
+		public Project DTEProject = new Project();
+		
+		public Project ConvertToDTEProject()
+		{
+			return DTEProject;
+		}
 	}
 }

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

@@ -37,7 +37,7 @@ namespace ICSharpCode.PackageManagement.Design
 		}
 		
 		#pragma warning disable 67
-		public event EventHandler<PackageOperationEventArgs> PackageInstalled;		
+		public event EventHandler<PackageOperationEventArgs> PackageInstalled;
 		public event EventHandler<PackageOperationEventArgs> PackageInstalling;
 		public event EventHandler<PackageOperationEventArgs> PackageUninstalled;
 		public event EventHandler<PackageOperationEventArgs> PackageUninstalling;
@@ -141,5 +141,15 @@ namespace ICSharpCode.PackageManagement.Design
 			PackageOperationsPassedToUpdatePackage = operations;
 			UpdateDependenciesPassedToUpdatePackage = updateDependencies;
 		}
+		
+		public void FirePackageInstalled(PackageOperationEventArgs e)
+		{
+			PackageInstalled(this, e);
+		}
+		
+		public void FirePackageUninstalled(PackageOperationEventArgs e)
+		{
+			PackageUninstalled(this, e);
+		}
 	}
 }

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

@@ -35,9 +35,17 @@ namespace ICSharpCode.PackageManagement.Design
 			}
 		}
 
+		public event EventHandler<PackageOperationEventArgs> PackageReferenceRemoved;
+		
+		protected virtual void OnPackageReferenceRemoved(IPackage package)
+		{
+			if (PackageReferenceRemoved != null) {
+				PackageReferenceRemoved(this, new PackageOperationEventArgs(package, String.Empty));
+			}
+		}
+		
 		#pragma warning disable 67
 		public event EventHandler<PackageOperationEventArgs> PackageReferenceAdding;
-		public event EventHandler<PackageOperationEventArgs> PackageReferenceRemoved;
 		public event EventHandler<PackageOperationEventArgs> PackageReferenceRemoving;
 		#pragma warning restore 67
 		
@@ -80,5 +88,10 @@ namespace ICSharpCode.PackageManagement.Design
 		{
 			OnPackageReferenceAdded(package);
 		}
+		
+		public void FirePackageReferenceRemoved(IPackage package)
+		{
+			OnPackageReferenceRemoved(package);
+		}
 	}
 }

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

@@ -9,8 +9,8 @@ namespace ICSharpCode.PackageManagement.Design
 	{
 		public bool IsExecuted;
 		
-		public FakeUninstallPackageAction()
-			: base((IPackageManagementProject)null, null)
+		public FakeUninstallPackageAction(IPackageManagementProject project)
+			: base(project, null)
 		{
 		}
 		

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

@@ -9,8 +9,8 @@ namespace ICSharpCode.PackageManagement.Design
 	{
 		public bool IsExecuted;
 		
-		public FakeUpdatePackageAction()
-			: base((IPackageManagementProject)null, null)
+		public FakeUpdatePackageAction(IPackageManagementProject project)
+			: base(project, null)
 		{
 		}
 		

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

@@ -0,0 +1,11 @@
+// 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.EnvDTE
+{
+	public class Project
+	{
+	}
+}

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

@@ -5,15 +5,23 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
+using ICSharpCode.PackageManagement.EnvDTE;
 using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
 	public interface IPackageManagementProject
 	{
+		event EventHandler<PackageOperationEventArgs> PackageInstalled;
+		event EventHandler<PackageOperationEventArgs> PackageUninstalled;
+		event EventHandler<PackageOperationEventArgs> PackageReferenceAdded;
+		event EventHandler<PackageOperationEventArgs> PackageReferenceRemoved;
+			
 		ILogger Logger { get; set; }
 		IPackageRepository SourceRepository { get; }
 		
+		Project ConvertToDTEProject();
+		
 		bool IsInstalled(IPackage package);
 		
 		IQueryable<IPackage> GetPackages();

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
+using ICSharpCode.PackageManagement.EnvDTE;
 using ICSharpCode.SharpDevelop.Project;
 using NuGet;
 
@@ -42,6 +43,26 @@ namespace ICSharpCode.PackageManagement
 			}
 		}
 		
+		public event EventHandler<PackageOperationEventArgs> PackageInstalled {
+			add { packageManager.PackageInstalled += value; }
+			remove { packageManager.PackageInstalled -= value; }
+		}
+		
+		public event EventHandler<PackageOperationEventArgs> PackageUninstalled {
+			add { packageManager.PackageUninstalled += value; }
+			remove { packageManager.PackageUninstalled -= value; }
+		}
+		
+		public event EventHandler<PackageOperationEventArgs> PackageReferenceAdded {
+			add { projectManager.PackageReferenceAdded += value; }
+			remove { projectManager.PackageReferenceAdded -= value; }
+		}
+		
+		public event EventHandler<PackageOperationEventArgs> PackageReferenceRemoved {
+			add { projectManager.PackageReferenceRemoved += value; }
+			remove { projectManager.PackageReferenceRemoved -= value; }
+		}
+		
 		public bool IsInstalled(IPackage package)
 		{
 			return projectManager.IsInstalled(package);
@@ -86,5 +107,10 @@ namespace ICSharpCode.PackageManagement
 		{
 			return new UpdatePackageAction(this, packageManagementEvents);
 		}
+		
+		public Project ConvertToDTEProject()
+		{
+			return null;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/ProcessPackageAction.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.Scripting;
 using ICSharpCode.SharpDevelop.Project;
 using NuGet;
 
@@ -24,6 +25,7 @@ namespace ICSharpCode.PackageManagement
 		public IPackage Package { get; set; }
 		public Version PackageVersion { get; set; }
 		public string PackageId { get; set; }
+		public IPackageScriptSession PackageScriptSession { get; set; }
 		
 		protected void OnParentPackageInstalled()
 		{
@@ -38,7 +40,9 @@ namespace ICSharpCode.PackageManagement
 		public void Execute()
 		{
 			BeforeExecute();
-			ExecuteCore();
+			using (RunPackageScriptsAction runScriptsAction = CreateRunPackageScriptsAction()) {
+				ExecuteCore();
+			}
 		}
 		
 		protected virtual void BeforeExecute()
@@ -48,6 +52,18 @@ namespace ICSharpCode.PackageManagement
 			GetPackageIfMissing();
 		}
 		
+		RunPackageScriptsAction CreateRunPackageScriptsAction()
+		{
+			return CreateRunPackageScriptsAction(PackageScriptSession, Project);
+		}
+		
+		protected virtual RunPackageScriptsAction CreateRunPackageScriptsAction(
+			IPackageScriptSession session,
+			IPackageManagementProject project)
+		{
+			return new RunPackageScriptsAction(session, project);
+		}
+		
 		protected virtual void ExecuteCore()
 		{
 		}

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

@@ -0,0 +1,14 @@
+// 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 interface IPackageScript
+	{
+		IPackageManagementProject Project { get; set; }
+		
+		void Execute();
+	}
+}

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

@@ -0,0 +1,15 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public interface IPackageScriptFactory
+	{
+		IPackageScript CreatePackageInitializeScript(string packageInstallDirectory);
+		IPackageScript CreatePackageUninstallScript(string packageInstallDirectory);
+		IPackageScript CreatePackageInstallScript(string packageInstallDirectory);
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/IPackageScriptSession.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;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public interface IPackageScriptSession
+	{
+		void SetEnvironmentPath(string path);
+		string GetEnvironmentPath();
+		
+		void AddVariable(string name, object value);
+		void RemoveVariable(string name);
+		
+		void InvokeScript(string script);
+	}
+}

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

@@ -0,0 +1,37 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class PackageInitializeScript : PackageScript
+	{
+		public PackageInitializeScript(
+			PackageInitializeScriptFileName fileName,
+			IPackageScriptSession session)
+			: base(fileName, session)
+		{
+		}
+		
+		protected override void BeforeExecute()
+		{
+			AddScriptDirectoryToEnvironmentPath();
+		}
+		
+		void AddScriptDirectoryToEnvironmentPath()
+		{
+			if (ScriptFileName.ScriptDirectoryExists()) {
+				string directory = ScriptFileName.GetScriptDirectory();
+				AddScriptDirectoryToEnvironmentPath(directory);
+			}
+		}
+		
+		void AddScriptDirectoryToEnvironmentPath(string directory)
+		{
+			var environmentPath = new PowerShellSessionEnvironmentPath(Session);
+			environmentPath.Append(directory);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/PackageInitializeScriptFileName.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;
+using System.IO;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class PackageInitializeScriptFileName : PackageScriptFileName
+	{
+		public PackageInitializeScriptFileName(string packageInstallDirectory)
+			: base(packageInstallDirectory)
+		{
+		}
+		
+		public PackageInitializeScriptFileName(IFileSystem fileSystem)
+			: base(fileSystem)
+		{
+		}
+		
+		public override string Name {
+			get { return "init.ps1"; }
+		}
+	}
+}

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

@@ -0,0 +1,17 @@
+// 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 PackageInstallScript : PackageScript
+	{
+		public PackageInstallScript(
+			PackageInstallScriptFileName fileName,
+			IPackageScriptSession session)
+			: base(fileName, session)
+		{
+		}
+	}
+}

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

@@ -0,0 +1,25 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class PackageInstallScriptFileName : PackageScriptFileName
+	{
+		public PackageInstallScriptFileName(string packageInstallDirectory)
+			: base(packageInstallDirectory)
+		{
+		}
+		
+		public PackageInstallScriptFileName(IFileSystem fileSystem)
+			: base(fileSystem)
+		{
+		}
+		
+		public override string Name {
+			get { return "install.ps1"; }
+		}
+	}
+}

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

@@ -0,0 +1,75 @@
+// 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.EnvDTE;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class PackageScript : IPackageScript
+	{
+		public PackageScript(
+			PackageScriptFileName fileName,
+			IPackageScriptSession session)
+		{
+			this.ScriptFileName = fileName;
+			this.Session = session;
+		}
+		
+		protected PackageScriptFileName ScriptFileName { get; private set; }
+		protected IPackageScriptSession Session { get; private set; }
+		
+		public IPackage Package { get; set; }
+		public IPackageManagementProject Project { get; set; }
+		
+		public void Execute()
+		{
+			BeforeExecute();
+			AddSessionVariables();
+			ExecuteScript();
+			RemoveSessionVariables();
+		}
+		
+		protected virtual void BeforeExecute()
+		{
+		}
+		
+		void AddSessionVariables()
+		{
+			Session.AddVariable("__rootPath", ScriptFileName.PackageInstallDirectory);
+			Session.AddVariable("__toolsPath", ScriptFileName.GetScriptDirectory());
+			Session.AddVariable("__package", Package);
+			Session.AddVariable("__project", GetProject());
+		}
+		
+		Project GetProject()
+		{
+			if (Project != null) {
+				return Project.ConvertToDTEProject();
+			}
+			return null;
+		}
+		
+		void ExecuteScript()
+		{
+			string script = GetScript();
+			Session.InvokeScript(script);
+		}
+		
+		string GetScript()
+		{
+			return String.Format(
+				"& '{0}' $__rootPath $__toolsPath $__package $__project",
+				ScriptFileName);
+		}
+		
+		void RemoveSessionVariables()
+		{
+			Session.RemoveVariable("__rootPath");
+			Session.RemoveVariable("__toolsPath");
+			Session.RemoveVariable("__package");
+			Session.RemoveVariable("__project");
+		}
+	}
+}

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

@@ -0,0 +1,36 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class PackageScriptFactory : IPackageScriptFactory
+	{
+		IPackageScriptSession session;
+		
+		public PackageScriptFactory(IPackageScriptSession session)
+		{
+			this.session = session;
+		}
+		
+		public IPackageScript CreatePackageInitializeScript(string packageInstallDirectory)
+		{
+			var scriptFileName = new PackageInitializeScriptFileName(packageInstallDirectory);
+			return new PackageInitializeScript(scriptFileName, session);
+		}
+		
+		public IPackageScript CreatePackageUninstallScript(string packageInstallDirectory)
+		{
+			var scriptFileName = new PackageUninstallScriptFileName(packageInstallDirectory);
+			return new PackageUninstallScript(scriptFileName, session);
+		}
+		
+		public IPackageScript CreatePackageInstallScript(string packageInstallDirectory)
+		{
+			var scriptFileName = new PackageInstallScriptFileName(packageInstallDirectory);
+			return new PackageInstallScript(scriptFileName, session);
+		}
+	}
+}

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

@@ -0,0 +1,57 @@
+// 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.IO;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public abstract class PackageScriptFileName
+	{
+		IFileSystem fileSystem;
+		string relativeScriptFilePath;
+		
+		public PackageScriptFileName(string packageInstallDirectory)
+			: this(new PhysicalFileSystem(packageInstallDirectory))
+		{
+		}
+		
+		public PackageScriptFileName(IFileSystem fileSystem)
+		{
+			this.fileSystem = fileSystem;
+			GetRelativeScriptFilePath();
+		}
+		
+		void GetRelativeScriptFilePath()
+		{
+			relativeScriptFilePath = Path.Combine("tools", Name);
+		}
+		
+		public abstract string Name { get; }
+		
+		public string PackageInstallDirectory {
+			get { return fileSystem.Root; }
+		}
+		
+		public override string ToString()
+		{
+			return fileSystem.GetFullPath(relativeScriptFilePath);
+		}
+		
+		public bool ScriptDirectoryExists()
+		{
+			return fileSystem.DirectoryExists("tools");
+		}
+		
+		public bool FileExists()
+		{
+			return fileSystem.FileExists(relativeScriptFilePath);
+		}
+		
+		public string GetScriptDirectory()
+		{
+			return fileSystem.GetFullPath("tools");
+		}
+	}
+}

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

@@ -0,0 +1,17 @@
+// 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 PackageUninstallScript : PackageScript
+	{
+		public PackageUninstallScript(
+			PackageUninstallScriptFileName fileName,
+			IPackageScriptSession session)
+			: base(fileName, session)
+		{
+		}
+	}
+}

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

@@ -0,0 +1,25 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class PackageUninstallScriptFileName : PackageScriptFileName
+	{
+		public PackageUninstallScriptFileName(string packageInstallDirectory)
+			: base(packageInstallDirectory)
+		{
+		}
+		
+		public PackageUninstallScriptFileName(IFileSystem fileSystem)
+			: base(fileSystem)
+		{
+		}
+		
+		public override string Name {
+			get { return "uninstall.ps1"; }
+		}
+	}
+}

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

@@ -0,0 +1,46 @@
+// 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 PowerShellSessionEnvironmentPath
+	{
+		IPackageScriptSession session;
+		
+		public PowerShellSessionEnvironmentPath(IPackageScriptSession session)
+		{
+			this.session = session;
+		}
+		
+		public void Append(string path)
+		{
+			string environmentPath = GetEnvironmentPath();
+			environmentPath = AppendPathSeparatorIfMissing(environmentPath);
+			SetEnvironmentPath(environmentPath + path);
+		}
+		
+		string GetEnvironmentPath()
+		{
+			return session.GetEnvironmentPath();
+		}
+		
+		string AppendPathSeparatorIfMissing(string path)
+		{
+			if (String.IsNullOrEmpty(path)) {
+				return String.Empty;
+			}
+			
+			if (path.EndsWith(";")) {
+				return path;
+			}
+			return path + ";";
+		}
+		
+		void SetEnvironmentPath(string path)
+		{
+			session.SetEnvironmentPath(path);
+		}
+	}
+}

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

@@ -0,0 +1,88 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class RunPackageScriptsAction : IDisposable
+	{
+		IPackageManagementProject project;
+		IPackageScriptFactory scriptFactory;
+		
+		public RunPackageScriptsAction(
+			IPackageScriptSession session,
+			IPackageManagementProject project)
+			: this(project, new PackageScriptFactory(session))
+		{
+		}
+		
+		public RunPackageScriptsAction(
+			IPackageManagementProject project,
+			IPackageScriptFactory scriptFactory)
+		{
+			this.project = project;
+			this.scriptFactory = scriptFactory;
+			
+			RegisterEvents();
+		}
+		
+		void RegisterEvents()
+		{
+			project.PackageInstalled += PackageInstalled;
+			project.PackageReferenceAdded += PackageReferenceAdded;
+			project.PackageReferenceRemoved += PackageReferenceRemoved;
+		}
+		
+		void UnregisterEvents()
+		{
+			project.PackageInstalled -= PackageInstalled;
+			project.PackageReferenceAdded -= PackageReferenceAdded;
+			project.PackageReferenceRemoved -= PackageReferenceRemoved;
+		}
+		
+		void PackageInstalled(object sender, PackageOperationEventArgs e)
+		{
+			RunInitScript(e);
+		}
+		
+		void PackageReferenceRemoved(object sender, PackageOperationEventArgs e)
+		{
+			RunUninstallScript(e);
+		}
+		
+		void PackageReferenceAdded(object sender, PackageOperationEventArgs e)
+		{
+			RunInstallScript(e);
+		}
+		
+		void RunInitScript(PackageOperationEventArgs e)
+		{
+			IPackageScript script = scriptFactory.CreatePackageInitializeScript(e.InstallPath);
+			script.Execute();
+		}
+		
+		void RunUninstallScript(PackageOperationEventArgs e)
+		{
+			IPackageScript script = scriptFactory.CreatePackageUninstallScript(e.InstallPath);
+			script.Project = project;
+			script.Execute();
+		}
+		
+		void RunInstallScript(PackageOperationEventArgs e)
+		{
+			IPackageScript script = scriptFactory.CreatePackageInstallScript(e.InstallPath);
+			script.Project = project;
+			script.Execute();
+		}
+		
+		public void Dispose()
+		{
+			IsDisposed = true;
+			UnregisterEvents();
+		}
+		
+		public bool IsDisposed { get; private set; }
+	}
+}

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

@@ -77,7 +77,10 @@
     <Compile Include="Src\Helpers\FakePackageManagementEvents.cs" />
     <Compile Include="Src\Helpers\FakePackageManagementOutputMessagesView.cs" />
     <Compile Include="Src\Helpers\FakePackageManagementProjectFactory.cs" />
+    <Compile Include="Src\Helpers\FakePackageScript.cs" />
+    <Compile Include="Src\Helpers\FakePackageScriptFactory.cs" />
     <Compile Include="Src\Helpers\FakePackageViewModelFactory.cs" />
+    <Compile Include="Src\Helpers\FakePowerShellSession.cs" />
     <Compile Include="Src\Helpers\TestableAddPackageReferenceCommand.cs" />
     <Compile Include="Src\PackageFromRepositoryTests.cs" />
     <Compile Include="Src\PackageManagementEventsTests.cs" />
@@ -154,6 +157,12 @@
     <Compile Include="Src\PackageSourceViewModelTests.cs" />
     <Compile Include="Src\PackagesViewModelTests.cs" />
     <Compile Include="Src\ProcessPackageActionTests.cs" />
+    <Compile Include="Src\Scripting\PackageInitializeScriptFileNameTests.cs" />
+    <Compile Include="Src\Scripting\PackageInitializeScriptTests.cs" />
+    <Compile Include="Src\Scripting\PackageInstallScriptFileNameTests.cs" />
+    <Compile Include="Src\Scripting\PackageInstallScriptTests.cs" />
+    <Compile Include="Src\Scripting\PackageUninstallScriptFileNameTests.cs" />
+    <Compile Include="Src\Scripting\RunPackageScriptsActionTests.cs" />
     <Compile Include="Src\UninstallPackageActionTests.cs" />
     <Compile Include="Src\UpdatedPackagesViewModelTests.cs" />
     <Compile Include="Src\PackageViewModelTests.cs" />

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

@@ -0,0 +1,21 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Scripting;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FakePackageScript : IPackageScript
+	{
+		public bool IsExecuted;
+		
+		public void Execute()
+		{
+			IsExecuted = true;
+		}
+		
+		public IPackageManagementProject Project { get; set; }
+	}
+}

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

@@ -0,0 +1,35 @@
+// 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 NuGet;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FakePackageScriptFactory : IPackageScriptFactory
+	{
+		public string PackageInstallDirectoryPassed;
+		public FakePackageScript FakePackageInitializeScript = new FakePackageScript();
+		public FakePackageScript FakePackageInstallScript = new FakePackageScript();
+		public FakePackageScript FakePackageUninstallScript = new FakePackageScript();
+		
+		public IPackageScript CreatePackageInitializeScript(string packageInstallDirectory)
+		{
+			PackageInstallDirectoryPassed = packageInstallDirectory;
+			return FakePackageInitializeScript;
+		}
+		
+		public IPackageScript CreatePackageUninstallScript(string packageInstallDirectory)
+		{
+			PackageInstallDirectoryPassed = packageInstallDirectory;
+			return FakePackageUninstallScript;
+		}
+		
+		public IPackageScript CreatePackageInstallScript(string packageInstallDirectory)
+		{
+			PackageInstallDirectoryPassed = packageInstallDirectory;
+			return FakePackageInstallScript;
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePowerShellSession.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 ICSharpCode.PackageManagement.Scripting;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FakePackageScriptSession : IPackageScriptSession
+	{
+		public string EnvironmentPath = String.Empty;
+		
+		public void SetEnvironmentPath(string path)
+		{
+			EnvironmentPath = path;
+		}
+		
+		public string GetEnvironmentPath()
+		{
+			return EnvironmentPath;
+		}
+		
+		public Dictionary<string, object> VariablesAdded = new Dictionary<string, object>();
+		
+		public void AddVariable(string name, object value)
+		{
+			VariablesAdded.Add(name, value);
+		}
+		
+		public List<string> VariablesRemoved = new List<string>();
+		
+		public void RemoveVariable(string name)
+		{
+			VariablesRemoved.Add(name);
+		}
+		
+		public string ScriptPassedToInvokeScript;
+		
+		public void InvokeScript(string script)
+		{
+			ScriptPassedToInvokeScript = script;
+		}
+	}
+}

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

@@ -4,6 +4,7 @@
 using System;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
+using ICSharpCode.PackageManagement.Scripting;
 
 namespace PackageManagement.Tests.Helpers
 {
@@ -32,5 +33,25 @@ namespace PackageManagement.Tests.Helpers
 		{
 			base.BeforeExecute();
 		}
+		
+		public bool IsRunPackageScriptsActionCreated;
+		public IPackageScriptSession SessionPassedToCreateRunPackageScriptsAction;
+		public IPackageManagementProject ProjectPassedToCreateRunPackageScriptsAction;
+		public RunPackageScriptsAction RunPackageScriptsAction;
+		
+		protected override RunPackageScriptsAction CreateRunPackageScriptsAction(
+			IPackageScriptSession session,
+			IPackageManagementProject project)
+		{
+			IsRunPackageScriptsActionCreated = true;
+			SessionPassedToCreateRunPackageScriptsAction = session;
+			ProjectPassedToCreateRunPackageScriptsAction = project;
+			RunPackageScriptsAction = base.CreateRunPackageScriptsAction(session, project);
+			return RunPackageScriptsAction;
+		}
+		
+		public bool IsRunPackageScriptsActionDisposed {
+			get { return RunPackageScriptsAction.IsDisposed; }
+		}
 	}
 }

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

@@ -368,5 +368,57 @@ namespace PackageManagement.Tests
 			
 			Assert.AreEqual(expectedLogger, actualLogger);
 		}
+		
+		[Test]
+		public void PackageInstalled_PackagerManagerPackageInstalledEventFired_EventFiresWithPackage()
+		{
+			CreateProject();
+			PackageOperationEventArgs eventArgs = null;
+			project.PackageInstalled += (sender, e) => eventArgs = e;
+			
+			var expectedEventArgs = new PackageOperationEventArgs(new FakePackage(), String.Empty);
+			fakePackageManager.FirePackageInstalled(expectedEventArgs);
+			
+			Assert.AreEqual(expectedEventArgs, eventArgs);
+		}
+		
+		[Test]
+		public void PackageUninstalled_PackagerManagerPackageUninstalledEventFired_EventFiresWithPackage()
+		{
+			CreateProject();
+			PackageOperationEventArgs eventArgs = null;
+			project.PackageUninstalled += (sender, e) => eventArgs = e;
+			
+			var expectedEventArgs = new PackageOperationEventArgs(new FakePackage(), String.Empty);
+			fakePackageManager.FirePackageUninstalled(expectedEventArgs);
+			
+			Assert.AreEqual(expectedEventArgs, eventArgs);
+		}
+		
+		[Test]
+		public void PackageReferenceAdded_ProjectManagerPackageReferenceAddedEventFired_EventFiresWithPackage()
+		{
+			CreateProject();
+			PackageOperationEventArgs eventArgs = null;
+			project.PackageReferenceAdded += (sender, e) => eventArgs = e;
+			
+			var expectedPackage = new FakePackage();
+			fakeProjectManager.FirePackageReferenceAdded(expectedPackage);
+			
+			Assert.AreEqual(expectedPackage, eventArgs.Package);
+		}
+		
+		[Test]
+		public void PackageReferenceRemoved_ProjectManagerPackageReferenceRemovedEventFired_EventFiresWithPackage()
+		{
+			CreateProject();
+			PackageOperationEventArgs eventArgs = null;
+			project.PackageReferenceRemoved += (sender, e) => eventArgs = e;
+			
+			var expectedPackage = new FakePackage();
+			fakeProjectManager.FirePackageReferenceRemoved(expectedPackage);
+			
+			Assert.AreEqual(expectedPackage, eventArgs.Package);
+		}
 	}
 }

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

@@ -63,6 +63,41 @@ namespace PackageManagement.Tests
 			ILogger actualLogger = fakeProject.Logger;
 			
 			Assert.AreEqual(expectedLogger, actualLogger);
-		}		
+		}
+		
+		[Test]
+		public void Execute_MethodCalled_RunPackageScriptsActionCreatedUsingPackageScriptSession()
+		{
+			CreateAction();
+			var expectedSession = new FakePackageScriptSession();
+			action.PackageScriptSession = expectedSession;
+			action.Execute();
+			
+			var actualSession = action.SessionPassedToCreateRunPackageScriptsAction;
+			
+			Assert.AreEqual(expectedSession, actualSession);
+		}
+		
+		[Test]
+		public void Execute_MethodCalled_RunPackageScriptsActionCreatedUsingProject()
+		{
+			CreateAction();
+			var expectedProject = new FakePackageManagementProject();
+			action.Project = expectedProject;
+			action.Execute();
+			
+			var actualProject = action.ProjectPassedToCreateRunPackageScriptsAction;
+			
+			Assert.AreEqual(expectedProject, actualProject);
+		}
+		
+		[Test]
+		public void Execute_MethodCalled_RunPackageScriptsActionIsDisposed()
+		{
+			CreateAction();
+			action.Execute();
+			
+			Assert.IsTrue(action.IsRunPackageScriptsActionDisposed);
+		}
 	}
 }

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

@@ -0,0 +1,142 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NUnit.Framework;
+
+namespace PackageManagement.Tests.Scripting
+{
+	[TestFixture]
+	public class PackageInitializeScriptFileNameTests
+	{
+		PackageInitializeScriptFileName scriptFileName;
+		FakeFileSystem fakeFileSystem;
+
+		void CreateFileSystem()
+		{
+			fakeFileSystem = new FakeFileSystem();
+		}
+		
+		void CreateFileName(string installPath)
+		{
+			scriptFileName = new PackageInitializeScriptFileName(installPath);
+		}
+		
+		void CreateFakeFileSystem()
+		{
+			fakeFileSystem = new FakeFileSystem();
+		}
+		
+		void CreateFileNameWithFakeFileSystem()
+		{
+			scriptFileName = new PackageInitializeScriptFileName(fakeFileSystem);
+		}
+		
+		[Test]
+		public void ToString_InstallDirectoryPassed_ReturnsFullPathToInitScript()
+		{
+			CreateFileName(@"d:\projects\MyProject\packages\Test");
+			
+			string actualFileName = scriptFileName.ToString();
+			string expectedFileName = @"d:\projects\MyProject\packages\Test\tools\init.ps1";
+			
+			Assert.AreEqual(expectedFileName, actualFileName);
+		}
+		
+		[Test]
+		public void PackageInstallDirectory_InstallDirectoryPassed_ReturnsFullPathToInitScript()
+		{
+			CreateFileName(@"d:\projects\MyProject\packages\Test");
+			
+			string actualDirectory = scriptFileName.PackageInstallDirectory;
+			string expectedDirectory = @"d:\projects\MyProject\packages\Test";
+			
+			Assert.AreEqual(expectedDirectory, actualDirectory);
+		}
+		
+		[Test]
+		public void ScriptDirectoryExists_FileSystemHasScriptDirectory_ReturnsTrue()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.DirectoryExistsReturnValue = true;
+			CreateFileNameWithFakeFileSystem();
+			
+			bool exists = scriptFileName.ScriptDirectoryExists();
+			
+			Assert.IsTrue(exists);
+		}
+		
+		[Test]
+		public void ScriptDirectoryExists_FileSystemDoesNotHaveScriptDirectory_ReturnsFalse()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.DirectoryExistsReturnValue = false;
+			CreateFileNameWithFakeFileSystem();
+			
+			bool exists = scriptFileName.ScriptDirectoryExists();
+			
+			Assert.IsFalse(exists);
+		}
+		
+		[Test]
+		public void ScriptDirectoryExists_FileSystemHasScriptDirectory_ToolsDirectoryCheckedForExistence()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.DirectoryExistsReturnValue = true;
+			CreateFileNameWithFakeFileSystem();
+			
+			scriptFileName.ScriptDirectoryExists();
+			
+			Assert.AreEqual("tools", fakeFileSystem.PathPassedToDirectoryExists);
+		}
+		
+		[Test]
+		public void FileExists_FileSystemHasScriptFile_ReturnsTrue()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.FileExistsReturnValue = true;
+			CreateFileNameWithFakeFileSystem();
+			
+			bool exists = scriptFileName.FileExists();
+			
+			Assert.IsTrue(exists);	
+		}
+		
+		[Test]
+		public void FileExists_FileSystemDoesNotHaveScriptFile_ReturnsFalse()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.FileExistsReturnValue = false;
+			CreateFileNameWithFakeFileSystem();
+			
+			bool exists = scriptFileName.FileExists();
+			
+			Assert.IsFalse(exists);	
+		}
+		
+		[Test]
+		public void FileExists_FileSystemHasScriptFile_ToolsScriptFileCheckedForExistence()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.FileExistsReturnValue = true;
+			CreateFileNameWithFakeFileSystem();
+			
+			scriptFileName.FileExists();
+			
+			Assert.AreEqual(@"tools\init.ps1", fakeFileSystem.PathPassedToFileExists);
+		}
+		
+		[Test]
+		public void GetScriptDirectory_InstallDirectoryPassed_ReturnsInitScriptDirectory()
+		{
+			CreateFileName(@"d:\projects\MyProject\packages\Test");
+			
+			string actualDirectory = scriptFileName.GetScriptDirectory();
+			string expectedDirectory = @"d:\projects\MyProject\packages\Test\tools";
+			
+			Assert.AreEqual(expectedDirectory, actualDirectory);
+		}
+	}
+}

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

@@ -0,0 +1,224 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests.Scripting
+{
+	[TestFixture]
+	public class PackageInitializeScriptTests
+	{
+		PackageInitializeScript script;
+		PackageInitializeScriptFileName scriptFileName;
+		FakeFileSystem fakeFileSystem;
+		FakePackageScriptSession fakeSession;
+		
+		void CreateScript()
+		{
+			fakeFileSystem = new FakeFileSystem();
+			fakeFileSystem.FileExistsReturnValue = true;
+			fakeFileSystem.DirectoryExistsReturnValue = true;
+			scriptFileName = new PackageInitializeScriptFileName(fakeFileSystem);
+			
+			fakeSession = new FakePackageScriptSession();
+			
+			script = new PackageInitializeScript(scriptFileName, fakeSession);
+		}
+		
+		void CreateScriptWithPhysicalFileSystem()
+		{
+			CreateScriptWithPhysicalFileSystem(@"d:\projects\myproject\packages\test");
+		}
+		
+		void CreateScriptWithPhysicalFileSystem(string packageInstallDirectory)
+		{
+			scriptFileName = new PackageInitializeScriptFileName(packageInstallDirectory);
+			fakeSession = new FakePackageScriptSession();
+			script = new PackageInitializeScript(scriptFileName, fakeSession);
+		}
+		
+		void AssertSessionVariableIsRemoved(string variableName)
+		{
+			bool removed = fakeSession.VariablesRemoved.Contains(variableName);
+			Assert.IsTrue(removed);			
+		}
+		
+		[Test]
+		public void Execute_ExistingEnvironmentPathIsEmptyString_PathToScriptAddedToEnvironmentPath()
+		{
+			CreateScript();
+			fakeFileSystem.PathToReturnFromGetFullPath = @"d:\projects\myproject\packages\test";
+			fakeSession.SetEnvironmentPath(String.Empty);
+			
+			script.Execute();
+			
+			string actualEnvironmentPath = fakeSession.GetEnvironmentPath();
+			string expectedEnvironmentPath = @"d:\projects\myproject\packages\test";
+			
+			Assert.AreEqual(expectedEnvironmentPath, actualEnvironmentPath);
+		}
+		
+		[Test]
+		public void Execute_OneItemInOriginalEnvironmentPath_PathToScriptAppendedToEnvironmentPath()
+		{
+			CreateScript();
+			fakeFileSystem.PathToReturnFromGetFullPath = @"d:\projects\myproject\packages\test";
+			fakeSession.SetEnvironmentPath(@"c:\users\sharpdevelop\ps;");
+			
+			script.Execute();
+			
+			string actualEnvironmentPath = fakeSession.GetEnvironmentPath();
+			string expectedEnvironmentPath = @"c:\users\sharpdevelop\ps;d:\projects\myproject\packages\test";
+			
+			Assert.AreEqual(expectedEnvironmentPath, actualEnvironmentPath);
+		}
+		
+		[Test]
+		public void Execute_OneItemInOriginalEnvironmentPathMissingSemiColonAtEnd_PathToScriptAppendedToEnvironmentPathWithSemiColonAtStart()
+		{
+			CreateScript();
+			fakeFileSystem.PathToReturnFromGetFullPath = @"d:\projects\myproject\packages\test";
+			fakeSession.SetEnvironmentPath(@"c:\users\sharpdevelop\ps");
+			
+			script.Execute();
+			
+			string actualEnvironmentPath = fakeSession.GetEnvironmentPath();
+			string expectedEnvironmentPath = @"c:\users\sharpdevelop\ps;d:\projects\myproject\packages\test";
+			
+			Assert.AreEqual(expectedEnvironmentPath, actualEnvironmentPath);
+		}
+		
+		[Test]
+		public void Execute_OriginalEnvironmentPathIsNull_PathToScriptAppendedToEnvironmentPath()
+		{
+			CreateScript();
+			fakeFileSystem.PathToReturnFromGetFullPath = @"d:\projects\myproject\packages\test";
+			fakeSession.SetEnvironmentPath(null);
+			
+			script.Execute();
+			
+			string actualEnvironmentPath = fakeSession.GetEnvironmentPath();
+			string expectedEnvironmentPath = @"d:\projects\myproject\packages\test";
+			
+			Assert.AreEqual(expectedEnvironmentPath, actualEnvironmentPath);
+		}
+		
+		[Test]
+		public void Execute_ScriptDirectoryDoesNotExist_PathIsNotUpdated()
+		{
+			CreateScript();
+			fakeFileSystem.PathToReturnFromGetFullPath = @"d:\projects\myproject\packages\test";
+			fakeFileSystem.DirectoryExistsReturnValue = false;
+			fakeSession.SetEnvironmentPath(String.Empty);
+			
+			script.Execute();
+			
+			string actualEnvironmentPath = fakeSession.GetEnvironmentPath();
+			string expectedEnvironmentPath = String.Empty;
+			
+			Assert.AreEqual(expectedEnvironmentPath, actualEnvironmentPath);
+		}
+		
+		[Test]
+		public void Execute_PackageIsSet_PackageSessionVariableIsSet()
+		{
+			CreateScriptWithPhysicalFileSystem();
+			var expectedPackage = new FakePackage("Test");
+			script.Package = expectedPackage;
+			script.Execute();
+			
+			var actualPackage = fakeSession.VariablesAdded["__package"];
+			
+			Assert.AreEqual(expectedPackage, actualPackage);
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_RootPathSessionVariableIsSet()
+		{
+			string expectedRootPath = @"d:\projects\myproject\packages\test";
+			CreateScriptWithPhysicalFileSystem(expectedRootPath);
+			script.Execute();
+			
+			var rootPath = fakeSession.VariablesAdded["__rootPath"];
+			
+			Assert.AreEqual(expectedRootPath, rootPath);
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_ToolsPathSessionVariableIsSet()
+		{
+			CreateScriptWithPhysicalFileSystem(@"d:\projects\myproject\packages\test");
+			script.Execute();
+			
+			var toolsPath = fakeSession.VariablesAdded["__toolsPath"];
+			string expectedToolsPath = @"d:\projects\myproject\packages\test\tools";
+			
+			Assert.AreEqual(expectedToolsPath, toolsPath);
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_ProjectSessionVariableIsSet()
+		{
+			CreateScriptWithPhysicalFileSystem();
+			script.Execute();
+			
+			var project = fakeSession.VariablesAdded["__project"];
+			
+			Assert.IsNull(project);
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_ScriptIsInvoked()
+		{
+			CreateScriptWithPhysicalFileSystem(@"d:\projects\myproject\packages\test");
+			script.Execute();
+			
+			string actualScript = fakeSession.ScriptPassedToInvokeScript;
+			
+			string expectedScript = 
+				"& 'd:\\projects\\myproject\\packages\\test\\tools\\init.ps1' $__rootPath $__toolsPath $__package $__project";
+			
+			Assert.AreEqual(expectedScript, actualScript);
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_PackageSessionVariableIsRemoved()
+		{
+			CreateScriptWithPhysicalFileSystem();
+			script.Execute();
+			
+			AssertSessionVariableIsRemoved("__package");
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_RootPathSessionVariableIsRemoved()
+		{
+			CreateScriptWithPhysicalFileSystem();
+			script.Execute();
+			
+			AssertSessionVariableIsRemoved("__rootPath");
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_ToolsPathSessionVariableIsRemoved()
+		{
+			CreateScriptWithPhysicalFileSystem();
+			script.Execute();
+			
+			AssertSessionVariableIsRemoved("__toolsPath");
+		}
+		
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_ProjectSessionVariableIsRemoved()
+		{
+			CreateScriptWithPhysicalFileSystem();
+			script.Execute();
+			
+			AssertSessionVariableIsRemoved("__project");
+		}
+	}
+}

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

@@ -0,0 +1,60 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NUnit.Framework;
+
+namespace PackageManagement.Tests.Scripting
+{
+	[TestFixture]
+	public class PackageInstallScriptFileNameTests
+	{
+		PackageInstallScriptFileName scriptFileName;
+		FakeFileSystem fakeFileSystem;
+
+		void CreateFileSystem()
+		{
+			fakeFileSystem = new FakeFileSystem();
+		}
+		
+		void CreateFileName(string installPath)
+		{
+			scriptFileName = new PackageInstallScriptFileName(installPath);
+		}
+		
+		void CreateFakeFileSystem()
+		{
+			fakeFileSystem = new FakeFileSystem();
+		}
+		
+		void CreateFileNameWithFakeFileSystem()
+		{
+			scriptFileName = new PackageInstallScriptFileName(fakeFileSystem);
+		}
+		
+		[Test]
+		public void ToString_InstallDirectoryPassed_ReturnsFullPathToInstallScript()
+		{
+			CreateFileName(@"d:\projects\MyProject\packages\Test");
+			
+			string actualFileName = scriptFileName.ToString();
+			string expectedFileName = @"d:\projects\MyProject\packages\Test\tools\install.ps1";
+			
+			Assert.AreEqual(expectedFileName, actualFileName);
+		}
+		
+		[Test]
+		public void FileExists_FileSystemHasScriptFile_ToolsScriptFileCheckedForExistence()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.FileExistsReturnValue = true;
+			CreateFileNameWithFakeFileSystem();
+			
+			scriptFileName.FileExists();
+			
+			Assert.AreEqual(@"tools\install.ps1", fakeFileSystem.PathPassedToFileExists);
+		}
+	}
+}

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

@@ -0,0 +1,47 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.EnvDTE;
+using ICSharpCode.PackageManagement.Scripting;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests.Scripting
+{
+	[TestFixture]
+	public class PackageInstallScriptTests
+	{
+		PackageInstallScriptFileName scriptFileName;
+		FakePackageScriptSession fakeSession;
+		PackageInstallScript script;
+		
+		void CreateScriptWithPhysicalFileSystem()
+		{
+			CreateScriptWithPhysicalFileSystem(@"d:\projects\myproject\packages\test");
+		}
+		
+		void CreateScriptWithPhysicalFileSystem(string packageInstallDirectory)
+		{
+			scriptFileName = new PackageInstallScriptFileName(packageInstallDirectory);
+			fakeSession = new FakePackageScriptSession();
+			script = new PackageInstallScript(scriptFileName, fakeSession);
+		}
+
+		[Test]
+		public void Execute_PackageInstallDirectoryIsSet_ProjectSessionVariableIsSet()
+		{
+			CreateScriptWithPhysicalFileSystem();
+			var expectedProject = new Project();
+			var project = new FakePackageManagementProject();
+			project.DTEProject = expectedProject;
+			script.Project = project;
+			script.Execute();
+			
+			var projectVariable = fakeSession.VariablesAdded["__project"];
+			
+			Assert.AreEqual(expectedProject, projectVariable);
+		}
+	}
+}

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

@@ -0,0 +1,60 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NUnit.Framework;
+
+namespace PackageManagement.Tests.Scripting
+{
+	[TestFixture]
+	public class PackageUninstallScriptFileNameTests
+	{
+		PackageUninstallScriptFileName scriptFileName;
+		FakeFileSystem fakeFileSystem;
+
+		void CreateFileSystem()
+		{
+			fakeFileSystem = new FakeFileSystem();
+		}
+		
+		void CreateFileName(string installPath)
+		{
+			scriptFileName = new PackageUninstallScriptFileName(installPath);
+		}
+		
+		void CreateFakeFileSystem()
+		{
+			fakeFileSystem = new FakeFileSystem();
+		}
+		
+		void CreateFileNameWithFakeFileSystem()
+		{
+			scriptFileName = new PackageUninstallScriptFileName(fakeFileSystem);
+		}
+		
+		[Test]
+		public void ToString_InstallDirectoryPassed_ReturnsFullPathToInstallScript()
+		{
+			CreateFileName(@"d:\projects\MyProject\packages\Test");
+			
+			string actualFileName = scriptFileName.ToString();
+			string expectedFileName = @"d:\projects\MyProject\packages\Test\tools\uninstall.ps1";
+			
+			Assert.AreEqual(expectedFileName, actualFileName);
+		}
+		
+		[Test]
+		public void FileExists_FileSystemHasScriptFile_ToolsScriptFileCheckedForExistence()
+		{
+			CreateFakeFileSystem();
+			fakeFileSystem.FileExistsReturnValue = true;
+			CreateFileNameWithFakeFileSystem();
+			
+			scriptFileName.FileExists();
+			
+			Assert.AreEqual(@"tools\uninstall.ps1", fakeFileSystem.PathPassedToFileExists);
+		}
+	}
+}

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

@@ -0,0 +1,178 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests.Scripting
+{
+	[TestFixture]
+	public class RunPackageScriptsActionTests
+	{
+		RunPackageScriptsAction action;
+		FakePackageManagementProject fakeProject;
+		FakePackageScriptFactory fakeScriptFactory;
+			
+		void CreateAction()
+		{
+			fakeProject = new FakePackageManagementProject();
+			fakeScriptFactory = new FakePackageScriptFactory();
+			action = new RunPackageScriptsAction(fakeProject, fakeScriptFactory);
+		}
+		
+		PackageOperationEventArgs CreatePackageOperationEventArgs()
+		{
+			return CreatePackageOperationEventArgs(@"d:\projects\myproject\packages\test");
+		}
+		
+		PackageOperationEventArgs CreatePackageOperationEventArgs(string installPath)
+		{
+			var package = new FakePackage("Test");
+			string targetPath = @"d:\projects\myproject\packages\target";
+			return new PackageOperationEventArgs(package, targetPath, installPath);
+		}
+		
+		[Test]
+		public void Constructor_PackageIsInstalled_PackageInitScriptIsRun()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageInstalledEvent(eventArgs);
+			
+			bool executed = fakeScriptFactory.FakePackageInitializeScript.IsExecuted;
+			
+			Assert.IsTrue(executed);
+		}
+		
+		[Test]
+		public void Constructor_PackageIsInstalled_PackageInitScriptIsCreated()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs(@"d:\projects\myproject\packages\test");
+
+			fakeProject.FirePackageInstalledEvent(eventArgs);
+			
+			string path = fakeScriptFactory.PackageInstallDirectoryPassed;
+			
+			Assert.AreEqual(@"d:\projects\myproject\packages\test", path);
+		}
+		
+		[Test]
+		public void Dispose_PackageIsInstalled_PackageInitScriptIsNotRun()
+		{
+			CreateAction();
+			action.Dispose();
+			
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageInstalledEvent(eventArgs);
+			
+			bool executed = fakeScriptFactory.FakePackageInitializeScript.IsExecuted;
+			
+			Assert.IsFalse(executed);
+		}
+		
+		[Test]
+		public void Constructor_PackageReferenceIsAdded_PackageInstallScriptIsRun()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageReferenceAddedEvent(eventArgs);
+			
+			bool executed = fakeScriptFactory.FakePackageInstallScript.IsExecuted;
+			
+			Assert.IsTrue(executed);
+		}
+		
+		[Test]
+		public void Constructor_PackageReferenceIsAdded_PackageInstallScriptIsCreated()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs(@"d:\projects\myproject\packages\test");
+			fakeProject.FirePackageReferenceAddedEvent(eventArgs);
+			
+			string path = fakeScriptFactory.PackageInstallDirectoryPassed;
+			
+			Assert.AreEqual(@"d:\projects\myproject\packages\test", path);
+		}
+		
+		[Test]
+		public void Dispose_PackageReferenceIsAdded_PackageInstallScriptIsNotRun()
+		{
+			CreateAction();
+			action.Dispose();
+			
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageReferenceAddedEvent(eventArgs);
+			
+			bool executed = fakeScriptFactory.FakePackageInstallScript.IsExecuted;
+			
+			Assert.IsFalse(executed);
+		}
+		
+		[Test]
+		public void Constructor_PackageReferenceIsAdded_InstallScriptIsPassedProject()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageReferenceAddedEvent(eventArgs);
+			
+			var project = fakeScriptFactory.FakePackageInstallScript.Project;
+			
+			Assert.AreEqual(fakeProject, project);
+		}
+		
+		[Test]
+		public void Constructor_PackageReferenceIsRemoved_PackageUninstallScriptIsRun()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageReferenceRemovedEvent(eventArgs);
+			
+			bool executed = fakeScriptFactory.FakePackageUninstallScript.IsExecuted;
+			
+			Assert.IsTrue(executed);
+		}
+		
+		[Test]
+		public void Constructor_PackageReferenceIsRemoved_PackageUninstallScriptIsCreated()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs(@"d:\projects\myproject\packages\test");
+			fakeProject.FirePackageReferenceRemovedEvent(eventArgs);
+			
+			string path = fakeScriptFactory.PackageInstallDirectoryPassed;
+			
+			Assert.AreEqual(@"d:\projects\myproject\packages\test", path);
+		}
+		
+		[Test]
+		public void Dispose_PackageReferenceIsRemoved_PackageUninstallScriptIsNotRun()
+		{
+			CreateAction();
+			action.Dispose();
+			
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageReferenceRemovedEvent(eventArgs);
+			
+			bool executed = fakeScriptFactory.FakePackageUninstallScript.IsExecuted;
+			
+			Assert.IsFalse(executed);
+		}
+		
+		[Test]
+		public void Constructor_PackageReferenceIsRemoved_UninstallScriptIsPassedProject()
+		{
+			CreateAction();
+			var eventArgs = CreatePackageOperationEventArgs();
+			fakeProject.FirePackageReferenceRemovedEvent(eventArgs);
+			
+			var project = fakeScriptFactory.FakePackageUninstallScript.Project;
+			
+			Assert.AreEqual(fakeProject, project);
+		}
+	}
+}