/// <inheritdoc/> public Collection <AttachmentSet> SendAfterTestRunStartAndGetResult(ITestMessageEventHandler runEventsHandler, bool isCancelled) { var isDataCollectionComplete = false; Collection <AttachmentSet> attachmentSets = null; this.communicationManager.SendMessage(MessageType.AfterTestRunEnd, isCancelled); // Cycle through the messages that the datacollector sends. // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification. while (!isDataCollectionComplete) { var message = this.communicationManager.ReceiveMessage(); if (message.MessageType == MessageType.DataCollectionMessage) { var msg = this.dataSerializer.DeserializePayload <DataCollectionMessageEventArgs>(message); runEventsHandler.HandleLogMessage(msg.Level, string.Format(CultureInfo.CurrentCulture, Resources.Resources.DataCollectorUriForLogMessage, msg.FriendlyName, msg.Message)); } else if (message.MessageType == MessageType.AfterTestRunEndResult) { attachmentSets = this.dataSerializer.DeserializePayload <Collection <AttachmentSet> >(message); isDataCollectionComplete = true; } } return(attachmentSets); }
private void InvokeDataCollectionServiceAction(Action action, ITestMessageEventHandler runEventsHandler) { try { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ProxyDataCollectionManager.InvokeDataCollectionServiceAction: Starting."); } action(); if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("ProxyDataCollectionManager.InvokeDataCollectionServiceAction: Completed."); } } catch (Exception ex) { if (EqtTrace.IsWarningEnabled) { EqtTrace.Warning("ProxyDataCollectionManager.InvokeDataCollectionServiceAction: TestPlatformException = {0}.", ex); } this.HandleExceptionMessage(runEventsHandler, ex); } }
/// <summary> /// Invoked before starting of test run /// </summary> /// <param name="resetDataCollectors"> /// The reset Data Collectors. /// </param> /// <param name="isRunStartingNow"> /// The is Run Starting Now. /// </param> /// <param name="runEventsHandler"> /// The run Events Handler. /// </param> /// <returns> /// BeforeTestRunStartResult object /// </returns> public DataCollectionParameters BeforeTestRunStart( bool resetDataCollectors, bool isRunStartingNow, ITestMessageEventHandler runEventsHandler) { var areTestCaseLevelEventsRequired = false; var isDataCollectionStarted = false; IDictionary <string, string> environmentVariables = null; var dataCollectionEventsPort = 0; this.InvokeDataCollectionServiceAction( () => { var result = this.dataCollectionRequestSender.SendBeforeTestRunStartAndGetResult(this.settingsXml, runEventsHandler); areTestCaseLevelEventsRequired = result.AreTestCaseLevelEventsRequired; environmentVariables = result.EnvironmentVariables; dataCollectionEventsPort = result.DataCollectionEventsPort; }, runEventsHandler); return(new DataCollectionParameters( isDataCollectionStarted, areTestCaseLevelEventsRequired, environmentVariables, dataCollectionEventsPort)); }
/// <summary> /// Invoked before starting of test run /// </summary> /// <param name="resetDataCollectors"> /// The reset Data Collectors. /// </param> /// <param name="isRunStartingNow"> /// The is Run Starting Now. /// </param> /// <param name="runEventsHandler"> /// The run Events Handler. /// </param> /// <returns> /// BeforeTestRunStartResult object /// </returns> public DataCollectionParameters BeforeTestRunStart( bool resetDataCollectors, bool isRunStartingNow, ITestMessageEventHandler runEventsHandler) { var areTestCaseLevelEventsRequired = false; IDictionary <string, string> environmentVariables = new Dictionary <string, string>(); var dataCollectionEventsPort = 0; this.InvokeDataCollectionServiceAction( () => { EqtTrace.Info("ProxyDataCollectionManager.BeforeTestRunStart: Get environment variable and port for datacollector processId: {0} port: {1}", this.dataCollectionProcessId, this.dataCollectionPort); var result = this.dataCollectionRequestSender.SendBeforeTestRunStartAndGetResult(this.SettingsXml, this.Sources, this.requestData.IsTelemetryOptedIn, runEventsHandler); environmentVariables = result.EnvironmentVariables; dataCollectionEventsPort = result.DataCollectionEventsPort; EqtTrace.Info( "ProxyDataCollectionManager.BeforeTestRunStart: SendBeforeTestRunStartAndGetResult successful, env variable from datacollector: {0} and testhost port: {1}", string.Join(";", environmentVariables), dataCollectionEventsPort); }, runEventsHandler); return(new DataCollectionParameters( areTestCaseLevelEventsRequired, environmentVariables, dataCollectionEventsPort)); }
/// <summary> /// Ensures that the engine is ready for test operations. Usually includes starting up the /// test host process. /// </summary> /// /// <param name="sources">List of test sources.</param> /// <param name="runSettings">Run settings to be used.</param> /// <param name="eventHandler">The events handler.</param> /// /// <returns> /// Returns true if the communication is established b/w runner and host, false otherwise. /// </returns> public virtual bool SetupChannel( IEnumerable <string> sources, string runSettings, ITestMessageEventHandler eventHandler) { return(this.SetupChannel(sources, runSettings)); }
private void HandleExceptionMessage(ITestMessageEventHandler runEventsHandler, Exception exception) { if (EqtTrace.IsErrorEnabled) { EqtTrace.Error(exception); } runEventsHandler.HandleLogMessage(ObjectModel.Logging.TestMessageLevel.Error, exception.Message); }
public Collection <AttachmentSet> SendAfterTestRunStartAndGetResult(ITestMessageEventHandler handler, bool isCancelled) { if (sendAfterTestRunStartAndGetResultThrowException) { throw new Exception("SocketException"); } this.sendAfterTestRunStartAndGetResult = true; return(Attachments); }
/// <summary> /// Invoked after ending of test run /// </summary> /// <param name="isCanceled"> /// The is Canceled. /// </param> /// <param name="runEventsHandler"> /// The run Events Handler. /// </param> /// <returns> /// The <see cref="Collection"/>. /// </returns> public Collection <AttachmentSet> AfterTestRunEnd(bool isCanceled, ITestMessageEventHandler runEventsHandler) { Collection <AttachmentSet> attachmentSet = null; this.InvokeDataCollectionServiceAction( () => { attachmentSet = this.dataCollectionRequestSender.SendAfterTestRunStartAndGetResult(runEventsHandler, isCanceled); }, runEventsHandler); return(attachmentSet); }
/// <summary> /// Invoked after ending of test run /// </summary> /// <param name="isCanceled"> /// The is Canceled. /// </param> /// <param name="runEventsHandler"> /// The run Events Handler. /// </param> /// <returns> /// The <see cref="Collection"/>. /// </returns> public Collection <AttachmentSet> AfterTestRunEnd(bool isCanceled, ITestMessageEventHandler runEventsHandler) { Collection <AttachmentSet> attachmentSet = null; this.InvokeDataCollectionServiceAction( () => { EqtTrace.Info("ProxyDataCollectionManager.AfterTestRunEnd: Get attachment set for datacollector processId: {0} port: {1}", dataCollectionProcessId, dataCollectionPort); attachmentSet = this.dataCollectionRequestSender.SendAfterTestRunEndAndGetResult(runEventsHandler, isCanceled); }, runEventsHandler); return(attachmentSet); }
/// <inheritdoc /> public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler) { this.messageEventHandler = eventHandler; this.onDisconnected = (disconnectedEventArgs) => { this.OnTestRunAbort(eventHandler, disconnectedEventArgs.Error, true); }; this.onMessageReceived = (sender, args) => this.OnExecutionMessageReceived(sender, args, eventHandler); this.channel.MessageReceived += this.onMessageReceived; // This code section is needed because we altered the old testhost launch process for // the debugging workflow. Now we don't ask VS to launch and attach to the testhost // process for us as we previously did, instead we launch it as a standalone process // and rely on the testhost to ask VS to attach the debugger to itself. // // In order to avoid breaking compatibility with previous testhost versions because of // those changes (older testhosts won't know to request VS to attach to themselves // thinking instead VS launched and attached to them already), we request VS to attach // to the testhost here before starting the test run. if (runCriteria.TestExecutionContext != null && runCriteria.TestExecutionContext.IsDebug && this.runtimeProvider is ITestRuntimeProvider2 convertedRuntimeProvider && this.protocolVersion < ObjectModelConstants.MinimumProtocolVersionWithDebugSupport) { var handler = (ITestRunEventsHandler2)eventHandler; if (!convertedRuntimeProvider.AttachDebuggerToTestHost()) { EqtTrace.Warning( string.Format( CultureInfo.CurrentUICulture, CommonResources.AttachDebuggerToDefaultTestHostFailure)); } } var message = this.dataSerializer.SerializePayload( MessageType.StartTestExecutionWithTests, runCriteria, this.protocolVersion); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("TestRequestSender.StartTestRun: Sending test run with message: {0}", message); } this.channel.Send(message); }
/// <inheritdoc/> public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 discoveryEventsHandler) { this.messageEventHandler = discoveryEventsHandler; this.onDisconnected = (disconnectedEventArgs) => { this.OnDiscoveryAbort(discoveryEventsHandler, disconnectedEventArgs.Error, true); }; this.onMessageReceived = (sender, args) => this.OnDiscoveryMessageReceived(discoveryEventsHandler, args); this.channel.MessageReceived += this.onMessageReceived; var message = this.dataSerializer.SerializePayload( MessageType.StartDiscovery, discoveryCriteria, this.protocolVersion); this.channel.Send(message); }
/// <inheritdoc /> public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler) { this.messageEventHandler = eventHandler; this.onDisconnected = (disconnectedEventArgs) => { this.OnTestRunAbort(eventHandler, disconnectedEventArgs.Error, true); }; this.onMessageReceived = (sender, args) => this.OnExecutionMessageReceived(sender, args, eventHandler); this.channel.MessageReceived += this.onMessageReceived; var message = this.dataSerializer.SerializePayload( MessageType.StartTestExecutionWithTests, runCriteria, this.protocolVersion); this.channel.Send(message); }
/// <summary> /// Initializes the execution manager. /// </summary> /// <param name="pathToAdditionalExtensions"> The path to additional extensions. </param> public void Initialize(IEnumerable <string> pathToAdditionalExtensions, ITestMessageEventHandler testMessageEventsHandler) { this.testMessageEventsHandler = testMessageEventsHandler; this.testPlatformEventSource.AdapterSearchStart(); if (pathToAdditionalExtensions != null && pathToAdditionalExtensions.Any()) { // Start using these additional extensions TestPluginCache.Instance.DefaultExtensionPaths = pathToAdditionalExtensions; } this.LoadExtensions(); //unsubscrive session logger this.sessionMessageLogger.TestRunMessage -= this.TestSessionMessageHandler; this.testPlatformEventSource.AdapterSearchStop(); }
/// <inheritdoc /> public override bool SetupChannel( IEnumerable <string> sources, string runSettings, ITestMessageEventHandler eventHandler) { // Log all the messages that are reported while initializing the DataCollectionClient. if (this.DataCollectionRunEventsHandler.Messages.Count > 0) { foreach (var message in this.DataCollectionRunEventsHandler.Messages) { eventHandler.HandleLogMessage(message.Item1, message.Item2); } this.DataCollectionRunEventsHandler.Messages.Clear(); } return(base.SetupChannel(sources, runSettings)); }
/// <summary> /// Invoked after ending of test run /// </summary> /// <param name="isCanceled"> /// The is Canceled. /// </param> /// <param name="runEventsHandler"> /// The run Events Handler. /// </param> /// <returns> /// The <see cref="Collection"/>. /// </returns> public Collection <AttachmentSet> AfterTestRunEnd(bool isCanceled, ITestMessageEventHandler runEventsHandler) { AfterTestRunEndResult afterTestRunEnd = null; this.InvokeDataCollectionServiceAction( () => { EqtTrace.Info("ProxyDataCollectionManager.AfterTestRunEnd: Get attachment set for datacollector processId: {0} port: {1}", dataCollectionProcessId, dataCollectionPort); afterTestRunEnd = this.dataCollectionRequestSender.SendAfterTestRunEndAndGetResult(runEventsHandler, isCanceled); }, runEventsHandler); if (requestData.IsTelemetryOptedIn && afterTestRunEnd?.Metrics != null) { foreach (var metric in afterTestRunEnd.Metrics) { requestData.MetricsCollection.Add(metric.Key, metric.Value); } } return(afterTestRunEnd?.AttachmentSets); }
/// <inheritdoc /> public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler) { this.messageEventHandler = eventHandler; this.onDisconnected = (disconnectedEventArgs) => { this.OnTestRunAbort(eventHandler, disconnectedEventArgs.Error, true); }; this.onMessageReceived = (sender, args) => this.OnExecutionMessageReceived(sender, args, eventHandler); this.channel.MessageReceived += this.onMessageReceived; var message = this.dataSerializer.SerializePayload( MessageType.StartTestExecutionWithTests, runCriteria, this.protocolVersion); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("TestRequestSender.StartTestRun: Sending test run with message: {0}", message); } this.channel.Send(message); }
/// <inheritdoc/> public Collection <AttachmentSet> SendAfterTestRunStartAndGetResult(ITestMessageEventHandler runEventsHandler, bool isCancelled) { var isDataCollectionComplete = false; Collection <AttachmentSet> attachmentSets = null; if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("DataCollectionRequestSender.SendAfterTestRunStartAndGetResult : Send AfterTestRunEnd message with isCancelled: {0}", isCancelled); } this.communicationManager.SendMessage(MessageType.AfterTestRunEnd, isCancelled); // Cycle through the messages that the datacollector sends. // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification. while (!isDataCollectionComplete && !isCancelled) { var message = this.communicationManager.ReceiveMessage(); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("DataCollectionRequestSender.SendAfterTestRunStartAndGetResult : Received message: {0}", message); } if (message.MessageType == MessageType.DataCollectionMessage) { var dataCollectionMessageEventArgs = this.dataSerializer.DeserializePayload <DataCollectionMessageEventArgs>(message); this.LogDataCollectorMessage(dataCollectionMessageEventArgs, runEventsHandler); } else if (message.MessageType == MessageType.AfterTestRunEndResult) { attachmentSets = this.dataSerializer.DeserializePayload <Collection <AttachmentSet> >(message); isDataCollectionComplete = true; } } return(attachmentSets); }
private void LogDataCollectorMessage(DataCollectionMessageEventArgs dataCollectionMessageEventArgs, ITestMessageEventHandler requestHandler) { string logMessage; if (string.IsNullOrWhiteSpace(dataCollectionMessageEventArgs.FriendlyName)) { // Message from data collection framework. logMessage = string.Format(CultureInfo.CurrentCulture, CommonResources.DataCollectionMessageFormat, dataCollectionMessageEventArgs.Message); } else { // Message from individual data collector. logMessage = string.Format(CultureInfo.CurrentCulture, CommonResources.DataCollectorMessageFormat, dataCollectionMessageEventArgs.FriendlyName, dataCollectionMessageEventArgs.Message); } requestHandler.HandleLogMessage(dataCollectionMessageEventArgs.Level, logMessage); }
/// <inheritdoc/> public BeforeTestRunStartResult SendBeforeTestRunStartAndGetResult(string settingsXml, ITestMessageEventHandler runEventsHandler) { var isDataCollectionStarted = false; BeforeTestRunStartResult result = null; if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("DataCollectionRequestSender.SendBeforeTestRunStartAndGetResult : Send BeforeTestRunStart message with settingsXml: {0}", settingsXml); } this.communicationManager.SendMessage(MessageType.BeforeTestRunStart, settingsXml); while (!isDataCollectionStarted) { var message = this.communicationManager.ReceiveMessage(); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("DataCollectionRequestSender.SendBeforeTestRunStartAndGetResult : Received message: {0}", message); } if (message.MessageType == MessageType.DataCollectionMessage) { var dataCollectionMessageEventArgs = this.dataSerializer.DeserializePayload <DataCollectionMessageEventArgs>(message); this.LogDataCollectorMessage(dataCollectionMessageEventArgs, runEventsHandler); } else if (message.MessageType == MessageType.BeforeTestRunStartResult) { isDataCollectionStarted = true; result = this.dataSerializer.DeserializePayload <BeforeTestRunStartResult>(message); } } return(result); }
/// <inheritdoc/> public BeforeTestRunStartResult SendBeforeTestRunStartAndGetResult(string settingsXml, ITestMessageEventHandler runEventsHandler) { var isDataCollectionStarted = false; BeforeTestRunStartResult result = null; this.communicationManager.SendMessage(MessageType.BeforeTestRunStart, settingsXml); while (!isDataCollectionStarted) { var message = this.communicationManager.ReceiveMessage(); if (message.MessageType == MessageType.DataCollectionMessage) { var msg = this.dataSerializer.DeserializePayload <DataCollectionMessageEventArgs>(message); runEventsHandler.HandleLogMessage(msg.Level, string.Format(CultureInfo.CurrentCulture, Resources.Resources.DataCollectorUriForLogMessage, msg.FriendlyName, msg.Message)); } else if (message.MessageType == MessageType.BeforeTestRunStartResult) { isDataCollectionStarted = true; result = this.dataSerializer.DeserializePayload <BeforeTestRunStartResult>(message); } } return(result); }
/// <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); }
/// <inheritdoc/> public BeforeTestRunStartResult SendBeforeTestRunStartAndGetResult(string settingsXml, IEnumerable <string> sources, bool isTelemetryOptedIn, ITestMessageEventHandler runEventsHandler) { var isDataCollectionStarted = false; BeforeTestRunStartResult result = null; if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("DataCollectionRequestSender.SendBeforeTestRunStartAndGetResult : Send BeforeTestRunStart message with settingsXml {0} and sources {1}: ", settingsXml, sources.ToString()); } var payload = new BeforeTestRunStartPayload { SettingsXml = settingsXml, Sources = sources, IsTelemetryOptedIn = isTelemetryOptedIn }; this.communicationManager.SendMessage(MessageType.BeforeTestRunStart, payload); while (!isDataCollectionStarted) { var message = this.communicationManager.ReceiveMessage(); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("DataCollectionRequestSender.SendBeforeTestRunStartAndGetResult : Received message: {0}", message); } if (message.MessageType == MessageType.DataCollectionMessage) { var dataCollectionMessageEventArgs = this.dataSerializer.DeserializePayload <DataCollectionMessageEventArgs>(message); this.LogDataCollectorMessage(dataCollectionMessageEventArgs, runEventsHandler); } else if (message.MessageType == MessageType.BeforeTestRunStartResult) { isDataCollectionStarted = true; result = this.dataSerializer.DeserializePayload <BeforeTestRunStartResult>(message); } } return(result); }
public BeforeTestRunStartResult SendBeforeTestRunStartAndGetResult(string settingXml, ITestMessageEventHandler handler) { if (this.sendBeforeTestRunStartAndGetResultThrowException) { throw new Exception("SocketException"); } this.sendBeforeTestRunStartAndGetResult = true; return(BeforeTestRunStartResult); }