Add install-package cmdlet.

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

@@ -5,7 +5,7 @@
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
     <OutputType>Library</OutputType>
-    <RootNamespace>PackageManagement.Cmdlets</RootNamespace>
+    <RootNamespace>ICSharpCode.PackageManagement.Cmdlets</RootNamespace>
     <AssemblyName>PackageManagement.Cmdlets</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <OutputPath>..\..\..\..\..\..\AddIns\Misc\PackageManagement\</OutputPath>
@@ -43,7 +43,12 @@
       <Link>Configuration\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Configuration\AssemblyInfo.cs" />
+    <Compile Include="Src\CmdletTerminatingError.cs" />
     <Compile Include="Src\GetPackageCmdlet.cs" />
+    <Compile Include="Src\ICmdletTerminatingError.cs" />
+    <Compile Include="Src\InstallPackageCmdlet.cs" />
+    <Compile Include="Src\ITerminatingCmdlet.cs" />
+    <Compile Include="Src\PackageManagementCmdlet.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\Main\Base\Project\ICSharpCode.SharpDevelop.csproj">

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

@@ -0,0 +1,33 @@
+// 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;
+
+namespace ICSharpCode.PackageManagement.Cmdlets
+{
+	public class CmdletTerminatingError : ICmdletTerminatingError
+	{
+		ITerminatingCmdlet cmdlet;
+		
+		public CmdletTerminatingError(ITerminatingCmdlet cmdlet)
+		{
+			this.cmdlet = cmdlet;
+		}
+		
+		public void ThrowNoProjectOpenError()
+		{
+			ErrorRecord error = CreateInvalidOperationErrorRecord("NoProjectOpen");
+			cmdlet.ThrowTerminatingError(error);
+		}
+		
+		ErrorRecord CreateInvalidOperationErrorRecord(string errorId)
+		{
+			return new ErrorRecord(
+				new InvalidOperationException(),
+				"NoProjectOpen",
+				ErrorCategory.InvalidOperation,
+				null);
+		}
+	}
+}

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

@@ -11,14 +11,11 @@ using ICSharpCode.PackageManagement.Scripting;
 using ICSharpCode.SharpDevelop.Project;
 using NuGet;
 
-namespace PackageManagement.Cmdlets
+namespace ICSharpCode.PackageManagement.Cmdlets
 {
-	[Cmdlet(VerbsCommon.Get, "Package", DefaultParameterSetName=ParameterAttribute.AllParameterSets)]
+	[Cmdlet(VerbsCommon.Get, "Package", DefaultParameterSetName = ParameterAttribute.AllParameterSets)]
-	public class GetPackageCmdlet : PSCmdlet
+	public class GetPackageCmdlet : PackageManagementCmdlet
 	{
-		IPackageManagementService packageManagementService;
-		IPackageManagementConsoleHost consoleHost;
-		IErrorRecordFactory errorRecordFactory;
 		int? skip;
 		int? take;
 		
@@ -26,18 +23,16 @@ namespace PackageManagement.Cmdlets
 			: this(
 				ServiceLocator.PackageManagementService,
 				ServiceLocator.PackageManagementConsoleHost,
-				new ErrorRecordFactory())
+				null)
 		{
 		}
 		
 		public GetPackageCmdlet(
 			IPackageManagementService packageManagementService,
 			IPackageManagementConsoleHost consoleHost,
-			IErrorRecordFactory errorRecordFactory)
+			ICmdletTerminatingError terminatingError)
+			: base(packageManagementService, consoleHost, terminatingError)
 		{
-			this.packageManagementService = packageManagementService;
-			this.consoleHost = consoleHost;
-			this.errorRecordFactory = errorRecordFactory;
 		}
 		
 		[Alias("Online", "Remote")]
@@ -98,12 +93,6 @@ namespace PackageManagement.Cmdlets
 			return true;
 		}
 		
-		void ThrowProjectNotOpenTerminatorError()
-		{
-			var error = errorRecordFactory.CreateNoProjectOpenErrorRecord();
-			CmdletThrowTerminatingError(error);
-		}
-		
 		protected virtual void CmdletThrowTerminatingError(ErrorRecord errorRecord)
 		{
 			ThrowTerminatingError(errorRecord);
@@ -120,7 +109,6 @@ namespace PackageManagement.Cmdlets
 			}
 			return GetInstalledPackages();
 		}
