Add file conflict dialog.

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

@@ -147,6 +147,7 @@
     <Compile Include="Src\EnvDTE\TextDocument.cs" />
     <Compile Include="Src\EnvDTE\TextPoint.cs" />
     <Compile Include="Src\EnvDTE\Window.cs" />
+    <Compile Include="Src\FileConflictResolver.cs" />
     <Compile Include="Src\IClassKindUpdater.cs" />
     <Compile Include="Src\IDocumentNamespaceCreator.cs" />
     <Compile Include="Src\IPackageExtensions.cs" />
@@ -224,6 +225,7 @@
     <Compile Include="Src\PackageLicenseViewModel.cs" />
     <Compile Include="Src\PackageManagementServiceProvider.cs" />
     <Compile Include="Src\ProjectBuilder.cs" />
+    <Compile Include="Src\ResolveFileConflictEventArgs.cs" />
     <Compile Include="Src\VirtualMethodUpdater.cs" />
     <Compile Include="Src\NewProjectsCreated.cs" />
     <Compile Include="Src\OpenMSBuildProjects.cs" />

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

@@ -0,0 +1,44 @@
+// 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.Core;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement
+{
+	public class FileConflictResolver : IFileConflictResolver
+	{
+		string[] buttons = new string[] { "Yes", "Yes to All", "No", "No to All" };
+		
+		const int YesButtonIndex = 0;
+		const int YesToAllButtonIndex = 1;
+		const int NoButtonIndex = 2;
+		const int NoToAllButtonIndex = 3;
+		
+		public FileConflictResolution ResolveFileConflict(string message)
+		{
+			int result = MessageService.ShowCustomDialog(
+				"File Conflict",
+				message,
+				NoButtonIndex, // "No" is default accept button.
+				-1,
+				buttons);
+			return MapResultToFileConflictResolution(result);
+		}
+		
+		FileConflictResolution MapResultToFileConflictResolution(int result)
+		{
+			switch (result) {
+				case YesButtonIndex:
+					return FileConflictResolution.Overwrite;
+				case YesToAllButtonIndex:
+					return FileConflictResolution.OverwriteAll;
+				case NoToAllButtonIndex:
+					return FileConflictResolution.IgnoreAll;
+				default:
+					return FileConflictResolution.Ignore;
+			}
+		}
+	}
+}

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

@@ -12,17 +12,19 @@ namespace ICSharpCode.PackageManagement
 		event EventHandler PackageOperationsStarting;
 		event EventHandler<AcceptLicensesEventArgs> AcceptLicenses;
 		event EventHandler<SelectProjectsEventArgs> SelectProjects;
+		event EventHandler<ResolveFileConflictEventArgs> ResolveFileConflict;
 		event EventHandler<PackageOperationExceptionEventArgs> PackageOperationError;
 		event EventHandler<ParentPackageOperationEventArgs> ParentPackageInstalled;
 		event EventHandler<ParentPackageOperationEventArgs> ParentPackageUninstalled;
 		event EventHandler<PackageOperationMessageLoggedEventArgs> PackageOperationMessageLogged;
 	
-		void OnPackageOperationsStarting();		
+		void OnPackageOperationsStarting();
 		void OnPackageOperationError(Exception ex);
 		bool OnAcceptLicenses(IEnumerable<IPackage> packages);
 		void OnParentPackageInstalled(IPackage package);
 		void OnParentPackageUninstalled(IPackage package);
 		void OnPackageOperationMessageLogged(MessageLevel level, string message, params object[] args);
 		bool OnSelectProjects(IEnumerable<IPackageManagementSelectedProject> selectedProjects);
+		FileConflictResolution OnResolveFileConflict(string message);
 	}
 }

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

@@ -11,6 +11,7 @@ namespace ICSharpCode.PackageManagement
 		
 		void SafeThreadAsyncCall<A>(Action<A> method, A arg1);
 		void SafeThreadAsyncCall<A, B>(Action<A, B> method, A arg1, B arg2);
