Bandaid-fix Version requirement in VBEInteraction

Vogel612 · Vogel612 · commit b23a1d7e9795 · 2018-09-14T00:32:12.000+02:00
diff --git a/Rubberduck.Core/UI/UnitTesting/Commands/AddTestModuleCommand.cs b/Rubberduck.Core/UI/UnitTesting/Commands/AddTestModuleCommand.cs
@@ -26,14 +26,16 @@ public class AddTestModuleCommand : CommandBase
         private readonly RubberduckParserState _state;
         private readonly IGeneralConfigService _configLoader;
         private readonly IMessageBox _messageBox;
+        private readonly IVBEInteraction _interaction;
 
-        public AddTestModuleCommand(IVBE vbe, RubberduckParserState state, IGeneralConfigService configLoader, IMessageBox messageBox)
+        public AddTestModuleCommand(IVBE vbe, RubberduckParserState state, IGeneralConfigService configLoader, IMessageBox messageBox, IVBEInteraction interaction)
             : base(LogManager.GetCurrentClassLogger())
         {
             _vbe = vbe;
             _state = state;
             _configLoader = configLoader;
             _messageBox = messageBox;
+            _interaction = interaction;
         }
 
         private readonly string _testModuleEmptyTemplate = new StringBuilder()
@@ -164,7 +166,8 @@ protected override void OnExecute(object parameter)
 
             if (settings.BindingMode == BindingMode.EarlyBinding)
             {
-                VBEInteraction.EnsureProjectReferencesUnitTesting(project);
+                // FIXME: Push the actual adding of TestModules into UnitTesting, which sidesteps VBEInteraction being inaccessble here
+                _interaction.EnsureProjectReferencesUnitTesting(project);
             }
 
             try
@@ -245,6 +248,7 @@ protected override void OnExecute(object parameter)
             _state.OnParseRequested(this);
         }
 