-
 		
 		IQueryable<IPackage> OrderPackages(IQueryable<IPackage> packages)
 		{
@@ -148,15 +136,12 @@ namespace PackageManagement.Cmdlets
 		IPackageRepository CreatePackageRepositoryForActivePackageSource()
 		{
 			PackageSource source = GetActivePackageSource();
-			return packageManagementService.CreatePackageRepository(source);
+			return PackageManagementService.CreatePackageRepository(source);
 		}
 		
 		PackageSource GetActivePackageSource()
 		{
-			if (Source != null) {
+			return GetActivePackageSource(Source);
-				return new PackageSource(Source);
-			}
-			return consoleHost.ActivePackageSource;
 		}
 		
 		IQueryable<IPackage> FilterPackages(IQueryable<IPackage> packages)
@@ -170,31 +155,32 @@ namespace PackageManagement.Cmdlets
 		
 		IQueryable<IPackage> GetUpdatedPackages()
 		{
-			var updatedPackages = new UpdatedPackages(packageManagementService, DefaultProject);
+			var updatedPackages = new UpdatedPackages(PackageManagementService, DefaultProject);
 			updatedPackages.SearchTerms = Filter;
 			return updatedPackages.GetUpdatedPackages().AsQueryable();
 		}
 		
 		IQueryable<IPackage> GetInstalledPackages()
 		{
-			IPackageRepository repository = CreatePackageRepositoryForActivePackageSource();
+			ISharpDevelopProjectManager projectManager = CreateProjectManagerForActiveProject();
-			ISharpDevelopProjectManager projectManager = CreateProjectManagerForActiveProject(repository);
 			IQueryable<IPackage> packages = projectManager.LocalRepository.GetPackages();
 			return FilterPackages(packages);
 		}
 		
-		ISharpDevelopProjectManager CreateProjectManagerForActiveProject(IPackageRepository repository)
+		ISharpDevelopProjectManager CreateProjectManagerForActiveProject()
 		{
-			return packageManagementService.CreateProjectManager(repository, DefaultProject);
+			IPackageRepository repository = CreatePackageRepositoryForActivePackageSource();
+			return CreateProjectManagerForActiveProject(repository);
 		}
 		
-		MSBuildBasedProject DefaultProject {
+		ISharpDevelopProjectManager CreateProjectManagerForActiveProject(IPackageRepository repository)
-			get { return consoleHost.DefaultProject as MSBuildBasedProject; }
+		{
+			return PackageManagementService.CreateProjectManager(repository, DefaultProject);
 		}
 		
 		IQueryable<IPackage> GetRecentPackages()
 		{
-			IQueryable<IPackage> packages = packageManagementService.RecentPackageRepository.GetPackages();
+			IQueryable<IPackage> packages = PackageManagementService.RecentPackageRepository.GetPackages();
 			return FilterPackages(packages);
 		}
 		

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/ICmdletTerminatingError.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.Cmdlets
+{
+	public interface ICmdletTerminatingError
+	{
+		void ThrowNoProjectOpenError();
+	}
+}

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

@@ -4,10 +4,10 @@
 using System;
 using System.Management.Automation;
 
-namespace ICSharpCode.PackageManagement.Scripting
+namespace ICSharpCode.PackageManagement.Cmdlets
 {
-	public interface IErrorRecordFactory
+	public interface ITerminatingCmdlet
 	{
-		ErrorRecord CreateNoProjectOpenErrorRecord();
+		void ThrowTerminatingError(ErrorRecord errorRecord);
 	}
 }

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

@@ -0,0 +1,80 @@
+// 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;
+using ICSharpCode.SharpDevelop.Project;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Cmdlets
+{
+	[Cmdlet(VerbsLifecycle.Install, "Package", DefaultParameterSetName = ParameterAttribute.AllParameterSets)]
+	public class InstallPackageCmdlet : PackageManagementCmdlet
+	{
+		public InstallPackageCmdlet()
+			: this(
+				ServiceLocator.PackageManagementService,
+				ServiceLocator.PackageManagementConsoleHost,
+				null)
+		{
+		}
+		
+		public InstallPackageCmdlet(
+			IPackageManagementService packageManagementService,
+			IPackageManagementConsoleHost consoleHost,
+			ICmdletTerminatingError terminatingError)
+			: base(packageManagementService, consoleHost, terminatingError)
+		{
+		}
+		
+		[Parameter(Position = 0, Mandatory = true)]
+		public string Id { get; set; }
+		
+		[Parameter(Position = 1)]
+		public string ProjectName { get; set; }
+		
+		[Parameter(Position = 2)]
+		public Version Version { get; set; }
+		
+		[Parameter(Position = 3)]
+		public string Source { get; set; }
+		
+		[Parameter]
+		public SwitchParameter IgnoreDependencies { get; set; }
+		
+		protected override void ProcessRecord()
+		{
+			ThrowErrorIfProjectNotOpen();
+			
+			InstallPackage();
+		}
+		
+		void ThrowErrorIfProjectNotOpen()
+		{
+			if (DefaultProject == null) {
+				ThrowProjectNotOpenTerminatorError();
+			}
+		}
+		
+		void InstallPackage()
+		{
+			PackageSource packageSource = GetActivePackageSource();
+			MSBuildBasedProject project = GetActiveProject();
+			PackageManagementService.InstallPackage(Id, Version, project, packageSource, IgnoreDependencies.IsPresent);
+		}
+		
+		PackageSource GetActivePackageSource()
+		{
+			return GetActivePackageSource(Source);
+		}
+		
+		MSBuildBasedProject GetActiveProject()
+		{
+			if (ProjectName != null) {
+				return PackageManagementService.GetProject(ProjectName);
+			}
+			return ConsoleHost.DefaultProject as MSBuildBasedProject;
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/PackageManagementCmdlet.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 System.Management.Automation;
+using ICSharpCode.PackageManagement.Scripting;
+using ICSharpCode.SharpDevelop.Project;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Cmdlets
+{
+	public abstract class PackageManagementCmdlet : PSCmdlet, ITerminatingCmdlet
+	{
+		IPackageManagementService packageManagementService;
+		IPackageManagementConsoleHost consoleHost;
+		ICmdletTerminatingError terminatingError;
+		
+		public PackageManagementCmdlet(
+			IPackageManagementService packageManagementService,
+			IPackageManagementConsoleHost consoleHost,
+			ICmdletTerminatingError terminatingError)
+		{
+			this.packageManagementService = packageManagementService;
+			this.consoleHost = consoleHost;
+			this.terminatingError = terminatingError;
+		}
+		
+		protected IPackageManagementService PackageManagementService {
+			get { return packageManagementService; }
+		}
+		
+		protected IPackageManagementConsoleHost ConsoleHost {
+			get { return consoleHost; }
+		}
+		
+		protected MSBuildBasedProject DefaultProject {
+			get { return consoleHost.DefaultProject as MSBuildBasedProject; }
+		}
+
+		protected ICmdletTerminatingError TerminatingError {
+			get {
+				if (terminatingError == null) {
+					terminatingError = new CmdletTerminatingError(this);
+				}
+				return terminatingError;
+			}
+		}
+			
+		protected void ThrowProjectNotOpenTerminatorError()
+		{
+			terminatingError.ThrowNoProjectOpenError();
+		}
+		
+		protected PackageSource GetActivePackageSource(string source)
+		{
+			if (source != null) {
+				return new PackageSource(source);
+			}
+			return ConsoleHost.ActivePackageSource;
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Helpers/FakeCmdletTerminatingError.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.Cmdlets;
+
+namespace PackageManagement.Cmdlets.Tests.Helpers
+{
+	public class FakeCmdletTerminatingError : ICmdletTerminatingError
+	{
+		public bool IsThrowNoProjectOpenErrorCalled;
+		
+		public void ThrowNoProjectOpenError()
+		{
+			IsThrowNoProjectOpenErrorCalled = true;
+		}
+	}
+}

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

@@ -1,20 +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 PackageManagement.Cmdlets.Tests.Helpers
-{
-	public class FakeErrorRecordFactory : IErrorRecordFactory
-	{
-		public ErrorRecord ErrorRecordToReturnFromCreateNoProjectOpenErrorRecord = 
-			new ErrorRecord(new InvalidOperationException(), "NoProjectOpen", ErrorCategory.InvalidOperation, null);
-		
-		public ErrorRecord CreateNoProjectOpenErrorRecord()
-		{
-			return ErrorRecordToReturnFromCreateNoProjectOpenErrorRecord;
-		}
-	}
-}

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

@@ -0,0 +1,19 @@
+// 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.Cmdlets;
+
+namespace PackageManagement.Cmdlets.Tests.Helpers
+{
+	public class FakeTerminatingCmdlet : ITerminatingCmdlet
+	{
+		public ErrorRecord ErrorRecordPassedToThrowTerminatingError;
+		
+		public void ThrowTerminatingError(ErrorRecord errorRecord)
+		{
+			ErrorRecordPassedToThrowTerminatingError = errorRecord;
+		}
+	}
+}

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

@@ -3,9 +3,7 @@
 
 using System;
 using System.Collections.Generic;
-using System.Management.Automation;
+using ICSharpCode.PackageManagement.Cmdlets;
-
-using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using NuGet;
 using PackageManagement.Tests.Helpers;
@@ -18,14 +16,14 @@ namespace PackageManagement.Cmdlets.Tests.Helpers
 		public FakeCommandRuntime FakeCommandRuntime;
 		public List<IPackage> PackagesPassedToWriteObject = new List<IPackage>();
 		public FakePackageManagementConsoleHost FakePackageManagementConsoleHost;
-		public FakeErrorRecordFactory FakeErrorRecordFactory;
+		public FakeCmdletTerminatingError FakeCmdletTerminatingError;
 		
 		public TestableGetPackageCmdlet()
 			: this(
 				new FakePackageManagementService(),
 				new FakePackageManagementConsoleHost(),
 				new FakeCommandRuntime(),
-				new FakeErrorRecordFactory())
+				new FakeCmdletTerminatingError())
 		{
 		}
 		
@@ -33,28 +31,19 @@ namespace PackageManagement.Cmdlets.Tests.Helpers
 			FakePackageManagementService packageManagementService,
 			FakePackageManagementConsoleHost consoleHost,
 			FakeCommandRuntime commandRuntime,
-			FakeErrorRecordFactory errorRecordFactory)
+			FakeCmdletTerminatingError terminatingError)
-			: base(packageManagementService, consoleHost, errorRecordFactory)
+			: base(packageManagementService, consoleHost, terminatingError)
 		{
 			this.FakePackageManagementService = packageManagementService;
 			this.FakePackageManagementConsoleHost = consoleHost;
 			this.FakeCommandRuntime = commandRuntime;
 			this.CommandRuntime = commandRuntime;
-			this.FakeErrorRecordFactory = errorRecordFactory;
+			this.FakeCmdletTerminatingError = terminatingError;
 		}
 		
 		public void RunProcessRecord()
 		{
 			base.ProcessRecord();
 		}
-		
-		public bool IsThrowTerminatingErrorCalled { get; set; }
-		public ErrorRecord ErrorRecordPassedToThrowTerminatingError;
-		
-		protected override void CmdletThrowTerminatingError(ErrorRecord errorRecord)
-		{
-			IsThrowTerminatingErrorCalled = true;
-			ErrorRecordPassedToThrowTerminatingError = errorRecord;
-		}
 	}
 }

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Helpers/TestableInstallPackageCmdlet.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.Design;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests.Helpers
+{
+	public class TestableInstallPackageCmdlet : InstallPackageCmdlet
+	{
+		public FakeCmdletTerminatingError FakeCmdletTerminatingError;
+		public FakePackageManagementConsoleHost FakePackageManagementConsoleHost;
+		public FakePackageManagementService FakePackageManagementService;
+		
+		public TestableInstallPackageCmdlet()
+			: this(
+				new FakePackageManagementService(),
+				new FakePackageManagementConsoleHost(),
+				new FakeCmdletTerminatingError())
+		{
+		}
+		
+		public TestableInstallPackageCmdlet(
+			FakePackageManagementService packageManagementService,
+			FakePackageManagementConsoleHost consoleHost,
+			FakeCmdletTerminatingError cmdletTerminatingError)
+			: base(packageManagementService, consoleHost, cmdletTerminatingError)
+		{
+			this.FakePackageManagementService = packageManagementService;
+			this.FakePackageManagementConsoleHost = consoleHost;
+			this.FakeCmdletTerminatingError = cmdletTerminatingError;
+		}
+				
+		public void CallProcessRecord()
+		{
+			base.ProcessRecord();
+		}
+	}
+}

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

@@ -43,10 +43,15 @@
       <Link>Configuration\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Configuration\AssemblyInfo.cs" />
+    <Compile Include="Helpers\FakeCmdletTerminatingError.cs" />
     <Compile Include="Helpers\FakeCommandRuntime.cs" />
-    <Compile Include="Helpers\FakeErrorRecordFactory.cs" />
+    <Compile Include="Helpers\FakeTerminatingCmdlet.cs" />
     <Compile Include="Helpers\TestableGetPackageCmdlet.cs" />
+    <Compile Include="Helpers\TestableInstallPackageCmdlet.cs" />
+    <Compile Include="Src\CmdletTerminatorErrorTests.cs" />
     <Compile Include="Src\GetPackageCmdletTests.cs" />
+    <Compile Include="Src\InstallPackageCmdletTests.cs" />
+    <Compile Include="Src\PackageManagementCmdletTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\Main\Base\Project\ICSharpCode.SharpDevelop.csproj">

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

@@ -0,0 +1,63 @@
+// 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.Cmdlets;
+using NUnit.Framework;
+using PackageManagement.Cmdlets.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests
+{
+	[TestFixture]
+	public class CmdletTerminatingErrorTests
+	{
+		CmdletTerminatingError terminatingError;
+		FakeTerminatingCmdlet fakeCmdlet;
+		
+		void CreateTerminatingError()
+		{
+			fakeCmdlet = new FakeTerminatingCmdlet();
+			terminatingError = new CmdletTerminatingError(fakeCmdlet);
+		}
+		
+		[Test]
+		public void ThrowNoProjectOpenError_NoProjectError_SendsNoProjectErrorToCmdletThrowTerminatingError()
+		{
+			CreateTerminatingError();
+			
+			terminatingError.ThrowNoProjectOpenError();
+			
+			var actualErrorId = fakeCmdlet.ErrorRecordPassedToThrowTerminatingError.FullyQualifiedErrorId;
+			var expectedErrorId = "NoProjectOpen";
+			
+			Assert.AreEqual(expectedErrorId, actualErrorId);
+		}
+		
+		[Test]
+		public void ThrowNoProjectOpenError_NoProjectError_ErrorRecordExceptionIsInvalidOperationException()
+		{
+			CreateTerminatingError();
+			
+			terminatingError.ThrowNoProjectOpenError();
+			
+			var ex = fakeCmdlet.ErrorRecordPassedToThrowTerminatingError.Exception;
+			bool result = ex is InvalidOperationException;
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void ThrowNoProjectOpenError_NoProjectError_ErrorRecordCategoryIsInvalidOperation()
+		{
+			CreateTerminatingError();
+			
+			terminatingError.ThrowNoProjectOpenError();
+			
+			var actualCategory = fakeCmdlet.ErrorRecordPassedToThrowTerminatingError.CategoryInfo.Category;
+			var expectedCategory = ErrorCategory.InvalidOperation;
+			
+			Assert.AreEqual(expectedCategory, actualCategory);
+		}
+	}
+}

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

@@ -12,21 +12,20 @@ using PackageManagement.Tests.Helpers;
 namespace PackageManagement.Cmdlets.Tests
 {
 	[TestFixture]
-	public class GetPackageCmdletTests
+	public class GetPackageCmdletTests : PackageManagementCmdletTests
 	{
 		TestableGetPackageCmdlet cmdlet;
-		FakePackageManagementService packageManagementService;
+		FakePackageManagementService fakePackageManagementService;
-		FakePackageManagementConsoleHost consoleHost;
+		FakeCommandRuntime fakeCommandRuntime;
-		FakeCommandRuntime commandRuntime;
+		FakeCmdletTerminatingError fakeTerminatingError;
-		FakeErrorRecordFactory errorRecordFactory;
 		
 		void CreateCmdlet()
 		{
 			cmdlet = new TestableGetPackageCmdlet();
-			packageManagementService = cmdlet.FakePackageManagementService;
+			fakePackageManagementService = cmdlet.FakePackageManagementService;
-			consoleHost = cmdlet.FakePackageManagementConsoleHost;
+			fakeConsoleHost = cmdlet.FakePackageManagementConsoleHost;
-			commandRuntime = cmdlet.FakeCommandRuntime;
+			fakeCommandRuntime = cmdlet.FakeCommandRuntime;
-			errorRecordFactory = cmdlet.FakeErrorRecordFactory;
+			fakeTerminatingError = cmdlet.FakeCmdletTerminatingError;
 		}
 		
 		void RunCmdlet()
@@ -44,28 +43,15 @@ namespace PackageManagement.Cmdlets.Tests
 			cmdlet.Updates = new SwitchParameter(true);
 		}
 		
-		TestableProject AddDefaultProjectToConsoleHost()
-		{
-			var project = ProjectHelper.CreateTestProject();
-			consoleHost.DefaultProject = project;
-			return project;
-		}
-
-		PackageSource AddPackageSourceToConsoleHost()
-		{
-			var source = new PackageSource("Test");
-			consoleHost.ActivePackageSource = source;
-			return source;
-		}
-		
 		FakePackage AddPackageToProjectManagerLocalRepository(string version)
 		{
 			return AddPackageToProjectManagerLocalRepository("Test", version);
 		}
+		
 		FakePackage AddPackageToProjectManagerLocalRepository(string id, string version)
 		{
 			var package = FakePackage.CreatePackageWithVersion(id, version);
-			packageManagementService
+			fakePackageManagementService
 				.FakeProjectManagerToReturnFromCreateProjectManager
 				.FakeLocalRepository
 				.FakePackages.Add(package);
@@ -79,7 +65,7 @@ namespace PackageManagement.Cmdlets.Tests
 		
 		FakePackage AddPackageToAggregateRepository(string id, string version)
 		{
-			return packageManagementService.AddFakePackageWithVersionToAggregrateRepository(id, version);
+			return fakePackageManagementService.AddFakePackageWithVersionToAggregrateRepository(id, version);
 		}
 		
 		void SetFilterParameter(string filter)
@@ -111,13 +97,13 @@ namespace PackageManagement.Cmdlets.Tests
 		public void ProcessRecord_ListAvailablePackagesWhenDefaultPackageSourceHasOnePackage_OutputIsPackagesFromPackageSourceRepository()
 		{
 			CreateCmdlet();
-			var repository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var repository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			repository.AddOneFakePackage("Test");
 			
 			EnableListAvailableParameter();
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = repository.FakePackages;
 			
 			CollectionAssert.AreEqual(expectedPackages, actualPackages);
@@ -127,7 +113,7 @@ namespace PackageManagement.Cmdlets.Tests
 		public void ProcessRecord_ListAvailablePackagesWhenDefaultPackageSourceHasThreePackages_OutputIsPackagesFromPackageSourceRepository()
 		{
 			CreateCmdlet();
-			var repository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var repository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			repository.AddOneFakePackage("A");
 			repository.AddOneFakePackage("B");
 			repository.AddOneFakePackage("C");
@@ -135,7 +121,7 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableListAvailableParameter();
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = repository.FakePackages;
 			
 			CollectionAssert.AreEqual(expectedPackages, actualPackages);
@@ -145,14 +131,14 @@ namespace PackageManagement.Cmdlets.Tests
 		public void ProcessRecord_ListAvailablePackagesWhenDefaultPackageSourceHasTwoPackages_PackagesAreSortedById()
 		{
 			CreateCmdlet();
-			var repository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var repository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			var packageB = repository.AddOneFakePackage("B");
 			var packageA = repository.AddOneFakePackage("A");
 			
 			EnableListAvailableParameter();
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				packageA,
 				packageB
@@ -170,7 +156,7 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableListAvailableParameter();
 			RunCmdlet();
 			
-			var actualSource = packageManagementService.PackageSourcePassedToCreatePackageRepository;
+			var actualSource = fakePackageManagementService.PackageSourcePassedToCreatePackageRepository;
 			
 			Assert.AreEqual(source, actualSource);
 		}
@@ -180,13 +166,13 @@ namespace PackageManagement.Cmdlets.Tests
 		{
 			CreateCmdlet();
 			AddDefaultProjectToConsoleHost();
-			FakeProjectManager projectManager = packageManagementService.FakeProjectManagerToReturnFromCreateProjectManager;
+			FakeProjectManager projectManager = fakePackageManagementService.FakeProjectManagerToReturnFromCreateProjectManager;
 			projectManager.FakeLocalRepository.AddOneFakePackage("One");
 			projectManager.FakeLocalRepository.AddOneFakePackage("Two");
 			
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = projectManager.FakeLocalRepository.FakePackages;
 			
 			Assert.AreEqual(expectedPackages, actualPackages);
@@ -200,7 +186,7 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			RunCmdlet();
 			
-			var actualSource = packageManagementService.PackageSourcePassedToCreatePackageRepository;
+			var actualSource = fakePackageManagementService.PackageSourcePassedToCreatePackageRepository;
 			
 			Assert.AreEqual(source, actualSource);
 		}
@@ -213,8 +199,8 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			RunCmdlet();
 			
-			var actualRepository = packageManagementService.PackageRepositoryPassedToCreateProjectManager;
+			var actualRepository = fakePackageManagementService.PackageRepositoryPassedToCreateProjectManager;
-			var expectedRepository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var expectedRepository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			
 			Assert.AreEqual(expectedRepository, actualRepository);
 		}
@@ -228,7 +214,7 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			RunCmdlet();
 			
-			var actualProject = packageManagementService.ProjectPassedToCreateProjectManager;
+			var actualProject = fakePackageManagementService.ProjectPassedToCreateProjectManager;
 			
 			Assert.AreEqual(project, actualProject);
 		}
@@ -244,7 +230,7 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableUpdatesParameter();
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				updatedPackage
 			};
@@ -260,7 +246,7 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableUpdatesParameter();
 			RunCmdlet();
 			
-			var actualProject = packageManagementService.ProjectPassedToCreateProjectManager;
+			var actualProject = fakePackageManagementService.ProjectPassedToCreateProjectManager;
 			
 			Assert.AreEqual(project, actualProject);
 		}
@@ -273,8 +259,8 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableUpdatesParameter();
 			RunCmdlet();
 			
-			var actualRepository = packageManagementService.PackageRepositoryPassedToCreateProjectManager;
+			var actualRepository = fakePackageManagementService.PackageRepositoryPassedToCreateProjectManager;
-			var expectedRepository = packageManagementService.FakeAggregateRepository;
+			var expectedRepository = fakePackageManagementService.FakeAggregateRepository;
 			
 			Assert.AreEqual(expectedRepository, actualRepository);
 		}
@@ -283,7 +269,7 @@ namespace PackageManagement.Cmdlets.Tests
 		public void ProcessRecord_ListAvailablePackagesAndFilterResults_PackagesReturnedMatchFilter()
 		{
 			CreateCmdlet();
-			var repository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var repository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			repository.AddOneFakePackage("A");
 			var package = repository.AddOneFakePackage("B");
 			repository.AddOneFakePackage("C");
@@ -292,7 +278,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetFilterParameter("B");
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				 package
 			};
@@ -305,14 +291,14 @@ namespace PackageManagement.Cmdlets.Tests
 		{
 			CreateCmdlet();
 			AddPackageSourceToConsoleHost();
-			FakeProjectManager projectManager = packageManagementService.FakeProjectManagerToReturnFromCreateProjectManager;
+			FakeProjectManager projectManager = fakePackageManagementService.FakeProjectManagerToReturnFromCreateProjectManager;
 			projectManager.FakeLocalRepository.AddOneFakePackage("A");
 			var package = projectManager.FakeLocalRepository.AddOneFakePackage("B");
 			
 			SetFilterParameter("B");
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				package
 			};
@@ -334,7 +320,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetFilterParameter("B");
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				updatedPackage
 			};
@@ -346,14 +332,14 @@ namespace PackageManagement.Cmdlets.Tests
 		public void ProcessRecord_ListAvailablePackagesWhenPackageSourceParameterSpecified_PackageRepositoryCreatedForPackageSourceSpecifiedByParameter()
 		{
 			CreateCmdlet();
-			var repository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var repository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			
 			SetSourceParameter("http://sharpdevelop.com/packages");
 			EnableListAvailableParameter();
 			RunCmdlet();
 			
-			var actualPackageSource = packageManagementService.PackageSourcePassedToCreatePackageRepository;
+			var actualPackageSource = fakePackageManagementService.PackageSourcePassedToCreatePackageRepository.Source;
-			var expectedPackageSource = new PackageSource("http://sharpdevelop.com/packages");
+			var expectedPackageSource = "http://sharpdevelop.com/packages";
 			
 			Assert.AreEqual(expectedPackageSource, actualPackageSource);
 		}
@@ -366,8 +352,8 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			RunCmdlet();
 			
-			var actualPackageSource = packageManagementService.PackageSourcePassedToCreatePackageRepository;
+			var actualPackageSource = fakePackageManagementService.PackageSourcePassedToCreatePackageRepository.Source;
-			var expectedPackageSource = new PackageSource("http://test");
+			var expectedPackageSource = "http://test";
 			
 			Assert.AreEqual(expectedPackageSource, actualPackageSource);
 		}
@@ -377,13 +363,13 @@ namespace PackageManagement.Cmdlets.Tests
 		{
 			CreateCmdlet();
 			
-			var recentPackageRepository = packageManagementService.FakeRecentPackageRepository;
+			var recentPackageRepository = fakePackageManagementService.FakeRecentPackageRepository;
 			recentPackageRepository.AddOneFakePackage("A");
 			
 			EnableRecentParameter();
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = recentPackageRepository.FakePackages;
 			
 			Assert.AreEqual(expectedPackages, actualPackages);
@@ -394,7 +380,7 @@ namespace PackageManagement.Cmdlets.Tests
 		{
 			CreateCmdlet();
 			
-			var recentPackageRepository = packageManagementService.FakeRecentPackageRepository;
+			var recentPackageRepository = fakePackageManagementService.FakeRecentPackageRepository;
 			recentPackageRepository.AddOneFakePackage("A");
 			var packageB = recentPackageRepository.AddOneFakePackage("B");
 			
@@ -402,7 +388,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetFilterParameter("B");
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				packageB
 			};
@@ -415,7 +401,7 @@ namespace PackageManagement.Cmdlets.Tests
 		{
 			CreateCmdlet();
 			AddPackageSourceToConsoleHost();
-			FakeProjectManager projectManager = packageManagementService.FakeProjectManagerToReturnFromCreateProjectManager;
+			FakeProjectManager projectManager = fakePackageManagementService.FakeProjectManagerToReturnFromCreateProjectManager;
 			var packageA = projectManager.FakeLocalRepository.AddOneFakePackage("A");
 			var packageB = projectManager.FakeLocalRepository.AddOneFakePackage("B");
 			var packageC = projectManager.FakeLocalRepository.AddOneFakePackage("C");
@@ -423,7 +409,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetFilterParameter("B C");
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				packageB,
 				packageC
@@ -440,7 +426,7 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			RunCmdlet();
 			
-			Assert.IsTrue(cmdlet.IsThrowTerminatingErrorCalled);
+			Assert.IsTrue(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
 		}
 		
 		[Test]
@@ -452,21 +438,7 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			RunCmdlet();
 			
-			Assert.IsFalse(cmdlet.IsThrowTerminatingErrorCalled);
+			Assert.IsFalse(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
-		}
-		
-		[Test]
-		public void ProcessRecord_RetrieveUpdatesWhenNoProjectIsOpen_ThrowsNoProjectOpenTerminatingError()
-		{
-			CreateCmdlet();
-			EnableUpdatesParameter();
-			
-			RunCmdlet();
-			
-			var actual = cmdlet.ErrorRecordPassedToThrowTerminatingError;
-			var expected = errorRecordFactory.ErrorRecordToReturnFromCreateNoProjectOpenErrorRecord;
-			
-			Assert.AreEqual(expected, actual);
 		}
 		
 		[Test]
@@ -475,10 +447,7 @@ namespace PackageManagement.Cmdlets.Tests
 			CreateCmdlet();
 			RunCmdlet();
 			
-			var actual = cmdlet.ErrorRecordPassedToThrowTerminatingError;
+			Assert.IsTrue(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
-			var expected = errorRecordFactory.ErrorRecordToReturnFromCreateNoProjectOpenErrorRecord;
-			
-			Assert.AreEqual(expected, actual);
 		}
 		
 		[Test]
@@ -488,9 +457,7 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableListAvailableParameter();
 			RunCmdlet();
 			
-			bool result = cmdlet.IsThrowTerminatingErrorCalled;
+			Assert.IsFalse(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
-			
-			Assert.IsFalse(result);
 		}
 		
 		[Test]
@@ -500,16 +467,14 @@ namespace PackageManagement.Cmdlets.Tests
 			EnableRecentParameter();
 			RunCmdlet();
 			
-			bool result = cmdlet.IsThrowTerminatingErrorCalled;
+			Assert.IsFalse(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
-			
-			Assert.IsFalse(result);
 		}
 		
 		[Test]
 		public void ProcessRecord_ListAvailableAndSkipFirstTwoPackages_ReturnsAllPackagesExceptionFirstTwo()
 		{
 			CreateCmdlet();
-			var repository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var repository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			repository.AddOneFakePackage("A");
 			repository.AddOneFakePackage("B");
 			var packageC = repository.AddOneFakePackage("C");			
@@ -518,7 +483,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetSkipParameter(2);
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				packageC
 			};
@@ -539,7 +504,7 @@ namespace PackageManagement.Cmdlets.Tests
 		public void ProcessRecord_ListAvailableAndTakeTwo_ReturnsFirstTwoPackages()
 		{
 			CreateCmdlet();
-			var repository = packageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
+			var repository = fakePackageManagementService.FakePackageRepositoryToReturnFromCreatePackageRepository;
 			var packageA = repository.AddOneFakePackage("A");
 			var packageB = repository.AddOneFakePackage("B");
 			repository.AddOneFakePackage("C");			
@@ -548,7 +513,7 @@ namespace PackageManagement.Cmdlets.Tests
 			SetTakeParameter(2);
 			RunCmdlet();
 			
-			var actualPackages = commandRuntime.ObjectsPassedToWriteObject;
+			var actualPackages = fakeCommandRuntime.ObjectsPassedToWriteObject;
 			var expectedPackages = new FakePackage[] {
 				packageA,
 				packageB

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

@@ -0,0 +1,231 @@
+// 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.Design;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Cmdlets.Tests.Helpers;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests
+{
+	[TestFixture]
+	public class InstallPackageCmdletTests : PackageManagementCmdletTests
+	{
+		TestableInstallPackageCmdlet cmdlet;
+		FakeCmdletTerminatingError fakeTerminatingError;
+		FakePackageManagementService fakePackageManagementService;
+		
+		void CreateCmdletWithoutActiveProject()
+		{
+			cmdlet = new TestableInstallPackageCmdlet();
+			fakeTerminatingError = cmdlet.FakeCmdletTerminatingError;
+			fakeConsoleHost = cmdlet.FakePackageManagementConsoleHost;
+			fakePackageManagementService = cmdlet.FakePackageManagementService;
+		}
+				
+		void CreateCmdletWithActivePackageSourceAndProject()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddPackageSourceToConsoleHost();
+			AddDefaultProjectToConsoleHost();
+		}
+
+		void RunCmdlet()
+		{
+			cmdlet.CallProcessRecord();
+		}
+		
+		void SetIdParameter(string id)
+		{
+			cmdlet.Id = id;
+		}
+		
+		void EnableIgnoreDependenciesParameter()
+		{
+			cmdlet.IgnoreDependencies = new SwitchParameter(true);
+		}
+		
+		void SetSourceParameter(string source)
+		{
+			cmdlet.Source = source;
+		}
+		
+		void SetVersionParameter(Version version)
+		{
+			cmdlet.Version = version;
+		}
+		
+		void SetProjectNameParameter(string name)
+		{
+			cmdlet.ProjectName = name;
+		}
+		
+		[Test]
+		public void ProcessRecord_NoActiveProject_ThrowsNoProjectOpenTerminatingError()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			RunCmdlet();
+						
+			Assert.IsTrue(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
+		}
+		
+		[Test]
+		public void ProcessRecord_ProjectIsActiveInConsoleHost_NoTerminatingErrorThrown()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			Assert.IsFalse(fakeTerminatingError.IsThrowNoProjectOpenErrorCalled);
+		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_PackageIdUsedToInstallPackage()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			var actualPackageId = fakePackageManagementService.PackageIdPassedToInstallPackage;
+			
+			Assert.AreEqual("Test", actualPackageId);
+		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_ActivePackageSourceUsedToInstallPackage()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddDefaultProjectToConsoleHost();
+			var packageSource = AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			var actualPackageSource = fakePackageManagementService.PackageSourcePassedToInstallPackage;
+			
+			Assert.AreEqual(packageSource, actualPackageSource);
+		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_ActiveProjectUsedToInstallPackage()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddPackageSourceToConsoleHost();
+			var project = AddDefaultProjectToConsoleHost();
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			var actualProject = fakePackageManagementService.ProjectPassedToInstallPackage;
+			
+			Assert.AreEqual(project, actualProject);
+		}
+		
+		[Test]
+		public void ProcessRecord_IgnoreDependenciesParameterSet_IgnoreDependenciesIsTrueWhenInstallingPackage()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			EnableIgnoreDependenciesParameter();
+			RunCmdlet();
+			
+			bool result = fakePackageManagementService.IgnoreDependenciesPassedToInstallPackage;
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void ProcessRecord_IgnoreDependenciesParameterNotSet_IgnoreDependenciesIsFalseWhenInstallingPackage()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			bool result = fakePackageManagementService.IgnoreDependenciesPassedToInstallPackage;
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void ProcessRecord_SourceParameterSet_CustomSourceUsedWhenInstallingPackage()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			SetSourceParameter("http://sharpdevelop.net/packages");
+			RunCmdlet();
+			
+			var expected = "http://sharpdevelop.net/packages";
+			var actual = fakePackageManagementService.PackageSourcePassedToInstallPackage.Source;
+			
+			Assert.AreEqual(expected, actual);
+		}
+		
+		[Test]
+		public void ProcessRecord_PackageVersionParameterSet_VersionUsedWhenInstallingPackage()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			var version = new Version("1.0.1");
+			SetVersionParameter(version);
+			RunCmdlet();
+			
+			var actualVersion = fakePackageManagementService.VersionPassedToInstallPackage;
+			
+			Assert.AreEqual(version, actualVersion);
+		}
+		
+		[Test]
+		public void ProcessRecord_PackageVersionParameterNotSet_VersionUsedWhenInstallingPackageIsNull()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			RunCmdlet();
+			
+			var actualVersion = fakePackageManagementService.VersionPassedToInstallPackage;
+			
+			Assert.IsNull(actualVersion);
+		}
+		
+		[Test]
+		public void ProcessRecord_ProjectNameSpecified_ProjectMatchingProjectNameUsedWhenInstallingPackage()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			fakePackageManagementService.FakeProjectToReturnFromGetProject = ProjectHelper.CreateTestProject();
+			
+			SetIdParameter("Test");
+			SetProjectNameParameter("MyProject");
+			RunCmdlet();
+			
+			var actualProject = fakePackageManagementService.ProjectPassedToInstallPackage;
+			var expectedProject = fakePackageManagementService.FakeProjectToReturnFromGetProject;
+			
+			Assert.AreEqual(expectedProject, actualProject);
+		}
+		
+		[Test]
+		public void ProcessRecord_ProjectNameSpecified_ProjectNameUsedToFindProject()
+		{
+			CreateCmdletWithActivePackageSourceAndProject();
+			
+			SetIdParameter("Test");
+			SetProjectNameParameter("MyProject");
+			RunCmdlet();
+			
+			var actual = fakePackageManagementService.NamePassedToGetProject;
+			var expected = "MyProject";
+			
+			Assert.AreEqual(expected, actual);
+		}
+	}
+}

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

