예제 #1
0
        public void DiscoverTestsShouldCallHandleDiscoveryCompleteOnDiscoveryCompletion()
        {
            var sources = new List <string>()
            {
                "Hello", "World"
            };
            string settingsXml       = "SettingsXml";
            var    mockHandler       = new Mock <ITestDiscoveryEventsHandler>();
            var    discoveryCriteria = new DiscoveryCriteria(sources, 100, settingsXml);

            var rawMessage      = "RunComplete";
            var completePayload = new DiscoveryCompletePayload()
            {
                IsAborted           = false,
                LastDiscoveredTests = null,
                TotalTests          = 1
            };
            var message = new Message()
            {
                MessageType = MessageType.DiscoveryComplete, Payload = null
            };

            this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
            this.mockDataSerializer.Setup(ds => ds.DeserializePayload <DiscoveryCompletePayload>(message)).Returns(completePayload);

            this.testRequestSender.DiscoverTests(discoveryCriteria, mockHandler.Object);

            this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartDiscovery, discoveryCriteria, this.protocolConfig.Version), Times.Once);
            this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Once);
            mockHandler.Verify(mh => mh.HandleDiscoveryComplete(1, null, false), Times.Once);
            mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Once);
        }
예제 #2
0
        private void StartDiscovery(DiscoveryRequestPayload discoveryRequestPayload, ITestRequestManager testRequestManager)
        {
            Task.Run(
                delegate
            {
                try
                {
                    testRequestManager.ResetOptions();
                    testRequestManager.DiscoverTests(discoveryRequestPayload, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Exception in StartDiscovery: " + ex);

                    // If there is an exception during test discovery request creation or some time during the process
                    // In such cases, TestPlatform will never send a DiscoveryComplete event and IDE need to be sent a discovery complete message
                    // We need recoverability in translationlayer-designmode scenarios
                    var testMessagePayload = new TestMessagePayload {
                        MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
                    };
                    this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);

                    var payload = new DiscoveryCompletePayload()
                    {
                        IsAborted           = true,
                        LastDiscoveredTests = null,
                        TotalTests          = -1
                    };

                    // Send run complete to translation layer
                    this.communicationManager.SendMessage(MessageType.DiscoveryComplete, payload);
                }
            });
        }
        public void DiscoveryManagerShouldPassOnHandleDiscoveredTests()
        {
            Mock <ITestDiscoveryEventsHandler2> mockTestDiscoveryEventsHandler = new Mock <ITestDiscoveryEventsHandler2>();
            var testCases = new List <TestCase>()
            {
                new TestCase("x.y.z", new Uri("x://y"), "x.dll")
            };

            this.testDiscoveryManager = this.GetProxyDiscoveryManager();
            this.SetupChannelMessage(MessageType.StartDiscovery, MessageType.TestCasesFound, testCases);

            var completePayload = new DiscoveryCompletePayload()
            {
                IsAborted           = false,
                LastDiscoveredTests = null,
                TotalTests          = 1
            };
            var completeMessage = new Message()
            {
                MessageType = MessageType.DiscoveryComplete, Payload = null
            };

            mockTestDiscoveryEventsHandler.Setup(mh => mh.HandleDiscoveredTests(It.IsAny <IEnumerable <TestCase> >())).Callback(
                () =>
            {
                this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
                this.mockDataSerializer.Setup(ds => ds.DeserializePayload <DiscoveryCompletePayload>(completeMessage)).Returns(completePayload);
            });

            // Act.
            this.testDiscoveryManager.DiscoverTests(this.discoveryCriteria, mockTestDiscoveryEventsHandler.Object);

            // Verify
            mockTestDiscoveryEventsHandler.Verify(mtdeh => mtdeh.HandleDiscoveredTests(It.IsAny <IEnumerable <TestCase> >()), Times.AtLeastOnce);
        }
