Refresh Testing (Pun Intended)

Rubberduck.Core/Settings/ConfigurationLoader.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using Rubberduck.SettingsProvider;
 using Rubberduck.SmartIndenter;
+using Rubberduck.UnitTesting.Settings;
 
 namespace Rubberduck.Settings
 {

Rubberduck.Core/Settings/UserSettings.cs

@@ -1,5 +1,6 @@
 using System.Xml.Serialization;
 using Rubberduck.SmartIndenter;
+using Rubberduck.UnitTesting.Settings;
 
 namespace Rubberduck.Settings
 {

Rubberduck.Core/UI/CodeExplorer/Commands/AddTestComponentCommand.cs

@@ -1,12 +1,10 @@
 using System;
 using System.Linq;
 using System.Runtime.InteropServices;
-using Rubberduck.Interaction;
 using Rubberduck.Navigation.CodeExplorer;
 using Rubberduck.Parsing.VBA;
-using Rubberduck.Settings;
 using Rubberduck.UI.UnitTesting.Commands;
-using Rubberduck.UnitTesting;
+using Rubberduck.UnitTesting.CodeGeneration;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
 namespace Rubberduck.UI.CodeExplorer.Commands
@@ -21,8 +19,8 @@ public class AddTestComponentCommand : AddTestModuleCommand
             typeof(CodeExplorerMemberViewModel)
         };
 
-        public AddTestComponentCommand(IVBE vbe, RubberduckParserState state, IGeneralConfigService configLoader, IMessageBox messageBox, IVBEInteraction interaction) 
-            : base(vbe, state, configLoader, messageBox, interaction) { }
+        public AddTestComponentCommand(IVBE vbe, RubberduckParserState state, ITestCodeGenerator codeGenerator) 
+            : base(vbe, state, codeGenerator) { }
 
         protected override bool EvaluateCanExecute(object parameter)
         {

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.Core/UI/Controls/GroupingGrid.xaml

@@ -3,7 +3,9 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-             xmlns:local="clr-namespace:Rubberduck.UI.Controls" x:Class="Rubberduck.UI.Controls.GroupingGrid"
+             xmlns:local="clr-namespace:Rubberduck.UI.Controls"
+             xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
+             x:Class="Rubberduck.UI.Controls.GroupingGrid"
              mc:Ignorable="d" 
              d:DesignHeight="300" d:DesignWidth="300">
     <DataGrid.Resources>
@@ -60,7 +62,8 @@
             <Setter Property="Template">
                 <Setter.Value>
                     <ControlTemplate>
-                        <Expander Background="WhiteSmoke" Foreground="Black" FontWeight="SemiBold">
+                        <Expander Background="WhiteSmoke" Foreground="Black" FontWeight="SemiBold" 
+                                  IsExpanded="{Binding InitialExpandedState, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type local:GroupingGrid}}}">
                             <Expander.Header>
                                 <StackPanel Orientation="Horizontal">
                                     <TextBlock Margin="4" 
@@ -76,6 +79,9 @@
                                 </StackPanel>
                             </Expander.Header>
                             <ItemsPresenter Margin="25,0,0,0" />
+                            <i:Interaction.Behaviors>
+                                <local:PersistGroupExpandedStateBehavior GroupName="{Binding Name}" />
+                            </i:Interaction.Behaviors>
                         </Expander>
                     </ControlTemplate>
                 </Setter.Value>

Rubberduck.Core/UI/Controls/GroupingGrid.xaml.cs

@@ -9,12 +9,21 @@ public partial class GroupingGrid
         public static readonly DependencyProperty ShowGroupingItemCountProperty =
             DependencyProperty.Register("ShowGroupingItemCount", typeof (bool), typeof(GroupingGrid));
 
+        public static readonly DependencyProperty InitialExpandedStateProperty =
+            DependencyProperty.Register("InitialExpandedState", typeof(bool), typeof(GroupingGrid));
+
         public bool ShowGroupingItemCount
         {
-            get => (bool) GetValue(ShowGroupingItemCountProperty);
+            get => (bool)GetValue(ShowGroupingItemCountProperty);
             set => SetValue(ShowGroupingItemCountProperty, value);
         }
 
+        public bool InitialExpandedState
+        {
+            get => (bool)GetValue(InitialExpandedStateProperty);
+            set => SetValue(InitialExpandedStateProperty, value);
+        }
+
         public GroupingGrid()
         {
             InitializeComponent();

Rubberduck.Core/UI/Controls/PersistGroupExpandedStateBehavior.cs

@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Interactivity;
+using GongSolutions.Wpf.DragDrop.Utilities;
+
+namespace Rubberduck.UI.Controls
+{
+    // Courtesy of @aKzenT - this is a heavily refactored implementation of https://stackoverflow.com/a/15924044/4088852
+    public class PersistGroupExpandedStateBehavior : Behavior<Expander>
+    {
+        public static readonly DependencyProperty InitialExpandedStateProperty = DependencyProperty.Register(
+            "InitialExpandedState",
+            typeof(bool),
+            typeof(PersistGroupExpandedStateBehavior),
+            new PropertyMetadata(default(bool)));
+
+        public static readonly DependencyProperty GroupNameProperty = DependencyProperty.Register(
+            "GroupName",
+            typeof(object),
+            typeof(PersistGroupExpandedStateBehavior),
+            new PropertyMetadata(default(object)));
+
+        private static readonly DependencyProperty ExpandedStateStoreProperty =
+            DependencyProperty.RegisterAttached(
+                "ExpandedStateStore",
+                typeof(IDictionary<object, bool>),
+                typeof(PersistGroupExpandedStateBehavior),
+                new PropertyMetadata(default(IDictionary<object, bool>)));
+
+        public bool InitialExpandedState
+        {
+            get => (bool)GetValue(InitialExpandedStateProperty);
+            set => SetValue(InitialExpandedStateProperty, value);
+        }
+
+        public object GroupName
+        {
+            get => GetValue(GroupNameProperty);
+            set => SetValue(GroupNameProperty, value);
+        }
+
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+
+            var states = GetExpandedStateStore();
+            var expanded = !states.ContainsKey(GroupName ?? string.Empty) ? (bool?)null : states[GroupName ?? string.Empty];
+
+            if (expanded != null)
+            {
+                AssociatedObject.IsExpanded = InitialExpandedState;
+            }
+
+            AssociatedObject.Expanded += OnExpanded;
+            AssociatedObject.Collapsed += OnCollapsed;
+        }
+
+        protected override void OnDetaching()
+        {
+            AssociatedObject.Expanded -= OnExpanded;
+            AssociatedObject.Collapsed -= OnCollapsed;
+
+            base.OnDetaching();
+        }
+
+        private void OnCollapsed(object sender, RoutedEventArgs e) => SetExpanded(false);
+
+        private void OnExpanded(object sender, RoutedEventArgs e) => SetExpanded(true);
+
+        private void SetExpanded(bool expanded) => GetExpandedStateStore()[GroupName ?? string.Empty] = expanded;
+
+        private IDictionary<object, bool> GetExpandedStateStore()
+        {
+            if (!(AssociatedObject?.GetVisualAncestor<ItemsControl>() is ItemsControl items))
+            {
+                return null;
+            }
+
+            var states = (IDictionary<object, bool>)items.GetValue(ExpandedStateStoreProperty);
+
+            if (states != null)
+            {
+                return states;
+            }
+
+            states = new Dictionary<object, bool>();
+            items.SetValue(ExpandedStateStoreProperty, states);
+
+            return states;
+        }
+    }
+}