@@ -0,0 +1,24 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using NuGet;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Cmdlets.Tests
+{
+	public abstract class PackageManagementCmdletTests
+	{
+		protected FakePackageManagementConsoleHost fakeConsoleHost;
+		
+		protected TestableProject AddDefaultProjectToConsoleHost()
+		{
+			return fakeConsoleHost.AddFakeDefaultProject();
+		}
+		
+		protected PackageSource AddPackageSourceToConsoleHost()
+		{
+			return fakeConsoleHost.AddTestPackageSource();
+		}
+	}
+}

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

@@ -85,6 +85,7 @@
     <Compile Include="Src\Design\FakePackageManagementOutputMessagesView.cs" />
     <Compile Include="Src\Design\FakePackageManagementProjectService.cs" />
     <Compile Include="Src\Design\FakePackageManagementService.cs" />
+    <Compile Include="Src\Design\FakePackageManager.cs" />
     <Compile Include="Src\Design\FakePackageRepository.cs" />
     <Compile Include="Src\Design\FakeProjectManager.cs" />
     <Compile Include="Src\Design\FakeProjectSystem.cs" />
@@ -94,9 +95,11 @@
     <Compile Include="Src\IMessageViewCategory.cs" />
     <Compile Include="Src\IPackageManagementOutputMessagesView.cs" />
     <Compile Include="Src\IPackageRepositoryCache.cs" />
