/// <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) { Task.Run(() => { try { // Initialize extension before discovery this.InitializeExtensions(discoveryCriteria.Sources); discoveryCriteria.UpdateDiscoveryCriteria(testHostManager); this.discoveryManager.DiscoverTests(discoveryCriteria, eventHandler); } catch (Exception exception) { EqtTrace.Error("InProcessProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception); // Send a discovery complete to caller. eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.ToString()); var discoveryCompeleteEventsArg = new DiscoveryCompleteEventArgs(-1, true); eventHandler.HandleDiscoveryComplete(discoveryCompeleteEventsArg, Enumerable.Empty <TestCase>()); } }); }
/// <inheritdoc/> public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 discoveryEventsHandler) { try { this.communicationManager.SendMessage(MessageType.StartDiscovery, discoveryCriteria, version: this.protocolVersion); var isDiscoveryComplete = false; // Cycle through the messages that the testhost sends. // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification. while (!isDiscoveryComplete) { var rawMessage = this.TryReceiveRawMessage(); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("Received message: {0}", rawMessage); } // Send raw message first to unblock handlers waiting to send message to IDEs discoveryEventsHandler.HandleRawMessage(rawMessage); var message = this.dataSerializer.DeserializeMessage(rawMessage); if (string.Equals(MessageType.TestCasesFound, message.MessageType)) { var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(message); discoveryEventsHandler.HandleDiscoveredTests(testCases); } else if (string.Equals(MessageType.DiscoveryComplete, message.MessageType)) { var discoveryCompletePayload = this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(message); var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted, discoveryCompletePayload.Metrics); discoveryEventsHandler.HandleDiscoveryComplete( discoveryCompleteEventArgs, discoveryCompletePayload.LastDiscoveredTests); isDiscoveryComplete = true; } else if (string.Equals(MessageType.TestMessage, message.MessageType)) { var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message); discoveryEventsHandler.HandleLogMessage( testMessagePayload.MessageLevel, testMessagePayload.Message); } } } catch (Exception ex) { this.OnDiscoveryAbort(discoveryEventsHandler, ex); } }
private void OnDiscoveryMessageReceived(ITestDiscoveryEventsHandler2 discoveryEventsHandler, MessageReceivedEventArgs args) { try { var rawMessage = args.Data; // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification. if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("TestRequestSender.OnDiscoveryMessageReceived: Received message: {0}", rawMessage); } // Send raw message first to unblock handlers waiting to send message to IDEs discoveryEventsHandler.HandleRawMessage(rawMessage); var data = this.dataSerializer.DeserializeMessage(rawMessage); switch (data.MessageType) { case MessageType.TestCasesFound: var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(data); discoveryEventsHandler.HandleDiscoveredTests(testCases); break; case MessageType.DiscoveryComplete: var discoveryCompletePayload = this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(data); var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted); discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics; discoveryEventsHandler.HandleDiscoveryComplete( discoveryCompleteEventArgs, discoveryCompletePayload.LastDiscoveredTests); this.SetOperationComplete(); break; case MessageType.TestMessage: var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>( data); discoveryEventsHandler.HandleLogMessage( testMessagePayload.MessageLevel, testMessagePayload.Message); break; } } catch (Exception ex) { this.OnDiscoveryAbort(discoveryEventsHandler, ex, false); } }
/// <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) { try { var discoveryEngineStartTime = DateTime.UtcNow; this.isCommunicationEstablished = this.SetupChannel(discoveryCriteria.Sources, this.cancellationTokenSource.Token); if (this.isCommunicationEstablished) { this.InitializeExtensions(discoveryCriteria.Sources); discoveryCriteria.UpdateDiscoveryCriteria(testHostManager); // Collecting Time Taken to Start Discovery Engine var discoveryEngineTotalTime = DateTime.UtcNow - discoveryEngineStartTime; this.requestData.MetricsCollection.Add(TelemetryDataConstants.TimeTakenInSecToStartDiscoveryEngine, discoveryEngineTotalTime.TotalSeconds.ToString()); this.RequestSender.DiscoverTests(discoveryCriteria, eventHandler); } } 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.Message }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload); eventHandler.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. eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message); var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(-1, true); eventHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, new List <ObjectModel.TestCase>()); } }
private void OnDiscoveryAbort(ITestDiscoveryEventsHandler2 eventHandler, Exception exception) { try { 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 var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true, null); eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null); this.CleanupCommunicationIfProcessExit(); } catch (Exception ex) { EqtTrace.Error(ex); throw ex; } }
/// <inheritdoc /> public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 discoveryEventsHandler) { this.messageEventHandler = discoveryEventsHandler; this.onDisconnected = (disconnectedEventArgs) => { this.OnDiscoveryAbort(discoveryEventsHandler, disconnectedEventArgs.Error, true); }; this.onMessageReceived = (sender, args) => { try { var rawMessage = args.Data; // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification. if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("TestRequestSender: Received message: {0}", rawMessage); } // Send raw message first to unblock handlers waiting to send message to IDEs discoveryEventsHandler.HandleRawMessage(rawMessage); var data = this.dataSerializer.DeserializeMessage(rawMessage); switch (data.MessageType) { case MessageType.TestCasesFound: var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(data); discoveryEventsHandler.HandleDiscoveredTests(testCases); break; case MessageType.DiscoveryComplete: var discoveryCompletePayload = this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(data); var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted, discoveryCompletePayload.Metrics); discoveryEventsHandler.HandleDiscoveryComplete( discoveryCompleteEventsArgs, discoveryCompletePayload.LastDiscoveredTests); this.SetOperationComplete(); break; case MessageType.TestMessage: var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>( data); discoveryEventsHandler.HandleLogMessage( testMessagePayload.MessageLevel, testMessagePayload.Message); break; } } catch (Exception ex) { this.OnDiscoveryAbort(discoveryEventsHandler, ex, false); } }; this.channel.MessageReceived += this.onMessageReceived; var message = this.dataSerializer.SerializePayload( MessageType.StartDiscovery, discoveryCriteria, this.protocolVersion); this.channel.Send(message); }
private async Task SendMessageAndListenAndReportTestCasesAsync(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 eventHandler) { try { this.communicationManager.SendMessage( MessageType.StartDiscovery, new DiscoveryRequestPayload() { Sources = sources, RunSettings = runSettings, TestPlatformOptions = options }, this.protocolVersion); var isDiscoveryComplete = false; // Cycle through the messages that the vstest.console sends. // Currently each of the operations are not separate tasks since they should not each take much time. // This is just a notification. while (!isDiscoveryComplete) { var message = await this.TryReceiveMessageAsync(); if (string.Equals(MessageType.TestCasesFound, message.MessageType)) { var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(message); eventHandler.HandleDiscoveredTests(testCases); } else if (string.Equals(MessageType.DiscoveryComplete, message.MessageType)) { if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("VsTestConsoleRequestSender.SendMessageAndListenAndReportTestCasesAsync: Discovery complete."); } var discoveryCompletePayload = this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(message); var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted); // Adding Metrics from VsTestConsole discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics; eventHandler.HandleDiscoveryComplete( discoveryCompleteEventArgs, discoveryCompletePayload.LastDiscoveredTests); isDiscoveryComplete = true; } else if (string.Equals(MessageType.TestMessage, message.MessageType)) { var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message); eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message); } } } catch (Exception exception) { EqtTrace.Error("Aborting Test Discovery Operation: {0}", exception); eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsDiscovery); var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true); eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null); // Earlier we were closing the connection with vstest.console in case of exceptions // Removing that code because vstest.console might be in a healthy state and letting the client // know of the error, so that the TL can wait for the next instruction from the client itself. // Also, connection termination might not kill the process which could result in files being locked by testhost. } this.testPlatformEventSource.TranslationLayerDiscoveryStop(); }
private async Task SendMessageAndListenAndReportTestCasesAsync(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 eventHandler) { try { this.communicationManager.SendMessage( MessageType.StartDiscovery, new DiscoveryRequestPayload() { Sources = sources, RunSettings = runSettings, TestPlatformOptions = options }, this.protocolVersion); var isDiscoveryComplete = false; // Cycle through the messages that the vstest.console sends. // Currently each of the operations are not separate tasks since they should not each take much time. // This is just a notification. while (!isDiscoveryComplete) { var message = await this.TryReceiveMessageAsync(); if (string.Equals(MessageType.TestCasesFound, message.MessageType)) { var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(message); eventHandler.HandleDiscoveredTests(testCases); } else if (string.Equals(MessageType.DiscoveryComplete, message.MessageType)) { var discoveryCompletePayload = this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(message); var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted); // Adding Metrics from VsTestConsole discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics; eventHandler.HandleDiscoveryComplete( discoveryCompleteEventArgs, discoveryCompletePayload.LastDiscoveredTests); isDiscoveryComplete = true; } else if (string.Equals(MessageType.TestMessage, message.MessageType)) { var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message); eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message); } } } catch (Exception exception) { EqtTrace.Error("Aborting Test Discovery Operation: {0}", exception); eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsDiscovery); var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true); eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null); CleanupCommunicationIfProcessExit(); } this.testPlatformEventSource.TranslationLayerDiscoveryStop(); }