+		R SafeThreadFunction<R>(Func<R> method);
 		void CreateConsolePad();
 	}
 }

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

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using NuGet;
 
 namespace ICSharpCode.PackageManagement
 {
@@ -10,31 +11,44 @@ namespace ICSharpCode.PackageManagement
 		ILicenseAcceptanceService licenseAcceptanceService;
 		ISelectProjectsService selectProjectsService;
 		IPackageManagementEvents packageManagementEvents;
+		IFileConflictResolver fileConflictResolver;
+		FileConflictResolution lastFileConflictResolution;
 		
 		public ManagePackagesUserPrompts(IPackageManagementEvents packageManagementEvents)
 			: this(
 				packageManagementEvents,
 				new LicenseAcceptanceService(),
-				new SelectProjectsService())
+				new SelectProjectsService(),
+				new FileConflictResolver())
 		{
 		}
 		
 		public ManagePackagesUserPrompts(
 			IPackageManagementEvents packageManagementEvents,
 			ILicenseAcceptanceService licenseAcceptanceService,
-			ISelectProjectsService selectProjectsService)
+			ISelectProjectsService selectProjectsService,
+			IFileConflictResolver fileConflictResolver)
 		{
 			this.packageManagementEvents = packageManagementEvents;
 			this.licenseAcceptanceService = licenseAcceptanceService;
 			this.selectProjectsService = selectProjectsService;
+			this.fileConflictResolver = fileConflictResolver;
 			
+			ResetFileConflictResolution();
 			SubscribeToEvents();
 		}
 		
+		void ResetFileConflictResolution()
+		{
+			lastFileConflictResolution = FileConflictResolution.Overwrite;
+		}
+		
 		void SubscribeToEvents()
 		{
-			packageManagementEvents.AcceptLicenses += AcceptLicenses;			
+			packageManagementEvents.AcceptLicenses += AcceptLicenses;
 			packageManagementEvents.SelectProjects += SelectProjects;
+			packageManagementEvents.ResolveFileConflict += ResolveFileConflict;
+			packageManagementEvents.PackageOperationsStarting += PackageOperationsStarting;
 		}
 		
 		void AcceptLicenses(object sender, AcceptLicensesEventArgs e)
@@ -47,6 +61,28 @@ namespace ICSharpCode.PackageManagement
 			e.IsAccepted = selectProjectsService.SelectProjects(e.SelectedProjects);
 		}
 		
+		void ResolveFileConflict(object sender, ResolveFileConflictEventArgs e)
+		{
+			if (UserPreviouslySelectedOverwriteAllOrIgnoreAll()) {
+				e.Resolution = lastFileConflictResolution;
+			} else {
+				e.Resolution = fileConflictResolver.ResolveFileConflict(e.Message);
+				lastFileConflictResolution = e.Resolution;
+			}
+		}
+		
+		bool UserPreviouslySelectedOverwriteAllOrIgnoreAll()
+		{
+			return
+				(lastFileConflictResolution == FileConflictResolution.IgnoreAll) ||
+				(lastFileConflictResolution == FileConflictResolution.OverwriteAll);
+		}
+		
+		void PackageOperationsStarting(object sender, EventArgs e)
+		{
+			ResetFileConflictResolution();
+		}
+		
 		public void Dispose()
 		{
 			UnsubscribeFromEvents();
@@ -56,6 +92,8 @@ namespace ICSharpCode.PackageManagement
 		{
 			packageManagementEvents.SelectProjects -= SelectProjects;
 			packageManagementEvents.AcceptLicenses -= AcceptLicenses;
+			packageManagementEvents.ResolveFileConflict -= ResolveFileConflict;
+			packageManagementEvents.PackageOperationsStarting -= PackageOperationsStarting;
 		}
 	}
 }

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

@@ -78,5 +78,17 @@ namespace ICSharpCode.PackageManagement
 			}
 			return true;
 		}
+		
+		public event EventHandler<ResolveFileConflictEventArgs> ResolveFileConflict;
+		
+		public FileConflictResolution OnResolveFileConflict(string message)
+		{
+			if (ResolveFileConflict != null) {
+				var eventArgs = new ResolveFileConflictEventArgs(message);
+				ResolveFileConflict(this, eventArgs);
+				return eventArgs.Resolution;
+			}
+			return FileConflictResolution.IgnoreAll;
+		}
 	}
 }

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

