Move ReorderParameters and its command to ISelectionService

MDoerner · MDoerner · commit 5a31af2a6238 · 2019-02-10T23:44:53.000+01:00
diff --git a/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs b/Rubberduck.Core/UI/Command/Refactorings/RefactorReorderParametersCommand.cs
@@ -9,6 +9,7 @@
 using Rubberduck.Refactorings.ReorderParameters;
 using Rubberduck.UI.Refactorings.ReorderParameters;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+using Rubberduck.VBEditor.Utility;
 
 namespace Rubberduck.UI.Command.Refactorings
 {
@@ -19,14 +20,16 @@ public class RefactorReorderParametersCommand : RefactorCommandBase
         private readonly IRewritingManager _rewritingManager;
         private readonly IMessageBox _msgbox;
         private readonly IRefactoringPresenterFactory _factory;
+        private readonly ISelectionService _selectionService;
 
-        public RefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IMessageBox msgbox, IRewritingManager rewritingManager) 
+        public RefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IMessageBox msgbox, IRewritingManager rewritingManager, ISelectionService selectionService) 
             : base (vbe)
         {
             _state = state;
             _rewritingManager = rewritingManager;
             _msgbox = msgbox;
             _factory = factory;
+            _selectionService = selectionService;
         }
 
         private static readonly DeclarationType[] ValidDeclarationTypes =
@@ -46,22 +49,18 @@ protected override bool EvaluateCanExecute(object parameter)
                 return false;
             }
 
-            var selection = Vbe.GetActiveSelection();
-            if (selection == null)
+            var activeSelection = _selectionService.ActiveSelection();
+            if (!activeSelection.HasValue)
             {
                 return false;
             }
-            var member = _state.AllUserDeclarations.FindTarget(selection.Value, ValidDeclarationTypes);
-            if (member == null)
-            {
-                return false;
-            }
-            if (_state.IsNewOrModified(member.QualifiedModuleName))
+            var member = _state.AllUserDeclarations.FindTarget(activeSelection.Value, ValidDeclarationTypes);
+            if (member == null || _state.IsNewOrModified(member.QualifiedModuleName))
             {
                 return false;
             }
 
-            var parameters = _state.AllUserDeclarations.Where(item => item.DeclarationType == DeclarationType.Parameter && member.Equals(item.ParentScopeDeclaration)).ToList();
+            var parameters = _state.DeclarationFinder.UserDeclarations(DeclarationType.Parameter).Where(item => member.Equals(item.ParentScopeDeclaration)).ToList();
             var canExecute = (member.DeclarationType == DeclarationType.PropertyLet || member.DeclarationType == DeclarationType.PropertySet)
                     ? parameters.Count > 2
                     : parameters.Count > 1;
@@ -71,15 +70,15 @@ protected override bool EvaluateCanExecute(object parameter)
 
         protected override void OnExecute(object parameter)
         {
-            var selection = Vbe.GetActiveSelection();
+            var activeSelection = _selectionService.ActiveSelection();
 
-            if (selection == null)
+            if (!activeSelection.HasValue)
             {
                 return;
             }
 
-            var refactoring = new ReorderParametersRefactoring(_state, Vbe, _factory, _msgbox, _rewritingManager);
-            refactoring.Refactor(selection.Value);
+            var refactoring = new ReorderParametersRefactoring(_state, _factory, _msgbox, _rewritingManager, _selectionService);
+            refactoring.Refactor(activeSelection.Value);
         }
     }
 }
