Determine PackageOperations only once and use them when installing packages.

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

@@ -14,6 +14,7 @@ namespace ICSharpCode.PackageManagement.Design
 		public event EventHandler PackageInstalled;
 		
 		PackageManagementOptions options = new PackageManagementOptions(new Properties());
+		public List<PackageOperation> PackageOperationsPassedToInstallPackage = new List<PackageOperation>();
 		
 		protected virtual void OnPackageInstalled()
 		{
@@ -63,12 +64,13 @@ namespace ICSharpCode.PackageManagement.Design
 			}
 		}
 		
-		public void InstallPackage(IPackageRepository repository, IPackage package)
+		public void InstallPackage(IPackageRepository repository, IPackage package, IEnumerable<PackageOperation> operations)
 		{
 			IsInstallPackageCalled = true;
 			RepositoryPassedToInstallPackage = repository;
 			PackagePassedToInstallPackage = package;
-		}		
+			PackageOperationsPassedToInstallPackage.AddRange(operations);
+		}
 		
 		public void UninstallPackage(IPackageRepository repository, IPackage package)
 		{

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

@@ -12,6 +12,11 @@ namespace ICSharpCode.PackageManagement.Design
 	{
 		public List<FakePackage> FakePackages = new List<FakePackage>();
 		public bool IsRemovePackageCalled;
+		public List<IPackage> PackagesAdded = new List<IPackage>();
+		
+		public IPackage FirstPackageAdded {
+			get { return PackagesAdded[0]; }
+		}
 		
 		public IQueryable<IPackage> GetPackages()
 		{
@@ -20,6 +25,7 @@ namespace ICSharpCode.PackageManagement.Design
 		
 		public void AddPackage(IPackage package)
 		{
+			PackagesAdded.Add(package);
 		}
 		
 		public void RemovePackage(IPackage package)

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

@@ -16,7 +16,7 @@ namespace ICSharpCode.PackageManagement
 		IPackageRepository ActivePackageRepository { get; }
 		IProjectManager ActiveProjectManager { get; }
 		
-		void InstallPackage(IPackageRepository repository, IPackage package);
+		void InstallPackage(IPackageRepository repository, IPackage package, IEnumerable<PackageOperation> operations);
 		void UninstallPackage(IPackageRepository repository, IPackage package);
 
 		PackageManagementOptions Options { get; }

src/AddIns/Misc/PackageManagement/Project/Src/ISharpDevelopPackageManager.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 NuGet;
 
 namespace ICSharpCode.PackageManagement
@@ -10,6 +11,7 @@ namespace ICSharpCode.PackageManagement
 	{
 		ISharpDevelopProjectManager ProjectManager { get; }
 		void InstallPackage(IPackage package);
+		void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations);
 		void UninstallPackage(IPackage package);
 	}
 }

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

@@ -83,10 +83,13 @@ namespace ICSharpCode.PackageManagement
 			return packageManager.ProjectManager;
 		}
 		
-		public void InstallPackage(IPackageRepository packageRepository, IPackage package)
+		public void InstallPackage(
+			IPackageRepository packageRepository,
+			IPackage package,
+			IEnumerable<PackageOperation> operations)
 		{
 			ISharpDevelopPackageManager packageManager = CreatePackageManager(packageRepository);
-			packageManager.InstallPackage(package);
+			packageManager.InstallPackage(package, operations);
 			projectService.RefreshProjectBrowser();
 			OnPackageInstalled();
 		}

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

@@ -17,6 +17,7 @@ namespace ICSharpCode.PackageManagement
 		IPackageManagementService packageManagementService;
 		ILicenseAcceptanceService licenseAcceptanceService;
 		IPackage package;
+		IEnumerable<PackageOperation> packageOperations = new PackageOperation[0];
 		IPackageRepository sourcePackageRepository;
 		IPackageRepository localPackageRepository;
 		bool? hasDependencies;