예제 #4
0
        public void DiscoverTestsShouldCollectMetricsOnHandleDiscoveryComplete()
        {
            var dict = new Dictionary <string, string>();

            dict.Add("DummyMessage", "DummyValue");

            var mockHandler     = new Mock <ITestDiscoveryEventsHandler2>();
            var completePayload = new DiscoveryCompletePayload()
            {
                IsAborted           = false,
                LastDiscoveredTests = null,
                TotalTests          = 1,
                Metrics             = dict
            };

            this.SetupDeserializeMessage(MessageType.DiscoveryComplete, completePayload);
            this.SetupFakeCommunicationChannel();

            DiscoveryCompleteEventArgs actualDiscoveryCompleteEventArgs = null;

            mockHandler.Setup(md => md.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), null))
            .Callback <DiscoveryCompleteEventArgs, IEnumerable <TestCase> >(
                (discoveryCompleteEventArgs, testCase) =>
            {
                actualDiscoveryCompleteEventArgs = discoveryCompleteEventArgs;
            });

            // Act.
            this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), mockHandler.Object);
            this.RaiseMessageReceivedEvent();

            // Verify
            Assert.AreEqual(dict, actualDiscoveryCompleteEventArgs.Metrics);
        }
        private void OnDiscoveryAbort(ITestDiscoveryEventsHandler eventHandler)
        {
            // Log to vstest console
            eventHandler.HandleLogMessage(TestMessageLevel.Error, CommonResources.AbortedTestDiscovery);

            // Log to vs ide test output
            var testMessagePayload = new TestMessagePayload {
                MessageLevel = TestMessageLevel.Error, Message = CommonResources.AbortedTestDiscovery
            };
            var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);

            eventHandler.HandleRawMessage(rawMessage);

            // Notify discovery abort to IDE test output
            var payload = new DiscoveryCompletePayload()
            {
                IsAborted           = true,
                LastDiscoveredTests = null,
                TotalTests          = -1
            };

            rawMessage = this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, payload);
            eventHandler.HandleRawMessage(rawMessage);

            // Complete discovery
            eventHandler.HandleDiscoveryComplete(-1, null, true);

            this.CleanupCommunicationIfProcessExit();
        }
예제 #6
0
        private void OnDiscoveryAbort(ITestDiscoveryEventsHandler2 eventHandler, Exception exception, bool getClientError)
        {
            if (this.IsOperationComplete())
            {
                EqtTrace.Verbose("TestRequestSender: OnDiscoveryAbort: Operation is already complete. Skip error message.");
                return;
            }

            EqtTrace.Verbose("TestRequestSender: OnDiscoveryAbort: Set operation complete.");
            this.SetOperationComplete();

            var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true);
            var reason = this.GetAbortErrorMessage(exception, getClientError);

            EqtTrace.Error("TestRequestSender: Aborting test discovery because {0}", reason);
            this.LogErrorMessage(string.Format(CommonResources.AbortedTestDiscovery, reason));

            // Notify discovery abort to IDE test output
            var payload = new DiscoveryCompletePayload()
            {
                IsAborted           = true,
                LastDiscoveredTests = null,
                TotalTests          = -1
            };
            var rawMessage = this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, payload);

            eventHandler.HandleRawMessage(rawMessage);

            // Complete discovery
            eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null);
        }
예제 #7
0
        private void OnDiscoveryAbort(ITestDiscoveryEventsHandler eventHandler, Exception exception)
        {
            EqtTrace.Error("Server: TestExecution: Aborting test discovery because {0}", exception);

            var reason = string.Format(CommonResources.AbortedTestDiscovery, exception?.Message);

            // Log to vstest console
            eventHandler.HandleLogMessage(TestMessageLevel.Error, reason);

            // Log to vs ide test output
            var testMessagePayload = new TestMessagePayload {
                MessageLevel = TestMessageLevel.Error, Message = reason
            };
            var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);

            eventHandler.HandleRawMessage(rawMessage);

            // Notify discovery abort to IDE test output
            var payload = new DiscoveryCompletePayload()
            {
                IsAborted           = true,
                LastDiscoveredTests = null,
                TotalTests          = -1
            };

            rawMessage = this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, payload);
            eventHandler.HandleRawMessage(rawMessage);

            // Complete discovery
            eventHandler.HandleDiscoveryComplete(-1, null, true);

            this.CleanupCommunicationIfProcessExit();
        }