+    <Compile Include="Src\IPackageOperationResolverFactory.cs" />
     <Compile Include="Src\PackageManagementCompilerMessageView.cs" />
     <Compile Include="Src\PackageManagementMessageViewCategory.cs" />
     <Compile Include="Src\PackageManagementOutputMessagesView.cs" />
+    <Compile Include="Src\PackageOperationsResolverFactory.cs" />
     <Compile Include="Src\PackageRepositoryCache.cs" />
     <Compile Include="Src\PackagesForSelectedPageResult.cs" />
     <Compile Include="Src\ILicenseAcceptanceService.cs" />
@@ -140,8 +143,6 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Src\PackagesViewModel.cs" />
-    <Compile Include="Src\Scripting\ErrorRecordFactory.cs" />
-    <Compile Include="Src\Scripting\IErrorRecordFactory.cs" />
     <Compile Include="Src\Scripting\PowerShellHostRawUserInterface.cs" />
     <Compile Include="Src\UpdatedPackagesViewModel.cs" />
     <Compile Include="Src\PackageViewModel.cs" />

src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManagementProjectService.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.SharpDevelop.Project;
 using ICSharpCode.PackageManagement;
 
@@ -51,5 +52,27 @@ namespace ICSharpCode.PackageManagement.Design
 				SolutionFolderRemoved(this, new SolutionFolderEventArgs(solutionFolder));
 			}
 		}
+		
+		public List<IProject> OpenProjects = new List<IProject>();
+		
+		public void AddFakeProject(IProject project)
+		{
+			OpenProjects.Add(project);
+		}
+		
+		public IEnumerable<IProject> GetOpenProjects()
+		{
+			return OpenProjects;
+		}
+		
+		public void AddProjectItem(IProject project, ProjectItem item)
+		{
+			ProjectService.AddProjectItem(project, item);
+		}
+		
+		public void Save(IProject project)
+		{
+			project.Save();
+		}
 	}
 }

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

@@ -166,6 +166,14 @@ namespace ICSharpCode.PackageManagement.Design
 			return FakeProjectManagerToReturnFromCreateProjectManager;
 		}
 		
+		public FakePackageManager FakePackageManagerToReturnFromCreatePackageManagerForActiveProject =
+			new FakePackageManager();
+		
+		public virtual ISharpDevelopPackageManager CreatePackageManagerForActiveProject()
+		{
+			return FakePackageManagerToReturnFromCreatePackageManagerForActiveProject;
+		}
+		
 		public FakePackage AddFakePackageWithVersionToAggregrateRepository(string version)
 		{
 			return AddFakePackageWithVersionToAggregrateRepository("Test", version);
@@ -177,5 +185,34 @@ namespace ICSharpCode.PackageManagement.Design
 			FakeAggregateRepository.FakePackages.Add(package);
 			return package;
 		}
+		
+		public string PackageIdPassedToInstallPackage;
+		public PackageSource PackageSourcePassedToInstallPackage;
+		public MSBuildBasedProject ProjectPassedToInstallPackage;
+		public bool IgnoreDependenciesPassedToInstallPackage;
+		public Version VersionPassedToInstallPackage;
+		
+		public void InstallPackage(
+			string packageId,
+			Version version,
+			MSBuildBasedProject project,
+			PackageSource packageSource,
+			bool ignoreDependencies)
+		{
+			PackageIdPassedToInstallPackage = packageId;
+			VersionPassedToInstallPackage = version;
+			ProjectPassedToInstallPackage = project;
+			PackageSourcePassedToInstallPackage = packageSource;
+			IgnoreDependenciesPassedToInstallPackage = ignoreDependencies;
+		}
+		
+		public MSBuildBasedProject FakeProjectToReturnFromGetProject;
+		public string NamePassedToGetProject;
+		
+		public MSBuildBasedProject GetProject(string name)
+		{
+			NamePassedToGetProject = name;
+			return FakeProjectToReturnFromGetProject;
+		}
 	}
 }

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

@@ -4,10 +4,9 @@
 using System;
 using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
-using ICSharpCode.PackageManagement.Design;
 using NuGet;
 
-namespace PackageManagement.Tests.Helpers
+namespace ICSharpCode.PackageManagement.Design
 {
 	public class FakePackageManager : ISharpDevelopPackageManager
 	{
@@ -35,7 +34,6 @@ namespace PackageManagement.Tests.Helpers
 					PackagePassedToInstallPackage,
 					IgnoreDependenciesPassedToInstallPackage);
 			}
-			
 		}
 		
 		#pragma warning disable 67
@@ -63,13 +61,6 @@ namespace PackageManagement.Tests.Helpers
 			ProjectManager = FakeProjectManager;
 		}
 		
-		public void InstallPackage(IPackage package)
-		{
-			LoggerSetBeforeInstallPackageCalled = Logger;
-			
-			InstallPackage(package, false);
-		}
-		
 		public void InstallPackage(IPackage package, bool ignoreDependencies)
 		{
 			LoggerSetBeforeInstallPackageCalled = Logger;
@@ -115,7 +106,7 @@ namespace PackageManagement.Tests.Helpers
 			throw new NotImplementedException();
 		}
 		
-		public void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations)
+		public void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations, bool ignoreDependencies)
 		{
 			LoggerSetBeforeInstallPackageCalled = Logger;
 			
@@ -125,7 +116,20 @@ namespace PackageManagement.Tests.Helpers
 			ParametersPassedToInstallPackage.PackagePassedToInstallPackage = package;
 			ParametersPassedToInstallPackage.PackageOperationsPassedToInstallPackage = operations;
 			
+			IgnoreDependenciesPassedToInstallPackage = ignoreDependencies;
+			
 			IsRefreshProjectBrowserCalledWhenInstallPackageCalled = FakeProjectService.IsRefreshProjectBrowserCalled;
 		}
+		
+		public List<PackageOperation> PackageOperationsToReturnFromGetInstallPackageOperations = new List<PackageOperation>();
+		public IPackage PackagePassedToGetInstallPackageOperations;
+		public bool IgnoreDependenciesPassedToGetInstallPackageOperations;
+		
+		public IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, bool ignoreDependencies)
+		{
+			PackagePassedToGetInstallPackageOperations = package;
+			IgnoreDependenciesPassedToGetInstallPackageOperations = ignoreDependencies;
+			return PackageOperationsToReturnFromGetInstallPackageOperations;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementProjectService.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.SharpDevelop.Project;
 
 namespace ICSharpCode.PackageManagement
@@ -17,5 +18,9 @@ namespace ICSharpCode.PackageManagement
 		event EventHandler<SolutionEventArgs> SolutionLoaded;
 		
 		void RefreshProjectBrowser();
+		void AddProjectItem(IProject project, ProjectItem item);
+		void Save(IProject project);
+		
+		IEnumerable<IProject> GetOpenProjects();		
 	}
 }

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

@@ -16,13 +16,23 @@ namespace ICSharpCode.PackageManagement
 		IPackageRepository CreateAggregatePackageRepository();
 		IPackageRepository CreatePackageRepository(PackageSource source);
 		ISharpDevelopProjectManager CreateProjectManager(IPackageRepository repository, MSBuildBasedProject project);
+		ISharpDevelopPackageManager CreatePackageManagerForActiveProject();
 		
 		IPackageRepository ActivePackageRepository { get; }
 		IProjectManager ActiveProjectManager { get; }
 		IPackageRepository RecentPackageRepository { get; }
 		
 		void InstallPackage(IPackageRepository repository, IPackage package, IEnumerable<PackageOperation> operations);
+		void InstallPackage(
+			string packageId,
+			Version version,
+			MSBuildBasedProject project,
+			PackageSource packageSource,
+			bool ignoreDependencies);
+		
 		void UninstallPackage(IPackageRepository repository, IPackage package);
+		
+		MSBuildBasedProject GetProject(string name);
 
 		PackageManagementOptions Options { get; }
 		

src/AddIns/Misc/PackageManagement/Project/Src/IPackageOperationResolverFactory.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;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public interface IPackageOperationResolverFactory
+	{
+		IPackageOperationResolver CreateInstallPackageOperationResolver(
+			IPackageRepository localRepository,
+			IPackageRepository sourceRepository,
+			ILogger logger,
+			bool ignoreDependencies);
+	}
+}

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

@@ -10,8 +10,9 @@ namespace ICSharpCode.PackageManagement
 	public interface ISharpDevelopPackageManager : IPackageManager
 	{
 		ISharpDevelopProjectManager ProjectManager { get; }
-		void InstallPackage(IPackage package);
+		
-		void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations);
+		void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations, bool ignoreDependencies);
 		void UninstallPackage(IPackage package);
+		IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, bool ignoreDependencies);
 	}
 }

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

@@ -2,6 +2,8 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
+using ICSharpCode.SharpDevelop.Gui;
 using ICSharpCode.SharpDevelop.Project;
 using ICSharpCode.SharpDevelop.Project.Commands;
 
@@ -19,8 +21,41 @@ namespace ICSharpCode.PackageManagement
 		
 		public void RefreshProjectBrowser()
 		{
-			var refreshCommand = new RefreshProjectBrowser();
+			if (WorkbenchSingleton.InvokeRequired) {
-			refreshCommand.Run();
+				WorkbenchSingleton.SafeThreadAsyncCall(RefreshProjectBrowser);
+			} else {
+				var refreshCommand = new RefreshProjectBrowser();
+				refreshCommand.Run();
+			}
+		}
+		
+		public IEnumerable<IProject> GetOpenProjects()
+		{
+			Solution solution = OpenSolution;
+			if (solution != null) {
+				return solution.Projects;
+			}
+			return new IProject[0];
+		}
+		
+		public void AddProjectItem(IProject project, ProjectItem item)
+		{
+			if (WorkbenchSingleton.InvokeRequired) {
+				Action<IProject, ProjectItem> action = AddProjectItem;
+				WorkbenchSingleton.SafeThreadCall<IProject, ProjectItem>(action, project, item);
+			} else {
+				ProjectService.AddProjectItem(project, item);
+			}
+		}
+		
+		public void Save(IProject project)
+		{
+			if (WorkbenchSingleton.InvokeRequired) {
+				Action<IProject> action = Save;
+				WorkbenchSingleton.SafeThreadCall<IProject>(action, project);
+			} else {
+				project.Save();
+			}
 		}
 		
 		public event ProjectEventHandler ProjectAdded {

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

@@ -84,7 +84,7 @@ namespace ICSharpCode.PackageManagement
 			}
 		}
 		
