diff --git a/src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj b/src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj index f00dfc4d90..8c5a032d6a 100644 --- a/src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj +++ b/src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj @@ -147,6 +147,7 @@ + @@ -224,6 +225,7 @@ + diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/FileConflictResolver.cs b/src/AddIns/Misc/PackageManagement/Project/Src/FileConflictResolver.cs new file mode 100644 index 0000000000..667623f706 --- /dev/null +++ b/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; + } + } + } +} diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementEvents.cs b/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementEvents.cs index c603626165..85124b15d7 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementEvents.cs +++ b/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementEvents.cs @@ -12,17 +12,19 @@ namespace ICSharpCode.PackageManagement event EventHandler PackageOperationsStarting; event EventHandler AcceptLicenses; event EventHandler SelectProjects; + event EventHandler ResolveFileConflict; event EventHandler PackageOperationError; event EventHandler ParentPackageInstalled; event EventHandler ParentPackageUninstalled; event EventHandler PackageOperationMessageLogged; - void OnPackageOperationsStarting(); + void OnPackageOperationsStarting(); void OnPackageOperationError(Exception ex); bool OnAcceptLicenses(IEnumerable packages); void OnParentPackageInstalled(IPackage package); void OnParentPackageUninstalled(IPackage package); void OnPackageOperationMessageLogged(MessageLevel level, string message, params object[] args); bool OnSelectProjects(IEnumerable selectedProjects); + FileConflictResolution OnResolveFileConflict(string message); } } diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementWorkbench.cs b/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementWorkbench.cs index 3755792cc5..fd0a1c0ddf 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementWorkbench.cs +++ b/src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementWorkbench.cs @@ -11,6 +11,7 @@ namespace ICSharpCode.PackageManagement void SafeThreadAsyncCall(Action method, A arg1); void SafeThreadAsyncCall(Action method, A arg1, B arg2); + R SafeThreadFunction(Func method); void CreateConsolePad(); } } diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/ManagePackagesUserPrompts.cs b/src/AddIns/Misc/PackageManagement/Project/Src/ManagePackagesUserPrompts.cs index e17dc73ef7..a240facd3f 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/ManagePackagesUserPrompts.cs +++ b/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; } } } diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementEvents.cs b/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementEvents.cs index 0faceea95b..5e048a962e 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementEvents.cs +++ b/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementEvents.cs @@ -78,5 +78,17 @@ namespace ICSharpCode.PackageManagement } return true; } + + public event EventHandler ResolveFileConflict; + + public FileConflictResolution OnResolveFileConflict(string message) + { + if (ResolveFileConflict != null) { + var eventArgs = new ResolveFileConflictEventArgs(message); + ResolveFileConflict(this, eventArgs); + return eventArgs.Resolution; + } + return FileConflictResolution.IgnoreAll; + } } } diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementLogger.cs b/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementLogger.cs index 9cdb8cc3f1..995de15543 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementLogger.cs +++ b/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); } } } diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementWorkbench.cs b/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementWorkbench.cs index 03cba04334..4724c06f03 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementWorkbench.cs +++ b/src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementWorkbench.cs @@ -36,5 +36,10 @@ namespace ICSharpCode.PackageManagement { WorkbenchSingleton.SafeThreadAsyncCall(method, arg1, arg2); } + + public R SafeThreadFunction(Func method) + { + return WorkbenchSingleton.SafeThreadFunction(method); + } } } diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/PackageViewModelOperationLogger.cs b/src/AddIns/Misc/PackageManagement/Project/Src/PackageViewModelOperationLogger.cs index 0d0505e32d..655a2e6859 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/PackageViewModelOperationLogger.cs +++ b/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); } } } diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/ResolveFileConflictEventArgs.cs b/src/AddIns/Misc/PackageManagement/Project/Src/ResolveFileConflictEventArgs.cs new file mode 100644 index 0000000000..bb75287bb4 --- /dev/null +++ b/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; } + } +} diff --git a/src/AddIns/Misc/PackageManagement/Project/Src/ThreadSafePackageManagementEvents.cs b/src/AddIns/Misc/PackageManagement/Project/Src/ThreadSafePackageManagementEvents.cs index af756e42fa..a6287f4d31 100644 --- a/src/AddIns/Misc/PackageManagement/Project/Src/ThreadSafePackageManagementEvents.cs +++ b/src/AddIns/Misc/PackageManagement/Project/Src/ThreadSafePackageManagementEvents.cs @@ -74,6 +74,11 @@ namespace ICSharpCode.PackageManagement workbench.SafeThreadAsyncCall(method, arg1, arg2); } + R SafeThreadFunction(Func method) + { + return workbench.SafeThreadFunction(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 ResolveFileConflict { + add { unsafeEvents.ResolveFileConflict += value; } + remove { unsafeEvents.ResolveFileConflict -= value; } + } + + public FileConflictResolution OnResolveFileConflict(string message) + { + return unsafeEvents.OnResolveFileConflict(message); + } } } diff --git a/src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj b/src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj index ead1877239..27a99869a3 100644 --- a/src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj +++ b/src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj @@ -190,8 +190,10 @@ + + diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementEvents.cs b/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementEvents.cs index e1b20a1e6b..e75874e924 100644 --- a/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementEvents.cs +++ b/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementEvents.cs @@ -19,6 +19,7 @@ namespace PackageManagement.Tests.Helpers public event EventHandler ParentPackageInstalled; public event EventHandler ParentPackageUninstalled; public event EventHandler PackageOperationMessageLogged; + public event EventHandler ResolveFileConflict; #pragma warning restore 0067 public bool IsOnPackageOperationsStartingCalled; @@ -108,5 +109,14 @@ namespace PackageManagement.Tests.Helpers { return new List(LastPackagesPassedToOnAcceptLicenses); } + + public string MessagePassedToOnResolveFileConflict; + public FileConflictResolution FileConflictResolutionToReturn = FileConflictResolution.Ignore; + + public FileConflictResolution OnResolveFileConflict(string message) + { + MessagePassedToOnResolveFileConflict = message; + return FileConflictResolutionToReturn; + } } } diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementWorkbench.cs b/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementWorkbench.cs index 84955c5ee5..c568e1584c 100644 --- a/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementWorkbench.cs +++ b/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(Func method) + { + IsSafeThreadFunctionCallMade = true; + return method(); + } } } diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/ManagePackagesUserPromptsTests.cs b/src/AddIns/Misc/PackageManagement/Test/Src/ManagePackagesUserPromptsTests.cs new file mode 100644 index 0000000000..ad71b9dc1f --- /dev/null +++ b/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(); + fakeLicenseService = MockRepository.GenerateStub(); + fakeSelectProjectsService = MockRepository.GenerateStub(); + fakeFileConflictResolver = MockRepository.GenerateStub(); + + 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.Is.Anything)) + .Return(resolution); + } + + void ResetFakeResolver() + { + fakeFileConflictResolver.BackToRecord(BackToRecordOptions.All); + fakeFileConflictResolver.Replay(); + } + + void AssertFileConflictResolverWasNotCalled() + { + fakeFileConflictResolver.AssertWasNotCalled(resolver => resolver.ResolveFileConflict(Arg.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); + } + } +} diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/ManagePackagesViewModelTests.cs b/src/AddIns/Misc/PackageManagement/Test/Src/ManagePackagesViewModelTests.cs index e01af7e2de..4be46b2b99 100644 --- a/src/AddIns/Misc/PackageManagement/Test/Src/ManagePackagesViewModelTests.cs +++ b/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(); userPrompts = new ManagePackagesUserPrompts( packageManagementEvents, fakeLicenseAcceptanceService, - fakeSelectProjectsService); + fakeSelectProjectsService, + fakeFileConflictResolver); fakeActionRunner = new FakePackageActionRunner(); packagesViewModels = new PackagesViewModels( diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementEventsTests.cs b/src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementEventsTests.cs index 966858deb9..9e3e4342dd 100644 --- a/src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementEventsTests.cs +++ b/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); + } } } diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementLoggerTests.cs b/src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementLoggerTests.cs index 74f33af0b0..ca765bf874 100644 --- a/src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementLoggerTests.cs +++ b/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(); 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); } } } diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/PackageViewModelOperationLoggerTests.cs b/src/AddIns/Misc/PackageManagement/Test/Src/PackageViewModelOperationLoggerTests.cs new file mode 100644 index 0000000000..502bc54a5a --- /dev/null +++ b/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(); + fakeLogger = MockRepository.GenerateStub(); + 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); + } + } +} diff --git a/src/AddIns/Misc/PackageManagement/Test/Src/ThreadSafePackageManagementEventsTests.cs b/src/AddIns/Misc/PackageManagement/Test/Src/ThreadSafePackageManagementEventsTests.cs index 47816c818f..6e4a412293 100644 --- a/src/AddIns/Misc/PackageManagement/Test/Src/ThreadSafePackageManagementEventsTests.cs +++ b/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); + } } }