private void OnDiscoveryComplete(object sender, DiscoveryCompletedEventArgs e)
        {
            if (e == null)
            {
                throw new ArgumentNullException(nameof(e));
            }

            if (!e.WasDiscoveryAborted)
            {
                var removedTestResults = new List <ITestResult>(_testResultsByTestCaseId.Count - _discoverySessionTestResultTestCaseIds.Count);
                foreach (var testResult in _testResultsByTestCaseId.Where(x => e.SourceAssemblyPaths.Contains(x.Value.TestCase.Source))
                         .Where(x => !_discoverySessionTestResultTestCaseIds.Contains(x.Value.TestCase.Id))
                         .Select(x => x.Value))
                {
                    removedTestResults.Add(testResult);
                }

                foreach (var testResult in removedTestResults)
                {
                    _testResultsByTestCaseId.Remove(testResult.TestCase.Id);
                }

                if (removedTestResults.Count > 0)
                {
                    RaiseTestResultsRemoved(removedTestResults);
                }

                _discoverySessionTestResultTestCaseIds.Clear();
            }
        }
        public void Constructor_Default_Always_SetsSourceAssemblyPathsToEmpty()
        {
            var uut = new DiscoveryCompletedEventArgs();

            var result = uut.SourceAssemblyPaths;

            CollectionAssert.IsEmpty(result);
        }
        public void Constructor_SourceAssemblyPathsWasDiscoveryAborted_Otherwise_SetsWasDiscoveryAbortedToGiven(bool wasDiscoveryAborted)
        {
            var sourceAssemblyPaths = Enumerable.Empty <string>();

            var uut = new DiscoveryCompletedEventArgs(sourceAssemblyPaths, wasDiscoveryAborted);

            var result = uut.WasDiscoveryAborted;

            Assert.AreEqual(wasDiscoveryAborted, result);
        }
        public void Constructor_SourceAssemblyPathsWasDiscoveryAborted_Otherwise_SourceAssemblyPathsIsEquivalentToGiven(int sourceAssemblyPathCount)
        {
            var sourceAssemblyPaths = Enumerable.Range(1, sourceAssemblyPathCount).Select(x => x.ToString());
            var wasDiscoveryAborted = true;

            var uut = new DiscoveryCompletedEventArgs(sourceAssemblyPaths, wasDiscoveryAborted);

            var result = uut.SourceAssemblyPaths;

            CollectionAssert.AreEquivalent(sourceAssemblyPaths, result);
        }
Beispiel #5
0
        public void HandleDiscoveryComplete_TotalTestsIsEqualToLastChunkCount_RaisesDiscoveryCompleteWithIsAbortedAsWasDiscoveryAbortedAs(bool isAborted)
        {
            var vstest = Substitute.For <IVsTestConsoleWrapper>();

            var uut = new TestCaseDiscoveryManager(vstest);

            uut.DiscoverTestCasesAsync(Enumerable.Empty <string>()).Wait();
            DiscoveryCompletedEventArgs args = null;
            var handler = Substitute.For <EventHandler <DiscoveryCompletedEventArgs> >();

            handler.When(x => x.Invoke(Arg.Any <object>(), Arg.Any <DiscoveryCompletedEventArgs>())).Do(x => args = (DiscoveryCompletedEventArgs)x[1]);
            uut.DiscoveryCompleted += handler;
            uut.HandleDiscoveryComplete(0, Enumerable.Empty <TestCase>(), isAborted);

            handler.Received(1).Invoke(uut, Arg.Any <DiscoveryCompletedEventArgs>());
            Assert.AreEqual(isAborted, args.WasDiscoveryAborted);
        }
Beispiel #6
0
        public void HandleDiscoveryComplete_LastChunkIsNull_RaisesDiscoveryCompletedWithTrueAsWasDiscoveryAborted()
        {
            var vstest = Substitute.For <IVsTestConsoleWrapper>();

            var uut = new TestCaseDiscoveryManager(vstest);

            var handler = Substitute.For <EventHandler <DiscoveryCompletedEventArgs> >();
            DiscoveryCompletedEventArgs args = null;

            handler.When(x => x.Invoke(Arg.Any <object>(), Arg.Any <DiscoveryCompletedEventArgs>())).Do(x => args = (DiscoveryCompletedEventArgs)x[1]);
            uut.DiscoveryCompleted += handler;
            uut.DiscoverTestCasesAsync(Enumerable.Empty <string>()).Wait();
            uut.HandleDiscoveryComplete(0, null, false);

            handler.Received(1).Invoke(uut, Arg.Any <DiscoveryCompletedEventArgs>());
            Assert.IsTrue(args.WasDiscoveryAborted);
        }
Beispiel #7
0
        public void HandleDiscoveryComplete_Otherwise_RaisesDiscoveryCompleteWithDiscoverTestCasesAsyncSourceAssemblyPaths()
        {
            var vstest = Substitute.For <IVsTestConsoleWrapper>();

            var uut = new TestCaseDiscoveryManager(vstest);

            var sourceAssemblyPaths = Enumerable.Repeat("DummyAssembly", 1);

            uut.DiscoverTestCasesAsync(sourceAssemblyPaths).Wait();
            DiscoveryCompletedEventArgs args = null;
            var handler = Substitute.For <EventHandler <DiscoveryCompletedEventArgs> >();

            handler.When(x => x.Invoke(Arg.Any <object>(), Arg.Any <DiscoveryCompletedEventArgs>())).Do(x => args = (DiscoveryCompletedEventArgs)x[1]);
            uut.DiscoveryCompleted += handler;
            uut.HandleDiscoveryComplete(0, Enumerable.Empty <TestCase>(), false);

            handler.Received(1).Invoke(uut, Arg.Any <DiscoveryCompletedEventArgs>());
            CollectionAssert.AreEquivalent(sourceAssemblyPaths, args.SourceAssemblyPaths);
        }
        public void Constructor_Default_Always_SetsWasDiscoveryAbortedToFalse()
        {
            var uut = new DiscoveryCompletedEventArgs();

            var result = uut.WasDiscoveryAborted;
        }