@@ -22,7 +22,7 @@ namespace ICSharpCode.PackageManagement
 		
 		public FileConflictResolution ResolveFileConflict(string message)
 		{
-			throw new NotImplementedException();
+			return packageManagementEvents.OnResolveFileConflict(message);
 		}
 	}
 }

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

@@ -36,5 +36,10 @@ namespace ICSharpCode.PackageManagement
 		{
 			WorkbenchSingleton.SafeThreadAsyncCall<A, B>(method, arg1, arg2);
 		}
+		
+		public R SafeThreadFunction<R>(Func<R> method)
+		{
+			return WorkbenchSingleton.SafeThreadFunction<R>(method);
+		}
 	}
 }

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

@@ -93,7 +93,7 @@ namespace ICSharpCode.PackageManagement
 		
 		public FileConflictResolution ResolveFileConflict(string message)
 		{
-			throw new NotImplementedException();
+			return logger.ResolveFileConflict(message);
 		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/ResolveFileConflictEventArgs.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 ResolveFileConflictEventArgs : EventArgs
+	{
+		public ResolveFileConflictEventArgs(string message)
+		{
+			this.Message = message;
+			this.Resolution = FileConflictResolution.Ignore;
+		}
+		
+		public string Message { get; private set; }
+		public FileConflictResolution Resolution { get; set; }
+	}
+}

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

@@ -74,6 +74,11 @@ namespace ICSharpCode.PackageManagement
 			workbench.SafeThreadAsyncCall<A, B>(method, arg1, arg2);
 		}
 		
+		R SafeThreadFunction<R>(Func<R> method)
+		{
+			return workbench.SafeThreadFunction<R>(method);
+		}
+		
 		public event EventHandler PackageOperationsStarting;
 		
 		void RaisePackageOperationErrorEventIfHasSubscribers(object sender, PackageOperationExceptionEventArgs e)
@@ -184,5 +189,15 @@ namespace ICSharpCode.PackageManagement
 		{
 			return unsafeEvents.OnSelectProjects(selectedProjects);
 		}
+		
+		public event EventHandler<ResolveFileConflictEventArgs> ResolveFileConflict {
+			add { unsafeEvents.ResolveFileConflict += value; }
+			remove { unsafeEvents.ResolveFileConflict -= value; }
+		}
+		
+		public FileConflictResolution OnResolveFileConflict(string message)
+		{
+			return unsafeEvents.OnResolveFileConflict(message);
+		}
 	}
 }

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

@@ -190,8 +190,10 @@
     <Compile Include="Src\Helpers\TestableInstallProjectTemplatePackagesCommand.cs" />
     <Compile Include="Src\Helpers\TestablePowerShellMissingConsoleHost.cs" />
     <Compile Include="Src\InstallProjectTemplatePackagesCommandTests.cs" />
+    <Compile Include="Src\ManagePackagesUserPromptsTests.cs" />
     <Compile Include="Src\OpenMSBuildProjectsTests.cs" />
     <Compile Include="Src\PackageManagementServiceProviderTests.cs" />
+    <Compile Include="Src\PackageViewModelOperationLoggerTests.cs" />
     <Compile Include="Src\VirtualMethodUpdaterTests.cs" />
     <Compile Include="Src\NewProjectsCreatedTests.cs" />
     <Compile Include="Src\PackageActionRunnerTests.cs" />

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

@@ -19,6 +19,7 @@ namespace PackageManagement.Tests.Helpers
 		public event EventHandler<ParentPackageOperationEventArgs> ParentPackageInstalled;
 		public event EventHandler<ParentPackageOperationEventArgs> ParentPackageUninstalled;
 		public event EventHandler<PackageOperationMessageLoggedEventArgs> PackageOperationMessageLogged;
+		public event EventHandler<ResolveFileConflictEventArgs> ResolveFileConflict;
 		#pragma warning restore 0067
 		
 		public bool IsOnPackageOperationsStartingCalled;