+        // FIXME push this into Rubberduck.UnitTesting assembly
         private string GetNextTestModuleName(IVBProject project)
         {
             var names = new HashSet<string>(project.ComponentNames().Where(module => module.StartsWith(TestModuleBaseName)));
diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs
@@ -123,6 +123,7 @@ public void Install(IWindsorContainer container, IConfigurationStore store)
 
             container.Register(Component.For<TestExplorerModel>()
                 .LifestyleSingleton());
+            container.Register(Component.For<VBEInteraction>().LifestyleSingleton());
 
             RegisterRefactoringDialogs(container);
 
diff --git a/Rubberduck.UnitTesting/Rubberduck.UnitTesting.csproj b/Rubberduck.UnitTesting/Rubberduck.UnitTesting.csproj
@@ -63,6 +63,7 @@
     <Compile Include="UnitTesting\ITestEngine.cs" />
     <Compile Include="ComClientHelpers\PermissiveObjectComparer.cs" />
     <Compile Include="ComClientHelpers\ReturnTypeConverter.cs" />
+    <Compile Include="UnitTesting\IVBEInteraction.cs" />
     <Compile Include="UnitTesting\TestCategory.cs" />
     <Compile Include="UnitTesting\TestEngine.cs" />
     <Compile Include="UnitTesting\TestMethod.cs" />
diff --git a/Rubberduck.UnitTesting/UnitTesting/IVBEInteraction.cs b/Rubberduck.UnitTesting/UnitTesting/IVBEInteraction.cs
@@ -0,0 +1,15 @@
+﻿using System;
+using System.Collections.Generic;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor.ComManagement.TypeLibs;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+
+namespace Rubberduck.UnitTesting
+{
+    public interface IVBEInteraction
+    {
+        void EnsureProjectReferencesUnitTesting(IVBProject project);
+        void RunDeclarations(ITypeLibWrapper typeLib, IEnumerable<Declaration> declarations);
+        void RunTestMethod(ITypeLibWrapper typeLib, TestMethod test, EventHandler<AssertCompletedEventArgs> assertCompletionHandler, out long duration);
+    }
+}
diff --git a/Rubberduck.UnitTesting/UnitTesting/TestEngine.cs b/Rubberduck.UnitTesting/UnitTesting/TestEngine.cs
@@ -29,7 +29,7 @@ internal class TestEngine : ITestEngine
 
         private readonly RubberduckParserState _state;
         private readonly IFakesFactory _fakesFactory;
-        private readonly IVBETypeLibsAPI _typeLibApi;
+        private readonly IVBEInteraction _declarationRunner;
         private readonly ITypeLibWrapperProvider _wrapperProvider;
         private readonly IUiDispatcher _uiDispatcher;
         private readonly IVBE _vbe;
@@ -43,12 +43,12 @@ internal class TestEngine : ITestEngine
         private bool refreshBackoff;
 
 
-        public TestEngine(RubberduckParserState state, IFakesFactory fakesFactory, IVBETypeLibsAPI typeLibApi, ITypeLibWrapperProvider wrapperProvider, IUiDispatcher uiDispatcher, IVBE vbe)
+        public TestEngine(RubberduckParserState state, IFakesFactory fakesFactory, IVBEInteraction declarationRunner, ITypeLibWrapperProvider wrapperProvider, IUiDispatcher uiDispatcher, IVBE vbe)
         {
             Debug.WriteLine("TestEngine created.");
             _state = state;
             _fakesFactory = fakesFactory;
-            _typeLibApi = typeLibApi;
+            _declarationRunner = declarationRunner;
             _wrapperProvider = wrapperProvider;
             _uiDispatcher = uiDispatcher;
             _vbe = vbe;
@@ -147,7 +147,7 @@ private void EnsureRubberduckIsReferencedForEarlyBoundTests()
 
             foreach (var project in projectsUsingAddInLibrary)
             {
-                VBEInteraction.EnsureProjectReferencesUnitTesting(project);
+                _declarationRunner.EnsureProjectReferencesUnitTesting(project);
             }
         }
 
@@ -196,7 +196,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)
                     {
                         try
                         {
-                            VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, TestDiscovery.FindModuleInitializeMethods(moduleName, _state));
+                            _declarationRunner.RunDeclarations(typeLibWrapper, TestDiscovery.FindModuleInitializeMethods(moduleName, _state));
                         }
                         catch (COMException ex)
                         {
@@ -221,7 +221,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)
                                 fakes.StartTest();
                                 try
                                 {
-                                    VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, testInitialize);
+                                    _declarationRunner.RunDeclarations(typeLibWrapper, testInitialize);
                                 }
                                 catch (COMException trace)
                                 {
@@ -234,7 +234,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)
                                 OnTestCompleted(test, result);
                                 try
                                 {
-                                    VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, testCleanup);
+                                    _declarationRunner.RunDeclarations(typeLibWrapper, testCleanup);
                                 }
                                 catch (COMException cleanupFail)
                                 {
@@ -249,7 +249,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)
                         }
                         try
                         {
-                            VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, TestDiscovery.FindModuleCleanupMethods(moduleName, _state));
+                            _declarationRunner.RunDeclarations(typeLibWrapper, TestDiscovery.FindModuleCleanupMethods(moduleName, _state));
                         }
                         catch (COMException ex)
                         {
@@ -277,7 +277,7 @@ private TestResult RunTestMethod(ITypeLibWrapper typeLib, TestMethod test)
             try
             {
                 var assertResults = new List<AssertCompletedEventArgs>();
-                VBEInteraction.RunTestMethod(_typeLibApi, typeLib, test, (s, e) => assertResults.Add(e), out duration);
+                _declarationRunner.RunTestMethod(typeLib, test, (s, e) => assertResults.Add(e), out duration);
                 return EvaluateResults(assertResults, duration);
             }
             catch (COMException e)
diff --git a/Rubberduck.UnitTesting/UnitTesting/VBEInteraction.cs b/Rubberduck.UnitTesting/UnitTesting/VBEInteraction.cs
@@ -9,25 +9,33 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Reflection;
 
 namespace Rubberduck.UnitTesting
 { 
     // FIXME litter some logging around here
-    public class VBEInteraction
+    internal class VBEInteraction : IVBEInteraction
     {
         private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
-        internal static void RunDeclarations(IVBETypeLibsAPI typeLibApi, ITypeLibWrapper typeLib, IEnumerable<Declaration> declarations)
+        private readonly Version _rubberduckVersion;
+        private readonly IVBETypeLibsAPI _typeLibsApi;
+
+        public VBEInteraction(IVBETypeLibsAPI typeLibsApi, Version rubberduckVersion)
+        {
+            _typeLibsApi = typeLibsApi;
+            _rubberduckVersion = rubberduckVersion;
+        }
+
+        public void RunDeclarations(ITypeLibWrapper typeLib, IEnumerable<Declaration> declarations)
         {
             foreach (var declaration in declarations)
             {
-                typeLibApi.ExecuteCode(typeLib, declaration.QualifiedModuleName.ComponentName,
+                _typeLibsApi.ExecuteCode(typeLib, declaration.QualifiedModuleName.ComponentName,
                     declaration.QualifiedName.MemberName);
             }
         }
 
-        internal static void RunTestMethod(IVBETypeLibsAPI tlApi, ITypeLibWrapper typeLib, TestMethod test, EventHandler<AssertCompletedEventArgs> assertCompletionHandler, out long duration)
+        public void RunTestMethod(ITypeLibWrapper typeLib, TestMethod test, EventHandler<AssertCompletedEventArgs> assertCompletionHandler, out long duration)
         {
             AssertHandler.OnAssertCompleted += assertCompletionHandler;
             var stopwatch = new Stopwatch();
@@ -36,7 +44,7 @@ internal static void RunTestMethod(IVBETypeLibsAPI tlApi, ITypeLibWrapper typeLi
                 var testDeclaration = test.Declaration;
 
                 stopwatch.Start();
-                tlApi.ExecuteCode(typeLib, testDeclaration.ComponentName, testDeclaration.QualifiedName.MemberName);
+                _typeLibsApi.ExecuteCode(typeLib, testDeclaration.ComponentName, testDeclaration.QualifiedName.MemberName);
                 stopwatch.Stop();
 
                 duration = stopwatch.ElapsedMilliseconds;
@@ -54,22 +62,20 @@ internal static void RunTestMethod(IVBETypeLibsAPI tlApi, ITypeLibWrapper typeLi
         }
             
 
-        public static void EnsureProjectReferencesUnitTesting(IVBProject project)
+        public void EnsureProjectReferencesUnitTesting(IVBProject project)
         {
             if (project == null || project.IsWrappingNullReference) { return; }
             var libFolder = IntPtr.Size == 8 ? "win64" : "win32";
-            // FIXME: This assumes the current assembly is same major/minor as the TLB!!!
-            var libVersion = Assembly.GetExecutingAssembly().GetName().Version;
             const string libGuid = RubberduckGuid.RubberduckTypeLibGuid;
-            var pathKey = Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{libVersion.Major}.{libVersion.Minor}\0\{libFolder}");
+            var pathKey = Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{_rubberduckVersion.Major}.{_rubberduckVersion.Minor}\0\{libFolder}");
 
             var referencePath = pathKey?.GetValue(string.Empty, string.Empty) as string;
             string name = null;
 
             if (!string.IsNullOrWhiteSpace(referencePath))
             {
                 var tlbKey =
-                    Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{libVersion.Major}.{libVersion.Minor}");
+                    Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{_rubberduckVersion.Major}.{_rubberduckVersion.Minor}");
 
                 name = tlbKey?.GetValue(string.Empty, string.Empty) as string;
             }
@@ -95,9 +101,9 @@ public static void EnsureProjectReferencesUnitTesting(IVBProject project)
             }
         }
 
-        private static IReference FindReferenceByName(IReferences refernences, string name)
+        private static IReference FindReferenceByName(IReferences references, string name)
         {
-            foreach (var reference in refernences)
+            foreach (var reference in references)
             {
                 if (reference.Name == name)
                 {
diff --git a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs
@@ -21,6 +21,7 @@
 using Rubberduck.VBEditor.ComManagement;
 using Rubberduck.Interaction;
 using Rubberduck.UI.UnitTesting.Commands;
+using Rubberduck.UnitTesting;
 
 namespace RubberduckTests.CodeExplorer
 {
@@ -652,9 +653,10 @@ public void AddTestModule()
                 var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider);
                 var vbeWrapper = vbe.Object;
                 var uiDispatcher = new Mock<IUiDispatcher>();
+                var interaction = new Mock<IVBEInteraction>();
                 
                 var vm = new CodeExplorerViewModel(new FolderHelper(state), state, removeCommand, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object);
-                vm.AddTestModuleCommand = new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object);
+                vm.AddTestModuleCommand = new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object, interaction.Object);
 
                 var parser = MockParser.Create(vbe.Object, state, projectRepository);
                 parser.Parse(new CancellationTokenSource());
@@ -691,10 +693,11 @@ public void AddTestModuleWithStubs()
             {
                 var vbeWrapper = vbe.Object;
                 var uiDispatcher = new Mock<IUiDispatcher>();
+                var interaction = new Mock<IVBEInteraction>();
                 var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider);
                 
                 var vm = new CodeExplorerViewModel(new FolderHelper(state), state, removeCommand, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object);
-                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object));
+                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object, interaction.Object));
 
                 var parser = MockParser.Create(vbe.Object, state, projectRepository);
                 parser.Parse(new CancellationTokenSource());
@@ -729,10 +732,11 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsProject()
             {
                 var vbeWrapper = vbe.Object;
                 var uiDispatcher = new Mock<IUiDispatcher>();
+                var interaction = new Mock<IVBEInteraction>();
                 var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider);
                 
                 var vm = new CodeExplorerViewModel(new FolderHelper(state), state, removeCommand, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object);
-                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object));
+                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object, interaction.Object));
 
                 var parser = MockParser.Create(vbe.Object, state, projectRepository);
                 parser.Parse(new CancellationTokenSource());
