Add context menu items to run selected test or all tests in active module. Closes #4776

Author: comintern

Rubberduck.Core/UI/Command/MenuItems/ParentMenus/CodePaneContextParentMenu.cs

@@ -20,5 +20,7 @@ public enum CodePaneContextMenuItemDisplayOrder
         FindSymbol,
         FindAllReferences,
         FindAllImplementations,
+        RunSelectedTestModule,
+        RunSelectedTest
     }
 }

Rubberduck.Core/UI/Command/MenuItems/RunSelectedTestMethodCommandMenuItem.cs

@@ -0,0 +1,22 @@
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.Command.MenuItems.ParentMenus;
+
+namespace Rubberduck.UI.Command.MenuItems
+{
+    public class RunSelectedTestMethodCommandMenuItem : CommandMenuItemBase
+    {
+        public RunSelectedTestMethodCommandMenuItem(RunSelectedTestMethodCommand command) : base(command) { }
+
+        public override string Key => "ContextMenu_RunSelectedTest";
+        public override int DisplayOrder => (int)CodePaneContextMenuItemDisplayOrder.RunSelectedTest;
+
+        public override bool EvaluateCanExecute(RubberduckParserState state)
+        {
+            return state != null && Command.CanExecute(null);
+        }
+
+        public override bool HiddenWhenDisabled => true;
+
+        public override bool BeginGroup => false;
+    }
+}

Rubberduck.Core/UI/Command/MenuItems/RunSelectedTestModuleCommandMenuItem.cs

@@ -0,0 +1,22 @@
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.Command.MenuItems.ParentMenus;
+
+namespace Rubberduck.UI.Command.MenuItems
+{
+    public class RunSelectedTestModuleCommandMenuItem : CommandMenuItemBase
+    {
+        public RunSelectedTestModuleCommandMenuItem(RunSelectedTestModuleCommand command) : base(command) { }
+
+        public override string Key => "ContextMenu_RunSelectedTestModule";
+        public override int DisplayOrder => (int)CodePaneContextMenuItemDisplayOrder.RunSelectedTestModule;
+
+        public override bool EvaluateCanExecute(RubberduckParserState state)
+        {
+            return state != null && Command.CanExecute(null);
+        }
+
+        public override bool HiddenWhenDisabled => true;
+
+        public override bool BeginGroup => true;
+    }
+}

Rubberduck.Core/UI/Command/RunSelectedTestMethodCommand.cs

@@ -0,0 +1,57 @@
+using System.Linq;
+using NLog;
+using Rubberduck.Parsing.Annotations;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UnitTesting;
+using Rubberduck.VBEditor.Utility;
+
+namespace Rubberduck.UI.Command
+{
+    public class RunSelectedTestMethodCommand : CommandBase
+    {
+        private readonly ITestEngine _engine;
+        private readonly ISelectionService _selectionService;
+        private readonly IDeclarationFinderProvider _finderProvider;
+
+        public RunSelectedTestMethodCommand(ITestEngine engine, ISelectionService selectionService, IDeclarationFinderProvider finderProvider) 
+            : base(LogManager.GetCurrentClassLogger())
+        {
+            _engine = engine;
+            _selectionService = selectionService;
+            _finderProvider = finderProvider;
+        }
+
+        protected override bool EvaluateCanExecute(object parameter)
+        {
+            return (parameter ?? FindDeclarationFromSelection()) is Declaration candidate &&
+                   !(_engine.Tests.FirstOrDefault(test => test.Declaration.Equals(candidate)) is null) &&
+                   _engine.CanRun;
+        }
+
+        protected override void OnExecute(object parameter)
+        {
+            if (!((parameter ?? FindDeclarationFromSelection()) is Declaration candidate) ||
+                !(_engine.Tests.FirstOrDefault(test => test.Declaration.Equals(candidate)) is TestMethod selectedTest) ||
+                !_engine.CanRun)
+            {
+                return;
+            }
+
+            _engine.Run(new [] { selectedTest });
+        }
+
+        private Declaration FindDeclarationFromSelection()
+        {
+            var active = _selectionService?.ActiveSelection();
+            if (!active.HasValue)
+            {
+                return null;
+            }
+
+            return _finderProvider.DeclarationFinder.FindDeclarationsForSelection(active.Value)
+                .SingleOrDefault(declaration => declaration.DeclarationType == DeclarationType.Procedure &&
+                                                declaration.Annotations.Any(annotation => annotation is TestMethodAnnotation));
+        }
+    }
+}

Rubberduck.Core/UI/Command/RunSelectedTestModuleCommand.cs

