Introduce CW support for tests

Modified EncapsulateFieldRefactoring tests to use a WindsorContainer to
manage ctor injection and object instantiations - causing some degree of
modification to all EF related tests.

Author: BZngr

RubberduckTests/Commands/RefactorCommands/EncapsulateFieldCommandTests.cs

@@ -1,15 +1,9 @@
-using System;
-using Moq;
+using Castle.Windsor;
 using NUnit.Framework;
-using Rubberduck.Interaction;
 using Rubberduck.Parsing.Rewriter;
-using Rubberduck.Parsing.UIContext;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Refactorings;
-using Rubberduck.Refactorings.EncapsulateField;
 using Rubberduck.UI.Command;
 using Rubberduck.UI.Command.Refactorings;
-using Rubberduck.UI.Command.Refactorings.Notifiers;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.Utility;
@@ -60,25 +54,9 @@ Sub Foo()
 
         protected override CommandBase TestCommand(IVBE vbe, RubberduckParserState state, IRewritingManager rewritingManager, ISelectionService selectionService)
         {
-            var resolver = new EncapsulateFieldTestComponentResolver(state, rewritingManager);
-
-            var msgBox = new Mock<IMessageBox>().Object;
-            var factory = new Mock<IRefactoringPresenterFactory>().Object;
-            var selectedDeclarationProvider = new SelectedDeclarationProvider(selectionService, state);
-            var uiDispatcherMock = new Mock<IUiDispatcher>();
-            uiDispatcherMock
-                .Setup(m => m.Invoke(It.IsAny<Action>()))
-                .Callback((Action action) => action.Invoke());
-            var userInteraction = new RefactoringUserInteraction<IEncapsulateFieldPresenter, EncapsulateFieldModel>(factory, uiDispatcherMock.Object);
-            var refactoring = new EncapsulateFieldRefactoring(resolver.Resolve<EncapsulateFieldRefactoringAction>(),
-                resolver.Resolve<EncapsulateFieldPreviewProvider>(),
-                resolver.Resolve<IEncapsulateFieldModelFactory>(),
-                userInteraction, 
-                selectionService, 
-                selectedDeclarationProvider);
-            var notifier = new EncapsulateFieldFailedNotifier(msgBox);
-            var selectedDeclarationService = new SelectedDeclarationProvider(selectionService, state);
-            return new RefactorEncapsulateFieldCommand(refactoring, notifier, state, selectionService, selectedDeclarationService);
+            var resolver = new EncapsulateFieldTestsResolver(state, rewritingManager, selectionService);
+            resolver.Install(new WindsorContainer(), null);
+            return resolver.Resolve<RefactorEncapsulateFieldCommand>();
         }
 
         protected override IVBE SetupAllowingExecution()

RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldInteractiveRefactoringTest.cs

@@ -0,0 +1,39 @@
+using System;
+using NUnit.Framework;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Refactorings;
+using Rubberduck.Refactorings.EncapsulateField;
+using Rubberduck.Refactorings.Exceptions;
+using Rubberduck.VBEditor.Utility;
+using RubberduckTests.Mocks;
+
+namespace RubberduckTests.Refactoring.EncapsulateField
+{
+    [TestFixture]
+    public abstract class EncapsulateFieldInteractiveRefactoringTest : InteractiveRefactoringTestBase<IEncapsulateFieldPresenter, EncapsulateFieldModel>
+    {
+        //RefactoringTestBase.NoActiveSelection_Throws passes a null
+        //IDeclarationFinderProvider parameter to 'TestRefactoring(...).  
+        //The EncapsulateFieldRefactoring tests Resolver throws a different
+        //exception type without a valid interface reference and causes the 
+        //base class version of the test to fail.
+        [Test]
+        [Category("Refactorings")]
+        public override void NoActiveSelection_Throws()
+        {
+            var testVbe = TestVbe(string.Empty, out _);
+            var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(testVbe);
+            using (state)
+            {
+                var refactoring = TestRefactoring(rewritingManager, state, initialSelection: null);
+                Assert.Throws<NoActiveSelectionException>(() => refactoring.Refactor());
+            }
+        }
+
+        protected override IRefactoring TestRefactoring(IRewritingManager rewritingManager, RubberduckParserState state, RefactoringUserInteraction<IEncapsulateFieldPresenter, EncapsulateFieldModel> userInteraction, ISelectionService selectionService)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

RubberduckTests/Refactoring/EncapsulateField/EncapsulateFieldTestComponentResolver.cs

@@ -1,9 +1,11 @@
+using Castle.Windsor;
 using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings;
 using Rubberduck.Refactorings.EncapsulateField;
 using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.SafeComWrappers;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.Utility;
 using RubberduckTests.Mocks;
@@ -13,8 +15,38 @@
 
 namespace RubberduckTests.Refactoring.EncapsulateField
 {
-    public class EncapsulateFieldTestSupport : InteractiveRefactoringTestBase<IEncapsulateFieldPresenter, EncapsulateFieldModel>
+    public class EncapsulateFieldTestSupport : EncapsulateFieldInteractiveRefactoringTest
     {
+        private EncapsulateFieldTestsResolver _testResolver;
+
+        public void ResetResolver()
+        {
+            _testResolver = null;
+        }
+
+        public T Resolve<T>(IDeclarationFinderProvider declarationFinderProvider, IRewritingManager rewritingManager = null, ISelectionService selectionService = null) where T : class
+        {
+            SetupResolver(declarationFinderProvider, rewritingManager, selectionService);
+            return Resolve<T>() as T;
+        }
+
+        public T Resolve<T>() where T : class 
+            => _testResolver?.Resolve<T>() as T ?? throw new InvalidOperationException("Test Resolver not initialized.  Call 'SetupResolver(...)' or use one of the 'Resolve<T>()' overloads");
+
+        public void SetupResolver(IDeclarationFinderProvider declarationFinderProvider, IRewritingManager rewritingManager = null, ISelectionService selectionService = null)
+        {
+            if (declarationFinderProvider is null)
+            {
+                throw new ArgumentNullException("declarationFinderProvider is null");
+            }
+
+            if (_testResolver is null)
+            {
+                _testResolver = new EncapsulateFieldTestsResolver(declarationFinderProvider, rewritingManager, selectionService);
+                _testResolver.Install(new WindsorContainer(), null);
+            }
+        }
+
         public string RHSIdentifier => Rubberduck.Resources.Refactorings.Refactorings.CodeBuilder_DefaultPropertyRHSParam;
 
         public string StateUDTDefaultTypeName => $"T{MockVbeBuilder.TestModuleName}";
@@ -116,14 +148,41 @@ public IRefactoring SupportTestRefactoring(
             RefactoringUserInteraction<IEncapsulateFieldPresenter, EncapsulateFieldModel> userInteraction,
             ISelectionService selectionService)
         {
-            var resolver = new EncapsulateFieldTestComponentResolver(state, rewritingManager);
-            var selectedDeclarationProvider = new SelectedDeclarationProvider(selectionService, state);
-            return new EncapsulateFieldRefactoring(resolver.Resolve<EncapsulateFieldRefactoringAction>(),
-                resolver.Resolve<EncapsulateFieldPreviewProvider>(),
-                resolver.Resolve<IEncapsulateFieldModelFactory>(),
+            SetupResolver(state, rewritingManager, selectionService);
+            return new EncapsulateFieldRefactoring(Resolve<EncapsulateFieldRefactoringAction>(state, rewritingManager, selectionService),
+                Resolve<EncapsulateFieldPreviewProvider>(),
+                Resolve<IEncapsulateFieldModelFactory>(),
                 userInteraction,
                 selectionService,
-                selectedDeclarationProvider);
+                Resolve<ISelectedDeclarationProvider>());
+        }
+
+        public IDictionary<string, string> RefactoredCode(
+            Func<EncapsulateFieldModel, EncapsulateFieldModel> presenterAction,
+            TestCodeString codeString,
+            params (string, string, ComponentType)[] otherModules)
+        {
+            return RefactoredCode(presenterAction,
+                (MockVbeBuilder.TestModuleName, codeString, ComponentType.StandardModule),
+                otherModules);
+        }
+
+        public IDictionary<string, string> RefactoredCode(
+            Func<EncapsulateFieldModel, EncapsulateFieldModel> presenterAction,
+            (string selectedModuleName, TestCodeString codeString, ComponentType componentType) moduleUnderTest,
+            params (string, string, ComponentType)[] otherModules)
+        {
+            var modules = otherModules.ToList();
+
+            modules.Add((moduleUnderTest.selectedModuleName, moduleUnderTest.codeString.Code, moduleUnderTest.componentType));
+
+            return RefactoredCode(
+                moduleUnderTest.selectedModuleName,
+                moduleUnderTest.codeString.CaretPosition.ToOneBased(),
+                presenterAction,
+                null,
+                false,
+                modules.ToArray());
         }
 
         public IEncapsulateFieldCandidate RetrieveEncapsulateFieldCandidate(string inputCode, string fieldName)
@@ -145,9 +204,7 @@ public IEncapsulateFieldCandidate RetrieveEncapsulateFieldCandidate(IVBE vbe, st
             {
                 var match = state.DeclarationFinder.MatchName(fieldName).Where(m => m.DeclarationType.Equals(declarationType)).Single();
 
-                var resolver = new EncapsulateFieldTestComponentResolver(state, null);
-
-                var model = resolver.Resolve<IEncapsulateFieldModelFactory>().Create(match);
+                var model = Resolve<IEncapsulateFieldModelFactory>(state).Create(match);
 
                 model.ConflictFinder.AssignNoConflictIdentifiers(model[match.IdentifierName]);