@@ -108,5 +109,14 @@ namespace PackageManagement.Tests.Helpers
 		{
 			return new List<IPackage>(LastPackagesPassedToOnAcceptLicenses);
 		}
+		
+		public string MessagePassedToOnResolveFileConflict;
+		public FileConflictResolution FileConflictResolutionToReturn = FileConflictResolution.Ignore;
+		
+		public FileConflictResolution OnResolveFileConflict(string message)
+		{
+			MessagePassedToOnResolveFileConflict = message;
+			return FileConflictResolutionToReturn;
+		}
 	}
 }

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

@@ -37,5 +37,13 @@ namespace PackageManagement.Tests.Helpers
 			Arg1PassedToSafeThreadAsyncCall = arg1;
 			Arg2PassedToSafeThreadAsyncCall = arg2;
 		}
+		
+		public bool IsSafeThreadFunctionCallMade;
+		
+		public R SafeThreadFunction<R>(Func<R> method)
+		{
+			IsSafeThreadFunctionCallMade = true;
+			return method();
+		}
 	}
 }

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

@@ -0,0 +1,145 @@
+// 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;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class ManagePackagesUserPromptsTests
+	{
+		ManagePackagesUserPrompts userPrompts;
+		IPackageManagementEvents fakeEvents;
+		ILicenseAcceptanceService fakeLicenseService;
+		ISelectProjectsService fakeSelectProjectsService;
+		IFileConflictResolver fakeFileConflictResolver;
+		
+		void CreateUserPrompts()
+		{
+			fakeEvents = MockRepository.GenerateStub<IPackageManagementEvents>();
+			fakeLicenseService = MockRepository.GenerateStub<ILicenseAcceptanceService>();
+			fakeSelectProjectsService = MockRepository.GenerateStub<ISelectProjectsService>();
+			fakeFileConflictResolver = MockRepository.GenerateStub<IFileConflictResolver>();
+			
+			userPrompts = new ManagePackagesUserPrompts(
+				fakeEvents,
+				fakeLicenseService,
+				fakeSelectProjectsService,
+				fakeFileConflictResolver);
+		}
+		
+		FileConflictResolution RaiseResolveFileConflict(string message)
+		{
+			var eventArgs = new ResolveFileConflictEventArgs(message);
+			fakeEvents.Raise(events => events.ResolveFileConflict += null, fakeEvents, eventArgs);
+			return eventArgs.Resolution;
+		}
+		
+		void RaisePackageOperationsStarting()
+		{
+			fakeEvents.Raise(events => events.PackageOperationsStarting += null, fakeEvents, new EventArgs());
+		}
+		
+		void ResolverReturns(FileConflictResolution resolution)
+		{
+			fakeFileConflictResolver
+				.Stub(r => r.ResolveFileConflict(Arg<string>.Is.Anything))
+				.Return(resolution);
+		}
+		
+		void ResetFakeResolver()
+		{
+			fakeFileConflictResolver.BackToRecord(BackToRecordOptions.All);
+			fakeFileConflictResolver.Replay();
+		}
+		
+		void AssertFileConflictResolverWasNotCalled()
+		{
+			fakeFileConflictResolver.AssertWasNotCalled(resolver => resolver.ResolveFileConflict(Arg<string>.Is.Anything));
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_MessagePassed_MessagePassedToFileConflictService()
+		{
+			CreateUserPrompts();
+			RaisePackageOperationsStarting();
+			
+			RaiseResolveFileConflict("message");
+			
+			fakeFileConflictResolver.AssertWasCalled(resolver => resolver.ResolveFileConflict("message"));
+		}
+		
+		[Test]
+		public void Dispose_ResolveFileConflictEventRaised_FileConflictServiceNotCalled()
+		{
+			CreateUserPrompts();
+			
+			userPrompts.Dispose();
+			RaiseResolveFileConflict("message");
+			
+			AssertFileConflictResolverWasNotCalled();
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_FileConflictResolverReturnsOverwrite_OverwriteSetInEventArgs()
+		{
+			CreateUserPrompts();
+			RaisePackageOperationsStarting();
+			ResolverReturns(FileConflictResolution.Overwrite);
+			
+			FileConflictResolution resolution = RaiseResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.Overwrite, resolution);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_ResolverReturnsIgnoreAllAndThenResolveFileConflictFiredAgain_IgnoreAllReturnedWithoutCallingFileConflictResolverAgain()
+		{
+			CreateUserPrompts();
+			RaisePackageOperationsStarting();
+			ResolverReturns(FileConflictResolution.IgnoreAll);
+			RaiseResolveFileConflict("message");
+			ResetFakeResolver();
+			ResolverReturns(FileConflictResolution.Overwrite);
+			
+			FileConflictResolution resolution = RaiseResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.IgnoreAll, resolution);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_ResolverReturnsOverwriteAllAndThenResolveFileConflictFiredAgain_OverwriteAllReturnedWithoutCallingFileConflictResolverAgain()
+		{
+			CreateUserPrompts();
+			RaisePackageOperationsStarting();
+			ResolverReturns(FileConflictResolution.OverwriteAll);
+			RaiseResolveFileConflict("message");
+			ResetFakeResolver();
+			ResolverReturns(FileConflictResolution.Ignore);
+			
+			FileConflictResolution resolution = RaiseResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.OverwriteAll, resolution);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_ResolverReturnsOverwriteAllAndNewPackageInstalledAndThenResolveFileConflictFiredAgain_FileConflictResolverUsedAgainForNewPackage()
+		{
+			CreateUserPrompts();
+			RaisePackageOperationsStarting();
+			ResolverReturns(FileConflictResolution.OverwriteAll);
+			RaiseResolveFileConflict("message");
+			ResetFakeResolver();
+			RaisePackageOperationsStarting();
+			ResolverReturns(FileConflictResolution.Ignore);
+			
+			FileConflictResolution resolution = RaiseResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.Ignore, resolution);
+		}
+	}
+}

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