@@ -0,0 +1,62 @@
+using System.Linq;
+using NLog;
+using Rubberduck.Parsing.Annotations;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UnitTesting;
+using Rubberduck.VBEditor.Utility;
+
+namespace Rubberduck.UI.Command
+{
+    public class RunSelectedTestModuleCommand : CommandBase
+    {
+        private readonly ITestEngine _engine;
+        private readonly ISelectionService _selectionService;
+        private readonly IDeclarationFinderProvider _finderProvider;
+
+        public RunSelectedTestModuleCommand(ITestEngine engine, ISelectionService selectionService, IDeclarationFinderProvider finderProvider)
+            : base(LogManager.GetCurrentClassLogger())
+        {
+            _engine = engine;
+            _selectionService = selectionService;
+            _finderProvider = finderProvider;
+        }
+
+        protected override bool EvaluateCanExecute(object parameter)
+        {
+            return (parameter ?? FindModuleFromSelection()) is Declaration candidate &&
+                   candidate.DeclarationType == DeclarationType.ProceduralModule &&
+                   candidate.Annotations.Any(annotation => annotation is TestModuleAnnotation) &&
+                   _engine.CanRun &&
+                   _engine.Tests.Any(test => test.Declaration.QualifiedModuleName.Equals(candidate.QualifiedModuleName));
+        }
+
+        protected override void OnExecute(object parameter)
+        {
+            if (!((parameter ?? FindModuleFromSelection()) is Declaration candidate) ||
+                candidate.DeclarationType != DeclarationType.ProceduralModule ||
+                !candidate.Annotations.Any(annotation => annotation is TestModuleAnnotation) ||
+                !_engine.CanRun)
+            {
+                return;
+            }
+
+            var tests = _engine.Tests.Where(test => test.Declaration.QualifiedModuleName.Equals(candidate.QualifiedModuleName)).ToList();
+
+            if (!tests.Any())
+            {
+                return;
+            }
+
+            _engine.Run(tests);
+        }
+
+        private Declaration FindModuleFromSelection()
+        {
+            var active = _selectionService?.ActiveSelection();
+            return !active.HasValue
+                ? null
+                : _finderProvider.DeclarationFinder.ModuleDeclaration(active.Value.QualifiedName);
+        }
+    }
+}

Rubberduck.Main/Root/RubberduckIoCInstaller.cs

@@ -447,7 +447,9 @@ private Type[] CodePaneContextMenuItems()
                 typeof(SmartIndenterParentMenu),
                 typeof(FindSymbolCommandMenuItem),
                 typeof(FindAllReferencesCommandMenuItem),
-                typeof(FindAllImplementationsCommandMenuItem)
+                typeof(FindAllImplementationsCommandMenuItem),
+                typeof(RunSelectedTestModuleCommandMenuItem),
+                typeof(RunSelectedTestMethodCommandMenuItem)
             };
         }
 

Rubberduck.Parsing/VBA/DeclarationCaching/DeclarationFinder.cs

@@ -319,6 +319,18 @@ public Declaration FindSelectedDeclaration(ICodePane activeCodePane)
             }
         }
 
+        /// <summary>
+        /// Finds all declarations contained within the passed selection.
+        /// </summary>
+        /// <param name="selection">The QualifiedSelection to find declarations for.</param>
+        /// <returns>An IEnumerable of matches.</returns>
+        public IEnumerable<Declaration> FindDeclarationsForSelection(QualifiedSelection selection)
+        {
+            return _declarationsBySelection.Keys
+                .Where(key => key.Contains(selection))
+                .SelectMany(key => _declarationsBySelection[key]).Distinct();
+        }
+
         public IEnumerable<Declaration> FreshUndeclared => _newUndeclared.AllValues();
 
         //This does not need a lock because enumerators over a ConcurrentBag uses a snapshot.    

Rubberduck.Resources/Menus/RubberduckMenus.Designer.cs

@@ -238,4 +238,10 @@
   <data name="AddRemoveReferences" xml:space="preserve">
     <value>Add/Remove References...</value>
   </data>
+  <data name="ContextMenu_RunSelectedTest" xml:space="preserve">
+    <value>Run selected test</value>
+  </data>
+  <data name="ContextMenu_RunSelectedTestModule" xml:space="preserve">
+    <value>Run tests in module</value>
+  </data>
 </root>

Rubberduck.Resources/Menus/RubberduckMenus.resx

@@ -14,6 +14,11 @@ public QualifiedSelection(QualifiedModuleName qualifiedName, Selection selection
 
         public Selection Selection { get; }
 
+        public bool Contains(QualifiedSelection other)
+        {
+            return QualifiedName.Equals(other.QualifiedName) && Selection.Contains(other.Selection);
+        }
+
         public int CompareTo(QualifiedSelection other)
         {
             return other.QualifiedName == QualifiedName