public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk) { if (lastChunk != null) { this.DiscoveredTestCases.AddRange(lastChunk); } }
void Discovery_Connect(DiscoveryCompleteEventArgs e) { //var reference = e.Reference; //foreach (var warning in reference.Warnings) logger.Warn(warning); //foreach (var error in reference.Errors) logger.Error(error); //if (reference.HasErrors) // logger.Write("Cannot create a connection."); //else //{ logger.Write("Click \"Next\" to continue."); // var reset = string.IsNullOrEmpty(Model.BindingName) || // !reference.Bindings.Any(b => b.Name == Model.BindingName); // if (reset) // { // Model.BindingName = reference.Bindings.Count > 0 // ? reference.Bindings[0].Name : ""; // } // BindingBox.ItemsSource = reference.Bindings.Select(b => b.Name); // BindingBox.SelectedItem = Model.BindingName; //} RestartButton.IsEnabled = true; Progress.IsIndeterminate = false; LogBox.ScrollToEnd(); //if (!reference.HasErrors && !reference.HasWarnings) //{ //SetVisiblePage(2); FinishButton.IsEnabled = true; //} }
public void HandleDiscoveryCompleteShouldCallLastChunkResultsIfPresent() { string payload = "Tests"; int totalTests = 10; bool aborted = false; var lastChunk = new List <TestCase>(); this.mockDataSerializer.Setup(mds => mds.SerializePayload(MessageType.TestCasesFound, lastChunk)) .Returns(payload); this.mockParallelProxyDiscoveryManager.Setup(mp => mp.HandlePartialDiscoveryComplete( this.mockProxyDiscoveryManager.Object, totalTests, lastChunk, aborted)).Returns(false); var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(totalTests, aborted, null); this.parallelDiscoveryEventsHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, lastChunk); // Raw message must be sent this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleRawMessage(payload), Times.Once); this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveredTests(lastChunk), Times.Once); this.mockParallelProxyDiscoveryManager.Verify(mp => mp.HandlePartialDiscoveryComplete( this.mockProxyDiscoveryManager.Object, totalTests, null, aborted), Times.Once); }
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); }
/// <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>()); } }); }
public void HandleDiscoveryCompleteShouldInformClient() { var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(0, false); this.testDiscoveryEventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null); this.mockClient.Verify(th => th.DiscoveryComplete(discoveryCompleteEventArgs, null), Times.Once); }
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); }
public void RaiseDiscoveryCompleteShouldInvokeRegisteredEventHandler() { bool discoveryCompleteReceived = false; DiscoveryCompleteEventArgs receivedEventArgs = null; EventWaitHandle waitHandle = new AutoResetEvent(false); DiscoveryCompleteEventArgs discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(2, false); // Register for the discovery complete event. loggerEvents.DiscoveryComplete += (sender, e) => { discoveryCompleteReceived = true; receivedEventArgs = e; waitHandle.Set(); }; loggerEvents.EnableEvents(); // Send the discovery complete event. loggerEvents.RaiseDiscoveryComplete(discoveryCompleteEventArgs); var waitSuccess = waitHandle.WaitOne(500); Assert.IsTrue(waitSuccess, "Event must be raised within timeout."); Assert.IsTrue(discoveryCompleteReceived); Assert.IsNotNull(receivedEventArgs); Assert.AreEqual(receivedEventArgs, discoveryCompleteEventArgs); }
public void HandleDiscoveryCompleteShouldCallTestDiscoveryCompleteOnActualHandlerIfParallelManagerReturnsCompleteAsTrue() { string payload = "DiscoveryComplete"; int totalTests = 10; bool aborted = false; this.mockParallelProxyDiscoveryManager.Setup(mp => mp.HandlePartialDiscoveryComplete( this.mockProxyDiscoveryManager.Object, totalTests, null, aborted)).Returns(true); this.mockDataSerializer.Setup(mds => mds.SerializeMessage(MessageType.DiscoveryComplete)).Returns(payload); // Act var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(totalTests, aborted, null); this.parallelDiscoveryEventsHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, null); // Verify this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveredTests(null), Times.Never); this.mockParallelProxyDiscoveryManager.Verify(mp => mp.HandlePartialDiscoveryComplete( this.mockProxyDiscoveryManager.Object, totalTests, null, aborted), Times.Once); this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleRawMessage(It.IsAny <string>()), Times.Once); this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), null), Times.Once); }
private void Events_DiscoveryComplete(object sender, DiscoveryCompleteEventArgs e) { var content = JsonSerializer.Serialize(TestCaseInfos.ToArray()); string path = Path.Combine(TestRunDirectory, "TestCaseInfo.json"); File.WriteAllText(path, content); }
/// <summary> /// Handle discovery complete. /// </summary> /// <param name="discoveryCompleteEventArgs"> Discovery Complete Events Args. </param> /// <param name="lastChunk"> The last chunk. </param> public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk) { if (EqtTrace.IsInfoEnabled) { EqtTrace.Info(discoveryCompleteEventArgs.IsAborted ? "Discover Aborted." : "Discover Finished."); } this.requestHandler.DiscoveryComplete(discoveryCompleteEventArgs, lastChunk); }
/// <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); } }
public void HandleDiscoveryCompleteShouldInvokeHandleDiscoveryCompleteOfLoggerManager() { var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false); var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2; eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, Enumerable.Empty <TestCase>()); loggerManager.Verify(lm => lm.HandleDiscoveryComplete(discoveryCompleteEventArgs), Times.Once); }
public void HandleDiscoveryCompleteShouldNotInvokeHandleDiscoveredTestsIfLastChunkNotPresent() { var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false); var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2; eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, Enumerable.Empty <TestCase>()); loggerManager.Verify(lm => lm.HandleDiscoveredTests(It.IsAny <DiscoveredTestsEventArgs>()), Times.Never); }
public void RaiseDiscoveryCompleteShouldThrowExceptionIfAlreadyDisposed() { var loggerEvents = GetDisposedLoggerEvents(); DiscoveryCompleteEventArgs discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(2, false); Assert.ThrowsException <ObjectDisposedException>(() => { loggerEvents.RaiseDiscoveryComplete(discoveryCompleteEventArgs); }); }
/// <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."); } }
/// <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); }
/// <summary> /// Raises discovery complete event to the enabled loggers. /// </summary> /// <param name="args"> Arguments to be raised. </param> internal void RaiseDiscoveryComplete(DiscoveryCompleteEventArgs args) { ValidateArg.NotNull <DiscoveryCompleteEventArgs>(args, "args"); CheckDisposed(); // Sending 0 size as this event is not expected to contain any data. SafeInvokeAsync(() => this.DiscoveryComplete, args, 0, "InternalTestLoggerEvents.SendDiscoveryComplete"); // Wait for the loggers to finish processing the messages for the run. this.loggerEventQueue.Flush(); }
/// <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); } }
/// <inheritdoc /> public void DiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk) { var data = this.dataSerializer.SerializePayload( MessageType.DiscoveryComplete, new DiscoveryCompletePayload { TotalTests = discoveryCompleteEventArgs.TotalCount, LastDiscoveredTests = discoveryCompleteEventArgs.IsAborted ? null : lastChunk, IsAborted = discoveryCompleteEventArgs.IsAborted, Metrics = discoveryCompleteEventArgs.Metrics }, this.protocolVersion); this.SendData(data); }
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); } }
public void HandleDiscoveryCompleteShouldInvokeHandleDiscoveredTestsIfLastChunkPresent() { var activeTestCases = new List <ObjectModel.TestCase> { new ObjectModel.TestCase( "A.C.M2", new Uri("executor://dummy"), "A") }; var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false); var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2; eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, activeTestCases); loggerManager.Verify(lm => lm.HandleDiscoveredTests(It.IsAny <DiscoveredTestsEventArgs>()), Times.Once); }
/// <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); } }
/// <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>()); } }
/// <summary> /// Handles discovery complete event. /// </summary> /// <param name="e">DiscoveryComplete event args.</param> public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs e) { if (!this.isDisposed) { try { this.loggerEvents.RaiseDiscoveryComplete(e); } finally { this.Dispose(); } } else { // Note: We are not raising warning in case testLoggerManager is disposed as HandleRawMessage and HandleDiscoveryComplete both can call HandleDiscoveryComplete. EqtTrace.Verbose("TestLoggerManager.HandleDiscoveryComplete: Ignoring as the object is disposed."); } }
/// <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>()); } }
public void HandleDiscoveryCompleteShouldNotCallLastChunkResultsIfNotPresent() { int totalTests = 10; bool aborted = false; this.mockParallelProxyDiscoveryManager.Setup(mp => mp.HandlePartialDiscoveryComplete( this.mockProxyDiscoveryManager.Object, totalTests, null, aborted)).Returns(false); var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(totalTests, aborted, null); this.parallelDiscoveryEventsHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, null); // Raw message must be sent this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleRawMessage(It.IsAny <string>()), Times.Never); this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveredTests(null), Times.Never); this.mockParallelProxyDiscoveryManager.Verify(mp => mp.HandlePartialDiscoveryComplete( this.mockProxyDiscoveryManager.Object, totalTests, null, aborted), Times.Once); }
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; } }
public void HandleDiscoveryCompleteShouldCollectMetrics() { var mockMetricsCollector = new Mock <IMetricsCollection>(); var dict = new Dictionary <string, string>(); dict.Add("DummyMessage", "DummyValue"); mockMetricsCollector.Setup(mc => mc.Metrics).Returns(dict); this.mockRequestData.Setup(rd => rd.MetricsCollection).Returns(mockMetricsCollector.Object); var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2; var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false); discoveryCompleteEventArgs.Metrics = dict; // Act eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, Enumerable.Empty <TestCase>()); // Verify. mockMetricsCollector.Verify(rd => rd.Add(TelemetryDataConstants.TimeTakenInSecForDiscovery, It.IsAny <string>()), Times.Once); mockMetricsCollector.Verify(rd => rd.Add("DummyMessage", "DummyValue"), Times.Once); }
public void DiscoverTestsShouldSendMetricsOnDiscoveryComplete() { var metricsCollector = new MetricsCollection(); metricsCollector.Add("DummyMessage", "DummyValue"); this.mockRequestData.Setup(rd => rd.MetricsCollection).Returns(metricsCollector); DiscoveryCompleteEventArgs receivedDiscoveryCompleteEventArgs = null; TestPluginCacheHelper.SetupMockExtensions( new string[] { typeof(DiscovererEnumeratorTests).GetTypeInfo().Assembly.Location }, () => { }); var sources = new List <string> { typeof(DiscoveryManagerTests).GetTypeInfo().Assembly.Location }; var mockLogger = new Mock <ITestDiscoveryEventsHandler2>(); var criteria = new DiscoveryCriteria(sources, 1, null); mockLogger.Setup(ml => ml.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), It.IsAny <IEnumerable <TestCase> >())) .Callback( (DiscoveryCompleteEventArgs complete, IEnumerable <TestCase> tests) => { receivedDiscoveryCompleteEventArgs = complete; }); // Act. this.discoveryManager.DiscoverTests(criteria, mockLogger.Object); // Assert Assert.IsNotNull(receivedDiscoveryCompleteEventArgs.Metrics); Assert.IsTrue(receivedDiscoveryCompleteEventArgs.Metrics.Any()); Assert.IsTrue(receivedDiscoveryCompleteEventArgs.Metrics.ContainsKey("DummyMessage")); }