예제 #8
0
        private void StartDiscovery(DiscoveryRequestPayload discoveryRequestPayload, ITestRequestManager testRequestManager)
        {
            Task.Run(
                delegate
            {
                try
                {
                    testRequestManager.ResetOptions();
                    testRequestManager.DiscoverTests(discoveryRequestPayload, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Exception in StartDiscovery: " + ex);

                    var testMessagePayload = new TestMessagePayload {
                        MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
                    };
                    this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);

                    var payload = new DiscoveryCompletePayload()
                    {
                        IsAborted           = true,
                        LastDiscoveredTests = null,
                        TotalTests          = -1
                    };

                    // Send run complete to translation layer
                    this.communicationManager.SendMessage(MessageType.DiscoveryComplete, payload);
                }
            });
        }
예제 #9
0
        /// <inheritdoc/>
        public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
        {
            var totalTests = discoveryCompleteEventArgs.TotalCount;
            var isAborted  = discoveryCompleteEventArgs.IsAborted;

            // we get discovery complete events from each host process
            // so we cannot "complete" the actual operation until all sources are consumed
            // We should not block last chunk results while we aggregate overall discovery data
            if (lastChunk != null)
            {
                ConvertToRawMessageAndSend(MessageType.TestCasesFound, lastChunk);
                this.HandleDiscoveredTests(lastChunk);
            }

            // Aggregate for final discovery complete
            discoveryDataAggregator.Aggregate(totalTests, isAborted);

            // Aggregate Discovery Data Metrics
            discoveryDataAggregator.AggregateDiscoveryDataMetrics(discoveryCompleteEventArgs.Metrics);

            // Do not send TestDiscoveryComplete to actual test discovery handler
            // We need to see if there are still sources left - let the parallel manager decide
            var parallelDiscoveryComplete = this.parallelProxyDiscoveryManager.HandlePartialDiscoveryComplete(
                this.proxyDiscoveryManager,
                totalTests,
                null,     // lastChunk should be null as we already sent this data above
                isAborted);

            if (parallelDiscoveryComplete)
            {
                // In case of sequential discovery - RawMessage would have contained a 'DiscoveryCompletePayload' object
                // To send a raw message - we need to create raw message from an aggregated payload object
                var testDiscoveryCompletePayload = new DiscoveryCompletePayload()
                {
                    TotalTests          = discoveryDataAggregator.TotalTests,
                    IsAborted           = discoveryDataAggregator.IsAborted,
                    LastDiscoveredTests = null
                };

                // Collecting Final Discovery State
                this.requestData.MetricsCollection.Add(TelemetryDataConstants.DiscoveryState, isAborted ? "Aborted" : "Completed");

                // Collect Aggregated Metrics Data
                var aggregatedDiscoveryDataMetrics = discoveryDataAggregator.GetAggregatedDiscoveryDataMetrics();
                testDiscoveryCompletePayload.Metrics = aggregatedDiscoveryDataMetrics;

                // we have to send raw messages as we block the discovery complete actual raw messages
                this.ConvertToRawMessageAndSend(MessageType.DiscoveryComplete, testDiscoveryCompletePayload);

                var finalDiscoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(this.discoveryDataAggregator.TotalTests,
                                                                                     this.discoveryDataAggregator.IsAborted);
                finalDiscoveryCompleteEventArgs.Metrics = aggregatedDiscoveryDataMetrics;

                // send actual test discovery complete to clients
                this.actualDiscoveryEventsHandler.HandleDiscoveryComplete(finalDiscoveryCompleteEventArgs, null);
            }
        }
예제 #10
0
        /// <inheritdoc/>
        public void DiscoveryComplete(long totalTests, IEnumerable <TestCase> lastChunk, bool isAborted)
        {
            var discoveryCompletePayload = new DiscoveryCompletePayload
            {
                TotalTests          = totalTests,
                LastDiscoveredTests = isAborted ? null : lastChunk,
                IsAborted           = isAborted
            };

            this.communicationManager.SendMessage(MessageType.DiscoveryComplete, discoveryCompletePayload, this.protocolVersion);
        }
