Add unit tests, replace tests targeting old interface.

Author: comintern

Rubberduck.Core/UI/Converters/NonZeroToBooleanConverter.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Data;
+
+namespace Rubberduck.UI.Converters
+{
+    public class NonZeroToBooleanConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (!(value is int number))
+            {
+                return false;
+            }
+
+            return number != 0 ? Visibility.Visible : Visibility.Hidden;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Rubberduck.Core/UI/UnitTesting/TestExplorerViewModel.cs

@@ -19,7 +19,7 @@
 
 namespace Rubberduck.UI.UnitTesting
 {
-    internal enum TestExplorerGrouping
+    public enum TestExplorerGrouping
     {
         None,
         Outcome,

Rubberduck.UnitTesting/UnitTesting/TestResult.cs

@@ -2,7 +2,7 @@
 
 namespace Rubberduck.UnitTesting
 {
-    public class TestResult
+    public struct TestResult
     {
         public TestResult(TestOutcome outcome, string output = "", long duration = 0)
         {

RubberduckTests/UnitTesting/EngineTests.cs

@@ -0,0 +1,247 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using Rubberduck.Parsing.UIContext;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UnitTesting;
+using Rubberduck.VBEditor.ComManagement.TypeLibs;
+using Rubberduck.VBEditor.SafeComWrappers;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+using RubberduckTests.Mocks;
+
+namespace RubberduckTests.UnitTesting
+{
+    internal class MockedTestEngine : IDisposable
+    {
+        public delegate void RunTestMethodCallback(ITypeLibWrapper wrapper, TestMethod method, EventHandler<AssertCompletedEventArgs> assertListener, out long duration);
+        public delegate (long Duration, TestResult result) ReturnTestResult(ITypeLibWrapper wrapper, TestMethod method, EventHandler<AssertCompletedEventArgs> assertListener, out long duration);
+
+        private const string TestMethodTemplate = 
+@"'@TestMethod
+Public Sub TestMethod{0}()
+End Sub";
+
+        private const string IgnoredTestTemplate =
+@"'@TestMethod
+'@IgnoreTest
+Public Sub TestMethod{0}()
+End Sub";
+
+        private const string TestMethodCategoryTemplate =
+            @"'@TestMethod(""{1}"")
+Public Sub TestMethod{0}()
+End Sub";
+
+        private const string IgnoredTestCategoryTemplate =
+            @"'@TestMethod(""{1}"")
+'@IgnoreTest
+Public Sub TestMethod{0}()
+End Sub";
+
+        private readonly Mock<IFakesFactory> _fakesFactory = new Mock<IFakesFactory>();
+        private readonly Mock<IFakes> _createdFakes = new Mock<IFakes>();
+        private long _durationStub;
+
+        private MockedTestEngine()
+        {
+            Dispatcher.Setup(d => d.InvokeAsync(It.IsAny<Action>())).Callback((Action action) => action.Invoke()).Verifiable();
+            
+            TypeLib.Setup(tlm => tlm.Dispose()).Verifiable();
+            WrapperProvider.Setup(p => p.TypeLibWrapperFromProject(It.IsAny<string>())).Returns(TypeLib.Object).Verifiable();
+
+            _fakesFactory.Setup(factory => factory.Create()).Returns(_createdFakes.Object);
+        }
+
+        public MockedTestEngine(string testModuleCode) : this()
+        {
+            var builder = new MockVbeBuilder()
+                .ProjectBuilder("TestProject1", ProjectProtection.Unprotected)
+                .AddComponent("TestModule1", ComponentType.StandardModule, TestModuleHeader + testModuleCode)
+                .AddProjectToVbeBuilder();
+
+            Vbe = builder.Build();
+            ParserState = MockParser.Create(Vbe.Object).State;
+            TestEngine = new TestEngine(ParserState, _fakesFactory.Object, VbeInteraction.Object, WrapperProvider.Object, Dispatcher.Object, Vbe.Object);
+        }
+
+        public MockedTestEngine(IReadOnlyList<string> moduleNames, IReadOnlyList<int> methodCounts) : this()
+        {
+            if (moduleNames.Count != methodCounts.Count)
+            {
+                Assert.Inconclusive("Test setup error.");
+            }
+
+            var builder = new MockVbeBuilder();
+            var project = builder.ProjectBuilder("TestProject1", ProjectProtection.Unprotected);
+
+            for (var index = 0; index < moduleNames.Count; index++)
+            {
+                var testModuleCode = string.Join(Environment.NewLine, Enumerable.Range(1, methodCounts[index]).Select(num => GetTestMethod(num)));
+
+                project.AddComponent(moduleNames[index], ComponentType.StandardModule, TestModuleHeader + testModuleCode);
+            }
+
+            project.AddProjectToVbeBuilder();
+            Vbe = builder.Build();
+            ParserState = MockParser.Create(Vbe.Object).State;
+            TestEngine = new TestEngine(ParserState, _fakesFactory.Object, VbeInteraction.Object, WrapperProvider.Object, Dispatcher.Object, Vbe.Object);
+        }
+
+        public MockedTestEngine(int testMethodCount) 
+            : this(string.Join(Environment.NewLine, Enumerable.Range(1, testMethodCount).Select(num => GetTestMethod(num))))
+        { }
+
+        public MockedTestEngine(List<(TestOutcome Outcome, string Output, long duration)> results) 
+            : this(string.Join(Environment.NewLine, Enumerable.Range(1, results.Count).Select(num => GetTestMethod(num, results[num - 1].Outcome == TestOutcome.Ignored))))
+        {
+            ParserState.OnParseRequested(this);
+            var testMethodCount = results.Count;
+            var testMethods = TestEngine.Tests.ToList();
+
+            if (testMethods.Count != testMethodCount)
+            {
+                Assert.Inconclusive("Test setup failure.");
+            }
+
+            for (var test = 0; test < results.Count; test++)
+            {
+                var (outcome, output, duration) = results[test];
+                SetupAssertCompleted(testMethods[test], new TestResult(outcome, output, duration));
+            }
+        }
+
+        public RubberduckParserState ParserState { get; set; }
+
+        public Mock<IVBE> Vbe { get; set; }
+
+        public ITestEngine TestEngine { get; set; }
+
+        public Mock<IVBEInteraction> VbeInteraction { get; } = new Mock<IVBEInteraction>();
+
+        public Mock<ITypeLibWrapper> TypeLib { get; } = new Mock<ITypeLibWrapper>();
+
+        public Mock<IUiDispatcher> Dispatcher { get; } = new Mock<IUiDispatcher>();
+
+        public Mock<ITypeLibWrapperProvider> WrapperProvider { get; } = new Mock<ITypeLibWrapperProvider>();
+
+        public static string GetTestMethod(int number, bool ignored = false, string category = null) =>
+            category is null 
+                ? string.Format(ignored ? IgnoredTestTemplate : TestMethodTemplate, number) 
+                : string.Format(ignored ? IgnoredTestCategoryTemplate : TestMethodCategoryTemplate, number, category);
+
+        public void SetupAssertCompleted(Action action)
+        {
+            if (action is null)
+            {
+                VbeInteraction.Setup(ia => ia.RunTestMethod(TypeLib.Object, It.IsAny<TestMethod>(), It.IsAny<EventHandler<AssertCompletedEventArgs>>(), out _durationStub))
+                    .Verifiable();
+                return;
+            }
+
+            var callback = GetAssertCompletedCallback(action);
+
+            VbeInteraction
+                .Setup(ia => ia.RunTestMethod(TypeLib.Object, It.IsAny<TestMethod>(), It.IsAny<EventHandler<AssertCompletedEventArgs>>(), out _durationStub))
+                .Callback(callback)
+                .Verifiable();
+        }
+
+        [SuppressMessage("ReSharper", "ImplicitlyCapturedClosure")] //This is fine - the closures' lifespan is limited to the test.
+        public void SetupAssertCompleted(TestMethod testMethod, TestResult result)
+        {
+            Action action;
+            switch (result.Outcome)
+            {
+                // Tests involving this case have concurrency issues when the UIDispatcher is mocked. The callbacks in production
+                // are moderated by flushing the message queue. There is no way to mock this behavior because in the testing environment
+                // there is no STA boundary being crossed, so the internal implementation of the AssertHandler is not constrained by
+                // the rental context that would normally be managed by Interop. These tests *do* pass as of the commit that adds them,
+                // but only if the context is force by running them through the debugger. Leaving these in as commented code mainly for
+                // the purpose of documenting this. Single asserts are fine.
+
+                //case TestOutcome.SpectacularFail:
+                //    action = () =>
+                //    {
+                //        for (var failure = 0; failure < 10; failure++)
+                //        {
+                //            AssertHandler.OnAssertFailed(result.Output, testMethod.Declaration.IdentifierName);
+                //        }
+                //    };
+                //    break;
+                case TestOutcome.Failed:
+                    action = () => AssertHandler.OnAssertFailed(result.Output, testMethod.Declaration.IdentifierName);
+                    break;
+                case TestOutcome.Inconclusive:
+                    action = () => AssertHandler.OnAssertInconclusive(result.Output);
+                    break;
+                case TestOutcome.Succeeded:
+                    action = AssertHandler.OnAssertSucceeded;
+                    break;
+                default:
+                    action = () => { };
+                    break;
+            }
+
+            var callback = new RunTestMethodCallback((ITypeLibWrapper _, TestMethod method, EventHandler<AssertCompletedEventArgs> assertHandler, out long duration) =>
+            {
+                duration = 0;
+                AssertHandler.OnAssertCompleted += assertHandler;
+                action.Invoke();
+                AssertHandler.OnAssertCompleted -= assertHandler;
+            });
+
+            VbeInteraction
+                .Setup(ia => ia.RunTestMethod(TypeLib.Object, It.Is<TestMethod>(test => testMethod.Equals(test)), It.IsAny<EventHandler<AssertCompletedEventArgs>>(), out _durationStub))
+                .Callback(callback)
+                .Verifiable();
+        }
+
+        public RunTestMethodCallback GetAssertCompletedCallback(Action action)
+        {
+            return (ITypeLibWrapper _, TestMethod method, EventHandler<AssertCompletedEventArgs> assertHandler, out long duration) =>
+            {
+                duration = 0;
+                AssertHandler.OnAssertCompleted += assertHandler;
+                action.Invoke();
+                AssertHandler.OnAssertCompleted -= assertHandler;
+            };
+        }
+
+        public void Dispose()
+        {
+            ParserState?.Dispose();
+        }
+
+        public const string TestModuleHeader = @"Option Explicit
+Option Private Module
+
+'@TestModule
+
+Private Assert As Object
+
+'@ModuleInitialize
+Public Sub ModuleInitialize()
+    'this method runs once per module.
+    Assert = CreateObject(""Rubberduck.AssertClass"")
+End Sub
+
+'@ModuleCleanup
+Public Sub ModuleCleanup()
+    'this method runs once per module.
+End Sub
+
+'@TestInitialize
+Public Sub TestInitialize()
+    'this method runs before every test in the module.
+End Sub
+
+'@TestCleanup
+Public Sub TestCleanup()
+    'this method runs after every test in the module.
+End Sub
+";
+    }
+}

RubberduckTests/UnitTesting/MockedTestEngine.cs

@@ -0,0 +1,36 @@
+using System;
+using Moq;
+using Rubberduck.Common;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.UnitTesting;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+
+namespace RubberduckTests.UnitTesting
+{
+    internal class MockedTestExplorer : IDisposable
+    {
+        public MockedTestExplorer(MockedTestExplorerModel model)
+        {
+            Vbe = model.Engine.Vbe.Object;
+            State = model.Engine.ParserState;
+            Model = model.Model;
+            ViewModel = new TestExplorerViewModel(State.ProjectsProvider, Model, ClipboardWriter.Object, null, null);
+        }
+
+        public RubberduckParserState State { get; set; }
+
+        public IVBE Vbe { get; }
+
+        public TestExplorerViewModel ViewModel { get; set; }
+
+        public TestExplorerModel Model { get; set; }
+
+        public Mock<IClipboardWriter> ClipboardWriter { get; } = new Mock<IClipboardWriter>();
+
+        public void Dispose()
+        {
+            Model?.Dispose();
+            ViewModel?.Dispose();
+        }
+    }
+}

RubberduckTests/UnitTesting/MockedTestExplorer.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Rubberduck.UI.UnitTesting;
+using Rubberduck.UnitTesting;
+
+namespace RubberduckTests.UnitTesting
+{
+    internal class MockedTestExplorerModel : IDisposable
+    {
+        public MockedTestExplorerModel(MockedTestEngine engine)
+        {
+            Engine = engine;
+            Model = new TestExplorerModel(Engine.TestEngine);
+        }
+
+        public MockedTestExplorerModel(List<(TestOutcome Outcome, string Output, long duration)> results)
+        {
+            var code = string.Join(Environment.NewLine,
+                Enumerable.Range(1, results.Count).Select(num =>
+                    MockedTestEngine.GetTestMethod(num, results[num - 1].Outcome == TestOutcome.Ignored)));
+
+            Engine = new MockedTestEngine(code);
+            Model = new TestExplorerModel(Engine.TestEngine);
+            Engine.ParserState.OnParseRequested(this);
+
+            var testMethodCount = results.Count;
+            var testMethods = Engine.TestEngine.Tests.ToList();
+
+            if (testMethods.Count != testMethodCount)
+            {
+                Assert.Inconclusive("Test setup failure.");
+            }
+
+            for (var test = 0; test < results.Count; test++)
+            {
+                var (outcome, output, duration) = results[test];
+                Engine.SetupAssertCompleted(testMethods[test], new TestResult(outcome, output, duration));
+            }
+        }
+
+        public TestExplorerModel Model { get; set; }
+
+        public MockedTestEngine Engine { get; set; }
+
+        public void Dispose()
+        {
+            Engine?.Dispose();
+            Model?.Dispose();
+        }
+    }
+}