@@ -9,6 +9,7 @@ using ICSharpCode.PackageManagement.Design;
 using NuGet;
 using NUnit.Framework;
 using PackageManagement.Tests.Helpers;
+using Rhino.Mocks;
 
 namespace PackageManagement.Tests
 {
@@ -19,6 +20,7 @@ namespace PackageManagement.Tests
 		PackageManagementEvents packageManagementEvents;
 		FakeLicenseAcceptanceService fakeLicenseAcceptanceService;
 		FakeSelectProjectsService fakeSelectProjectsService;
+		IFileConflictResolver fakeFileConflictResolver;
 		FakePackageManagementSolution fakeSolution;
 		FakeRegisteredPackageRepositories fakeRegisteredPackageRepositories;
 		FakeTaskFactory fakeTaskFactory;
@@ -57,10 +59,12 @@ namespace PackageManagement.Tests
 			fakeTaskFactory = new FakeTaskFactory();
 			fakeLicenseAcceptanceService = new FakeLicenseAcceptanceService();
 			fakeSelectProjectsService = new FakeSelectProjectsService();
+			fakeFileConflictResolver = MockRepository.GenerateStub<IFileConflictResolver>();
 			userPrompts = new ManagePackagesUserPrompts(
 				packageManagementEvents,
 				fakeLicenseAcceptanceService,
-				fakeSelectProjectsService);
+				fakeSelectProjectsService,
+				fakeFileConflictResolver);
 			fakeActionRunner = new FakePackageActionRunner();
 			
 			packagesViewModels = new PackagesViewModels(

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

@@ -335,5 +335,57 @@ namespace PackageManagement.Tests
 			
 			Assert.IsTrue(result);
 		}