예제 #11
0
        /// <inheritdoc/>
        public void DiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
        {
            var discoveryCompletePayload = new DiscoveryCompletePayload
            {
                TotalTests          = discoveryCompleteEventArgs.TotalCount,
                LastDiscoveredTests = discoveryCompleteEventArgs.IsAborted ? null : lastChunk,
                IsAborted           = discoveryCompleteEventArgs.IsAborted,
                Metrics             = discoveryCompleteEventArgs.Metrics
            };

            this.communicationManager.SendMessage(MessageType.DiscoveryComplete, discoveryCompletePayload, this.protocolVersion);
        }
예제 #12
0
        public void DiscoveryCompleteShouldSendDiscoveryCompletePayloadOnChannel()
        {
            var discoveryComplete = new DiscoveryCompletePayload { TotalTests = 1, LastDiscoveredTests = Enumerable.Empty<TestCase>(), IsAborted = false };
            var message = this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, discoveryComplete);
            this.SetupChannel();

            this.ProcessRequestsAsync(this.mockTestHostManagerFactory.Object);

            this.requestHandler.DiscoveryComplete(new DiscoveryCompleteEventArgs(discoveryComplete.TotalTests, discoveryComplete.IsAborted), discoveryComplete.LastDiscoveredTests);

            this.VerifyResponseMessageEquals(message);
            this.SendSessionEnd();
        }
예제 #13
0
        public void DiscoverTestsShouldNotifyDiscoveryCompleteOnCompleteMessageReceived()
        {
            var completePayload = new DiscoveryCompletePayload {
                TotalTests = 10, IsAborted = false
            };

            this.SetupDeserializeMessage(MessageType.DiscoveryComplete, completePayload);
            this.SetupFakeCommunicationChannel();

            this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), this.mockDiscoveryEventsHandler.Object);

            this.RaiseMessageReceivedEvent();
            this.mockDiscoveryEventsHandler.Verify(eh => eh.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), null));
        }
예제 #14
0
        public void DiscoverTestsShouldCallHandleLogMessageOnTestMessage()
        {
            var sources = new List <string>()
            {
                "Hello", "World"
            };
            string settingsXml       = "SettingsXml";
            var    mockHandler       = new Mock <ITestDiscoveryEventsHandler>();
            var    discoveryCriteria = new DiscoveryCriteria(sources, 100, settingsXml);

            var rawMessage     = "TestMessage";
            var messagePayload = new TestMessagePayload()
            {
                MessageLevel = TestMessageLevel.Error, Message = rawMessage
            };
            var message = new Message()
            {
                MessageType = MessageType.TestMessage, Payload = null
            };

            this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
            this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestMessagePayload>(message)).Returns(messagePayload);


            var completePayload = new DiscoveryCompletePayload()
            {
                IsAborted           = false,
                LastDiscoveredTests = null,
                TotalTests          = 1
            };
            var completeMessage = new Message()
            {
                MessageType = MessageType.DiscoveryComplete, Payload = null
            };

            mockHandler.Setup(mh => mh.HandleLogMessage(TestMessageLevel.Error, rawMessage)).Callback(
                () =>
            {
                this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
                this.mockDataSerializer.Setup(ds => ds.DeserializePayload <DiscoveryCompletePayload>(completeMessage)).Returns(completePayload);
            });

            this.testRequestSender.DiscoverTests(discoveryCriteria, mockHandler.Object);

            this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartDiscovery, discoveryCriteria), Times.Once);
            this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Exactly(2));
            mockHandler.Verify(mh => mh.HandleLogMessage(TestMessageLevel.Error, rawMessage), Times.Once);
            mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Exactly(2));
        }
예제 #15
0
        public void DiscoverTestsShouldStopServerOnCompleteMessageReceived()
        {
            var completePayload = new DiscoveryCompletePayload {
                TotalTests = 10, IsAborted = false
            };

            this.SetupDeserializeMessage(MessageType.DiscoveryComplete, completePayload);
            this.SetupFakeCommunicationChannel();

            this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), this.mockDiscoveryEventsHandler.Object);

            this.RaiseMessageReceivedEvent();

            this.mockServer.Verify(ms => ms.Stop());
        }