@@ -132,9 +133,7 @@ namespace ICSharpCode.PackageManagement
 		}
 		
 		public bool HasDownloadCount {
-			get {
-				return package.DownloadCount >= 0;
-			}
+			get { return package.DownloadCount >= 0; }
 		}
 		
 		public string Id {
@@ -167,6 +166,7 @@ namespace ICSharpCode.PackageManagement
 		
 		public void AddPackage()
 		{
+			GetPackageOperations();
 			if (CanInstallPackage()) {
 				InstallPackage();
 			}
@@ -194,32 +194,37 @@ namespace ICSharpCode.PackageManagement
 		
 		IList<IPackage> GetPackagesToBeInstalled()
 		{
-			var walker = new InstallWalker(LocalPackageRepository,
+			List<IPackage> packages = new List<IPackage>();
+			foreach (PackageOperation operation in packageOperations) {
+				if (operation.Action == PackageAction.Install) {
+					packages.Add(operation.Package);
+				}
+			}
+			return packages;
+		}
+		
+		void GetPackageOperations()
+		{
+			IPackageOperationResolver resolver = CreatePackageOperationResolver();
+			packageOperations = resolver.ResolveOperations(package);
+		}
+		
+		protected virtual IPackageOperationResolver CreatePackageOperationResolver()
+		{
+			return new InstallWalker(LocalPackageRepository,
                 sourcePackageRepository,
                 NullLogger.Instance,
                 ignoreDependencies: false);
-			
-			IEnumerable<PackageOperation> packageOperations = walker.ResolveOperations(package);
-			return GetPackages(packageOperations);
 		}
-		
+
 		bool PackageRequiresLicenseAcceptance(IPackage package)
 		{
 			return package.RequireLicenseAcceptance && !IsPackageInstalled(package);
 		}
 		
-		IList<IPackage> GetPackages(IEnumerable<PackageOperation> packageOperations)
-		{
-			List<IPackage> packages = new List<IPackage>();
-			foreach (PackageOperation operation in packageOperations) {
-				packages.Add(operation.Package);
-			}
-			return packages;
-		}
-		
 		void InstallPackage()
 		{
-			packageManagementService.InstallPackage(sourcePackageRepository, package);
+			packageManagementService.InstallPackage(sourcePackageRepository, package, packageOperations);
 			OnPropertyChanged(model => model.IsAdded);
 		}
 		

src/AddIns/Misc/PackageManagement/Project/Src/SharpDevelopPackageManager.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 NuGet;
 
@@ -11,32 +12,41 @@ namespace ICSharpCode.PackageManagement
 	{
 		IProjectSystem projectSystem;
 		
-		public SharpDevelopPackageManager(IPackageRepository sourceRepository,
+		public SharpDevelopPackageManager(
+			IPackageRepository sourceRepository,
 			MSBuildBasedProject project,
 			ISharedPackageRepository localRepository,
 			PackageRepositoryPaths repositoryPaths)
-			: this(sourceRepository, new SharpDevelopProjectSystem(project), localRepository, repositoryPaths)
+			: this(
+				sourceRepository,
+				new SharpDevelopProjectSystem(project),
+				localRepository,
+				repositoryPaths)
 		{
 		}
 		
-		public SharpDevelopPackageManager(IPackageRepository sourceRepository,
+		public SharpDevelopPackageManager(
+			IPackageRepository sourceRepository,
 			IProjectSystem projectSystem,
 			ISharedPackageRepository localRepository,
 			PackageRepositoryPaths repositoryPaths)
-			: this(sourceRepository,
+			: this(
+				sourceRepository,
 				projectSystem,
 				localRepository,
 				repositoryPaths,
 				repositoryPaths.SolutionPackagesPath)
-		{			
+		{
 		}
 		
-		SharpDevelopPackageManager(IPackageRepository sourceRepository,
+		SharpDevelopPackageManager(
+			IPackageRepository sourceRepository,
 			IProjectSystem projectSystem,
 			ISharedPackageRepository localRepository,
 			PackageRepositoryPaths repositoryPaths,
 			string solutionPackagesPath)
-			: base(sourceRepository,
+			: base(
+				sourceRepository,
 				new DefaultPackagePathResolver(solutionPackagesPath),
 				new PhysicalFileSystem(solutionPackagesPath),
 				localRepository)
@@ -52,26 +62,55 @@ namespace ICSharpCode.PackageManagement
 		/// 	source repo = sharedRepository
 		/// </summary>
 		void CreateProjectManager()
+		{
+			var packageRefRepository = CreatePackageReferenceRepository();
+			ProjectManager = CreateProjectManager(packageRefRepository);
+		}
+		
+		PackageReferenceRepository CreatePackageReferenceRepository()
 		{
 			var sharedRepository = LocalRepository as ISharedPackageRepository;
 			var packageRefRepository = new PackageReferenceRepository(projectSystem, sharedRepository);
 			packageRefRepository.RegisterIfNecessary();
-
-			ProjectManager = new SharpDevelopProjectManager(LocalRepository, PathResolver, projectSystem, packageRefRepository);
+			return packageRefRepository;
 		}
 		
 		public ISharpDevelopProjectManager ProjectManager { get; set; }
 		
+		SharpDevelopProjectManager CreateProjectManager(PackageReferenceRepository packageRefRepository)
+		{
+			return new SharpDevelopProjectManager(LocalRepository, PathResolver, projectSystem, packageRefRepository);
+		}
+		
 		public void InstallPackage(IPackage package)
 		{
 			bool ignoreDependencies = false;
 			InstallPackage(package, ignoreDependencies);
 		}
 		
+		public void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations)
+		{
+			foreach (PackageOperation operation in operations) {
+				Execute(operation);
+			}
+			AddPackageReference(package);
+		}
+
+		void AddPackageReference(IPackage package)
+		{
+			bool ignoreDependencies = false;
+			AddPackageReference(package, ignoreDependencies);
+		}
+		
+		void AddPackageReference(IPackage package, bool ignoreDependencies)
+		{
+			ProjectManager.AddPackageReference(package.Id, package.Version, ignoreDependencies);			
+		}
+		
 		public override void InstallPackage(IPackage package, bool ignoreDependencies)
 		{
 			base.InstallPackage(package, ignoreDependencies);
-			ProjectManager.AddPackageReference(package.Id, package.Version, ignoreDependencies);
+			AddPackageReference(package, ignoreDependencies);
 		}
 		
 		public override void UninstallPackage(IPackage package, bool forceRemove, bool removeDependencies)

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

@@ -73,6 +73,7 @@
     <Compile Include="Src\Helpers\FakeLicenseAcceptanceService.cs" />
     <Compile Include="Src\Helpers\FakePackageManager.cs" />
     <Compile Include="Src\Helpers\FakePackageManagerFactory.cs" />
+    <Compile Include="Src\Helpers\FakePackageOperationResolver.cs" />
     <Compile Include="Src\Helpers\FakePackageRepositoryFactory.cs" />
     <Compile Include="Src\Helpers\FakePackageManagementProjectService.cs" />
     <Compile Include="Src\Helpers\FakePackagePathResolver.cs" />
@@ -85,6 +86,7 @@
     <Compile Include="Src\Helpers\PageCollectionAssert.cs" />
     <Compile Include="Src\Helpers\ReferenceProjectItemAssert.cs" />
     <Compile Include="Src\Helpers\TestablePackagesViewModel.cs" />
+    <Compile Include="Src\Helpers\TestablePackageViewModel.cs" />
     <Compile Include="Src\Helpers\TestableProject.cs" />
     <Compile Include="Src\Helpers\TestableProjectManager.cs" />
     <Compile Include="Src\Helpers\FakeProjectSystem.cs" />

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

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
 using NuGet;
@@ -26,6 +27,7 @@ namespace PackageManagement.Tests.Helpers
 		public struct InstallPackageParameters {
 			public IPackage PackagePassedToInstallPackage;
 			public bool IgnoreDependenciesPassedToInstallPackage;
+			public IEnumerable<PackageOperation> PackageOperationsPassedToInstallPackage;
 			
 			public override string ToString()
 			{
@@ -101,5 +103,16 @@ namespace PackageManagement.Tests.Helpers
 		{
 			throw new NotImplementedException();
 		}
+		
+		public void InstallPackage(IPackage package, IEnumerable<PackageOperation> operations)
+		{
+			PackagePassedToInstallPackage = package;
+			
+			ParametersPassedToInstallPackage = new InstallPackageParameters();
+			ParametersPassedToInstallPackage.PackagePassedToInstallPackage = package;
+			ParametersPassedToInstallPackage.PackageOperationsPassedToInstallPackage = operations;
+			
+			IsRefreshProjectBrowserCalledWhenInstallPackageCalled = FakeProjectService.IsRefreshProjectBrowserCalled;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageOperationResolver.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.Collections.Generic;
+using NuGet;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FakePackageOperationResolver : IPackageOperationResolver
+	{
+		public List<PackageOperation> PackageOperations = new List<PackageOperation>();
+		
+		public IEnumerable<PackageOperation> ResolveOperations(IPackage package)
+		{
+			return PackageOperations;
+		}
+	}
+}

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

@@ -2,8 +2,10 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections.Generic;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
+using NuGet;
 
 namespace PackageManagement.Tests.Helpers
 {
@@ -16,6 +18,7 @@ namespace PackageManagement.Tests.Helpers
 		};
 		
 		public FakePackageRepository PackageRepository = new FakePackageRepository();
+		public List<PackageOperation> PackageOperations = new List<PackageOperation>();
 		
 		public InstallPackageHelper(PackageManagementService packageManagementService)
 		{
@@ -24,7 +27,15 @@ namespace PackageManagement.Tests.Helpers
 		
 		public void InstallTestPackage()
 		{
-			packageManagementService.InstallPackage(PackageRepository, TestPackage);
+			packageManagementService.InstallPackage(PackageRepository, TestPackage, PackageOperations);
+		}
+		
+		public FakePackage AddPackageInstallOperation()
+		{
+			var package = new FakePackage("Package to install");
+			var operation = new PackageOperation(package, PackageAction.Install);
+			PackageOperations.Add(operation);
+			return package;
 		}
 	}
 }

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

@@ -0,0 +1,50 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Design;
+using NuGet;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class TestablePackageViewModel : PackageViewModel
+	{
+		public FakePackageOperationResolver FakePackageOperationResolver;
+		public FakePackageRepository FakeSourcePackageRepository;
+		public FakePackageManagementService	FakePackageManagementService;
+		public FakeLicenseAcceptanceService	FakeLicenseAcceptanceService;
+		public FakePackage FakePackage;
+		
+		public TestablePackageViewModel()
+			: this(
+				new FakePackage(),
+				new FakePackageManagementService(),
+				new FakeLicenseAcceptanceService())
+		{
+		}
+		
+		public TestablePackageViewModel(
+			FakePackage package,
+			FakePackageManagementService packageManagementService,
+			FakeLicenseAcceptanceService licenseAcceptanceService)
+			: base(
+				package,
+				packageManagementService,
+				licenseAcceptanceService)
+		{
+			this.FakePackage = package;
+			this.FakePackageManagementService = packageManagementService;
+			this.FakeLicenseAcceptanceService = licenseAcceptanceService;
+			this.FakeSourcePackageRepository = FakePackageManagementService.FakeActivePackageRepository;
+		}
+		
+		protected override IPackageOperationResolver CreatePackageOperationResolver()
+		{
+			if (FakePackageOperationResolver != null) {
+				return FakePackageOperationResolver;
+			}
+			return base.CreatePackageOperationResolver();
+		}
+	}
+}

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

@@ -23,6 +23,7 @@ namespace PackageManagement.Tests
 		FakePackageManagerFactory fakePackageManagerFactory;
 		FakePackageManagementProjectService fakeProjectService;
 		TestableProject testProject;
+		InstallPackageHelper installPackageHelper;
 		
 		void CreatePackageSources()
 		{
@@ -46,20 +47,22 @@ namespace PackageManagement.Tests
 				new PackageManagementService(options,
 					fakePackageRepositoryFactory,
 					fakePackageManagerFactory,
-					fakeProjectService);		
+					fakeProjectService);
+
+			installPackageHelper = new InstallPackageHelper(packageManagementService);
 		}
 		
 		[Test]
 		public void InstallPackage_PackageObjectPassed_CallsPackageManagerInstallPackage()
 		{
 			CreatePackageManagementService();
-			InstallPackageHelper installPackageHelper = new InstallPackageHelper(packageManagementService);
 			installPackageHelper.InstallTestPackage();
 			
 			bool expectedIgnoreDependencies = false;
 			var expectedInstallPackageParameters = new FakePackageManager.InstallPackageParameters() {
 				IgnoreDependenciesPassedToInstallPackage = expectedIgnoreDependencies,
-				PackagePassedToInstallPackage = installPackageHelper.TestPackage
+				PackagePassedToInstallPackage = installPackageHelper.TestPackage,
+				PackageOperationsPassedToInstallPackage = installPackageHelper.PackageOperations
 			};
 			
 			var actualInstallPackageParameters = fakePackageManagerFactory.FakePackageManager.ParametersPassedToInstallPackage;
@@ -71,7 +74,6 @@ namespace PackageManagement.Tests
 		public void InstallPackage_PackageAndPackageRepositoryPassed_CreatesPackageManagerWithPackageRepository()
 		{
 			CreatePackageManagementService();
-			InstallPackageHelper installPackageHelper = new InstallPackageHelper(packageManagementService);
 			installPackageHelper.InstallTestPackage();
 			
 			IPackageRepository expectedRepository = installPackageHelper.PackageRepository;
@@ -87,7 +89,6 @@ namespace PackageManagement.Tests
 			IProject expectedProject = ProjectHelper.CreateTestProject();
 			fakeProjectService.CurrentProject = expectedProject;
 			
-			InstallPackageHelper installPackageHelper = new InstallPackageHelper(packageManagementService);
 			installPackageHelper.InstallTestPackage();
 			
 			IProject actualProject = fakePackageManagerFactory.ProjectPassedToCreateRepository;
@@ -99,7 +100,6 @@ namespace PackageManagement.Tests
 		public void InstallPackage_PackageAndPackageRepositoryPassed_RefreshesProjectBrowserWindow()
 		{
 			CreatePackageManagementService();
-			InstallPackageHelper installPackageHelper = new InstallPackageHelper(packageManagementService);
 			installPackageHelper.InstallTestPackage();
 			
 			Assert.IsTrue(fakeProjectService.IsRefreshProjectBrowserCalled);
@@ -111,7 +111,6 @@ namespace PackageManagement.Tests
 			CreatePackageManagementService();
 			fakePackageManagerFactory.FakePackageManager.FakeProjectService = fakeProjectService;
 			
-			InstallPackageHelper installPackageHelper = new InstallPackageHelper(packageManagementService);
 			installPackageHelper.InstallTestPackage();
 			
 			bool result = fakePackageManagerFactory.FakePackageManager.IsRefreshProjectBrowserCalledWhenInstallPackageCalled;
@@ -209,7 +208,6 @@ namespace PackageManagement.Tests
 			packageManagementService.PackageInstalled += (sender, e) => {
 				package = fakePackageManagerFactory.FakePackageManager.PackagePassedToInstallPackage;
 			};
-			InstallPackageHelper installPackageHelper = new InstallPackageHelper(packageManagementService);
 			installPackageHelper.InstallTestPackage();
 			
 			Assert.AreEqual(installPackageHelper.TestPackage, package);
@@ -382,5 +380,22 @@ namespace PackageManagement.Tests
 			
 			CollectionAssert.AreEqual(expectedPackages, packages);
 		}
+		
+		[Test]
+		public void InstallPackage_OnePackageOperation_PackageOperationPassedToPackageManagerWhenInstallingPackage()
+		{
+			CreatePackageManagementService();
+			
+			installPackageHelper.AddPackageInstallOperation();
+			installPackageHelper.InstallTestPackage();
+			
+			var actualOperations = 
+				fakePackageManagerFactory
+					.FakePackageManager
+					.ParametersPassedToInstallPackage
+					.PackageOperationsPassedToInstallPackage;
+			
+			CollectionAssert.AreEqual(installPackageHelper.PackageOperations, actualOperations);
+		}
 	}
 }

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

@@ -13,7 +13,7 @@ namespace PackageManagement.Tests
 	[TestFixture]
 	public class PackageViewModelTests
 	{
-		PackageViewModel viewModel;
+		TestablePackageViewModel viewModel;
 		FakePackage package;
 		FakePackageManagementService packageManagementService;
 		FakePackageRepository sourcePackageRepository;
@@ -21,13 +21,11 @@ namespace PackageManagement.Tests
 		
 		void CreateViewModel()
 		{
-			package = new FakePackage();
-			sourcePackageRepository = new FakePackageRepository();
-			packageManagementService = new FakePackageManagementService();
-			licenseAcceptanceService = new FakeLicenseAcceptanceService();
-			PackageViewModelFactory factory = new PackageViewModelFactory(packageManagementService, licenseAcceptanceService);
-			packageManagementService.ActivePackageRepository = sourcePackageRepository;
-			viewModel = factory.CreatePackageViewModel(package);
+			viewModel = new TestablePackageViewModel();
+			package = viewModel.FakePackage;
+			packageManagementService = viewModel.FakePackageManagementService;
+			sourcePackageRepository = packageManagementService.FakeActivePackageRepository;
+			licenseAcceptanceService = viewModel.FakeLicenseAcceptanceService;
 		}
 		
 		FakePackage AddPackageDependencyThatDoesNotRequireLicenseAcceptance(string packageId)
@@ -57,6 +55,19 @@ namespace PackageManagement.Tests
 			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()
 		{
@@ -64,9 +75,30 @@ namespace PackageManagement.Tests
 			viewModel.AddPackageCommand.Execute(null);
 						
 			Assert.AreEqual(package, packageManagementService.PackagePassedToInstallPackage);
+		}
+		
+		[Test]
+		public void AddPackage_PackageAddedSuccessfully_PackageAddedFromSourcePackageRepository()
+		{
+			CreateViewModel();
+			viewModel.AddPackage();
+						
 			Assert.AreEqual(sourcePackageRepository, packageManagementService.RepositoryPassedToInstallPackage);
 		}
 		
+		[Test]
+		public void AddPackage_PackageAddedSuccessfully_PackageOperationsUsedWhenInstallingPackage()
+		{
+			CreateViewModel();
+			viewModel.AddPackage();
+		
+			PackageOperation[] expectedOperations = new PackageOperation[] {
+				new PackageOperation(package, PackageAction.Install)
+			};
+			
+			CollectionAssert.AreEqual(expectedOperations, packageManagementService.PackageOperationsPassedToInstallPackage);
+		}
+		
 		[Test]
 		public void AddPackage_PackageAddedSuccessfully_PropertyNotifyChangedFiredForIsAddedProperty()
 		{
@@ -395,5 +427,17 @@ namespace PackageManagement.Tests
 			
 			Assert.IsFalse(licenseAcceptanceService.IsAcceptLicensesCalled);
 		}
+		
+		[Test]
+		public void AddPackage_OnePackageOperationIsToUninstallPackageWhichRequiresLicenseAcceptance_UserIsNotAskedToAcceptLicenseAgreementForPackageToBeUninstalled()
+		{
+			CreateViewModel();
+			package.RequireLicenseAcceptance = false;
+			FakePackage packageToUninstall = AddPackageUninstallOperation();
+			packageToUninstall.RequireLicenseAcceptance = true;
+			viewModel.AddPackage();
+			
+			Assert.IsFalse(licenseAcceptanceService.IsAcceptLicensesCalled);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/SharpDevelopPackageManagerTests.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.Core;
 using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.Design;
@@ -60,6 +61,7 @@ namespace PackageManagement.Tests
 		void CreateTestableProjectManager()
 		{
 			testableProjectManager = new TestableProjectManager();
+			packageManager.ProjectManager = testableProjectManager;
 		}
 		
 		FakePackage CreateFakePackage()
@@ -70,6 +72,88 @@ namespace PackageManagement.Tests
 			return package;
 		}
 		
+		FakePackage InstallPackage()
+		{
+			FakePackage package = CreateFakePackage();
+			packageManager.InstallPackage(package);
+			return package;
+		}
+		
+		FakePackage InstallPackageWithNoPackageOperations()
+		{
+			FakePackage package = CreateFakePackage();
+			var operations = new List<PackageOperation>();
+			packageManager.InstallPackage(package, operations);
+			return package;
+		}
+		
+		FakePackage InstallPackageWithOnePackageOperation(PackageOperation operation)
+		{
+			var operations = new PackageOperation[] {
+				operation
+			};
+			FakePackage package = CreateFakePackage();
+			packageManager.InstallPackage(package, operations);
+			return package;
+		}
+		
+		FakePackage InstallPackageAndIgnoreDependencies()
+		{
+			FakePackage package = CreateFakePackage();
+			packageManager.InstallPackage(package, true);
+			return package;
+		}
+		
+		FakePackage InstallPackageAndDoNotIgnoreDependencies()
+		{
+			FakePackage package = CreateFakePackage();
+			packageManager.InstallPackage(package, false);
+			return package;
+		}
+		
+		FakePackage UninstallPackage()
+		{	
+			FakePackage package = CreateFakePackage();
+			testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
+			
+			packageManager.UninstallPackage(package);
+			return package;
+		}
+
+		FakePackage UninstallPackageAndForceRemove()
+		{
+			FakePackage package = CreateFakePackage();			
+			testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
+			
+			bool removeDependencies = false;
+			bool forceRemove = true;
+			packageManager.UninstallPackage(package, forceRemove, removeDependencies);
+			
+			return package;
+		}
+		
+		FakePackage UninstallPackageAndRemoveDependencies()
+		{
+			FakePackage package = CreateFakePackage();
+			testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
+			
+			bool removeDependencies = true;
+			bool forceRemove = false;
+			packageManager.UninstallPackage(package, forceRemove, removeDependencies);
+			
+			return package;
+		}
+		
+		PackageOperation CreateOneInstallPackageOperation()
+		{
+			var package = CreateFakePackage();
+			package.Id = "PackageToInstall";
+			
+			return new PackageOperation(package, PackageAction.Install);
+		}
+		
+		
+
 		[Test]
 		public void ProjectManager_InstanceCreated_SourceRepositoryIsSharedRepositoryPassedToPackageManager()
 		{
@@ -113,41 +197,90 @@ namespace PackageManagement.Tests
 		public void InstallPackage_PackageInstancePassed_AddsReferenceToProject()
 		{
 			CreatePackageManager();
-			CreateTestableProjectManager();
+			var package = InstallPackage();
 			
-			packageManager.ProjectManager = testableProjectManager;
-			FakePackage package = CreateFakePackage();
-			packageManager.InstallPackage(package);
+			Assert.AreEqual(package, testableProjectManager.PackagePassedToAddPackageReference);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageInstancePassed_DependenciesNotIgnoredWhenAddingReferenceToProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			InstallPackage();
 			
+			Assert.IsFalse(testableProjectManager.IgnoreDependenciesPassedToAddPackageReference);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageInstanceAndPackageOperationsPassed_AddsReferenceToProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			FakePackage package = InstallPackageWithNoPackageOperations();
+				
 			Assert.AreEqual(package, testableProjectManager.PackagePassedToAddPackageReference);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageInstanceAndPackageOperationsPassed_DoNotIgnoreDependenciesWhenAddingReferenceToProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			InstallPackageWithNoPackageOperations();
+				
 			Assert.IsFalse(testableProjectManager.IgnoreDependenciesPassedToAddPackageReference);
 		}
 		
 		[Test]
-		public void InstallPackage_PackageDependenciesNotIgnored_IgnoreDependenciesPassedToProjectManager()
+		public void InstallPackage_PackageInstanceAndOneInstallPackageOperationPassed_PackageDefinedInOperationIsInstalledInLocalRepository()
 		{
 			CreatePackageManager();
 			CreateTestableProjectManager();
 			
-			packageManager.ProjectManager = testableProjectManager;
-			FakePackage package = CreateFakePackage();
-			packageManager.InstallPackage(package, true);
+			PackageOperation operation = CreateOneInstallPackageOperation();
+			InstallPackageWithOnePackageOperation(operation);
+				
+			Assert.AreEqual(operation.Package, fakeSolutionSharedRepository.FirstPackageAdded);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageDependenciesIgnored_IgnoreDependenciesPassedToProjectManager()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			InstallPackageAndIgnoreDependencies();
 			
 			Assert.IsTrue(testableProjectManager.IgnoreDependenciesPassedToAddPackageReference);
-			Assert.AreEqual(package, testableProjectManager.PackagePassedToAddPackageReference);
 		}
 		
 		[Test]
-		public void InstallPackage_PackageDependenciesIgnored_IgnoreDependenciesPassedToProjectManager()
+		public void InstallPackage_PackageDependenciesIgnored_AddsReferenceToPackage()
 		{
 			CreatePackageManager();
 			CreateTestableProjectManager();
+			var package = InstallPackageAndIgnoreDependencies();
 			
-			packageManager.ProjectManager = testableProjectManager;
-			FakePackage package = CreateFakePackage();
-			packageManager.InstallPackage(package, false);
+			Assert.AreEqual(package, testableProjectManager.PackagePassedToAddPackageReference);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageDependenciesNotIgnored_IgnoreDependenciesPassedToProjectManager()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			InstallPackageAndDoNotIgnoreDependencies();
 			
 			Assert.IsFalse(testableProjectManager.IgnoreDependenciesPassedToAddPackageReference);
+		}
+		
+		[Test]
+		public void InstallPackage_PackageDependenciesNotIgnored_AddsReferenceToPackage()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			var package = InstallPackageAndDoNotIgnoreDependencies();
+			
 			Assert.AreEqual(package, testableProjectManager.PackagePassedToAddPackageReference);
 		}
 		
@@ -156,36 +289,50 @@ namespace PackageManagement.Tests
 		{
 			CreatePackageManager();
 			CreateTestableProjectManager();
-			
-			packageManager.ProjectManager = testableProjectManager;
-			FakePackage package = CreateFakePackage();
-			package.Id = "Test";
-			
-			testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
-			
-			packageManager.UninstallPackage(package);
+			var package = UninstallPackage();
 			
 			Assert.AreEqual(package.Id, testableProjectManager.PackagePassedToRemovePackageReference.Id);
+		}
+		
+		[Test]
+		public void UninstallPackage_PackageInProjectLocalRepository_DoesNotRemoveReferenceForcefullyFromProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			UninstallPackage();
+			
 			Assert.IsFalse(testableProjectManager.ForcePassedToRemovePackageReference);
-			Assert.IsFalse(testableProjectManager.RemoveDependenciesPassedToRemovePackageReference);
 		}
 		
 		[Test]
-		public void UninstallPackage_PassingForceRemoveAndRemoveDependencyFlags_FlagsPassedToProjectManager()
+		public void UninstallPackage_PackageInProjectLocalRepository_DependenciesNotRemovedWhenPackageReferenceRemovedFromProject()
 		{
 			CreatePackageManager();
 			CreateTestableProjectManager();
+			UninstallPackage();
 			
-			packageManager.ProjectManager = testableProjectManager;
-			FakePackage package = CreateFakePackage();
-			package.Id = "Test";
+			Assert.IsFalse(testableProjectManager.RemoveDependenciesPassedToRemovePackageReference);
+		}
+		
+		[Test]
+		public void UninstallPackage_PassingForceRemove_ReferenceForcefullyRemovedFromProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
 			
-			testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
-			bool removeDependencies = true;
-			bool forceRemove = true;
-			packageManager.UninstallPackage(package, forceRemove, removeDependencies);
+			UninstallPackageAndForceRemove();
 			
 			Assert.IsTrue(testableProjectManager.ForcePassedToRemovePackageReference);
+		}
+		
+		[Test]
+		public void UninstallPackage_PassingRemoveDependencies_DependenciesRemovedWhenPackageReferenceRemovedFromProject()
+		{
+			CreatePackageManager();
+			CreateTestableProjectManager();
+			
+			UninstallPackageAndRemoveDependencies();
+			
 			Assert.IsTrue(testableProjectManager.RemoveDependenciesPassedToRemovePackageReference);
 		}
 		
@@ -195,7 +342,6 @@ namespace PackageManagement.Tests
 			CreatePackageManager();
 			CreateTestableProjectManager();
 			
-			packageManager.ProjectManager = testableProjectManager;
 			FakePackage package = CreateFakePackage();
 			package.Id = "Test";