@@ -766,10 +770,11 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsFolder()
             using (var state = new RubberduckParserState(vbe.Object, projectRepository, new DeclarationFinderFactory(), vbeEvents.Object))
             {
                 var vbeWrapper = vbe.Object;
+                var interaction = new Mock<IVBEInteraction>();
                 var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider);
 
                 var vm = new CodeExplorerViewModel(new FolderHelper(state), state, removeCommand, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object);
-                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object));
+                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object, interaction.Object));
 
                 var parser = MockParser.Create(vbe.Object, state, projectRepository);
                 parser.Parse(new CancellationTokenSource());
@@ -803,10 +808,11 @@ public void AddTestModuleWithStubs_DisabledWhenParameterIsModuleMember()
             {
                 var vbeWrapper = vbe.Object;
                 var uiDispatcher = new Mock<IUiDispatcher>();
+                var interaction = new Mock<IVBEInteraction>();
                 var removeCommand = new RemoveCommand(saveFileDialog.Object, messageBox.Object, state.ProjectsProvider);
 
                 var vm = new CodeExplorerViewModel(new FolderHelper(state), state, removeCommand, _generalSettingsProvider.Object, _windowSettingsProvider.Object, uiDispatcher.Object, vbe.Object);
-                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object));
+                vm.AddTestModuleWithStubsCommand = new AddTestModuleWithStubsCommand(vbeWrapper, new AddTestModuleCommand(vbeWrapper, state, configLoader.Object, messageBox.Object, interaction.Object));
 
                 var parser = MockParser.Create(vbe.Object, state, projectRepository);
                 parser.Parse(new CancellationTokenSource());