예제 #16
0
        public void DiscoverTestsShouldCallHandleDiscoveredTestsOnTestCaseEvent()
        {
            var sources = new List <string>()
            {
                "Hello", "World"
            };
            string settingsXml       = "SettingsXml";
            var    mockHandler       = new Mock <ITestDiscoveryEventsHandler>();
            var    discoveryCriteria = new DiscoveryCriteria(sources, 100, settingsXml);

            var testCases = new List <TestCase>()
            {
                new TestCase("x.y.z", new Uri("x://y"), "x.dll")
            };
            var rawMessage = "OnDiscoveredTests";
            var message    = new Message()
            {
                MessageType = MessageType.TestCasesFound, Payload = null
            };

            this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
            this.mockDataSerializer.Setup(ds => ds.DeserializePayload <IEnumerable <TestCase> >(message)).Returns(testCases);

            var completePayload = new DiscoveryCompletePayload()
            {
                IsAborted           = false,
                LastDiscoveredTests = null,
                TotalTests          = 1
            };
            var completeMessage = new Message()
            {
                MessageType = MessageType.DiscoveryComplete, Payload = null
            };

            mockHandler.Setup(mh => mh.HandleDiscoveredTests(testCases)).Callback(
                () =>
            {
                this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
                this.mockDataSerializer.Setup(ds => ds.DeserializePayload <DiscoveryCompletePayload>(completeMessage)).Returns(completePayload);
            });

            this.testRequestSender.DiscoverTests(discoveryCriteria, mockHandler.Object);

            this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartDiscovery, discoveryCriteria, this.protocolConfig.Version), Times.Once);
            this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Exactly(2));
            mockHandler.Verify(mh => mh.HandleDiscoveredTests(testCases), Times.Once);
            mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Exactly(2));
        }
예제 #17
0
        public void DiscoverTestsShouldNotAbortDiscoveryIfClientDisconnectedAndOperationIsComplete()
        {
            var completePayload = new DiscoveryCompletePayload {
                TotalTests = 10, IsAborted = false
            };

            this.SetupDeserializeMessage(MessageType.DiscoveryComplete, completePayload);
            this.SetupFakeCommunicationChannel();
            this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), this.mockDiscoveryEventsHandler.Object);
            this.RaiseMessageReceivedEvent();   // Raise discovery complete

            this.RaiseClientDisconnectedEvent();

            this.mockDiscoveryEventsHandler.Verify(eh => eh.HandleLogMessage(TestMessageLevel.Error, It.IsAny <string>()), Times.Never);
            this.mockDiscoveryEventsHandler.Verify(eh => eh.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), null), Times.Once);
        }
예제 #18
0
        /// <summary>
        /// Handles LoggerManager's DiscoveryComplete.
        /// </summary>
        /// <param name="discoveryCompletePayload">Discovery complete payload.</param>
        private void HandleLoggerManagerDiscoveryComplete(DiscoveryCompletePayload discoveryCompletePayload)
        {
            if (this.LoggerManager.LoggersInitialized && discoveryCompletePayload != null)
            {
                // Send last chunk to logger manager.
                if (discoveryCompletePayload.LastDiscoveredTests != null)
                {
                    var discoveredTestsEventArgs = new DiscoveredTestsEventArgs(discoveryCompletePayload.LastDiscoveredTests);
                    this.LoggerManager.HandleDiscoveredTests(discoveredTestsEventArgs);
                }

                // Send discovery complete to logger manager.
                var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted);
                discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics;
                this.LoggerManager.HandleDiscoveryComplete(discoveryCompleteEventArgs);
            }
        }