diff --git a/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs b/Rubberduck.Refactorings/ReorderParameters/ReorderParametersRefactoring.cs
@@ -18,30 +18,30 @@ namespace Rubberduck.Refactorings.ReorderParameters
     public class ReorderParametersRefactoring : IRefactoring
     {
         private readonly RubberduckParserState _state;
-        private readonly IVBE _vbe;
         private readonly IRefactoringPresenterFactory _factory;
         private ReorderParametersModel _model;
         private readonly IMessageBox _messageBox;
         private readonly IRewritingManager _rewritingManager;
+        private readonly ISelectionService _selectionService;
 
-        public ReorderParametersRefactoring(RubberduckParserState state, IVBE vbe, IRefactoringPresenterFactory factory, IMessageBox messageBox, IRewritingManager rewritingManager)
+        public ReorderParametersRefactoring(RubberduckParserState state, IRefactoringPresenterFactory factory, IMessageBox messageBox, IRewritingManager rewritingManager, ISelectionService selectionService)
         {
             _state = state;
-            _vbe = vbe;
+            _selectionService = selectionService;
             _factory = factory;
             _messageBox = messageBox;
             _rewritingManager = rewritingManager;
         }
 
         private ReorderParametersModel InitializeModel()
         {
-            var selection = _vbe.GetActiveSelection();
-            if (!selection.HasValue)
+            var activeSelection = _selectionService.ActiveSelection();
+            if (!activeSelection.HasValue)
             {
                 return null;
             }
 
-            return new ReorderParametersModel(_state, selection.Value);
+            return new ReorderParametersModel(_state, activeSelection.Value);
         }
 
         public void Refactor()
@@ -77,14 +77,9 @@ public void Refactor()
 
         public void Refactor(QualifiedSelection target)
         {
-            using (var pane = _vbe.ActiveCodePane)
+            if (!_selectionService.TrySetActiveSelection(target))
             {
-                if (pane == null || pane.IsWrappingNullReference)
-                {
-                    return;
-                }
-
-                pane.Selection = target.Selection;
+                return;
             }
             Refactor();
         }
@@ -96,15 +91,7 @@ public void Refactor(Declaration target)
                 throw new ArgumentException("Invalid declaration type");
             }
 
-            using (var pane = _vbe.ActiveCodePane)
-            {
-                if (pane == null || pane.IsWrappingNullReference)
-                {
-                    return;
-                }
-                pane.Selection = target.QualifiedSelection.Selection;
-            }
-            Refactor();
+            Refactor(target.QualifiedSelection);
         }
 
         private bool IsValidParamOrder()
diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs
@@ -36,7 +36,6 @@ public void EncapsulateField_CanExecute_NullActiveCodePane()
         [Test]
         public void EncapsulateField_CanExecute_NonReadyState()
         {
-
             var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _);
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
@@ -93,7 +92,7 @@ public void EncapsulateField_CanExecute_Field()
 Sub Foo()
 End Sub";
 
-            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 5, 1, 5));
+            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out var component, new Selection(1, 5, 1, 5));
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
@@ -105,7 +104,7 @@ Sub Foo()
         private RefactorEncapsulateFieldCommand TestRefactorEncapsulateFieldCommand(IVBE vbe, RubberduckParserState state, IRewritingManager rewritingManager)
         {
             var factory = new Mock<IRefactoringPresenterFactory>().Object;
-            var selectionService = new Mock<ISelectionService>().Object;
+            var selectionService = MockedSelectionService(vbe);
             return new RefactorEncapsulateFieldCommand(vbe, state, null, factory, rewritingManager, selectionService);
         }
 
@@ -937,8 +936,7 @@ public void ReorderParameters_CanExecute_NullActiveCodePane()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -954,8 +952,7 @@ public void ReorderParameters_CanExecute_NonReadyState()
             {
                 state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None);
 
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -970,8 +967,7 @@ public void ReorderParameters_CanExecute_Event_OneParam()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -988,9 +984,7 @@ public void ReorderParameters_CanExecute_Proc_OneParam()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1007,9 +1001,7 @@ public void ReorderParameters_CanExecute_Function_OneParam()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1026,9 +1018,7 @@ public void ReorderParameters_CanExecute_PropertyGet_OneParam()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1045,9 +1035,7 @@ public void ReorderParameters_CanExecute_PropertyLet_TwoParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1064,9 +1052,7 @@ public void ReorderParameters_CanExecute_PropertySet_TwoParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsFalse(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1082,9 +1068,7 @@ public void ReorderParameters_CanExecute_Event_TwoParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsTrue(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1101,9 +1085,7 @@ public void ReorderParameters_CanExecute_Proc_TwoParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsTrue(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1120,9 +1102,7 @@ public void ReorderParameters_CanExecute_Function_TwoParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsTrue(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1139,9 +1119,7 @@ public void ReorderParameters_CanExecute_PropertyGet_TwoParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsTrue(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1158,9 +1136,7 @@ public void ReorderParameters_CanExecute_PropertyLet_ThreeParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsTrue(reorderParametersCommand.CanExecute(null));
             }
         }
@@ -1177,11 +1153,25 @@ public void ReorderParameters_CanExecute_PropertySet_ThreeParams()
             var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);
             using (state)
             {
-
-                var factory = new Mock<IRefactoringPresenterFactory>();
-                var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);
+                var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);
                 Assert.IsTrue(reorderParametersCommand.CanExecute(null));
             }
         }
