Merge pull request #2134 from Hosch250/unitTests

Unit tests

Author: retailcoder

RetailCoder.VBE/Root/RubberduckModule.cs

@@ -27,7 +27,6 @@
 using Rubberduck.UI.SourceControl;
 using Rubberduck.UI.ToDoItems;
 using Rubberduck.UI.UnitTesting;
-using Rubberduck.UnitTesting;
 using Rubberduck.VBEditor.VBEHost;
 using Rubberduck.Parsing.Preprocessing;
 using System.Globalization;
@@ -63,8 +62,6 @@ public override void Load()
             Bind<App>().ToSelf().InSingletonScope();
             Bind<RubberduckParserState>().ToSelf().InSingletonScope();
             Bind<GitProvider>().ToSelf().InSingletonScope();
-            Bind<NewUnitTestModuleCommand>().ToSelf().InSingletonScope();
-            Bind<NewTestMethodCommand>().ToSelf().InSingletonScope();
             Bind<RubberduckCommandBar>().ToSelf().InSingletonScope();
             Bind<TestExplorerModel>().ToSelf().InSingletonScope();
             Bind<IOperatingSystem>().To<WindowsOperatingSystem>().InSingletonScope();
@@ -107,10 +104,10 @@ public override void Load()
                 .InSingletonScope()
                 .WithConstructorArgument<IDockableUserControl>(new CodeInspectionsWindow { ViewModel = Kernel.Get<InspectionResultsViewModel>() });
 
-            Bind<IControlView>().To<ChangesView>().Named("changesView");
-            Bind<IControlView>().To<BranchesView>().Named("branchesView");
-            Bind<IControlView>().To<UnsyncedCommitsView>().Named("unsyncedCommitsView");
-            Bind<IControlView>().To<SettingsView>().Named("settingsView");
+            Bind<IControlView>().To<ChangesView>();
+            Bind<IControlView>().To<BranchesView>();
+            Bind<IControlView>().To<UnsyncedCommitsView>();
+            Bind<IControlView>().To<SettingsView>();
 
             Bind<IControlViewModel>().To<ChangesViewViewModel>()
                 .WhenInjectedInto<ChangesView>();

RetailCoder.VBE/Rubberduck.csproj

@@ -952,8 +952,6 @@
     <Compile Include="UnitTesting\IAssert.cs" />
     <Compile Include="UnitTesting\ITestEngine.cs" />
     <Compile Include="UnitTesting\ITestRunner.cs" />
-    <Compile Include="UnitTesting\NewTestMethodCommand.cs" />
-    <Compile Include="UnitTesting\NewUnitTestModuleCommand.cs" />
     <Compile Include="UnitTesting\ProjectTestExtensions.cs" />
     <Compile Include="UnitTesting\TestEngine.cs" />
     <Compile Include="UnitTesting\TestMethod.cs" />

RetailCoder.VBE/UI/CodeExplorer/Commands/AddTestModuleCommand.cs

@@ -4,17 +4,16 @@
 using Rubberduck.Navigation.CodeExplorer;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.UI.Command;
