/// <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);
}