+
+        private RefactorReorderParametersCommand TestRefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IRewritingManager rewritingManager)
+        {
+            var factory = new Mock<IRefactoringPresenterFactory>().Object;
+            var selectionService = MockedSelectionService(vbe);
+            var msgBox = new Mock<IMessageBox>().Object;
+            return new RefactorReorderParametersCommand(vbe, state, factory, msgBox, rewritingManager, selectionService);
+        }
+
+        private ISelectionService MockedSelectionService(IVBE vbe)
+        {
+            var selectionServiceMock = new Mock<ISelectionService>();
+            var activeSelection = vbe.ActiveCodePane?.GetQualifiedSelection();
+            selectionServiceMock.Setup(m => m.ActiveSelection()).Returns(() => activeSelection);
+            return selectionServiceMock.Object;
+        }
     }
 }
diff --git a/RubberduckTests/Refactoring/ReorderParametersTests.cs b/RubberduckTests/Refactoring/ReorderParametersTests.cs

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using Rubberduck.Refactorings.ReorderParameters;`
`10`	`10`	`using Rubberduck.UI.Refactorings.ReorderParameters;`
`11`	`11`	`using Rubberduck.VBEditor.SafeComWrappers.Abstract;`
	`12`	`+using Rubberduck.VBEditor.Utility;`
`12`	`13`
`13`	`14`	`namespace Rubberduck.UI.Command.Refactorings`
`14`	`15`	`{`
`@@ -19,14 +20,16 @@ public class RefactorReorderParametersCommand : RefactorCommandBase`
`19`	`20`	`private readonly IRewritingManager _rewritingManager;`
`20`	`21`	`private readonly IMessageBox _msgbox;`
`21`	`22`	`private readonly IRefactoringPresenterFactory _factory;`
	`23`	`+ private readonly ISelectionService _selectionService;`
`22`	`24`
`23`		`- public RefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IMessageBox msgbox, IRewritingManager rewritingManager)`
	`25`	`+ public RefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IRefactoringPresenterFactory factory, IMessageBox msgbox, IRewritingManager rewritingManager, ISelectionService selectionService)`
`24`	`26`	`: base (vbe)`
`25`	`27`	`{`
`26`	`28`	`_state = state;`
`27`	`29`	`_rewritingManager = rewritingManager;`
`28`	`30`	`_msgbox = msgbox;`
`29`	`31`	`_factory = factory;`
	`32`	`+ _selectionService = selectionService;`
`30`	`33`	`}`
`31`	`34`
`32`	`35`	`private static readonly DeclarationType[] ValidDeclarationTypes =`
`@@ -46,22 +49,18 @@ protected override bool EvaluateCanExecute(object parameter)`
`46`	`49`	`return false;`
`47`	`50`	`}`
`48`	`51`
`49`		`- var selection = Vbe.GetActiveSelection();`
`50`		`- if (selection == null)`
	`52`	`+ var activeSelection = _selectionService.ActiveSelection();`
	`53`	`+ if (!activeSelection.HasValue)`
`51`	`54`	`{`
`52`	`55`	`return false;`
`53`	`56`	`}`
`54`		`- var member = _state.AllUserDeclarations.FindTarget(selection.Value, ValidDeclarationTypes);`
`55`		`- if (member == null)`
`56`		`- {`
`57`		`- return false;`
`58`		`- }`
`59`		`- if (_state.IsNewOrModified(member.QualifiedModuleName))`
	`57`	`+ var member = _state.AllUserDeclarations.FindTarget(activeSelection.Value, ValidDeclarationTypes);`
	`58`	`+ if (member == null \|\| _state.IsNewOrModified(member.QualifiedModuleName))`
`60`	`59`	`{`
`61`	`60`	`return false;`
`62`	`61`	`}`
`63`	`62`
`64`		`- var parameters = _state.AllUserDeclarations.Where(item => item.DeclarationType == DeclarationType.Parameter && member.Equals(item.ParentScopeDeclaration)).ToList();`
	`63`	`+ var parameters = _state.DeclarationFinder.UserDeclarations(DeclarationType.Parameter).Where(item => member.Equals(item.ParentScopeDeclaration)).ToList();`
`65`	`64`	`var canExecute = (member.DeclarationType == DeclarationType.PropertyLet \|\| member.DeclarationType == DeclarationType.PropertySet)`
`66`	`65`	`? parameters.Count > 2`
`67`	`66`	`: parameters.Count > 1;`
`@@ -71,15 +70,15 @@ protected override bool EvaluateCanExecute(object parameter)`
`71`	`70`
`72`	`71`	`protected override void OnExecute(object parameter)`
`73`	`72`	`{`
`74`		`- var selection = Vbe.GetActiveSelection();`
	`73`	`+ var activeSelection = _selectionService.ActiveSelection();`
`75`	`74`
`76`		`- if (selection == null)`
	`75`	`+ if (!activeSelection.HasValue)`
`77`	`76`	`{`
`78`	`77`	`return;`
`79`	`78`	`}`
`80`	`79`
`81`		`- var refactoring = new ReorderParametersRefactoring(_state, Vbe, _factory, _msgbox, _rewritingManager);`
`82`		`- refactoring.Refactor(selection.Value);`
	`80`	`+ var refactoring = new ReorderParametersRefactoring(_state, _factory, _msgbox, _rewritingManager, _selectionService);`
	`81`	`+ refactoring.Refactor(activeSelection.Value);`
`83`	`82`	`}`
`84`	`83`	`}`
`85`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,30 +18,30 @@ namespace Rubberduck.Refactorings.ReorderParameters`
`18`	`18`	`public class ReorderParametersRefactoring : IRefactoring`
`19`	`19`	`{`
`20`	`20`	`private readonly RubberduckParserState _state;`
`21`		`- private readonly IVBE _vbe;`
`22`	`21`	`private readonly IRefactoringPresenterFactory _factory;`
`23`	`22`	`private ReorderParametersModel _model;`
`24`	`23`	`private readonly IMessageBox _messageBox;`
`25`	`24`	`private readonly IRewritingManager _rewritingManager;`
	`25`	`+ private readonly ISelectionService _selectionService;`