-using Rubberduck.UnitTesting;
 
 namespace Rubberduck.UI.CodeExplorer.Commands
 {
     [CodeExplorerCommand]
     public class AddTestModuleCommand : CommandBase
     {
         private readonly VBE _vbe;
-        private readonly NewUnitTestModuleCommand _newUnitTestModuleCommand;
+        private readonly Command.AddTestModuleCommand _newUnitTestModuleCommand;
 
-        public AddTestModuleCommand(VBE vbe, NewUnitTestModuleCommand newUnitTestModuleCommand) : base(LogManager.GetCurrentClassLogger())
+        public AddTestModuleCommand(VBE vbe, Command.AddTestModuleCommand newUnitTestModuleCommand) : base(LogManager.GetCurrentClassLogger())
         {
             _vbe = vbe;
             _newUnitTestModuleCommand = newUnitTestModuleCommand;
@@ -34,14 +33,9 @@ protected override bool CanExecuteImpl(object parameter)
 
         protected override void ExecuteImpl(object parameter)
         {
-            if (parameter != null)
-            {
-                _newUnitTestModuleCommand.NewUnitTestModule(GetDeclaration(parameter).Project);
-            }
-            else
-            {
-                _newUnitTestModuleCommand.NewUnitTestModule(_vbe.VBProjects.Item(1));
-            }
+            _newUnitTestModuleCommand.Execute(parameter != null
+                ? GetDeclaration(parameter).Project
+                : _vbe.VBProjects.Item(1));
         }
 
         private Declaration GetDeclaration(object parameter)

RetailCoder.VBE/UI/Command/AddTestMethodCommand.cs

@@ -16,19 +16,36 @@ namespace Rubberduck.UI.Command
     public class AddTestMethodCommand : CommandBase
     {
         private readonly VBE _vbe;
-        private readonly NewTestMethodCommand _command;
         private readonly RubberduckParserState _state;
 
-        public AddTestMethodCommand(VBE vbe, RubberduckParserState state, NewTestMethodCommand command) : base(LogManager.GetCurrentClassLogger())
+        public AddTestMethodCommand(VBE vbe, RubberduckParserState state) : base(LogManager.GetCurrentClassLogger())
         {
             _vbe = vbe;
-            _command = command;
             _state = state;
         }
 
+        public const string NamePlaceholder = "%METHODNAME%";
+        private const string TestMethodBaseName = "TestMethod";
+
+        public static readonly string TestMethodTemplate = string.Concat(
+            "'@TestMethod\r\n",
+            "Public Sub ", NamePlaceholder, "() 'TODO ", RubberduckUI.UnitTest_NewMethod_Rename, "\r\n",
+            "    On Error GoTo TestFail\r\n",
+            "    \r\n",
+            "    'Arrange:\r\n\r\n",
+            "    'Act:\r\n\r\n",
+            "    'Assert:\r\n",
+            "    Assert.Inconclusive\r\n\r\n",
+            "TestExit:\r\n",
+            "    Exit Sub\r\n",
+            "TestFail:\r\n",
+            "    Assert.Fail \"", RubberduckUI.UnitTest_NewMethod_RaisedTestError, ": #\" & Err.Number & \" - \" & Err.Description\r\n",
+            "End Sub\r\n"
+            );
+
         protected override bool CanExecuteImpl(object parameter)
         {
-            if (_state.Status != ParserState.Ready) { return false; }
+            if (_state.Status != ParserState.Ready || _vbe.ActiveCodePane == null) { return false; }
 
             var testModules = _state.AllUserDeclarations.Where(d =>
                         d.DeclarationType == DeclarationType.ProceduralModule &&
@@ -49,7 +66,34 @@ protected override bool CanExecuteImpl(object parameter)
 
         protected override void ExecuteImpl(object parameter)
         {
-            _command.NewTestMethod();
+            if (_vbe.ActiveCodePane == null) { return; }
+
+            try
+            {
+                var declaration = _state.GetTestModules().FirstOrDefault(f =>
+                            f.QualifiedName.QualifiedModuleName.Component.CodeModule == _vbe.ActiveCodePane.CodeModule);
+
+                if (declaration != null)
+                {
+                    var module = _vbe.ActiveCodePane.CodeModule;
+                    var name = GetNextTestMethodName(module.Parent);
+                    var body = TestMethodTemplate.Replace(NamePlaceholder, name);
+                    module.InsertLines(module.CountOfLines, body);
+                }
+            }
+            catch (COMException)
+            {
+            }
+
+            _state.OnParseRequested(this, _vbe.SelectedVBComponent);
+        }
+
+        private string GetNextTestMethodName(VBComponent component)
+        {
+            var names = component.GetTests(_vbe, _state).Select(test => test.Declaration.IdentifierName);
+            var index = names.Count(n => n.StartsWith(TestMethodBaseName)) + 1;
+
+            return string.Concat(TestMethodBaseName, index);
         }
     }
 }

RetailCoder.VBE/UI/Command/AddTestMethodExpectedErrorCommand.cs

@@ -16,19 +16,41 @@ namespace Rubberduck.UI.Command
     public class AddTestMethodExpectedErrorCommand : CommandBase
     {
         private readonly VBE _vbe;
-        private readonly NewTestMethodCommand _command;
         private readonly RubberduckParserState _state;
 
-        public AddTestMethodExpectedErrorCommand(VBE vbe, RubberduckParserState state, NewTestMethodCommand command) : base(LogManager.GetCurrentClassLogger())
+        public AddTestMethodExpectedErrorCommand(VBE vbe, RubberduckParserState state) : base(LogManager.GetCurrentClassLogger())
         {
             _vbe = vbe;
-            _command = command;
             _state = state;
         }
 
+        public const string NamePlaceholder = "%METHODNAME%";
+        private const string TestMethodBaseName = "TestMethod";
+
+        public static readonly string TestMethodExpectedErrorTemplate = string.Concat(
+            "'@TestMethod\r\n",
+            "Public Sub ", NamePlaceholder, "() 'TODO ", RubberduckUI.UnitTest_NewMethod_Rename, "\r\n",
+            "    Const ExpectedError As Long = 0 'TODO ", RubberduckUI.UnitTest_NewMethod_ChangeErrorNo, "\r\n",
+            "    On Error GoTo TestFail\r\n",
+            "    \r\n",
+            "    'Arrange:\r\n\r\n",
+            "    'Act:\r\n\r\n",
+            "Assert:\r\n",
+            "    Assert.Fail \"", RubberduckUI.UnitTest_NewMethod_ErrorNotRaised, ".\"\r\n\r\n",
+            "TestExit:\r\n",
+            "    Exit Sub\r\n",
+            "TestFail:\r\n",
+            "    If Err.Number = ExpectedError Then\r\n",
+            "        Resume TestExit\r\n",
+            "    Else\r\n",
+            "        Resume Assert\r\n",
+            "    End If\r\n",
+            "End Sub\r\n"
+            );
+
         protected override bool CanExecuteImpl(object parameter)
         {
-            if (_state.Status != ParserState.Ready) { return false; }
+            if (_state.Status != ParserState.Ready || _vbe.ActiveCodePane == null) { return false; }
 
             var testModules = _state.AllUserDeclarations.Where(d =>
                         d.DeclarationType == DeclarationType.ProceduralModule &&
@@ -49,7 +71,34 @@ protected override bool CanExecuteImpl(object parameter)
 
         protected override void ExecuteImpl(object parameter)
         {
-            _command.NewExpectedErrorTestMethod();
+            if (_vbe.ActiveCodePane == null) { return; }
+
+            try
+            {
+                var declaration = _state.GetTestModules().FirstOrDefault(f =>
+                            f.QualifiedName.QualifiedModuleName.Component.CodeModule == _vbe.ActiveCodePane.CodeModule);
+
+                if (declaration != null)
+                {
+                    var module = _vbe.ActiveCodePane.CodeModule;
+                    var name = GetNextTestMethodName(module.Parent);
+                    var body = TestMethodExpectedErrorTemplate.Replace(NamePlaceholder, name);
+                    module.InsertLines(module.CountOfLines, body);
+                }
+            }
+            catch (COMException)
+            {
+            }
+
+            _state.OnParseRequested(this, _vbe.SelectedVBComponent);
+        }
+
+        private string GetNextTestMethodName(VBComponent component)
+        {
+            var names = component.GetTests(_vbe, _state).Select(test => test.Declaration.IdentifierName);
+            var index = names.Count(n => n.StartsWith(TestMethodBaseName)) + 1;
+
+            return string.Concat(TestMethodBaseName, index);
         }
     }
 }

RetailCoder.VBE/UI/Command/AddTestModuleCommand.cs

@@ -1,7 +1,10 @@
+using System;
+using System.Linq;
 using System.Runtime.InteropServices;
 using Microsoft.Vbe.Interop;
 using NLog;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.Settings;
 using Rubberduck.UnitTesting;
 using Rubberduck.VBEditor.Extensions;
 
@@ -14,22 +17,134 @@ namespace Rubberduck.UI.Command
     public class AddTestModuleCommand : CommandBase
     {
         private readonly VBE _vbe;
-        private readonly NewUnitTestModuleCommand _command;
+        private readonly RubberduckParserState _state;
+        private readonly IGeneralConfigService _configLoader;
 
-        public AddTestModuleCommand(VBE vbe, RubberduckParserState state, NewUnitTestModuleCommand command) : base(LogManager.GetCurrentClassLogger())
+        public AddTestModuleCommand(VBE vbe, RubberduckParserState state, IGeneralConfigService configLoader)
+            : base(LogManager.GetCurrentClassLogger())
         {
             _vbe = vbe;
-            _command = command;
+            _state = state;
+            _configLoader = configLoader;
         }
 
-        protected override bool CanExecuteImpl(object parameter)
+        private const string ModuleLateBinding = "Private Assert As Object\r\n";
+        private const string ModuleEarlyBinding = "Private Assert As New Rubberduck.{0}AssertClass\r\n";
+
+        private const string TestModuleEmptyTemplate = "'@TestModule\r\n{0}\r\n";
+
+        private const string ModuleInitLateBinding = "Set Assert = CreateObject(\"Rubberduck.{0}AssertClass\")\r\n";
+        private readonly string _moduleInit = string.Concat(
+            "'@ModuleInitialize\r\n"
+            , "Public Sub ModuleInitialize()\r\n"
+            , "    '", RubberduckUI.UnitTest_NewModule_RunOnce, ".\r\n    {0}\r\n"
+            , "End Sub\r\n\r\n"
+            , "'@ModuleCleanup\r\n"
+            , "Public Sub ModuleCleanup()\r\n"
+            , "    '", RubberduckUI.UnitTest_NewModule_RunOnce, ".\r\n"
+            , "End Sub\r\n\r\n"
+        );
+
+        private readonly string _methodInit = string.Concat(
+            "'@TestInitialize\r\n"
+            , "Public Sub TestInitialize()\r\n"
+            , "    '", RubberduckUI.UnitTest_NewModule_RunBeforeTest, ".\r\n"
+            , "End Sub\r\n\r\n"
+            , "'@TestCleanup\r\n"
+            , "Public Sub TestCleanup()\r\n"
+            , "    '", RubberduckUI.UnitTest_NewModule_RunAfterTest, ".\r\n"
+            , "End Sub\r\n\r\n"
+        );
+
+        private const string TestModuleBaseName = "TestModule";
+
+        private string GetTestModule(UnitTestSettings settings)
         {
-            return _vbe.HostSupportsUnitTests();
+            var assertClass = settings.AssertMode == AssertMode.StrictAssert ? string.Empty : "Permissive";
+            var moduleBinding = settings.BindingMode == BindingMode.EarlyBinding
+                ? string.Format(ModuleEarlyBinding, assertClass)
+                : ModuleLateBinding;
+
+            var formattedModuleTemplate = string.Format(TestModuleEmptyTemplate, moduleBinding);
+
+            if (settings.ModuleInit)
+            {
+                var lateBindingString = string.Format(ModuleInitLateBinding,
+                    settings.AssertMode == AssertMode.StrictAssert ? string.Empty : "Permissive");
+
+                formattedModuleTemplate += string.Format(_moduleInit, settings.BindingMode == BindingMode.EarlyBinding ? string.Empty : lateBindingString);
+            }
+
+            if (settings.MethodInit)
+            {
+                formattedModuleTemplate += _methodInit;
+            }
+
+            return formattedModuleTemplate;
         }
 
+        private VBProject GetProject()
+        {
+            return _vbe.ActiveVBProject ?? (_vbe.VBProjects.Count == 1 ? _vbe.VBProjects.Item(1) : null);
+        }
+
+        protected override bool CanExecuteImpl(object parameter)
+        {
+            return GetProject() != null &&
+                _vbe.HostSupportsUnitTests();
+        }
+        
         protected override void ExecuteImpl(object parameter)
         {
-            _command.NewUnitTestModule(_vbe.ActiveVBProject);
+            var project = parameter as VBProject ?? GetProject();
+            if (project == null) { return; }
+
+            var settings = _configLoader.LoadConfiguration().UserSettings.UnitTestSettings;
+            VBComponent component;
+
+            try
+            {
+                if (settings.BindingMode == BindingMode.EarlyBinding)
+                {
+                    project.EnsureReferenceToAddInLibrary();
+                }
+
+                component = project.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule);
+                component.Name = GetNextTestModuleName(project);
+
+                var hasOptionExplicit = false;
+                if (component.CodeModule.CountOfLines > 0 && component.CodeModule.CountOfDeclarationLines > 0)
+                {
+                    hasOptionExplicit = component.CodeModule.Lines[1, component.CodeModule.CountOfDeclarationLines].Contains("Option Explicit");
+                }
+
+                var options = string.Concat(hasOptionExplicit ? string.Empty : "Option Explicit\r\n", "Option Private Module\r\n\r\n");
+
+                var defaultTestMethod = string.Empty;
+                if (settings.DefaultTestStubInNewModule)
+                {
+                    defaultTestMethod = AddTestMethodCommand.TestMethodTemplate.Replace(
+                        AddTestMethodCommand.NamePlaceholder, "TestMethod1");
+                }
+
+                component.CodeModule.AddFromString(options + GetTestModule(settings) + defaultTestMethod);
+                component.Activate();
+            }
+            catch (Exception)
+            {
+                //can we please comment when we swallow every possible exception?
+                return;
+            }
+
+            _state.OnParseRequested(this, component);
+        }
+
+        private string GetNextTestModuleName(VBProject project)
+        {
+            var names = project.ComponentNames();
+            var index = names.Count(n => n.StartsWith(TestModuleBaseName)) + 1;
+
+            return string.Concat(TestModuleBaseName, index);
         }
     }
 }