예제 #19
0
        /// <summary>
        /// Update raw message with telemetry info.
        /// </summary>
        /// <param name="discoveryCompletePayload">Discovery complete payload.</param>
        /// <param name="message">Message.</param>
        /// <returns>Updated rawMessage.</returns>
        private string UpdateRawMessageWithTelemetryInfo(DiscoveryCompletePayload discoveryCompletePayload, Message message)
        {
            var rawMessage = default(string);

            if (this.requestData.IsTelemetryOptedIn)
            {
                if (discoveryCompletePayload != null)
                {
                    if (discoveryCompletePayload.Metrics == null)
                    {
                        discoveryCompletePayload.Metrics = this.requestData.MetricsCollection.Metrics;
                    }
                    else
                    {
                        foreach (var kvp in this.requestData.MetricsCollection.Metrics)
                        {
                            discoveryCompletePayload.Metrics[kvp.Key] = kvp.Value;
                        }
                    }

                    var discoveryFinalTimeTakenForDesignMode = DateTime.UtcNow - this.discoveryStartTime;

                    // Collecting Total Time Taken
                    discoveryCompletePayload.Metrics[TelemetryDataConstants.TimeTakenInSecForDiscovery] = discoveryFinalTimeTakenForDesignMode.TotalSeconds;
                }

                if (message is VersionedMessage message1)
                {
                    var version = message1.Version;

                    rawMessage = this.dataSerializer.SerializePayload(
                        MessageType.DiscoveryComplete,
                        discoveryCompletePayload,
                        version);
                }
                else
                {
                    rawMessage = this.dataSerializer.SerializePayload(
                        MessageType.DiscoveryComplete,
                        discoveryCompletePayload);
                }
            }

            return(rawMessage);
        }
        /// <summary>
        /// Discovers tests
        /// </summary>
        /// <param name="discoveryCriteria">Settings, parameters for the discovery request</param>
        /// <param name="eventHandler">EventHandler for handling discovery events from Engine</param>
        public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 eventHandler)
        {
            this.baseTestDiscoveryEventsHandler = eventHandler;
            try
            {
                this.isCommunicationEstablished = this.SetupChannel(discoveryCriteria.Sources, discoveryCriteria.RunSettings);

                if (this.isCommunicationEstablished)
                {
                    this.InitializeExtensions(discoveryCriteria.Sources);
                    discoveryCriteria.UpdateDiscoveryCriteria(testHostManager);

                    this.RequestSender.DiscoverTests(discoveryCriteria, this);
                }
            }
            catch (Exception exception)
            {
                EqtTrace.Error("ProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception);

                // Log to vs ide test output
                var testMessagePayload = new TestMessagePayload {
                    MessageLevel = TestMessageLevel.Error, Message = exception.ToString()
                };
                var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
                this.HandleRawMessage(rawMessage);

                // Log to vstest.console
                // Send a discovery complete to caller. Similar logic is also used in ParallelProxyDiscoveryManager.DiscoverTestsOnConcurrentManager
                // Aborted is `true`: in case of parallel discovery (or non shared host), an aborted message ensures another discovery manager
                // created to replace the current one. This will help if the current discovery manager is aborted due to irreparable error
                // and the test host is lost as well.
                this.HandleLogMessage(TestMessageLevel.Error, exception.ToString());

                var discoveryCompletePayload = new DiscoveryCompletePayload()
                {
                    IsAborted           = true,
                    LastDiscoveredTests = null,
                    TotalTests          = -1
                };
                this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, discoveryCompletePayload));
                var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(-1, true);

                this.HandleDiscoveryComplete(discoveryCompleteEventsArgs, new List <ObjectModel.TestCase>());
            }
        }
