private void StartTestRunAttachmentsProcessing(TestRunAttachmentsProcessingPayload attachmentsProcessingPayload, ITestRequestManager testRequestManager) { Task.Run( () => { try { testRequestManager.ProcessTestRunAttachments(attachmentsProcessingPayload, new TestRunAttachmentsProcessingEventsHandler(this.communicationManager), this.protocolConfig); } catch (Exception ex) { EqtTrace.Error("DesignModeClient: Exception in StartTestRunAttachmentsProcessing: " + ex); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = ex.ToString() }; this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload); var payload = new TestRunAttachmentsProcessingCompletePayload() { Attachments = null }; // Send run complete to translation layer this.communicationManager.SendMessage(MessageType.TestRunAttachmentsProcessingComplete, payload); } }); }
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); } }); }
private void onTestMessageReceived(object sender, TestMessagePayload e) { if (e.MessageLevel != TestMessageLevel.Informational) { this.messageLogger.SendMessage(e.MessageLevel, e.Message); } }
internal void InvokeMessageReceived(object sender, TestMessagePayload args) { if (!this.DisableInvoke && this.onTestMessageReceived != null) { this.onTestMessageReceived.Invoke(sender, args); } }
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool skipTestHostLaunch) { Task.Run( delegate { try { testRequestManager.ResetOptions(); var customLauncher = skipTestHostLaunch ? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(this, testRunPayload) : null; testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig); } catch (Exception ex) { EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex); // If there is an exception during test run request creation or some time during the process // In such cases, TestPlatform will never send a TestRunComplete event and IDE need to be sent a run 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 runCompletePayload = new TestRunCompletePayload() { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue), LastRunTests = null }; // Send run complete to translation layer this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload); } }); }
/// <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, ITestDiscoveryEventsHandler eventHandler) { try { if (!this.testHostManager.Shared) { // If the test host doesn't support sharing across sources, we must initialize it // with sources. this.InitializeExtensions(discoveryCriteria.Sources); } this.SetupChannel(discoveryCriteria.Sources); 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 eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message); eventHandler.HandleDiscoveryComplete(0, new List <ObjectModel.TestCase>(), false); } }
private void OnTestRunAbort(ITestRunEventsHandler testRunEventsHandler, Exception exception) { EqtTrace.Error("Server: TestExecution: Aborting test run because {0}", exception); // log console message to vstest console testRunEventsHandler.HandleLogMessage(TestMessageLevel.Error, CommonResources.AbortedTestRun); // log console message to vstest console wrapper var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = CommonResources.AbortedTestRun }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload); testRunEventsHandler.HandleRawMessage(rawMessage); // notify test run abort to vstest console wrapper var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero); var payload = new TestRunCompletePayload { TestRunCompleteArgs = completeArgs }; rawMessage = this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, payload); testRunEventsHandler.HandleRawMessage(rawMessage); // notify of a test run complete and bail out. testRunEventsHandler.HandleTestRunComplete(completeArgs, null, null, null); this.CleanupCommunicationIfProcessExit(); }
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(); }
private void OnTestMessageReceived(object sender, TestMessagePayload e) { if (e.MessageLevel != TestMessageLevel.Informational) { this.frameworkHandle.SendMessage(e.MessageLevel, e.Message); } }
/// <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, ITestDiscoveryEventsHandler eventHandler) { try { this.isCommunicationEstablished = this.SetupChannel(discoveryCriteria.Sources, this.cancellationTokenSource.Token); if (this.isCommunicationEstablished) { this.InitializeExtensions(discoveryCriteria.Sources); 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); eventHandler.HandleDiscoveryComplete(-1, new List <ObjectModel.TestCase>(), true); } }
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool skipTestHostLaunch) { Task.Run( delegate { try { testRequestManager.ResetOptions(); var customLauncher = skipTestHostLaunch ? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(this, testRunPayload) : null; testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig); } catch (Exception ex) { EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = ex.ToString() }; this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload); var runCompletePayload = new TestRunCompletePayload() { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue), LastRunTests = null }; // Send run complete to translation layer this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload); } }); }
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(); }
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); } }); }
/// <inheritdoc/> public void SendLog(TestMessageLevel messageLevel, string message) { var testMessagePayload = new TestMessagePayload { MessageLevel = messageLevel, Message = message }; this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload, this.protocolVersion); }
/// <inheritdoc /> public void SendTestMessage(TestMessageLevel level, string message) { var payload = new TestMessagePayload { MessageLevel = level, Message = message }; this.communicationManager.SendMessage(MessageType.TestMessage, payload); }
/// <summary> /// Sends the test session logger warning and error messages to IDE; /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void TestRunMessageHandler(object sender, TestRunMessageEventArgs e) { if (e.Level == TestMessageLevel.Error || e.Level == TestMessageLevel.Warning) { var payload = new TestMessagePayload { MessageLevel = e.Level, Message = e.Message }; this.communicationManager.SendMessage(MessageType.TestMessage, payload); } }
public void DesignModeClientSendTestMessageShouldSendTestMessage() { var testPayload = new TestMessagePayload { MessageLevel = ObjectModel.Logging.TestMessageLevel.Error, Message = "DummyMessage" }; this.designModeClient.SendTestMessage(testPayload.MessageLevel, testPayload.Message); this.mockCommunicationManager.Verify(cm => cm.SendMessage(MessageType.TestMessage, It.IsAny <TestMessagePayload>()), Times.Once()); }
/// <inheritdoc /> public void HandleLogMessage(TestMessageLevel level, string message) { var messagePayload = new TestMessagePayload() { MessageLevel = level, Message = message }; this.communicationManager.SendMessage(MessageType.TestMessage, messagePayload); }
/// <summary> /// Triggers the discovery for the next data object on the concurrent discoverer /// Each concurrent discoverer calls this method, once its completed working on previous data /// </summary> /// <param name="ProxyDiscoveryManager">Proxy discovery manager instance.</param> private void DiscoverTestsOnConcurrentManager(IProxyDiscoveryManager proxyDiscoveryManager) { // Peek to see if we have sources to trigger a discovery if (this.TryFetchNextSource(this.sourceEnumerator, out string nextSource)) { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ProxyParallelDiscoveryManager: Triggering test discovery for next source: {0}", nextSource); } // Kick off another discovery task for the next source var discoveryCriteria = new DiscoveryCriteria(new[] { nextSource }, this.actualDiscoveryCriteria.FrequencyOfDiscoveredTestsEvent, this.actualDiscoveryCriteria.DiscoveredTestEventTimeout, this.actualDiscoveryCriteria.RunSettings); discoveryCriteria.TestCaseFilter = this.actualDiscoveryCriteria.TestCaseFilter; Task.Run(() => { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ParallelProxyDiscoveryManager: Discovery started."); } proxyDiscoveryManager.DiscoverTests(discoveryCriteria, this.GetHandlerForGivenManager(proxyDiscoveryManager)); }) .ContinueWith(t => { // Just in case, the actual discovery couldn't start for an instance. Ensure that // we call discovery complete since we have already fetched a source. Otherwise // discovery will not terminate if (EqtTrace.IsErrorEnabled) { EqtTrace.Error("ParallelProxyDiscoveryManager: Failed to trigger discovery. Exception: " + t.Exception); } var handler = this.GetHandlerForGivenManager(proxyDiscoveryManager); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = t.Exception.ToString() }; handler.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload)); handler.HandleLogMessage(TestMessageLevel.Error, t.Exception.ToString()); // Send discovery complete. Similar logic is also used in ProxyDiscoveryManager.DiscoverTests. // Differences: // Total tests must be zero here since parallel discovery events handler adds the count // Keep `lastChunk` as null since we don't want a message back to the IDE (discovery didn't even begin) // Set `isAborted` as true since we want this instance of discovery manager to be replaced var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(-1, true); handler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, null); }, TaskContinuationOptions.OnlyOnFaulted); } if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ProxyParallelDiscoveryManager: No sources available for discovery."); } }
private void LogMessage(TestMessageLevel testMessageLevel, string message, ITestRunEventsHandler eventHandler) { // Log to vs ide test output var testMessagePayload = new TestMessagePayload { MessageLevel = testMessageLevel, Message = message }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload); eventHandler.HandleRawMessage(rawMessage); // Log to vstest.console eventHandler.HandleLogMessage(testMessageLevel, message); }
private void LogMessage(TestMessageLevel testMessageLevel, string message) { // Log to translation layer. var testMessagePayload = new TestMessagePayload { MessageLevel = testMessageLevel, Message = message }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload); this.HandleRawMessage(rawMessage); // Log to vstest.console layer. this.HandleLogMessage(testMessageLevel, message); }
public void StartTestRunShouldNotifyLogMessageOnTestMessageReceived() { var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = "Dummy" }; this.SetupDeserializeMessage(MessageType.TestMessage, testMessagePayload); this.SetupFakeCommunicationChannel(); this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object); this.RaiseMessageReceivedEvent(); this.mockExecutionEventsHandler.Verify(eh => eh.HandleLogMessage(TestMessageLevel.Error, "Dummy"), Times.Once); }
public void DiscoverTestShouldNotifyLogMessageOnTestMessageReceived() { var message = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = "Message1" }; this.SetupDeserializeMessage(MessageType.TestMessage, message); this.SetupFakeCommunicationChannel(); this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), this.mockDiscoveryEventsHandler.Object); this.RaiseMessageReceivedEvent(); this.mockDiscoveryEventsHandler.Verify(eh => eh.HandleLogMessage(TestMessageLevel.Error, "Message1")); }
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)); }
public void StartTestRunShouldCallHandleLogMessageOnTestMessage() { var mockHandler = new Mock <ITestRunEventsHandler>(); var runCriteria = new TestRunCriteriaWithSources(null, null, null, null); var rawMessage = "OnLogMessage"; var message = new Message() { MessageType = MessageType.TestMessage, Payload = null }; var payload = new TestMessagePayload() { MessageLevel = TestMessageLevel.Error, Message = rawMessage }; this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestMessagePayload>(message)).Returns(payload); var completePayload = new TestRunCompletePayload() { ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null }; var completeMessage = new Message() { MessageType = MessageType.ExecutionComplete, Payload = null }; var waitHandle = new AutoResetEvent(false); 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 <TestRunCompletePayload>(completeMessage)).Callback(() => { waitHandle.Set(); }) .Returns(completePayload); }); this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object); waitHandle.WaitOne(); this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithSources, runCriteria, this.protocolConfig.Version), Times.Once); this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(It.IsAny <string>()), Times.AtLeast(2)); // Asserting that 'StartTestRun" should have been completed, & invoked only once this.mockDataSerializer.Verify(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage), Times.Exactly(1)); mockHandler.Verify(mh => mh.HandleLogMessage(payload.MessageLevel, payload.Message), Times.Once); mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.AtLeastOnce); }
internal void OnTestSessionTimeout(object obj) { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose(string.Format("TestRunRequest.OnTestSessionTimeout: calling cancellation as test run exceeded testSessionTimeout {0} milliseconds", testSessionTimeout)); } string message = string.Format(ClientResources.TestSessionTimeoutMessage, this.testSessionTimeout); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = message }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload); this.HandleLogMessage(TestMessageLevel.Error, message); this.HandleRawMessage(rawMessage); this.Abort(); }
/// <inheritdoc/> public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 eventHandler) { this.baseTestDiscoveryEventsHandler = eventHandler; try { this.isCommunicationEstablished = this.proxyOperationManager.SetupChannel(discoveryCriteria.Sources, discoveryCriteria.RunSettings); if (this.isCommunicationEstablished) { this.InitializeExtensions(discoveryCriteria.Sources); discoveryCriteria.UpdateDiscoveryCriteria(testHostManager); this.proxyOperationManager.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>()); } }
private void LogErrorMessage(string message) { if (this.messageEventHandler == null) { EqtTrace.Error("TestRequestSender.LogErrorMessage: Message event handler not set. Error: " + message); return; } // Log to vstest console this.messageEventHandler.HandleLogMessage(TestMessageLevel.Error, message); // Log to vs ide test output var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = message }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload); this.messageEventHandler.HandleRawMessage(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) { 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 StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool shouldLaunchTesthost) { Task.Run( () => { try { testRequestManager.ResetOptions(); // We must avoid re-launching the test host if the test run payload already // contains test session info. Test session info being present is an indicative // of an already running test host spawned by a start test session call. var customLauncher = shouldLaunchTesthost && testRunPayload.TestSessionInfo == null ? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun( this, testRunPayload.DebuggingEnabled) : null; testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig); } catch (Exception ex) { EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = ex.ToString() }; this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload); var runCompletePayload = new TestRunCompletePayload() { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue), LastRunTests = null }; // Send run complete to translation layer this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload); } }); }