+		
+		[Test]
+		public void OnResolveFileConflict_OneEventSubscriber_SenderIsPackageEvents()
+		{
+			CreateEvents();
+			object eventSender = null;
+			events.ResolveFileConflict += (sender, e) => eventSender = sender;
+			events.OnResolveFileConflict("message");
+			
+			Assert.AreEqual(events, eventSender);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_OneEventSubscriber_MessageAddedToEventArgs()
+		{
+			CreateEvents();
+			ResolveFileConflictEventArgs eventArgs = null;
+			events.ResolveFileConflict += (sender, e) => eventArgs = e;
+			events.OnResolveFileConflict("message");
+			
+			Assert.AreEqual("message", eventArgs.Message);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_OneEventSubscriberWhichDoesNotChangeEventArgs_EventArgsHasFileConflictResolutionOfIgnore()
+		{
+			CreateEvents();
+			ResolveFileConflictEventArgs eventArgs = null;
+			events.ResolveFileConflict += (sender, e) => eventArgs = e;
+			events.OnResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.Ignore, eventArgs.Resolution);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_OneEventSubscriberWhichChangesResolutionToOverwrite_ReturnsOverwrite()
+		{
+			CreateEvents();
+			events.ResolveFileConflict += (sender, e) => e.Resolution = FileConflictResolution.Overwrite;
+			FileConflictResolution resolution = events.OnResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.Overwrite, resolution);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_NoEventSubscribers_ReturnsIgnoreAll()
+		{
+			CreateEvents();
+			FileConflictResolution resolution = events.OnResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.IgnoreAll, resolution);
+		}
 	}
 }

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

@@ -5,22 +5,39 @@ using System;
 using ICSharpCode.PackageManagement;
 using NuGet;
 using NUnit.Framework;
-using PackageManagement.Tests.Helpers;
+using Rhino.Mocks;
 
 namespace PackageManagement.Tests
 {
 	[TestFixture]
 	public class PackageManagementLoggerTests
 	{
-		FakePackageManagementEvents fakePackageManagementEvents;
+		IPackageManagementEvents fakePackageManagementEvents;
 		PackageManagementLogger logger;
 		
 		void CreateLogger()
 		{
-			fakePackageManagementEvents = new FakePackageManagementEvents();
+			fakePackageManagementEvents = MockRepository.GenerateStub<IPackageManagementEvents>();
 			logger = new PackageManagementLogger(fakePackageManagementEvents);
 		}
 		
+		void AssertOnPackageOperationMessageLoggedCalled(MessageLevel level, string message)
+		{
+			fakePackageManagementEvents.AssertWasCalled(
+				events => events.OnPackageOperationMessageLogged(level, message));
+		}
+		
+		void AssertOnPackageOperationMessageLoggedCalled(MessageLevel level, string message, object arg)
+		{
+			fakePackageManagementEvents.AssertWasCalled(
+				events => events.OnPackageOperationMessageLogged(level, message, arg));
+		}
+		
+		void AssertOnResolveFileConflictCalled(string message)
+		{
+			fakePackageManagementEvents.AssertWasCalled(events => events.OnResolveFileConflict(message));
+		}
+		
 		[Test]
 		public void Log_WarningMessageLogged_RaisesMessageLoggedEventWithWarningMessageLevel()
 		{
@@ -28,7 +45,7 @@ namespace PackageManagement.Tests
 			
 			logger.Log(MessageLevel.Warning, "test");
 			
-			Assert.AreEqual(MessageLevel.Warning, fakePackageManagementEvents.MessageLevelPassedToOnPackageOperationMessageLogged);
+			AssertOnPackageOperationMessageLoggedCalled(MessageLevel.Warning, "test");
 		}
 		
 		[Test]
@@ -39,9 +56,30 @@ namespace PackageManagement.Tests
 			string format = "Test {0}";
 			logger.Log(MessageLevel.Info, format, "C");
 			
-			string message = fakePackageManagementEvents.FormattedStringPassedToOnPackageOperationMessageLogged;
+			AssertOnPackageOperationMessageLoggedCalled(MessageLevel.Info, format, "C");
+		}
+		
+		[Test]
+		public void ResolveFileConflict_MessagePassed_RaisesOnResolveFileConflictEvent()
+		{
+			CreateLogger();
+			
+			logger.ResolveFileConflict("message");
+			
+			AssertOnResolveFileConflictCalled("message");
+		}
+		
+		[Test]
+		public void ResolveFileConflict_PackageManagementEventsResolveFileConflictReturnsIgnoreAll_ReturnsIgnoreAll()
+		{
+			CreateLogger();
+			fakePackageManagementEvents
+				.Stub(events => events.OnResolveFileConflict("message"))
+				.Return(FileConflictResolution.IgnoreAll);
+			
+			FileConflictResolution resolution = logger.ResolveFileConflict("message");
 			
-			Assert.AreEqual("Test C", message);
+			Assert.AreEqual(FileConflictResolution.IgnoreAll, resolution);
 		}
 	}
 }

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