`26`	`26`
`27`		`- public ReorderParametersRefactoring(RubberduckParserState state, IVBE vbe, IRefactoringPresenterFactory factory, IMessageBox messageBox, IRewritingManager rewritingManager)`
	`27`	`+ public ReorderParametersRefactoring(RubberduckParserState state, IRefactoringPresenterFactory factory, IMessageBox messageBox, IRewritingManager rewritingManager, ISelectionService selectionService)`
`28`	`28`	`{`
`29`	`29`	`_state = state;`
`30`		`- _vbe = vbe;`
	`30`	`+ _selectionService = selectionService;`
`31`	`31`	`_factory = factory;`
`32`	`32`	`_messageBox = messageBox;`
`33`	`33`	`_rewritingManager = rewritingManager;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`private ReorderParametersModel InitializeModel()`
`37`	`37`	`{`
`38`		`- var selection = _vbe.GetActiveSelection();`
`39`		`- if (!selection.HasValue)`
	`38`	`+ var activeSelection = _selectionService.ActiveSelection();`
	`39`	`+ if (!activeSelection.HasValue)`
`40`	`40`	`{`
`41`	`41`	`return null;`
`42`	`42`	`}`
`43`	`43`
`44`		`- return new ReorderParametersModel(_state, selection.Value);`
	`44`	`+ return new ReorderParametersModel(_state, activeSelection.Value);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public void Refactor()`
`@@ -77,14 +77,9 @@ public void Refactor()`
`77`	`77`
`78`	`78`	`public void Refactor(QualifiedSelection target)`
`79`	`79`	`{`
`80`		`- using (var pane = _vbe.ActiveCodePane)`
	`80`	`+ if (!_selectionService.TrySetActiveSelection(target))`
`81`	`81`	`{`
`82`		`- if (pane == null \|\| pane.IsWrappingNullReference)`
`83`		`- {`
`84`		`- return;`
`85`		`- }`
`86`		`-`
`87`		`- pane.Selection = target.Selection;`
	`82`	`+ return;`
`88`	`83`	`}`
`89`	`84`	`Refactor();`
`90`	`85`	`}`
`@@ -96,15 +91,7 @@ public void Refactor(Declaration target)`
`96`	`91`	`throw new ArgumentException("Invalid declaration type");`
`97`	`92`	`}`
`98`	`93`
`99`		`- using (var pane = _vbe.ActiveCodePane)`
`100`		`- {`
`101`		`- if (pane == null \|\| pane.IsWrappingNullReference)`
`102`		`- {`
`103`		`- return;`
`104`		`- }`
`105`		`- pane.Selection = target.QualifiedSelection.Selection;`
`106`		`- }`
`107`		`- Refactor();`
	`94`	`+ Refactor(target.QualifiedSelection);`
`108`	`95`	`}`
`109`	`96`
`110`	`97`	`private bool IsValidParamOrder()`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,6 @@ public void EncapsulateField_CanExecute_NullActiveCodePane()`
`36`	`36`	`[Test]`
`37`	`37`	`public void EncapsulateField_CanExecute_NonReadyState()`
`38`	`38`	`{`
`39`		`-`
`40`	`39`	`var vbe = MockVbeBuilder.BuildFromSingleStandardModule(string.Empty, out _);`
`41`	`40`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`42`	`41`	`using (state)`
`@@ -93,7 +92,7 @@ public void EncapsulateField_CanExecute_Field()`
`93`	`92`	`Sub Foo()`
`94`	`93`	`End Sub";`
`95`	`94`
`96`		`- var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out _, new Selection(1, 5, 1, 5));`
	`95`	`+ var vbe = MockVbeBuilder.BuildFromSingleStandardModule(input, out var component, new Selection(1, 5, 1, 5));`