예제 #21
0
        public void DiscoveryManagerShouldPassOnHandleDiscoveredTests()
        {
            Mock <ITestDiscoveryEventsHandler2> mockTestDiscoveryEventsHandler = new Mock <ITestDiscoveryEventsHandler2>();

            this.mockRequestSender.Setup(s => s.WaitForRequestHandlerConnection(It.IsAny <int>())).Returns(true);
            var testCases = new List <TestCase>()
            {
                new TestCase("x.y.z", new Uri("x://y"), "x.dll")
            };
            var rawMessage = "OnDiscoveredTests";
            var message    = new Message()
            {
                MessageType = MessageType.TestCasesFound, Payload = null
            };

            this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);

            var completePayload = new DiscoveryCompletePayload()
            {
                IsAborted           = false,
                LastDiscoveredTests = null,
                TotalTests          = 1
            };
            var completeMessage = new Message()
            {
                MessageType = MessageType.DiscoveryComplete, Payload = null
            };

            mockTestDiscoveryEventsHandler.Setup(mh => mh.HandleDiscoveredTests(It.IsAny <IEnumerable <TestCase> >())).Callback(
                () =>
            {
                this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
                this.mockDataSerializer.Setup(ds => ds.DeserializePayload <DiscoveryCompletePayload>(completeMessage)).Returns(completePayload);
            });


            // Act.
            this.testDiscoveryManager.DiscoverTests(this.discoveryCriteria, mockTestDiscoveryEventsHandler.Object);

            // Verify
            mockTestDiscoveryEventsHandler.Verify(mtdeh => mtdeh.HandleDiscoveredTests(It.IsAny <IEnumerable <TestCase> >()), Times.AtLeastOnce);
        }
        /// <inheritdoc/>
        public void HandleDiscoveryComplete(long totalTests, IEnumerable <TestCase> lastChunk, bool isAborted)
        {
            // we get discovery complete events from each host process
            // so we cannot "complete" the actual operation until all sources are consumed
            // We should not block last chunk results while we aggregate overall discovery data
            if (lastChunk != null)
            {
                ConvertToRawMessageAndSend(MessageType.TestCasesFound, lastChunk);
                this.HandleDiscoveredTests(lastChunk);
            }

            // Aggregate for final discoverycomplete
            discoveryDataAggregator.Aggregate(totalTests, isAborted);

            // Do not send TestDiscoveryComplete to actual test discovery handler
            // We need to see if there are still sources left - let the parallel manager decide
            var parallelDiscoveryComplete = this.parallelProxyDiscoveryManager.HandlePartialDiscoveryComplete(
                this.proxyDiscoveryManager,
                totalTests,
                null,     // lastChunk should be null as we already sent this data above
                isAborted);

            if (parallelDiscoveryComplete)
            {
                // In case of sequential discovery - RawMessage would have contained a 'DiscoveryCompletePayload' object
                // To send a raw message - we need to create raw message from an aggregated payload object
                var testDiscoveryCompletePayload = new DiscoveryCompletePayload()
                {
                    TotalTests          = discoveryDataAggregator.TotalTests,
                    IsAborted           = discoveryDataAggregator.IsAborted,
                    LastDiscoveredTests = null
                };

                // we have to send raw messages as we block the discoverycomplete actual raw messages
                this.ConvertToRawMessageAndSend(MessageType.DiscoveryComplete, testDiscoveryCompletePayload);

                // send actual test discoverycomplete to clients
                this.actualDiscoveryEventsHandler.HandleDiscoveryComplete(discoveryDataAggregator.TotalTests, null, discoveryDataAggregator.IsAborted);
            }
        }
예제 #23
0
        public void DiscoverTestsShouldCollectMetricsOnHandleDiscoveryComplete()
        {
            var dict = new Dictionary <string, object>();

            dict.Add("DummyMessage", "DummyValue");

            var mockHandler     = new Mock <ITestDiscoveryEventsHandler2>();
            var rawMessage      = "RunComplete";
            var completePayload = new DiscoveryCompletePayload()
            {
                IsAborted           = false,
                LastDiscoveredTests = null,
                TotalTests          = 1,
                Metrics             = dict
            };
            var message = new Message()
            {
                MessageType = MessageType.DiscoveryComplete, Payload = null
            };

            this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
            this.mockDataSerializer.Setup(ds => ds.DeserializePayload <DiscoveryCompletePayload>(message)).Returns(completePayload);

            DiscoveryCompleteEventArgs actualDiscoveryCompleteEventArgs = null;

            mockHandler.Setup(md => md.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), null))
            .Callback <DiscoveryCompleteEventArgs, IEnumerable <TestCase> >(
                (discoveryCompleteEventArgs, testCase) =>
            {
                actualDiscoveryCompleteEventArgs = discoveryCompleteEventArgs;
            });

            // Act.
            this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), mockHandler.Object);

            // Verify
            Assert.AreEqual(actualDiscoveryCompleteEventArgs.Metrics, dict);
        }