diff --git a/RubberduckTests/Commands/UnitTestCommandTests.cs b/RubberduckTests/Commands/UnitTestCommandTests.cs
diff --git a/RubberduckTests/UnitTesting/EngineTests.cs b/RubberduckTests/UnitTesting/EngineTests.cs

Original file line number	Diff line number	Diff line change
`@@ -26,14 +26,16 @@ public class AddTestModuleCommand : CommandBase`
`26`	`26`	`private readonly RubberduckParserState _state;`
`27`	`27`	`private readonly IGeneralConfigService _configLoader;`
`28`	`28`	`private readonly IMessageBox _messageBox;`
	`29`	`+ private readonly IVBEInteraction _interaction;`
`29`	`30`
`30`		`- public AddTestModuleCommand(IVBE vbe, RubberduckParserState state, IGeneralConfigService configLoader, IMessageBox messageBox)`
	`31`	`+ public AddTestModuleCommand(IVBE vbe, RubberduckParserState state, IGeneralConfigService configLoader, IMessageBox messageBox, IVBEInteraction interaction)`
`31`	`32`	`: base(LogManager.GetCurrentClassLogger())`
`32`	`33`	`{`
`33`	`34`	`_vbe = vbe;`
`34`	`35`	`_state = state;`
`35`	`36`	`_configLoader = configLoader;`
`36`	`37`	`_messageBox = messageBox;`
	`38`	`+ _interaction = interaction;`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`private readonly string _testModuleEmptyTemplate = new StringBuilder()`