`97`	`96`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`98`	`97`	`using (state)`
`99`	`98`	`{`
`@@ -105,7 +104,7 @@ Sub Foo()`
`105`	`104`	`private RefactorEncapsulateFieldCommand TestRefactorEncapsulateFieldCommand(IVBE vbe, RubberduckParserState state, IRewritingManager rewritingManager)`
`106`	`105`	`{`
`107`	`106`	`var factory = new Mock<IRefactoringPresenterFactory>().Object;`
`108`		`- var selectionService = new Mock<ISelectionService>().Object;`
	`107`	`+ var selectionService = MockedSelectionService(vbe);`
`109`	`108`	`return new RefactorEncapsulateFieldCommand(vbe, state, null, factory, rewritingManager, selectionService);`
`110`	`109`	`}`
`111`	`110`
`@@ -937,8 +936,7 @@ public void ReorderParameters_CanExecute_NullActiveCodePane()`
`937`	`936`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`938`	`937`	`using (state)`
`939`	`938`	`{`
`940`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`941`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`939`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`942`	`940`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`943`	`941`	`}`
`944`	`942`	`}`
`@@ -954,8 +952,7 @@ public void ReorderParameters_CanExecute_NonReadyState()`
`954`	`952`	`{`
`955`	`953`	`state.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations, CancellationToken.None);`
`956`	`954`
`957`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`958`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`955`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`959`	`956`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`960`	`957`	`}`
`961`	`958`	`}`
`@@ -970,8 +967,7 @@ public void ReorderParameters_CanExecute_Event_OneParam()`
`970`	`967`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`971`	`968`	`using (state)`
`972`	`969`	`{`
`973`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`974`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`970`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`975`	`971`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`976`	`972`	`}`
`977`	`973`	`}`
`@@ -988,9 +984,7 @@ public void ReorderParameters_CanExecute_Proc_OneParam()`
`988`	`984`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`989`	`985`	`using (state)`
`990`	`986`	`{`
`991`		`-`
`992`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`993`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`987`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`994`	`988`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`995`	`989`	`}`
`996`	`990`	`}`
`@@ -1007,9 +1001,7 @@ public void ReorderParameters_CanExecute_Function_OneParam()`
`1007`	`1001`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1008`	`1002`	`using (state)`
`1009`	`1003`	`{`
`1010`		`-`
`1011`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1012`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1004`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1013`	`1005`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`1014`	`1006`	`}`
`1015`	`1007`	`}`
`@@ -1026,9 +1018,7 @@ public void ReorderParameters_CanExecute_PropertyGet_OneParam()`
`1026`	`1018`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1027`	`1019`	`using (state)`
`1028`	`1020`	`{`
`1029`		`-`
`1030`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1031`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1021`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1032`	`1022`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`1033`	`1023`	`}`
`1034`	`1024`	`}`
`@@ -1045,9 +1035,7 @@ public void ReorderParameters_CanExecute_PropertyLet_TwoParams()`
`1045`	`1035`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1046`	`1036`	`using (state)`
`1047`	`1037`	`{`
`1048`		`-`
`1049`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1050`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1038`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1051`	`1039`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`1052`	`1040`	`}`
`1053`	`1041`	`}`
`@@ -1064,9 +1052,7 @@ public void ReorderParameters_CanExecute_PropertySet_TwoParams()`
`1064`	`1052`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1065`	`1053`	`using (state)`
`1066`	`1054`	`{`
`1067`		`-`
`1068`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1069`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1055`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1070`	`1056`	`Assert.IsFalse(reorderParametersCommand.CanExecute(null));`
`1071`	`1057`	`}`
`1072`	`1058`	`}`
`@@ -1082,9 +1068,7 @@ public void ReorderParameters_CanExecute_Event_TwoParams()`
`1082`	`1068`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1083`	`1069`	`using (state)`
`1084`	`1070`	`{`
`1085`		`-`
`1086`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1087`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1071`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1088`	`1072`	`Assert.IsTrue(reorderParametersCommand.CanExecute(null));`
`1089`	`1073`	`}`
`1090`	`1074`	`}`
`@@ -1101,9 +1085,7 @@ public void ReorderParameters_CanExecute_Proc_TwoParams()`
`1101`	`1085`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1102`	`1086`	`using (state)`
`1103`	`1087`	`{`
`1104`		`-`
`1105`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1106`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1088`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1107`	`1089`	`Assert.IsTrue(reorderParametersCommand.CanExecute(null));`
`1108`	`1090`	`}`
`1109`	`1091`	`}`
`@@ -1120,9 +1102,7 @@ public void ReorderParameters_CanExecute_Function_TwoParams()`
`1120`	`1102`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1121`	`1103`	`using (state)`
`1122`	`1104`	`{`
`1123`		`-`
`1124`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1125`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1105`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1126`	`1106`	`Assert.IsTrue(reorderParametersCommand.CanExecute(null));`
`1127`	`1107`	`}`
`1128`	`1108`	`}`
`@@ -1139,9 +1119,7 @@ public void ReorderParameters_CanExecute_PropertyGet_TwoParams()`
`1139`	`1119`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1140`	`1120`	`using (state)`
`1141`	`1121`	`{`
`1142`		`-`
`1143`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1144`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1122`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1145`	`1123`	`Assert.IsTrue(reorderParametersCommand.CanExecute(null));`
`1146`	`1124`	`}`
`1147`	`1125`	`}`
`@@ -1158,9 +1136,7 @@ public void ReorderParameters_CanExecute_PropertyLet_ThreeParams()`
`1158`	`1136`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1159`	`1137`	`using (state)`
`1160`	`1138`	`{`
`1161`		`-`
`1162`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1163`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1139`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1164`	`1140`	`Assert.IsTrue(reorderParametersCommand.CanExecute(null));`
`1165`	`1141`	`}`
`1166`	`1142`	`}`
`@@ -1177,11 +1153,25 @@ public void ReorderParameters_CanExecute_PropertySet_ThreeParams()`
`1177`	`1153`	`var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe.Object);`
`1178`	`1154`	`using (state)`
`1179`	`1155`	`{`
`1180`		`-`
`1181`		`- var factory = new Mock<IRefactoringPresenterFactory>();`
`1182`		`- var reorderParametersCommand = new RefactorReorderParametersCommand(vbe.Object, state, factory.Object, null, rewritingManager);`
	`1156`	`+ var reorderParametersCommand = TestRefactorReorderParametersCommand(vbe.Object, state, rewritingManager);`
`1183`	`1157`	`Assert.IsTrue(reorderParametersCommand.CanExecute(null));`
`1184`	`1158`	`}`
`1185`	`1159`	`}`
	`1160`	`+`
	`1161`	`+ private RefactorReorderParametersCommand TestRefactorReorderParametersCommand(IVBE vbe, RubberduckParserState state, IRewritingManager rewritingManager)`
	`1162`	`+ {`
	`1163`	`+ var factory = new Mock<IRefactoringPresenterFactory>().Object;`
	`1164`	`+ var selectionService = MockedSelectionService(vbe);`
	`1165`	`+ var msgBox = new Mock<IMessageBox>().Object;`
	`1166`	`+ return new RefactorReorderParametersCommand(vbe, state, factory, msgBox, rewritingManager, selectionService);`
	`1167`	`+ }`
	`1168`	`+`
	`1169`	`+ private ISelectionService MockedSelectionService(IVBE vbe)`
	`1170`	`+ {`
	`1171`	`+ var selectionServiceMock = new Mock<ISelectionService>();`
	`1172`	`+ var activeSelection = vbe.ActiveCodePane?.GetQualifiedSelection();`
	`1173`	`+ selectionServiceMock.Setup(m => m.ActiveSelection()).Returns(() => activeSelection);`
	`1174`	`+ return selectionServiceMock.Object;`
	`1175`	`+ }`
`1186`	`1176`	`}`
`1187`	`1177`	`}`