Add more tests around refactoring input validation

Author: MDoerner

Rubberduck.Refactorings/ExtractInterface/ExtractInterfaceRefactoring.cs

@@ -34,8 +34,8 @@ public ExtractInterfaceRefactoring(IDeclarationFinderProvider declarationFinderP
         protected override Declaration FindTargetDeclaration(QualifiedSelection targetSelection)
         {
             var candidates = _declarationFinderProvider.DeclarationFinder
-                .AllUserDeclarations
-                .Where(item => ModuleTypes.Contains(item.DeclarationType)).ToList();
+                .Members(targetSelection.QualifiedName)
+                .Where(item => ModuleTypes.Contains(item.DeclarationType));
 
             return candidates.SingleOrDefault(item =>
                 item.QualifiedSelection.QualifiedName.Equals(targetSelection.QualifiedName));
@@ -50,7 +50,7 @@ protected override ExtractInterfaceModel InitializeModel(Declaration target)
 
             if (!ModuleTypes.Contains(target.DeclarationType))
             {
-                throw new InvalidTargetDeclarationException(target);
+                throw new InvalidDeclarationTypeException(target);
             }
 
             return new ExtractInterfaceModel(_declarationFinderProvider, target);

Rubberduck.Refactorings/MoveCloserToUsage/MoveCloserToUsageRefactoring.cs

@@ -44,14 +44,14 @@ private void CheckThatTargetIsValid(Declaration target)
                 throw new TargetDeclarationIsNullException();
             }
 
-            if (target.DeclarationType != DeclarationType.Variable)
+            if (!target.IsUserDefined)
             {
-                throw new InvalidDeclarationTypeException(target);
+                throw new TargetDeclarationNotUserDefinedException(target);
             }
 
-            if (!target.IsUserDefined)
+            if (target.DeclarationType != DeclarationType.Variable)
             {
-                throw new TargetDeclarationNotUserDefinedException(target);
+                throw new InvalidDeclarationTypeException(target);
             }
 
             if (!target.References.Any())

RubberduckTests/Refactoring/EncapsulateFieldTests.cs

@@ -46,6 +46,36 @@ End Property
             Assert.AreEqual(expectedCode, actualCode);
         }
 
+        [Test]
+        [Category("Refactorings")]
+        [Category("Encapsulate Field")]
+        public void EncapsulatePublicField_InvalidDeclarationType_Throws()
+        {
+            //Input
+            const string inputCode =
+                @"Public fizz As Integer";
+
+            var presenterAction = SetParameters("Name", implementLet: true);
+            var actualCode = RefactoredCode(inputCode, "TestModule1", DeclarationType.ProceduralModule, presenterAction, typeof(InvalidDeclarationTypeException));
+            Assert.AreEqual(inputCode, actualCode);
+        }
+
+        [Test]
+        [Category("Refactorings")]
+        [Category("Encapsulate Field")]
+        public void EncapsulatePublicField_InvalidIdentifierSelected_Throws()
+        {
+            //Input
+            const string inputCode =
+                @"Public Function fizz() As Integer
+End Function";
+            var selection = new Selection(1, 19);
+
+            var presenterAction = SetParameters("Name", implementLet: true);
+            var actualCode = RefactoredCode(inputCode, selection, presenterAction, typeof(NoDeclarationForSelectionException));
+            Assert.AreEqual(inputCode, actualCode);
+        }
+
         [Test]
         [Category("Refactorings")]
         [Category("Encapsulate Field")]

RubberduckTests/Refactoring/ExtractInterfaceTests.cs

@@ -65,6 +65,66 @@ End Sub
             Assert.AreEqual(expectedInterfaceCode, actualInterfaceCode);
         }
 
+        [Test]
+        [Category("Refactorings")]
+        [Category("Extract Interface")]
+        public void ExtractInterfaceRefactoring_InvalidTargetType_Throws()
+        {
+            //Input
+            const string inputCode =
+                @"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String)
+End Sub";
+
+            Func<ExtractInterfaceModel, ExtractInterfaceModel> presenterAction = model =>
+            {
+                foreach (var interfaceMember in model.Members)
+                {
+                    interfaceMember.IsSelected = true;
+                }
+
+                return model;
+            };
+
+            var actualCode = RefactoredCode(
+                "Module", 
+                DeclarationType.ProceduralModule, 
+                presenterAction, 
+                typeof(InvalidDeclarationTypeException),
+                ("Module", inputCode, ComponentType.StandardModule));
+            Assert.AreEqual(inputCode, actualCode["Module"]);
+        }
+
+        [Test]
+        [Category("Refactorings")]
+        [Category("Extract Interface")]
+        public void ExtractInterfaceRefactoring_NoValidTargetSelected_Throws()
+        {
+            //Input
+            const string inputCode =
+                @"Public Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String)
+End Sub";
+            var selection = new Selection(1, 23, 1, 27);
+
+            Func<ExtractInterfaceModel, ExtractInterfaceModel> presenterAction = model =>
+            {
+                foreach (var interfaceMember in model.Members)
+                {
+                    interfaceMember.IsSelected = true;
+                }
+
+                return model;
+            };
+
+            var actualCode = RefactoredCode(
+                "Module",
+                selection,
+                presenterAction,
+                typeof(NoDeclarationForSelectionException),
+                false,
+                ("Module", inputCode, ComponentType.StandardModule));
+            Assert.AreEqual(inputCode, actualCode["Module"]);
+        }
+
         [Test]
         [Category("Refactorings")]
         [Category("Extract Interface")]

RubberduckTests/Refactoring/ImplementInterfaceTests.cs

@@ -5,6 +5,7 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings;
+using Rubberduck.Refactorings.Exceptions;
 using Rubberduck.Refactorings.Exceptions.ImplementInterface;
 using Rubberduck.Refactorings.ImplementInterface;
 using Rubberduck.VBEditor;