-		public IPackageRepository CreateRecentPackageRepository()
+		IPackageRepository CreateRecentPackageRepository()
 		{
 			recentPackageRepository = new RecentPackageRepository(this);
 			return recentPackageRepository;
@@ -115,9 +115,19 @@ namespace ICSharpCode.PackageManagement
 			return packageManager.ProjectManager;
 		}
 		
+		public ISharpDevelopPackageManager CreatePackageManagerForActiveProject()
+		{
+			return CreatePackageManager(ActivePackageRepository);
+		}
+		
 		ISharpDevelopPackageManager CreatePackageManager(IPackageRepository packageRepository)
 		{
 			MSBuildBasedProject project = projectService.CurrentProject as MSBuildBasedProject;
+			return CreatePackageManager(packageRepository, project);
+		}
+		
+		ISharpDevelopPackageManager CreatePackageManager(IPackageRepository packageRepository, MSBuildBasedProject project)
+		{
 			ISharpDevelopPackageManager packageManager = packageManagerFactory.CreatePackageManager(packageRepository, project);
 			ConfigureLogger(packageManager);
 			return packageManager;
@@ -125,7 +135,7 @@ namespace ICSharpCode.PackageManagement
 		
 		public ISharpDevelopProjectManager CreateProjectManager(IPackageRepository repository, MSBuildBasedProject project)
 		{
-			ISharpDevelopPackageManager packageManager = packageManagerFactory.CreatePackageManager(repository, project);
+			ISharpDevelopPackageManager packageManager = CreatePackageManager(repository, project);
 			return packageManager.ProjectManager;
 		}
 		
@@ -145,12 +155,56 @@ namespace ICSharpCode.PackageManagement
 			IEnumerable<PackageOperation> operations)
 		{
 			ISharpDevelopPackageManager packageManager = CreatePackageManager(packageRepository);
-			packageManager.InstallPackage(package, operations);
+			bool ignoreDependencies = false;
+			InstallPackage(packageManager, package, operations, ignoreDependencies);
+		}
+		
+		void InstallPackage(
+			IPackageRepository packageRepository,
+			IPackage package,
+			IEnumerable<PackageOperation> operations,
+			bool ignoreDependencies)
+		{
+			ISharpDevelopPackageManager packageManager = CreatePackageManager(packageRepository);
+			InstallPackage(packageManager, package, operations, ignoreDependencies);
+		}
+		
+		void InstallPackage(
+			ISharpDevelopPackageManager packageManager,
+			IPackage package,
+			IEnumerable<PackageOperation> operations,
+			bool ignoreDependencies)
+		{
+			packageManager.InstallPackage(package, operations, ignoreDependencies);
 			projectService.RefreshProjectBrowser();
 			RecentPackageRepository.AddPackage(package);
 			OnPackageInstalled();
 		}
 		
+		public void InstallPackage(
+			string packageId,
+			Version version,
+			MSBuildBasedProject project,
+			PackageSource packageSource,
+			bool ignoreDependencies)
+		{
+			ISharpDevelopPackageManager packageManager = CreatePackageManager(packageSource, project);
+			IPackage package = packageManager.SourceRepository.FindPackage(packageId, version);
+			InstallPackage(packageManager, package, ignoreDependencies);
+		}
+		
+		void InstallPackage(ISharpDevelopPackageManager packageManager, IPackage package, bool ignoreDependencies)
+		{
+			IEnumerable<PackageOperation> operations = packageManager.GetInstallPackageOperations(package, ignoreDependencies);
+			InstallPackage(packageManager, package, operations, ignoreDependencies);
+		}
+		
+		ISharpDevelopPackageManager CreatePackageManager(PackageSource packageSource, MSBuildBasedProject project)
+		{
+			IPackageRepository packageRepository = CreatePackageRepository(packageSource);
+			return CreatePackageManager(packageRepository, project);
+		}
+		
 		public void UninstallPackage(IPackageRepository repository, IPackage package)
 		{
 			ISharpDevelopPackageManager packageManager = CreatePackageManager(repository);
@@ -197,5 +251,20 @@ namespace ICSharpCode.PackageManagement
 		{
 			return packageRepositoryCache.CreateRepository(source);
 		}
+		
+		public MSBuildBasedProject GetProject(string name)
+		{
+			foreach (IProject project in projectService.GetOpenProjects()) {
+				if (IsProjectNameMatch(project.Name, name)) {
+					return project as MSBuildBasedProject;
+				}
+			}
+			return null;
+		}
+		
+		bool IsProjectNameMatch(string a, string b)
+		{
+			return String.Equals(a, b, StringComparison.InvariantCultureIgnoreCase);
+		}
 	}
 }

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

@@ -0,0 +1,20 @@
+// 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
+{
+	public class PackageOperationsResolverFactory : IPackageOperationResolverFactory
+	{
+		public IPackageOperationResolver CreateInstallPackageOperationResolver(
+			IPackageRepository localRepository,
+			IPackageRepository sourceRepository,
+			ILogger logger,
+			bool ignoreDependencies)
+		{
+			return new InstallWalker(localRepository, sourceRepository, logger, ignoreDependencies);
+		}
+	}
+}

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

@@ -20,7 +20,6 @@ namespace ICSharpCode.PackageManagement
 		IPackage package;
 		IEnumerable<PackageOperation> packageOperations = new PackageOperation[0];
 		IPackageRepository sourcePackageRepository;
-		IPackageRepository localPackageRepository;
 		bool? hasDependencies;
 		
 		public PackageViewModel(
@@ -43,25 +42,7 @@ namespace ICSharpCode.PackageManagement
 			addPackageCommand = new DelegateCommand(param => AddPackage());
 			removePackageCommand = new DelegateCommand(param => RemovePackage());
 		}
-		
+	
-		public IPackageRepository SourcePackageRepository {
-			get { return sourcePackageRepository; }
-		}
-		
-		public IPackageRepository LocalPackageRepository {
-			get {
-				if (localPackageRepository == null) {
-					GetLocalPackageRepository();
-				}
-				return localPackageRepository;
-			}
-		}
-		
-		void GetLocalPackageRepository()
-		{
-			localPackageRepository = packageManagementService.ActiveProjectManager.LocalRepository;
-		}
-		
 		public ICommand AddPackageCommand {
 			get { return addPackageCommand; }
 		}
@@ -229,21 +210,15 @@ namespace ICSharpCode.PackageManagement
 		
 		void GetPackageOperations()
 		{
-			IPackageOperationResolver resolver = CreatePackageOperationResolver();
+			ISharpDevelopPackageManager packageManager = CreatePackageManagerForActiveProject();
-			packageOperations = resolver.ResolveOperations(package);
+			packageOperations = packageManager.GetInstallPackageOperations(package, false);
-		}
-		
-		IPackageOperationResolver CreatePackageOperationResolver()
-		{
-			return CreatePackageOperationResolver(Logger);
 		}
 		
-		protected virtual IPackageOperationResolver CreatePackageOperationResolver(ILogger logger)
+		ISharpDevelopPackageManager CreatePackageManagerForActiveProject()
 		{
-			return new InstallWalker(LocalPackageRepository,
+			ISharpDevelopPackageManager packageManager = packageManagementService.CreatePackageManagerForActiveProject();
-			                         sourcePackageRepository,
+			packageManager.Logger = Logger;
-			                         logger,
+			return packageManager;
-			                         ignoreDependencies: false);
 		}
 		
 		bool CanInstallPackage()

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

@@ -1,20 +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;
-
-namespace ICSharpCode.PackageManagement.Scripting
-{
-	public class ErrorRecordFactory : IErrorRecordFactory
-	{
-		public ErrorRecord CreateNoProjectOpenErrorRecord()
-		{
-			return new ErrorRecord(
-				new InvalidOperationException("No project is currently open."),
-				"NoProjectOpen",
-				ErrorCategory.InvalidOperation,
-				null);
-		}
-	}
-}

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

@@ -118,6 +118,6 @@ namespace ICSharpCode.PackageManagement.Scripting
 		void ProcessLine(string line)
 		{
 			powerShellHost.ExecuteCommand(line);
-		}		
+		}
 	}
 }

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

@@ -11,13 +11,15 @@ namespace ICSharpCode.PackageManagement
 	public class SharpDevelopPackageManager : PackageManager, ISharpDevelopPackageManager
 	{
 		IProjectSystem projectSystem;
+		IPackageOperationResolverFactory packageOperationResolverFactory;
 		
 		public SharpDevelopPackageManager(
 			IPackageRepository sourceRepository,
 			IProjectSystem projectSystem,
 			IFileSystem fileSystem,
 			ISharedPackageRepository localRepository,
-			IPackagePathResolver pathResolver)
+			IPackagePathResolver pathResolver,
+			IPackageOperationResolverFactory packageOperationResolverFactory)
 			: base(
 				sourceRepository,
 				pathResolver,
@@ -25,6 +27,7 @@ namespace ICSharpCode.PackageManagement
 				localRepository)
 		{
 			this.projectSystem = projectSystem;
+			this.packageOperationResolverFactory = packageOperationResolverFactory;
 			CreateProjectManager();
 		}
 		
@@ -61,17 +64,11 @@ namespace ICSharpCode.PackageManagement
 			InstallPackage(package, ignoreDependencies);
 		}
 		
-		public void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations)
+		public void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations, bool ignoreDependencies)
 		{
 			foreach (PackageOperation operation in operations) {
 				Execute(operation);
 			}
-			AddPackageReference(package);
-		}
-
-		void AddPackageReference(IPackage package)
-		{
-			bool ignoreDependencies = false;
 			AddPackageReference(package, ignoreDependencies);
 		}
 		
@@ -91,5 +88,20 @@ namespace ICSharpCode.PackageManagement
 			ProjectManager.RemovePackageReference(package.Id, forceRemove, removeDependencies);
 			base.UninstallPackage(package, forceRemove, removeDependencies);
 		}
+		
+		public IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, bool ignoreDependencies)
+		{
+			IPackageOperationResolver resolver = CreateInstallPackageOperationResolver(ignoreDependencies);
+			return resolver.ResolveOperations(package);
+		}
+		
+		IPackageOperationResolver CreateInstallPackageOperationResolver(bool ignoreDependencies)
+		{
+			return packageOperationResolverFactory.CreateInstallPackageOperationResolver(
+				LocalRepository,
+				SourceRepository,
+				Logger,
+				ignoreDependencies);
+		}
 	}
 }

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

@@ -14,15 +14,17 @@ namespace ICSharpCode.PackageManagement
 		ISharpDevelopProjectSystemFactory projectSystemFactory;
 		
 		public SharpDevelopPackageManagerFactory()
-			: this(new SharpDevelopPackageRepositoryFactory(),
+			: this(
-			       new SharpDevelopProjectSystemFactory(),
+				new SharpDevelopPackageRepositoryFactory(),
-			       new PackageManagementOptions())
+				new SharpDevelopProjectSystemFactory(),
+				new PackageManagementOptions())
 		{
 		}
 		
-		public SharpDevelopPackageManagerFactory(ISharpDevelopPackageRepositoryFactory packageRepositoryFactory,
+		public SharpDevelopPackageManagerFactory(
-		                                         ISharpDevelopProjectSystemFactory projectSystemFactory,
+			ISharpDevelopPackageRepositoryFactory packageRepositoryFactory,
-		                                         PackageManagementOptions options)
+		    ISharpDevelopProjectSystemFactory projectSystemFactory,
+		    PackageManagementOptions options)
 		{
 			this.packageRepositoryFactory = packageRepositoryFactory;
 			this.projectSystemFactory = projectSystemFactory;
@@ -49,7 +51,15 @@ namespace ICSharpCode.PackageManagement
 			DefaultPackagePathResolver pathResolver = new DefaultPackagePathResolver(fileSystem);
 			ISharedPackageRepository sharedRepository = CreateSharedRepository(pathResolver, fileSystem);
 			IProjectSystem projectSystem = CreateProjectSystem(project);
-			return new SharpDevelopPackageManager(packageRepository, projectSystem, fileSystem, sharedRepository, pathResolver);
+			PackageOperationsResolverFactory packageOperationResolverFactory = new PackageOperationsResolverFactory();
+			
+			return new SharpDevelopPackageManager(
+				packageRepository,
+				projectSystem,
+				fileSystem,
+				sharedRepository,
+				pathResolver,
+				packageOperationResolverFactory);
 		}
 		
 		IProjectSystem CreateProjectSystem(MSBuildBasedProject project)

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

@@ -17,17 +17,22 @@ namespace ICSharpCode.PackageManagement
 		MSBuildBasedProject project;
 		ProjectTargetFramework targetFramework;
 		IPackageManagementFileService fileService;
+		IPackageManagementProjectService projectService;
 		
 		public SharpDevelopProjectSystem(MSBuildBasedProject project)
-			: this(project, new PackageManagementFileService())
+			: this(project, new PackageManagementFileService(), new PackageManagementProjectService())
 		{
 		}
 		
-		public SharpDevelopProjectSystem(MSBuildBasedProject project, IPackageManagementFileService fileService)
+		public SharpDevelopProjectSystem(
+			MSBuildBasedProject project,
+			IPackageManagementFileService fileService,
+			IPackageManagementProjectService projectService)
 			: base(AppendTrailingSlashToDirectory(project.Directory))
 		{
 			this.project = project;
 			this.fileService = fileService;
+			this.projectService = projectService;
 		}
 		
 		static string AppendTrailingSlashToDirectory(string directory)