`@@ -164,7 +166,8 @@ protected override void OnExecute(object parameter)`
`164`	`166`
`165`	`167`	`if (settings.BindingMode == BindingMode.EarlyBinding)`
`166`	`168`	`{`
`167`		`- VBEInteraction.EnsureProjectReferencesUnitTesting(project);`
	`169`	`+ // FIXME: Push the actual adding of TestModules into UnitTesting, which sidesteps VBEInteraction being inaccessble here`
	`170`	`+ _interaction.EnsureProjectReferencesUnitTesting(project);`
`168`	`171`	`}`
`169`	`172`
`170`	`173`	`try`
`@@ -245,6 +248,7 @@ protected override void OnExecute(object parameter)`
`245`	`248`	`_state.OnParseRequested(this);`
`246`	`249`	`}`
`247`	`250`
	`251`	`+ // FIXME push this into Rubberduck.UnitTesting assembly`
`248`	`252`	`private string GetNextTestModuleName(IVBProject project)`
`249`	`253`	`{`
`250`	`254`	`var names = new HashSet<string>(project.ComponentNames().Where(module => module.StartsWith(TestModuleBaseName)));`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ internal class TestEngine : ITestEngine`
`29`	`29`
`30`	`30`	`private readonly RubberduckParserState _state;`
`31`	`31`	`private readonly IFakesFactory _fakesFactory;`
`32`		`- private readonly IVBETypeLibsAPI _typeLibApi;`
	`32`	`+ private readonly IVBEInteraction _declarationRunner;`
`33`	`33`	`private readonly ITypeLibWrapperProvider _wrapperProvider;`
`34`	`34`	`private readonly IUiDispatcher _uiDispatcher;`
`35`	`35`	`private readonly IVBE _vbe;`
`@@ -43,12 +43,12 @@ internal class TestEngine : ITestEngine`
`43`	`43`	`private bool refreshBackoff;`
`44`	`44`
`45`	`45`
`46`		`- public TestEngine(RubberduckParserState state, IFakesFactory fakesFactory, IVBETypeLibsAPI typeLibApi, ITypeLibWrapperProvider wrapperProvider, IUiDispatcher uiDispatcher, IVBE vbe)`
	`46`	`+ public TestEngine(RubberduckParserState state, IFakesFactory fakesFactory, IVBEInteraction declarationRunner, ITypeLibWrapperProvider wrapperProvider, IUiDispatcher uiDispatcher, IVBE vbe)`
`47`	`47`	`{`
`48`	`48`	`Debug.WriteLine("TestEngine created.");`
`49`	`49`	`_state = state;`
`50`	`50`	`_fakesFactory = fakesFactory;`
`51`		`- _typeLibApi = typeLibApi;`
	`51`	`+ _declarationRunner = declarationRunner;`
`52`	`52`	`_wrapperProvider = wrapperProvider;`
`53`	`53`	`_uiDispatcher = uiDispatcher;`
`54`	`54`	`_vbe = vbe;`
`@@ -147,7 +147,7 @@ private void EnsureRubberduckIsReferencedForEarlyBoundTests()`
`147`	`147`
`148`	`148`	`foreach (var project in projectsUsingAddInLibrary)`
`149`	`149`	`{`
`150`		`- VBEInteraction.EnsureProjectReferencesUnitTesting(project);`
	`150`	`+ _declarationRunner.EnsureProjectReferencesUnitTesting(project);`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
`@@ -196,7 +196,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)`
`196`	`196`	`{`
`197`	`197`	`try`
`198`	`198`	`{`
`199`		`- VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, TestDiscovery.FindModuleInitializeMethods(moduleName, _state));`
	`199`	`+ _declarationRunner.RunDeclarations(typeLibWrapper, TestDiscovery.FindModuleInitializeMethods(moduleName, _state));`
`200`	`200`	`}`
`201`	`201`	`catch (COMException ex)`
`202`	`202`	`{`
`@@ -221,7 +221,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)`
`221`	`221`	`fakes.StartTest();`
`222`	`222`	`try`
`223`	`223`	`{`
`224`		`- VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, testInitialize);`
	`224`	`+ _declarationRunner.RunDeclarations(typeLibWrapper, testInitialize);`
`225`	`225`	`}`
`226`	`226`	`catch (COMException trace)`
`227`	`227`	`{`
`@@ -234,7 +234,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)`
`234`	`234`	`OnTestCompleted(test, result);`
`235`	`235`	`try`
`236`	`236`	`{`
`237`		`- VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, testCleanup);`
	`237`	`+ _declarationRunner.RunDeclarations(typeLibWrapper, testCleanup);`
`238`	`238`	`}`
`239`	`239`	`catch (COMException cleanupFail)`
`240`	`240`	`{`
`@@ -249,7 +249,7 @@ private void RunWhileSuspended(IEnumerable<TestMethod> tests)`
`249`	`249`	`}`
`250`	`250`	`try`
`251`	`251`	`{`
`252`		`- VBEInteraction.RunDeclarations(_typeLibApi, typeLibWrapper, TestDiscovery.FindModuleCleanupMethods(moduleName, _state));`
	`252`	`+ _declarationRunner.RunDeclarations(typeLibWrapper, TestDiscovery.FindModuleCleanupMethods(moduleName, _state));`
`253`	`253`	`}`
`254`	`254`	`catch (COMException ex)`
`255`	`255`	`{`
`@@ -277,7 +277,7 @@ private TestResult RunTestMethod(ITypeLibWrapper typeLib, TestMethod test)`
`277`	`277`	`try`
`278`	`278`	`{`
`279`	`279`	`var assertResults = new List<AssertCompletedEventArgs>();`
`280`		`- VBEInteraction.RunTestMethod(_typeLibApi, typeLib, test, (s, e) => assertResults.Add(e), out duration);`
	`280`	`+ _declarationRunner.RunTestMethod(typeLib, test, (s, e) => assertResults.Add(e), out duration);`
`281`	`281`	`return EvaluateResults(assertResults, duration);`
`282`	`282`	`}`
`283`	`283`	`catch (COMException e)`
Original file line number	Diff line number	Diff line change
`@@ -9,25 +9,33 @@`
`9`	`9`	`using System;`
`10`	`10`	`using System.Collections.Generic;`
`11`	`11`	`using System.Diagnostics;`
`12`		`-using System.Reflection;`
`13`	`12`
`14`	`13`	`namespace Rubberduck.UnitTesting`
`15`	`14`	`{`
`16`	`15`	`// FIXME litter some logging around here`
`17`		`- public class VBEInteraction`
	`16`	`+ internal class VBEInteraction : IVBEInteraction`
`18`	`17`	`{`
`19`	`18`	`private static readonly Logger Logger = LogManager.GetCurrentClassLogger();`
`20`	`19`
`21`		`- internal static void RunDeclarations(IVBETypeLibsAPI typeLibApi, ITypeLibWrapper typeLib, IEnumerable<Declaration> declarations)`
	`20`	`+ private readonly Version _rubberduckVersion;`
	`21`	`+ private readonly IVBETypeLibsAPI _typeLibsApi;`
	`22`	`+`
	`23`	`+ public VBEInteraction(IVBETypeLibsAPI typeLibsApi, Version rubberduckVersion)`
	`24`	`+ {`
	`25`	`+ _typeLibsApi = typeLibsApi;`
	`26`	`+ _rubberduckVersion = rubberduckVersion;`
	`27`	`+ }`
	`28`	`+`
	`29`	`+ public void RunDeclarations(ITypeLibWrapper typeLib, IEnumerable<Declaration> declarations)`
`22`	`30`	`{`
`23`	`31`	`foreach (var declaration in declarations)`
`24`	`32`	`{`
`25`		`- typeLibApi.ExecuteCode(typeLib, declaration.QualifiedModuleName.ComponentName,`
	`33`	`+ _typeLibsApi.ExecuteCode(typeLib, declaration.QualifiedModuleName.ComponentName,`
`26`	`34`	`declaration.QualifiedName.MemberName);`
`27`	`35`	`}`
`28`	`36`	`}`
`29`	`37`
`30`		`- internal static void RunTestMethod(IVBETypeLibsAPI tlApi, ITypeLibWrapper typeLib, TestMethod test, EventHandler<AssertCompletedEventArgs> assertCompletionHandler, out long duration)`
	`38`	`+ public void RunTestMethod(ITypeLibWrapper typeLib, TestMethod test, EventHandler<AssertCompletedEventArgs> assertCompletionHandler, out long duration)`
`31`	`39`	`{`
`32`	`40`	`AssertHandler.OnAssertCompleted += assertCompletionHandler;`
`33`	`41`	`var stopwatch = new Stopwatch();`
`@@ -36,7 +44,7 @@ internal static void RunTestMethod(IVBETypeLibsAPI tlApi, ITypeLibWrapper typeLi`
`36`	`44`	`var testDeclaration = test.Declaration;`
`37`	`45`
`38`	`46`	`stopwatch.Start();`
`39`		`- tlApi.ExecuteCode(typeLib, testDeclaration.ComponentName, testDeclaration.QualifiedName.MemberName);`
	`47`	`+ _typeLibsApi.ExecuteCode(typeLib, testDeclaration.ComponentName, testDeclaration.QualifiedName.MemberName);`
`40`	`48`	`stopwatch.Stop();`
`41`	`49`
`42`	`50`	`duration = stopwatch.ElapsedMilliseconds;`
`@@ -54,22 +62,20 @@ internal static void RunTestMethod(IVBETypeLibsAPI tlApi, ITypeLibWrapper typeLi`
`54`	`62`	`}`
`55`	`63`
`56`	`64`
`57`		`- public static void EnsureProjectReferencesUnitTesting(IVBProject project)`
	`65`	`+ public void EnsureProjectReferencesUnitTesting(IVBProject project)`
`58`	`66`	`{`
`59`	`67`	`if (project == null \|\| project.IsWrappingNullReference) { return; }`
`60`	`68`	`var libFolder = IntPtr.Size == 8 ? "win64" : "win32";`
`61`		`- // FIXME: This assumes the current assembly is same major/minor as the TLB!!!`
`62`		`- var libVersion = Assembly.GetExecutingAssembly().GetName().Version;`
`63`	`69`	`const string libGuid = RubberduckGuid.RubberduckTypeLibGuid;`
`64`		`- var pathKey = Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{libVersion.Major}.{libVersion.Minor}\0\{libFolder}");`
	`70`	`+ var pathKey = Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{_rubberduckVersion.Major}.{_rubberduckVersion.Minor}\0\{libFolder}");`
`65`	`71`
`66`	`72`	`var referencePath = pathKey?.GetValue(string.Empty, string.Empty) as string;`
`67`	`73`	`string name = null;`
`68`	`74`
`69`	`75`	`if (!string.IsNullOrWhiteSpace(referencePath))`
`70`	`76`	`{`
`71`	`77`	`var tlbKey =`
`72`		`- Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{libVersion.Major}.{libVersion.Minor}");`
	`78`	`+ Registry.ClassesRoot.OpenSubKey($@"TypeLib\{{{libGuid}}}\{_rubberduckVersion.Major}.{_rubberduckVersion.Minor}");`
`73`	`79`
`74`	`80`	`name = tlbKey?.GetValue(string.Empty, string.Empty) as string;`
`75`	`81`	`}`
`@@ -95,9 +101,9 @@ public static void EnsureProjectReferencesUnitTesting(IVBProject project)`
`95`	`101`	`}`
`96`	`102`	`}`
`97`	`103`
`98`		`- private static IReference FindReferenceByName(IReferences refernences, string name)`
	`104`	`+ private static IReference FindReferenceByName(IReferences references, string name)`
`99`	`105`	`{`
`100`		`- foreach (var reference in refernences)`
	`106`	`+ foreach (var reference in references)`
`101`	`107`	`{`
`102`	`108`	`if (reference.Name == name)`
`103`	`109`	`{`