@@ -0,0 +1,49 @@
+// 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;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests
+{
+	[TestFixture]
+	public class PackageViewModelOperationLoggerTests
+	{
+		PackageViewModelOperationLogger operationLogger;
+		IPackage fakePackage;
+		ILogger fakeLogger;
+		
+		void CreateLogger()
+		{
+			fakePackage = MockRepository.GenerateStub<IPackage>();
+			fakeLogger = MockRepository.GenerateStub<ILogger>();
+			operationLogger = new PackageViewModelOperationLogger(fakeLogger, fakePackage);
+		}
+		
+		[Test]
+		public void ResolveFileConflict_MessagePassed_MessagePassedToWrappedLogger()
+		{
+			CreateLogger();
+			
+			FileConflictResolution resolution = operationLogger.ResolveFileConflict("message");
+			
+			fakeLogger.AssertWasCalled(logger => logger.ResolveFileConflict("message"));
+		}
+		
+		[Test]
+		public void ResolveFileConflict_WrappedLoggerResolveFileConflictReturnsOverwriteAll_ReturnsOverwriteAll()
+		{
+			CreateLogger();
+			fakeLogger
+				.Stub(logger => logger.ResolveFileConflict("message"))
+				.Return(FileConflictResolution.OverwriteAll);
+			
+			FileConflictResolution resolution = operationLogger.ResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.OverwriteAll, resolution);
+		}
+	}
+}

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

@@ -453,5 +453,58 @@ namespace PackageManagement.Tests
 			
 			Assert.IsFalse(eventHandlerFired);
 		}
+		
+		[Test]
+		public void OnResolveFileConflict_NoInvokeRequired_NonThreadSafeOnResolveFileConflictMethodCalledWithMessage()
+		{
+			CreateEvents();
+			threadSafeEvents.OnResolveFileConflict("message");
+			
+			Assert.AreEqual("message", fakeEvents.MessagePassedToOnResolveFileConflict);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_NoInvokeRequired_ValueReturnedFromNonThreadSafeOnResolveFileConflict()
+		{
+			CreateEvents();
+			fakeEvents.FileConflictResolutionToReturn = FileConflictResolution.OverwriteAll;
+			FileConflictResolution result = threadSafeEvents.OnResolveFileConflict("message");
+			
+			Assert.AreEqual(FileConflictResolution.OverwriteAll, result);
+		}
+		
+		[Test]
+		public void OnResolveFileConflict_UnsafeEventFired_ThreadSafeEventFired()
+		{
+			CreateEventsWithRealPackageManagementEvents();
+			bool fired = false;
+			threadSafeEvents.ResolveFileConflict += (sender, e) => fired = true;
+			unsafeEvents.OnResolveFileConflict("message");
+			
+			Assert.IsTrue(fired);
+		}
+		
+		[Test]
+		public void ResolveFileConflict_UnsafeEventFired_ThreadSafeEventFired()
+		{
+			CreateEventsWithRealPackageManagementEvents();
+			bool fired = false;
+			threadSafeEvents.ResolveFileConflict += (sender, e) => fired = true;
+			unsafeEvents.OnResolveFileConflict("message");
+			
+			Assert.IsTrue(fired);
+		}
+		
+		[Test]
+		public void ResolveFileConflict_UnsafeEventFiredAfterEventHandlerRemoved_ThreadSafeEventIsNotFired()
+		{
+			CreateEventsWithRealPackageManagementEvents();
+			eventHandlerFired = false;
+			threadSafeEvents.ResolveFileConflict += OnEventHandlerFired;
+			threadSafeEvents.ResolveFileConflict -= OnEventHandlerFired;
+			unsafeEvents.OnResolveFileConflict("message");
+			
+			Assert.IsFalse(eventHandlerFired);
+		}
 	}
 }