@@ -59,8 +64,8 @@ namespace ICSharpCode.PackageManagement
 		public void AddReference(string referencePath, Stream stream)
 		{
 			ReferenceProjectItem assemblyReference = CreateReference(referencePath);
-			ProjectService.AddProjectItem(project, assemblyReference);
+			projectService.AddProjectItem(project, assemblyReference);
-			project.Save();
+			projectService.Save(project);
 			LogAddedReferenceToProject(assemblyReference);
 		}
 		
@@ -177,8 +182,8 @@ namespace ICSharpCode.PackageManagement
 		void AddFileToProject(string path)
 		{
 			FileProjectItem fileItem = CreateFileProjectItem(path);
-			ProjectService.AddProjectItem(project, fileItem);
+			projectService.AddProjectItem(project, fileItem);
-			project.Save();
+			projectService.Save(project);
 		}
 		
 		FileProjectItem CreateFileProjectItem(string path)

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

@@ -78,9 +78,9 @@
     <Compile Include="Src\Helpers\FakeMessageReporter.cs" />
     <Compile Include="Src\Helpers\FakePackageManagementAddInPath.cs" />
     <Compile Include="Src\Helpers\FakePackageManagementConsoleHost.cs" />
-    <Compile Include="Src\Helpers\FakePackageManager.cs" />
     <Compile Include="Src\Helpers\FakePackageManagerFactory.cs" />
     <Compile Include="Src\Helpers\FakePackageOperationResolver.cs" />
+    <Compile Include="Src\Helpers\FakePackageOperationResolverFactory.cs" />
     <Compile Include="Src\Helpers\FakePackageRepositoryFactory.cs" />
     <Compile Include="Src\Helpers\FakePackagePathResolver.cs" />
     <Compile Include="Src\Helpers\FakePackageTests.cs" />

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using NuGet;
 
@@ -14,6 +15,7 @@ namespace PackageManagement.Tests.Helpers
 		public Exception ExeptionToThrowWhenInstallPackageCalled { get; set; }
 		public Exception ExeptionToThrowWhenUninstallPackageCalled { get; set; }
 		public Exception ExeptionToThrowWhenActiveRepositoryAccessed { get; set; }
+		public Exception ExceptionToThrowWhenCreatePackageManagerForActiveProjectCalled { get; set; }
 
 		public override IProjectManager ActiveProjectManager {
 			get {
@@ -43,5 +45,13 @@ namespace PackageManagement.Tests.Helpers
 		{
 			throw ExeptionToThrowWhenUninstallPackageCalled;
 		}
+		
+		public override ISharpDevelopPackageManager CreatePackageManagerForActiveProject()
+		{
+			if (ExceptionToThrowWhenCreatePackageManagerForActiveProjectCalled != null) {
+				throw ExceptionToThrowWhenCreatePackageManagerForActiveProjectCalled;
+			}
+			return base.CreatePackageManagerForActiveProject();
+		}
 	}
 }

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

@@ -34,5 +34,19 @@ namespace PackageManagement.Tests.Helpers
 		{
 			IsRunCalled = true;
 		}
+		
+		public TestableProject AddFakeDefaultProject()
+		{
+			var project = ProjectHelper.CreateTestProject();
+			DefaultProject = project;
+			return project;
+		}
+		
+		public PackageSource AddTestPackageSource()
+		{
+			var source = new PackageSource("Test");
+			ActivePackageSource = source;
+			return source;
+		}
 	}
 }

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

@@ -2,7 +2,9 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Design;
 using ICSharpCode.SharpDevelop.Project;
 using NuGet;
 

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

@@ -10,9 +10,11 @@ namespace PackageManagement.Tests.Helpers
 	public class FakePackageOperationResolver : IPackageOperationResolver
 	{
 		public List<PackageOperation> PackageOperations = new List<PackageOperation>();
+		public IPackage PackagePassedToResolveOperations;
 		
 		public virtual IEnumerable<PackageOperation> ResolveOperations(IPackage package)
 		{
+			PackagePassedToResolveOperations = package;
 			return PackageOperations;
 		}
 	}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageOperationResolverFactory.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 ICSharpCode.PackageManagement;
+using NuGet;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FakePackageOperationResolverFactory : IPackageOperationResolverFactory
+	{
+		public FakePackageOperationResolver FakeInstallPackageOperationResolver = new FakePackageOperationResolver();
+		public IPackageRepository LocalRepositoryPassedToCreateInstallPackageOperationsResolver;
+		public IPackageRepository SourceRepositoryPassedToCreateInstallPackageOperationsResolver;
+		public ILogger LoggerPassedToCreateInstallPackageOperationResolver;
+		public bool IgnoreDependenciesPassedToCreateInstallPackageOperationResolver;
+		
+		public IPackageOperationResolver CreateInstallPackageOperationResolver(
+			IPackageRepository localRepository,
+			IPackageRepository sourceRepository,
+			ILogger logger,
+			bool ignoreDependencies)
+		{
+			LocalRepositoryPassedToCreateInstallPackageOperationsResolver = localRepository;
+			SourceRepositoryPassedToCreateInstallPackageOperationsResolver = sourceRepository;
+			LoggerPassedToCreateInstallPackageOperationResolver = logger;
+			IgnoreDependenciesPassedToCreateInstallPackageOperationResolver = ignoreDependencies;
+			
+			return FakeInstallPackageOperationResolver;
+		}
+	}
+}

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

@@ -37,5 +37,20 @@ namespace PackageManagement.Tests.Helpers
 			PackageOperations.Add(operation);
 			return package;
 		}
+		
+		public PackageSource PackageSource = new PackageSource("http://sharpdevelop/packages");
+		public TestableProject TestableProject = ProjectHelper.CreateTestProject();
+		public bool IgnoreDependencies;
+		public Version Version;
+		
+		public void InstallPackageById(string packageId)
+		{
+			packageManagementService.InstallPackage(
+				packageId, 
+				Version,
+				TestableProject,
+				PackageSource,
+				IgnoreDependencies);
+		}
 	}
 }

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

@@ -10,13 +10,18 @@ namespace PackageManagement.Tests.Helpers
 	public static class ProjectHelper
 	{
 		public static TestableProject CreateTestProject()
+		{
+			return CreateTestProject("TestProject");
+		}
+		
+		public static TestableProject CreateTestProject(string name)
 		{
 			Solution solution = new Solution();
 			solution.FileName = @"d:\projects\Test\TestSolution.sln";
 			
 			ProjectCreateInformation createInfo = new ProjectCreateInformation();
 			createInfo.Solution = solution;
-			createInfo.ProjectName = "TestProject";
+			createInfo.ProjectName = name;
 			createInfo.SolutionPath = @"d:\projects\Test";
 			createInfo.ProjectBasePath = @"d:\projects\Test\TestProject";
 			createInfo.OutputProjectFileName = @"d:\projects\Test\TestProject\TestProject.csproj";

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

@@ -10,13 +10,11 @@ namespace PackageManagement.Tests.Helpers
 {
 	public class TestablePackageViewModel : PackageViewModel
 	{
-		public FakePackageOperationResolver FakePackageOperationResolver;
 		public FakePackageRepository FakeSourcePackageRepository;
 		public FakePackageManagementService	FakePackageManagementService;
 		public FakeLicenseAcceptanceService	FakeLicenseAcceptanceService;
 		public FakeMessageReporter FakeMessageReporter;
 		public FakePackage FakePackage;
-		public ILogger LoggerUsedWhenCreatingPackageResolver;
 		public string PackageViewModelAddingPackageMessageFormat = String.Empty;
 		public string PackageViewModelRemovingPackageMessageFormat = String.Empty;
 		
@@ -47,15 +45,6 @@ namespace PackageManagement.Tests.Helpers
 			this.FakeSourcePackageRepository = FakePackageManagementService.FakeActivePackageRepository;
 		}
 		
-		protected override IPackageOperationResolver CreatePackageOperationResolver(ILogger logger)
-		{
-			LoggerUsedWhenCreatingPackageResolver = logger;
-			if (FakePackageOperationResolver != null) {
-				return FakePackageOperationResolver;
-			}
-			return base.CreatePackageOperationResolver(logger);
-		}
-		
 		protected override string AddingPackageMessageFormat {
 			get { return PackageViewModelAddingPackageMessageFormat; }
 		}
@@ -63,5 +52,30 @@ namespace PackageManagement.Tests.Helpers
 		protected override string RemovingPackageMessageFormat {
 			get { return PackageViewModelRemovingPackageMessageFormat; }
 		}
+		
+		public PackageOperation AddOneFakeInstallPackageOperationForViewModelPackage()
+		{
+			var operation = new PackageOperation(FakePackage, PackageAction.Install);
+			
+			FakePackageManagementService
+				.FakePackageManagerToReturnFromCreatePackageManagerForActiveProject
+				.PackageOperationsToReturnFromGetInstallPackageOperations
+				.Add(operation);
+			
+			return operation;
+		}
+		
+		public PackageOperation AddOneFakeUninstallPackageOperation()
+		{
+			var package = new FakePackage("PackageToUninstall");			
+			var operation = new PackageOperation(package, PackageAction.Uninstall);
+			
+			FakePackageManagementService
+				.FakePackageManagerToReturnFromCreatePackageManagerForActiveProject
+				.PackageOperationsToReturnFromGetInstallPackageOperations
+				.Add(operation);
+			
+			return operation;
+		}
 	}
 }

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

@@ -14,6 +14,7 @@ namespace PackageManagement.Tests.Helpers
 		public string PathPassedToPhysicalFileSystemAddFile;
 		public Stream StreamPassedToPhysicalFileSystemAddFile;
 		public FakeFileService FakeFileService;
+		public FakePackageManagementProjectService FakeProjectService;
 		public FakePackageManagementOutputMessagesView FakeOutputMessagesView;
 		public string FileNamePassedToLogDeletedFile;
 		public FileNameAndDirectory FileNameAndDirectoryPassedToLogDeletedFileFromDirectory;
@@ -23,14 +24,18 @@ namespace PackageManagement.Tests.Helpers
 		public FileNameAndProjectName FileNameAndProjectNamePassedToLogAddedFileToProject;
 		
 		public TestableSharpDevelopProjectSystem(MSBuildBasedProject project)
-			: this(project, new FakeFileService(project))
+			: this(project, new FakeFileService(project), new FakePackageManagementProjectService())
 		{
 		}
 		
-		TestableSharpDevelopProjectSystem(MSBuildBasedProject project, IPackageManagementFileService fileService)
+		TestableSharpDevelopProjectSystem(
-			: base(project, fileService)
+			MSBuildBasedProject project,
+			IPackageManagementFileService fileService,
+			IPackageManagementProjectService projectService)
+			: base(project, fileService, projectService)
 		{
 			FakeFileService = (FakeFileService)fileService;
+			FakeProjectService = (FakePackageManagementProjectService)projectService;
 			Logger = FakeOutputMessagesView;
 		}
 		

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

@@ -55,6 +55,36 @@ namespace PackageManagement.Tests
 			installPackageHelper = new InstallPackageHelper(packageManagementService);
 		}
 		
+		FakePackage AddOneFakePackageToPackageRepositoryFactoryRepository(string id)
+		{
+			return fakePackageRepositoryFactory.FakePackageRepository.AddOneFakePackage(id);
+		}
+		
+		void MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame()
+		{
+			fakePackageManagerFactory.FakePackageManager.SourceRepository = 
+				fakePackageRepositoryFactory.FakePackageRepository;
+		}
+		
+		IEnumerable<PackageOperation> AddOnePackageOperationToPackageManager()
+		{		
+			var operations = fakePackageManagerFactory
+				.FakePackageManager
+				.PackageOperationsToReturnFromGetInstallPackageOperations;
+			
+			var operation = new PackageOperation(new FakePackage("A"), PackageAction.Install);
+			operations.Add(operation);
+			
+			return operations;
+		}
+		
+		TestableProject AddProject(string name)
+		{
+			var project = ProjectHelper.CreateTestProject(name);
+			fakeProjectService.AddFakeProject(project);
+			return project;
+		}
+		
 		[Test]
 		public void InstallPackage_PackageObjectPassed_CallsPackageManagerInstallPackage()
 		{
@@ -544,5 +574,247 @@ namespace PackageManagement.Tests
 			
 			Assert.AreEqual(expectedProject, project);
 		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassed_RepositoryCreatedForPackageSource()
+		{
+			CreatePackageManagementService();
+			AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			var expectedPackageSource = installPackageHelper.PackageSource;
+			var actualPackageSource = fakePackageRepositoryFactory.FirstPackageSourcePassedToCreateRepository;
+			
+			Assert.AreEqual(expectedPackageSource, actualPackageSource);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassed_InstallsPackageFromPackageSource()
+		{
+			CreatePackageManagementService();
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			var actualPackage = fakePackageManagerFactory.FakePackageManager.PackagePassedToInstallPackage;
+			
+			Assert.AreEqual(package, actualPackage);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassed_RepositoryCreatedFromPackageSourceIsUsedToCreatePackageManager()
+		{
+			CreatePackageManagementService();
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			var repository = fakePackageRepositoryFactory.FakePackageRepository;
+			
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			var actualRepository = fakePackageManagerFactory.PackageRepositoryPassedToCreatePackageManager;
+			
+			Assert.AreEqual(repository, actualRepository);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassed_ProjectIsUsedToCreatePackageManager()
+		{
+			CreatePackageManagementService();
+			fakeProjectService.CurrentProject = null;
+			AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			var actualProject = fakePackageManagerFactory.ProjectPassedToCreateRepository;
+			var expectedProject = installPackageHelper.TestableProject;
+			
+			Assert.AreEqual(expectedProject, actualProject);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassed_PackageOperationsToInstallPackage()
+		{
+			CreatePackageManagementService();
+			AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			var packageOperations = AddOnePackageOperationToPackageManager();
+			
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			var packageManager = fakePackageManagerFactory.FakePackageManager;
+			var actualPackageOperations = packageManager.ParametersPassedToInstallPackage.PackageOperationsPassedToInstallPackage;
+			
+			Assert.AreEqual(packageOperations, actualPackageOperations);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassed_PackageOperationsCreatedForInstallPackage()
+		{
+			CreatePackageManagementService();
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			var packageOperations = AddOnePackageOperationToPackageManager();
+			
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			var actualPackage = fakePackageManagerFactory.FakePackageManager.PackagePassedToGetInstallPackageOperations;
+			
+			Assert.AreEqual(package, actualPackage);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassedAndIgnoreDependenciesIsTrue_DependenciesIgnoredWhenInstallingPackage()
+		{
+			CreatePackageManagementService();
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			installPackageHelper.IgnoreDependencies = true;
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			bool result = fakePackageManagerFactory.FakePackageManager.IgnoreDependenciesPassedToInstallPackage;
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassedAndIgnoreDependenciesIsTrue_DependenciesIgnoredWhenGettingPackageOperations()
+		{
+			CreatePackageManagementService();
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			installPackageHelper.IgnoreDependencies = true;
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			bool result = fakePackageManagerFactory.FakePackageManager.IgnoreDependenciesPassedToGetInstallPackageOperations;
+			
+			Assert.IsTrue(result);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassedAndIgnoreDependenciesIsFalse_DependenciesNotIgnoredWhenGettingPackageOperations()
+		{
+			CreatePackageManagementService();
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			installPackageHelper.IgnoreDependencies = false;
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			bool result = fakePackageManagerFactory.FakePackageManager.IgnoreDependenciesPassedToGetInstallPackageOperations;
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageIdAndSourceAndProjectPassedAndIgnoreDependenciesIsFalse_DependenciesNotIgnoredWhenInstallingPackage()
+		{
+			CreatePackageManagementService();
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			installPackageHelper.IgnoreDependencies = false;
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			bool result = fakePackageManagerFactory.FakePackageManager.IgnoreDependenciesPassedToInstallPackage;
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void CreatePackageManagerForActiveProject_ProjectIsSelected_ReferencesSelectedProject()
+		{
+			CreatePackageManagementService();
+			
+			packageManagementService.CreatePackageManagerForActiveProject();
+			
+			IProject expectedProject = fakeProjectService.CurrentProject;
+			IProject actualProject = fakePackageManagerFactory.ProjectPassedToCreateRepository;
+			
+			Assert.AreEqual(expectedProject, actualProject);
+		}
+		
+		[Test]
+		public void CreatePackageManagerForActiveProject_ProjectIsSelected_UsesActiveRepository()
+		{
+			CreatePackageManagementService();
+			
+			packageManagementService.CreatePackageManagerForActiveProject();
+			
+			var expectedRepository = packageManagementService.ActivePackageRepository;
+			var actualRepository = fakePackageManagerFactory.PackageRepositoryPassedToCreatePackageManager;
+			
+			Assert.AreEqual(expectedRepository, actualRepository);
+		}
+		
+		[Test]
+		public void CreatePackageManagerForActiveProject_ReturnsPackageManager()
+		{
+			CreatePackageManagementService();
+			
+			ISharpDevelopPackageManager packageManager = 
+				packageManagementService.CreatePackageManagerForActiveProject();
+			
+			var expectedPackageManager = fakePackageManagerFactory.FakePackageManager;
+			
+			Assert.AreEqual(expectedPackageManager, packageManager);
+		}
+		
+		[Test]
+		public void InstallPackage_VersionSpecified_VersionUsedWhenSearchingForPackage()
+		{
+			CreatePackageManagementService();
+			MakePackageManagementSourceRepositoryAndPackageRepositoryFactoryRepositoryTheSame();
+			
+			var recentPackage = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			recentPackage.Version = new Version("1.2.0");
+			
+			var oldPackage = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			oldPackage.Version = new Version("1.0.0");
+			
+			var package = AddOneFakePackageToPackageRepositoryFactoryRepository("PackageId");
+			var version = new Version("1.1.0");
+			package.Version = version;
+			
+			installPackageHelper.Version = version;
+			installPackageHelper.InstallPackageById("PackageId");
+			
+			var actualPackage = fakePackageManagerFactory.FakePackageManager.PackagePassedToInstallPackage;
+			
+			Assert.AreEqual(package, actualPackage);
+		}
+		
+		[Test]
+		public void GetProject_ThreeProjectsOpenAndProjectWithNameExists_ReturnsMatchingProject()
+		{
+			CreatePackageManagementService();
+			
+			AddProject("One");
+			var expectedProject = AddProject("Two");
+			AddProject("Three");
+			
+			var actualProject = packageManagementService.GetProject("Two");
+			
+			Assert.AreEqual(expectedProject, actualProject);
+		}
+		
+		[Test]
+		public void GetProject_ProjectNameHasDifferentCase_ReturnsMatchingProjectIgnoringCase()
+		{
+			CreatePackageManagementService();
+			
+			AddProject("One");
+			var expectedProject = AddProject("TWO");
+			AddProject("Three");
+			
+			var actualProject = packageManagementService.GetProject("two");
+			
+			Assert.AreEqual(expectedProject, actualProject);
+		}
 	}
 }

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

@@ -42,51 +42,13 @@ namespace PackageManagement.Tests
 			licenseAcceptanceService = viewModel.FakeLicenseAcceptanceService;
 			messageReporter = viewModel.FakeMessageReporter;
 		}
-		
-		FakePackage AddPackageDependencyThatDoesNotRequireLicenseAcceptance(string packageId)
-		{
-			return AddPackageDependency(package, packageId, false);
-		}
-		
-		FakePackage AddPackageDependencyThatRequiresLicenseAcceptance(string packageId)
-		{
-			return AddPackageDependencyThatRequiresLicenseAcceptance(package, packageId);
-		}
-		
-		FakePackage AddPackageDependencyThatRequiresLicenseAcceptance(FakePackage fakePackage, string packageId)
-		{
-			return AddPackageDependency(fakePackage, packageId, true);
-		}
-
-		FakePackage AddPackageDependency(FakePackage fakePackage, string packageId, bool requiresLicenseAcceptance)
-		{
-			fakePackage.AddDependency(packageId);
-			
-			var packageDependedUpon = new FakePackage(packageId);
-			packageDependedUpon.RequireLicenseAcceptance = requiresLicenseAcceptance;
-			
-			sourcePackageRepository.FakePackages.Add(packageDependedUpon);
-			
-			return packageDependedUpon;
-		}
-		
-		FakePackage AddPackageUninstallOperation()
-		{
-			var package = new FakePackage();
-			package.Id = "PackageToUninstall";
-			
-			var operation = new PackageOperation(package, PackageAction.Uninstall);
-			var resolver = new FakePackageOperationResolver();
-			resolver.PackageOperations.Add(operation);
-			viewModel.FakePackageOperationResolver = resolver;
-			
-			return package;
-		}
 
 		[Test]
 		public void AddPackageCommand_CommandExecuted_InstallsPackage()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
+			
 			viewModel.AddPackageCommand.Execute(null);
 						
 			Assert.AreEqual(package, packageManagementService.PackagePassedToInstallPackage);
@@ -96,6 +58,8 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageAddedSuccessfully_PackageAddedFromSourcePackageRepository()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
+			
 			viewModel.AddPackage();
 						
 			Assert.AreEqual(sourcePackageRepository, packageManagementService.RepositoryPassedToInstallPackage);
@@ -105,6 +69,7 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageAddedSuccessfully_PackageOperationsUsedWhenInstallingPackage()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.AddPackage();
 		
 			PackageOperation[] expectedOperations = new PackageOperation[] {
@@ -118,6 +83,8 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageAddedSuccessfully_PropertyNotifyChangedFiredForIsAddedProperty()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
+
 			string propertyChangedName = null;
 			viewModel.PropertyChanged += (sender, e) => propertyChangedName = e.PropertyName;
 			viewModel.AddPackage();
@@ -302,8 +269,10 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageRequiresLicenseAgreementAcceptance_UserAskedToAcceptLicenseAgreementForPackageBeforeInstalling()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			package.RequireLicenseAcceptance = true;
 			licenseAcceptanceService.AcceptLicensesReturnValue = true;
+			
 			viewModel.AddPackage();
 			
 			var expectedPackages = new FakePackage[] {
@@ -329,8 +298,10 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageRequiresLicenseAgreementAcceptanceAndUserDeclinesAgreement_PackageIsNotInstalled()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			package.RequireLicenseAcceptance = true;
 			licenseAcceptanceService.AcceptLicensesReturnValue = false;
+			
 			viewModel.AddPackage();
 			
 			Assert.IsFalse(packageManagementService.IsInstallPackageCalled);
@@ -340,107 +311,15 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageRequiresLicenseAgreementAcceptanceAndUserDeclinesAgreement_PropertyChangedEventNotFired()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			package.RequireLicenseAcceptance = true;
 			licenseAcceptanceService.AcceptLicensesReturnValue = false;
 			bool propertyChangedEventFired = false;
 			viewModel.PropertyChanged += (sender, e) => propertyChangedEventFired = true;
-			viewModel.AddPackage();
-			
-			Assert.IsFalse(propertyChangedEventFired);
-		}
-		
-		[Test]
-		public void AddPackage_PackageHasOneDependencyThatRequiresLicenseAgreementAcceptance_UserAskedToAcceptLicenseForPackageDependency()
-		{
-			CreateViewModel();
-			package.RequireLicenseAcceptance = false;
-			licenseAcceptanceService.AcceptLicensesReturnValue = false;
-			FakePackage packageDependedUpon = 
-				AddPackageDependencyThatRequiresLicenseAcceptance("PackageDependencyId");
-			
-			viewModel.AddPackage();
-			
-			var expectedPackages = new FakePackage[] {
-				packageDependedUpon
-			};
-			
-			var actualPackages = licenseAcceptanceService.PackagesPassedToAcceptLicenses;
-			
-			CollectionAssert.AreEqual(expectedPackages, actualPackages);
-		}
-		
-		[Test]
-		public void AddPackage_PackageAndPackageDependencyRequiresLicenseAgreementAcceptance_UserAskedToAcceptLicenseForPackageAndPackageDependency()
-		{
-			CreateViewModel();
-			package.RequireLicenseAcceptance = true;
-			licenseAcceptanceService.AcceptLicensesReturnValue = false;
-			FakePackage packageDependedUpon = 
-				AddPackageDependencyThatRequiresLicenseAcceptance("PackageDependencyId");
-			
-			viewModel.AddPackage();
-			
-			var expectedPackages = new FakePackage[] {
-				packageDependedUpon,
-				package
-			};
-			
-			var actualPackages = licenseAcceptanceService.PackagesPassedToAcceptLicenses;
-			
-			PackageCollectionAssert.AreEqual(expectedPackages, actualPackages);
-		}
-		
-		[Test]
-		public void AddPackage_PackageHasOneDependencyThatDoesNotRequireLicenseAgreementAcceptance_UserNotAskedToAcceptLicenseForPackageDependency()
-		{
-			CreateViewModel();
-			package.RequireLicenseAcceptance = false;
-			licenseAcceptanceService.AcceptLicensesReturnValue = false;			
-			AddPackageDependencyThatDoesNotRequireLicenseAcceptance("PackageDependencyId");
 			
 			viewModel.AddPackage();
 			
-			Assert.IsFalse(licenseAcceptanceService.IsAcceptLicensesCalled);
+			Assert.IsFalse(propertyChangedEventFired);
-		}
-		
-		[Test]
-		public void AddPackage_PackageDependencyHasDependencyThatRequiresLicenseAcceptance_UserAskedToAcceptLicenseForPackageDependencyChildPackage()
-		{
-			CreateViewModel();
-			package.RequireLicenseAcceptance = false;
-			licenseAcceptanceService.AcceptLicensesReturnValue = false;
-			FakePackage packageDependedUpon = 
-				AddPackageDependencyThatDoesNotRequireLicenseAcceptance("ParentPackageIdForDependency");
-			
-			FakePackage childPackageDependedUpon =
-				AddPackageDependencyThatRequiresLicenseAcceptance(
-					packageDependedUpon,
-					"ChildPackageIdForDependency");
-			
-			viewModel.AddPackage();
-			
-			var expectedPackages = new FakePackage[] {
-				childPackageDependedUpon
-			};
-			
-			var actualPackages = licenseAcceptanceService.PackagesPassedToAcceptLicenses;
-			
-			CollectionAssert.AreEqual(expectedPackages, actualPackages);			
-		}
-		
-		[Test]
-		public void AddPackage_PackageHasOneDependencyThatRequiresLicenseAgreementAcceptanceButIsAlreadyInstalledLocally_UserIsNotAskedToAcceptLicenseForPackageDependency()
-		{
-			CreateViewModel();
-			package.RequireLicenseAcceptance = false;
-			licenseAcceptanceService.AcceptLicensesReturnValue = false;			
-			var packageDependedUpon = AddPackageDependencyThatRequiresLicenseAcceptance("PackageDependencyId");
-			packageManagementService.AddPackageToProjectLocalRepository(packageDependedUpon);
-			packageManagementService.FakeActiveProjectManager.IsInstalledReturnValue = true;
-			
-			viewModel.AddPackage();
-			
-			Assert.IsFalse(licenseAcceptanceService.IsAcceptLicensesCalled);
 		}
 		
 		[Test]
@@ -448,7 +327,8 @@ namespace PackageManagement.Tests
 		{
 			CreateViewModel();
 			package.RequireLicenseAcceptance = false;
-			FakePackage packageToUninstall = AddPackageUninstallOperation();
+			var operation = viewModel.AddOneFakeUninstallPackageOperation();
+			FakePackage packageToUninstall = operation.Package as FakePackage;
 			packageToUninstall.RequireLicenseAcceptance = true;
 			viewModel.AddPackage();
 			
@@ -459,16 +339,21 @@ namespace PackageManagement.Tests
 		public void AddPackage_CheckLoggerUsed_OutputMessagesLoggerUsedWhenResolvingPackageOperations()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.AddPackage();
 			
 			ILogger expectedLogger = packageManagementService.FakeOutputMessagesView;
-			Assert.AreEqual(expectedLogger, viewModel.LoggerUsedWhenCreatingPackageResolver);
+			ILogger actualLogger = packageManagementService
+				.FakePackageManagerToReturnFromCreatePackageManagerForActiveProject
+				.Logger;
+			Assert.AreEqual(expectedLogger, actualLogger);
 		}
 		
 		[Test]
 		public void AddPackage_PackageAddedSuccessfully_InstallingPackageMessageIsFirstMessageLogged()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			package.Id = "Test.Package";
 			package.Version = new Version(1, 2, 0, 55);
 			viewModel.PackageViewModelAddingPackageMessageFormat = "Updating...{0}";
@@ -484,6 +369,7 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageAddedSuccessfully_NextToLastMessageLoggedMarksEndOfInstallation()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.AddPackage();
 			
 			string expectedMessage = "==============================";
@@ -496,6 +382,7 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageAddedSuccessfully_LastMessageLoggedIsEmptyLine()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.AddPackage();
 			
 			string expectedMessage = String.Empty;
@@ -508,6 +395,7 @@ namespace PackageManagement.Tests
 		public void RemovePackage_PackageRemovedSuccessfully_UninstallingPackageMessageIsFirstMessageLogged()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			package.Id = "Test.Package";
 			package.Version = new Version(1, 2, 0, 55);
 			viewModel.PackageViewModelRemovingPackageMessageFormat = "Removing...{0}";
@@ -523,6 +411,7 @@ namespace PackageManagement.Tests
 		public void RemovePackage_PackageRemovedSuccessfully_NextToLastMessageLoggedMarksEndOfInstallation()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.RemovePackage();
 			
 			string expectedMessage = "==============================";
@@ -547,6 +436,7 @@ namespace PackageManagement.Tests
 		public void AddPackage_ExceptionWhenInstallingPackage_ExceptionErrorMessageReported()
 		{
 			CreateViewModelWithExceptionThrowingPackageManagementService();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			Exception ex = new Exception("Test");
 			exceptionThrowingPackageManagementService.ExeptionToThrowWhenInstallPackageCalled = ex;
 			viewModel.AddPackage();
@@ -558,6 +448,7 @@ namespace PackageManagement.Tests
 		public void AddPackage_PackageAddedSuccessfully_MessagesReportedPreviouslyAreCleared()
 		{
 			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			viewModel.AddPackage();
 			
 			Assert.IsTrue(messageReporter.IsClearMessageCalled);
@@ -567,6 +458,7 @@ namespace PackageManagement.Tests
 		public void AddPackage_ExceptionWhenInstallingPackage_ExceptionLogged()
 		{
 			CreateViewModelWithExceptionThrowingPackageManagementService();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 			Exception ex = new Exception("Exception error message");
 			exceptionThrowingPackageManagementService.ExeptionToThrowWhenInstallPackageCalled = ex;
 			viewModel.AddPackage();
@@ -614,13 +506,43 @@ namespace PackageManagement.Tests
 		[Test]
 		public void AddPackage_ExceptionThrownWhenResolvingPackageOperations_ExceptionReported()
 		{
-			CreateViewModel();
+			CreateViewModelWithExceptionThrowingPackageManagementService();
-			var resolver = new ExceptionThrowingPackageOperationResolver();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
-			viewModel.FakePackageOperationResolver = resolver;
+			
-			resolver.ResolveOperationsExceptionToThrow = new Exception("Test");
+			exceptionThrowingPackageManagementService.ExceptionToThrowWhenCreatePackageManagerForActiveProjectCalled =
+				new Exception("Test");
 			viewModel.AddPackage();
 			
 			Assert.AreEqual("Test", messageReporter.MessagePassedToShowErrorMessage);
 		}
+		
+		[Test]
+		public void AddPackage_PackagesInstalledSuccessfully_ViewModelPackageUsedWhenResolvingPackageOperations()
+		{
+			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
+			viewModel.AddPackage();
+			
+			var expectedPackage = package;
+			var actualPackage = packageManagementService
+				.FakePackageManagerToReturnFromCreatePackageManagerForActiveProject
+				.PackagePassedToGetInstallPackageOperations;
+			
+			Assert.AreEqual(expectedPackage, actualPackage);
+		}
+		
+		[Test]
+		public void AddPackage_PackagesInstalledSuccessfully_PackageDependenciesNotIgnoredWhenCheckingForPackageOperations()
+		{
+			CreateViewModel();
+			viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
+			viewModel.AddPackage();
+			
+			bool result = packageManagementService
+				.FakePackageManagerToReturnFromCreatePackageManagerForActiveProject
+				.IgnoreDependenciesPassedToGetInstallPackageOperations;
+			
+			Assert.IsFalse(result);
+		}
 	}
 }

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

@@ -25,6 +25,7 @@ namespace PackageManagement.Tests
 		PackageReferenceRepositoryHelper packageRefRepositoryHelper;
 		TestableProjectManager testableProjectManager;
 		FakeFileSystem fakeFileSystem;
+		FakePackageOperationResolverFactory fakePackageOperationResolverFactory;
 		
 		void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper)
 		{
@@ -39,11 +40,14 @@ namespace PackageManagement.Tests
 			fakeFeedSourceRepository = new FakePackageRepository();
 			fakeSolutionSharedRepository = packageRefRepositoryHelper.FakeSharedSourceRepository;
 			
+			fakePackageOperationResolverFactory = new FakePackageOperationResolverFactory();
+			
 			packageManager = new SharpDevelopPackageManager(fakeFeedSourceRepository,
 				packageRefRepositoryHelper.FakeProjectSystem,
 				fakeFileSystem,
 				fakeSolutionSharedRepository,
-				pathResolver);
+				pathResolver,
+				fakePackageOperationResolverFactory);
 		}
 		
 		void CreatePackageManager()
@@ -85,10 +89,20 @@ namespace PackageManagement.Tests
 		}
 		
 		FakePackage InstallPackageWithNoPackageOperations()
+		{
+			return InstallPackageWithNoPackageOperations(ignoreDependencies: false);
+		}
+		
+		FakePackage InstallPackageWithNoPackageOperationsAndIgnoreDependencies()
+		{
+			return InstallPackageWithNoPackageOperations(ignoreDependencies: true);
+		}
+		
+		FakePackage InstallPackageWithNoPackageOperations(bool ignoreDependencies)
 		{
 			FakePackage package = CreateFakePackage();
 			var operations = new List<PackageOperation>();
-			packageManager.InstallPackage(package, operations);
+			packageManager.InstallPackage(package, operations, ignoreDependencies);
 			return package;
 		}
 		
@@ -98,7 +112,7 @@ namespace PackageManagement.Tests
 				operation
 			};
 			FakePackage package = CreateFakePackage();
-			packageManager.InstallPackage(package, operations);
+			packageManager.InstallPackage(package, operations, false);
 			return package;
 		}
 		
@@ -157,6 +171,16 @@ namespace PackageManagement.Tests
 			return new PackageOperation(package, PackageAction.Install);
 		}
 		
+		IEnumerable<PackageOperation> GetInstallPackageOperations(FakePackage package)
+		{
+			return packageManager.GetInstallPackageOperations(package, false);
+		}
+		
+		IEnumerable<PackageOperation>  GetInstallPackageOperationsAndIgnoreDependencies(FakePackage package)
+		{
+			return packageManager.GetInstallPackageOperations(package, true);
+		}
+		
 		[Test]
 		public void ProjectManager_InstanceCreated_SourceRepositoryIsSharedRepositoryPassedToPackageManager()
 		{
@@ -235,6 +259,16 @@ namespace PackageManagement.Tests
 			Assert.IsFalse(testableProjectManager.IgnoreDependenciesPassedToAddPackageReference);
 		}
 		
+		[Test]
+		public void InstallPackage_PackageInstanceAndPackageOperationsPassedAndIgnoreDependenciesIsTrue_IgnoreDependenciesWhenAddingReferenceToProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			InstallPackageWithNoPackageOperationsAndIgnoreDependencies();
+				
+			Assert.IsTrue(testableProjectManager.IgnoreDependenciesPassedToAddPackageReference);
+		}
+		
 		[Test]
 		public void InstallPackage_PackageInstanceAndOneInstallPackageOperationPassed_PackageDefinedInOperationIsInstalledInLocalRepository()
 		{
@@ -358,5 +392,94 @@ namespace PackageManagement.Tests
 			
 			Assert.AreEqual("Test", packageRemovedFromProject.Id);
 		}
+		
+		[Test]
+		public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageOperationsReturnedFromPackageOperationsResolverCreated()
+		{
+			CreatePackageManager();
+			var package = new FakePackage();			
+			var operations = GetInstallPackageOperations(package);
+			
+			var expectedOperations = fakePackageOperationResolverFactory.FakeInstallPackageOperationResolver.PackageOperations;
+			
+			Assert.AreEqual(expectedOperations, operations);
+		}
+		
+		[Test]
+		public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesLocalRepositoryWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			var package = new FakePackage();
+			GetInstallPackageOperations(package);
+			
+			var expectedRepository = packageManager.LocalRepository;
+			var actualRepository = fakePackageOperationResolverFactory.LocalRepositoryPassedToCreateInstallPackageOperationsResolver;
+			
+			Assert.AreEqual(expectedRepository, actualRepository);
+		}
+		
+		[Test]
+		public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesSourceRepositoryWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			var package = new FakePackage();
+			GetInstallPackageOperations(package);
+			
+			var expectedRepository = packageManager.SourceRepository;
+			var actualRepository = fakePackageOperationResolverFactory.SourceRepositoryPassedToCreateInstallPackageOperationsResolver;
+			
+			Assert.AreEqual(expectedRepository, actualRepository);
+		}
+		
+		[Test]
+		public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_DependenciesNotIgnored()
+		{
+			CreatePackageManager();
+			var package = new FakePackage();
+			GetInstallPackageOperations(package);
+			
+			var result = fakePackageOperationResolverFactory.IgnoreDependenciesPassedToCreateInstallPackageOperationResolver;
+			
+			Assert.IsFalse(result);
+		}
+		
+		[Test]
+		public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesLoggerWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			var package = new FakePackage();
+			GetInstallPackageOperations(package);
+			
+			var expectedLogger = packageManager.Logger;
+			var actualLogger = fakePackageOperationResolverFactory.LoggerPassedToCreateInstallPackageOperationResolver;
+			
+			Assert.AreEqual(expectedLogger, actualLogger);
+		}
+		
+		[Test]
+		public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageUsedWhenGettingPackageOperations()
+		{
+			CreatePackageManager();
+			var package = new FakePackage();
+			GetInstallPackageOperations(package);
+			
+			var actualPackage = fakePackageOperationResolverFactory
+				.FakeInstallPackageOperationResolver
+				.PackagePassedToResolveOperations;
+			
+			Assert.AreEqual(package, actualPackage);
+		}
+		
+		[Test]
+		public void GetInstallPackageOperations_IgnoreDependenciesIsTrue_PackageOperationResolverIgnoresDependencies()
+		{
+			CreatePackageManager();
+			var package = new FakePackage();
+			GetInstallPackageOperationsAndIgnoreDependencies(package);
+			
+			bool result = fakePackageOperationResolverFactory.IgnoreDependenciesPassedToCreateInstallPackageOperationResolver;
+			
+			Assert.IsTrue(result);
+		}
 	}
 }