/// <summary>
/// Fetches the ExecutionManager for this engine. This manager would provide all functionality required for execution.
/// </summary>
/// <param name="testHostManager">Test host manager.</param>
/// <param name="testRunCriteria">Test run criterion.</param>
/// <returns>
/// ITestExecutionManager object that can do execution
/// </returns>
public IProxyExecutionManager GetExecutionManager(ITestRuntimeProvider testHostManager, TestRunCriteria testRunCriteria)
{
var distinctSources = GetDistinctNumberOfSources(testRunCriteria);
int parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(distinctSources, testRunCriteria.TestRunSettings);
var runconfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(testRunCriteria.TestRunSettings);
var isDataCollectorEnabled = XmlRunSettingsUtilities.IsDataCollectionEnabled(testRunCriteria.TestRunSettings);
// SetupChannel ProxyExecutionManager with data collection if data collectors are specififed in run settings.
Func <IProxyExecutionManager> proxyExecutionManagerCreator =
() =>
isDataCollectorEnabled
? new ProxyExecutionManagerWithDataCollection(testHostManager, new ProxyDataCollectionManager(testRunCriteria.TestRunSettings))
: new ProxyExecutionManager(testHostManager);
// parallelLevel = 1 for desktop should go via else route.
if (parallelLevel > 1 || !testHostManager.Shared)
{
return(new ParallelProxyExecutionManager(proxyExecutionManagerCreator, parallelLevel, sharedHosts: testHostManager.Shared));
}
else
{
return(proxyExecutionManagerCreator());
}
}
public TestableProxyOperationManager(
IRequestData requestData,
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager,
int clientConnectionTimeout) : base(requestData, requestSender, testHostManager, clientConnectionTimeout)
{
}
/// <summary>
/// Fetches the ExecutionManager for this engine. This manager would provide all functionality required for execution.
/// </summary>
/// <param name="testHostManager">Test host manager.</param>
/// <param name="testRunCriteria">Test run criterion.</param>
/// <param name="config">Protocol related information</param>
/// <returns>
/// ITestExecutionManager object that can do execution
/// </returns>
public IProxyExecutionManager GetExecutionManager(ITestRuntimeProvider testHostManager, TestRunCriteria testRunCriteria, ProtocolConfig config)
{
var distinctSources = GetDistinctNumberOfSources(testRunCriteria);
var parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(distinctSources, testRunCriteria.TestRunSettings);
var isDataCollectorEnabled = XmlRunSettingsUtilities.IsDataCollectionEnabled(testRunCriteria.TestRunSettings);
// SetupChannel ProxyExecutionManager with data collection if data collectors are specififed in run settings.
Func <IProxyExecutionManager> proxyExecutionManagerCreator = delegate
{
// Create a new HostManager, to be associated with individual ProxyExecutionManager(&POM)
var hostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(testRunCriteria.TestRunSettings);
hostManager?.Initialize(TestSessionMessageLogger.Instance, testRunCriteria.TestRunSettings);
if (testRunCriteria.TestHostLauncher != null)
{
hostManager.SetCustomLauncher(testRunCriteria.TestHostLauncher);
}
var requestSender = new TestRequestSender(config);
return(isDataCollectorEnabled ? new ProxyExecutionManagerWithDataCollection(requestSender, hostManager, new ProxyDataCollectionManager(testRunCriteria.TestRunSettings))
: new ProxyExecutionManager(requestSender, hostManager));
};
// parallelLevel = 1 for desktop should go via else route.
if (parallelLevel > 1 || !testHostManager.Shared)
{
return(new ParallelProxyExecutionManager(proxyExecutionManagerCreator, parallelLevel, sharedHosts: testHostManager.Shared));
}
else
{
return(proxyExecutionManagerCreator());
}
}
public TestEngineTests()
{
TestPluginCacheTests.SetupMockExtensions(new[] { typeof(TestEngineTests).GetTypeInfo().Assembly.Location }, () => { });
this.mockProcessHelper = new Mock <IProcessHelper>();
this.testableTestRuntimeProvider = new TestableRuntimeProvider(true);
this.mockRequestData = new Mock <IRequestData>();
this.mockRequestData.Setup(rd => rd.MetricsCollection).Returns(new NoOpMetricsCollection());
}
public TestableProxyOperationManager(
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager,
int clientConnectionTimeout,
int errorLength) : base(requestSender, testHostManager, clientConnectionTimeout)
{
base.ErrorLength = errorLength;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyExecutionManager"/> class.
/// Constructor with Dependency injection. Used for unit testing.
/// </summary>
/// <param name="requestSender">Request Sender instance</param>
/// <param name="testHostManager">Test host manager instance</param>
/// <param name="dataSerializer"></param>
/// <param name="clientConnectionTimeout">The client Connection Timeout</param>
internal ProxyExecutionManager(ITestRequestSender requestSender, ITestRuntimeProvider testHostManager, IDataSerializer dataSerializer, int clientConnectionTimeout)
: base(requestSender, testHostManager, clientConnectionTimeout)
{
this.testHostManager = testHostManager;
this.dataSerializer = dataSerializer;
this.cancellationTokenSource = new CancellationTokenSource();
this.isCommunicationEstablished = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyOperationManager"/> class.
/// </summary>
/// <param name="requestSender">Request Sender instance.</param>
/// <param name="testHostManager">Test host manager instance.</param>
/// <param name="clientConnectionTimeout">Client Connection Timeout.</param>
protected ProxyOperationManager(ITestRequestSender requestSender, ITestRuntimeProvider testHostManager, int clientConnectionTimeout)
{
this.RequestSender = requestSender;
this.connectionTimeout = clientConnectionTimeout;
this.testHostManager = testHostManager;
this.processHelper = new ProcessHelper();
this.initialized = false;
}
private void ThrowExceptionIfTestHostManagerIsNull(ITestRuntimeProvider testHostManager, string settingXml)
{
if (testHostManager == null)
{
EqtTrace.Error("TestPlatform.CreateTestRunRequest: No suitable testHostProvider found for runsettings : {0}", settingXml);
throw new TestPlatformException(string.Format(CultureInfo.CurrentCulture, ClientResources.NoTestHostProviderFound));
}
}
public TestableProxyOperationManager(
IRequestData requestData,
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager,
CancellationTokenSource cancellationTokenSource) : base(requestData, requestSender, testHostManager)
{
this.CancellationTokenSource = cancellationTokenSource;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyDiscoveryManager"/> class.
/// Constructor with Dependency injection. Used for unit testing.
/// </summary>
/// <param name="requestSender">
/// The request Sender.
/// </param>
/// <param name="testHostManager">
/// Test host Manager instance
/// </param>
/// <param name="clientConnectionTimeout">
/// The client Connection Timeout
/// </param>
internal ProxyDiscoveryManager(
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager,
int clientConnectionTimeout)
: base(requestSender, testHostManager, clientConnectionTimeout)
{
this.testHostManager = testHostManager;
}
/// <inheritdoc/>
public IProxyTestSessionManager GetTestSessionManager(
IRequestData requestData,
ITestRuntimeProvider testHostManager,
StartTestSessionCriteria testSessionCriteria)
{
var parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(
testSessionCriteria.Sources.Count,
testSessionCriteria.RunSettings);
requestData.MetricsCollection.Add(
TelemetryDataConstants.ParallelEnabledDuringStartTestSession,
parallelLevel > 1 ? "True" : "False");
var isDataCollectorEnabled = XmlRunSettingsUtilities.IsDataCollectionEnabled(testSessionCriteria.RunSettings);
var isInProcDataCollectorEnabled = XmlRunSettingsUtilities.IsInProcDataCollectionEnabled(testSessionCriteria.RunSettings);
if (this.ShouldRunInNoIsolation(
testSessionCriteria.RunSettings,
parallelLevel > 1,
isDataCollectorEnabled || isInProcDataCollectorEnabled))
{
// This condition is the equivalent of the in-process proxy execution manager case.
// In this case all tests will be run in the vstest.console process, so there's no
// test host to be started. As a consequence there'll be no session info.
return(null);
}
Func <ProxyOperationManager> proxyCreator = () =>
{
var hostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(testSessionCriteria.RunSettings);
hostManager?.Initialize(TestSessionMessageLogger.Instance, testSessionCriteria.RunSettings);
if (testSessionCriteria.TestHostLauncher != null)
{
hostManager.SetCustomLauncher(testSessionCriteria.TestHostLauncher);
}
var requestSender = new TestRequestSender(requestData.ProtocolConfig, hostManager);
return(isDataCollectorEnabled
? new ProxyOperationManagerWithDataCollection(
requestData,
requestSender,
hostManager,
new ProxyDataCollectionManager(
requestData,
testSessionCriteria.RunSettings,
testSessionCriteria.Sources))
: new ProxyOperationManager(
requestData,
requestSender,
hostManager));
};
return(new ProxyTestSessionManager(parallelLevel, proxyCreator));
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyOperationManager"/> class.
/// </summary>
///
/// <param name="requestData">Request data instance.</param>
/// <param name="requestSender">Request sender instance.</param>
/// <param name="testHostManager">Test host manager instance.</param>
public ProxyOperationManager(
IRequestData requestData,
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager)
: this(
requestData,
requestSender,
testHostManager,
null)
{ }
/// <summary>
/// Initializes a new instance of the <see cref="ProxyExecutionManager"/> class.
/// Constructor with Dependency injection. Used for unit testing.
/// </summary>
/// <param name="requestData">The Request Data for Common services and data for Run.</param>
/// <param name="requestSender">Request Sender instance</param>
/// <param name="testHostManager">Test host manager instance</param>
/// <param name="dataSerializer"></param>
internal ProxyExecutionManager(IRequestData requestData, ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager, IDataSerializer dataSerializer, IFileHelper fileHelper)
: base(requestData, requestSender, testHostManager)
{
this.testHostManager = testHostManager;
this.dataSerializer = dataSerializer;
this.isCommunicationEstablished = false;
this.requestData = requestData;
this.fileHelper = fileHelper;
}
public void GetExecutionManagerShouldReturnParallelExecutionManagerIfHostIsNotShared()
{
this.testableTestRuntimeProvider = new TestableRuntimeProvider(false);
var testRunCriteria = new TestRunCriteria(new List <string> {
"1.dll", "2.dll"
}, 100, false, null);
Assert.IsNotNull(this.testEngine.GetExecutionManager(this.testableTestRuntimeProvider, testRunCriteria, this.protocolConfig));
Assert.IsInstanceOfType(this.testEngine.GetExecutionManager(this.testableTestRuntimeProvider, testRunCriteria, this.protocolConfig), typeof(ParallelProxyExecutionManager));
}
private static bool TryCheckTestSourceDifferFromPackage(ITestRuntimeProvider testRuntimeProvider,
IEnumerable <string> inputPackages, out IEnumerable <string> actualTestSources)
{
actualTestSources = testRuntimeProvider.GetTestSources(inputPackages);
// For netcore/fullclr both packages and sources are same thing,
// For UWP the actual source(exe) differs from input source(.appxrecipe) which we call package.
// So in such models we check if they differ, then we pass this info to test host to update TestCase source with package info,
// since this is needed by IDE's to map a TestCase to project.
return(inputPackages.Except(actualTestSources).Any());
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyOperationManager"/> class.
/// </summary>
/// <param name="requestData"></param>
/// <param name="requestSender">Request Sender instance.</param>
/// <param name="testHostManager">Test host manager instance.</param>
protected ProxyOperationManager(IRequestData requestData, ITestRequestSender requestSender, ITestRuntimeProvider testHostManager)
{
this.RequestSender = requestSender;
this.CancellationTokenSource = new CancellationTokenSource();
this.testHostManager = testHostManager;
this.processHelper = new ProcessHelper();
this.initialized = false;
this.testHostLaunched = false;
this.testHostProcessId = -1;
this.requestData = requestData;
}
private void ThrowExceptionIfTestHostManagerIsNull(ITestRuntimeProvider testHostManager, string settingXml)
{
if (testHostManager == null)
{
var config = XmlRunSettingsUtilities.GetRunConfigurationNode(settingXml);
var framework = config.TargetFramework;
EqtTrace.Error("TestPlatform.CreateTestRunRequest: No suitable testHostProvider found for runsettings : {0}", settingXml);
throw new TestPlatformException(String.Format(CultureInfo.CurrentCulture, ClientResources.NoTestHostProviderFound));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TestRequestSender"/> class.
/// </summary>
/// <param name="protocolConfig">Protocol configuration.</param>
/// <param name="runtimeProvider">The runtime provider.</param>
public TestRequestSender(ProtocolConfig protocolConfig, ITestRuntimeProvider runtimeProvider)
: this(
runtimeProvider,
communicationEndPoint : null,
runtimeProvider.GetTestHostConnectionInfo(),
JsonDataSerializer.Instance,
protocolConfig,
ClientProcessExitWaitTimeout)
{
this.SetCommunicationEndPoint();
}
public void GetDiscoveryManagerShouldReturnsParallelDiscoveryManagerIfTestHostIsNotShared()
{
var discoveryCriteria = new DiscoveryCriteria(new List <string> {
"1.dll"
}, 100, null);
this.testableTestRuntimeProvider = new TestableRuntimeProvider(false);
Assert.IsNotNull(this.testEngine.GetDiscoveryManager(this.testableTestRuntimeProvider, discoveryCriteria, this.protocolConfig));
Assert.IsInstanceOfType(this.testEngine.GetDiscoveryManager(this.testableTestRuntimeProvider, discoveryCriteria, this.protocolConfig), typeof(ParallelProxyDiscoveryManager));
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyExecutionManager"/> class.
/// </summary>
///
/// <param name="requestData">
/// The request data for providing services and data for run.
/// </param>
/// <param name="requestSender">Test request sender instance.</param>
/// <param name="testHostManager">Test host manager for this proxy.</param>
public ProxyExecutionManager(
IRequestData requestData,
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager) :
this(
requestData,
requestSender,
testHostManager,
JsonDataSerializer.Instance,
new FileHelper())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyDiscoveryManager"/> class.
/// </summary>
///
/// <param name="requestData">
/// The request data for providing discovery services and data.
/// </param>
/// <param name="testRequestSender">Test request sender instance.</param>
/// <param name="testHostManager">Test host manager instance.</param>
public ProxyDiscoveryManager(
IRequestData requestData,
ITestRequestSender testRequestSender,
ITestRuntimeProvider testHostManager)
: this(
requestData,
testRequestSender,
testHostManager,
JsonDataSerializer.Instance,
new FileHelper())
{
this.testHostManager = testHostManager;
}
/// <summary>
/// Fetches the DiscoveryManager for this engine. This manager would provide all functionality required for discovery.
/// </summary>
/// <param name="testHostManager">
/// Test host manager
/// </param>
/// <param name="discoveryCriteria">
/// The discovery Criteria.
/// </param>
/// <param name="protocolConfig">Protocol related information</param>
/// <returns>
/// ITestDiscoveryManager object that can do discovery
/// </returns>
public IProxyDiscoveryManager GetDiscoveryManager(ITestRuntimeProvider testHostManager, DiscoveryCriteria discoveryCriteria, ProtocolConfig protocolConfig)
{
var parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(discoveryCriteria.Sources.Count(), discoveryCriteria.RunSettings);
Func <IProxyDiscoveryManager> proxyDiscoveryManagerCreator = delegate
{
var hostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(discoveryCriteria.RunSettings);
hostManager?.Initialize(TestSessionMessageLogger.Instance, discoveryCriteria.RunSettings);
return(new ProxyDiscoveryManager(new TestRequestSender(protocolConfig), hostManager));
};
return(!testHostManager.Shared ? new ParallelProxyDiscoveryManager(proxyDiscoveryManagerCreator, parallelLevel, sharedHosts: testHostManager.Shared) : proxyDiscoveryManagerCreator());
}
/// <summary>
/// Fetches the ExecutionManager for this engine. This manager would provide all functionality required for execution.
/// </summary>
/// <param name="requestData">The request data for providing execution services and data</param>
/// <param name="testHostManager">Test host manager.</param>
/// <param name="testRunCriteria">Test run criterion.</param>
/// <returns>
/// ITestExecutionManager object that can do execution
/// </returns>
public IProxyExecutionManager GetExecutionManager(IRequestData requestData, ITestRuntimeProvider testHostManager, TestRunCriteria testRunCriteria)
{
var distinctSources = GetDistinctNumberOfSources(testRunCriteria);
var parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(distinctSources, testRunCriteria.TestRunSettings);
// Collecting IsParallel Enabled
requestData.MetricsCollection.Add(TelemetryDataConstants.ParallelEnabledDuringExecution, parallelLevel > 1 ? "True" : "False");
var isDataCollectorEnabled = XmlRunSettingsUtilities.IsDataCollectionEnabled(testRunCriteria.TestRunSettings);
// Collecting IsDataCollector Enabled
requestData.MetricsCollection.Add(TelemetryDataConstants.DataCollectorsEnabled, isDataCollectorEnabled.ToString());
var isInProcDataCollectorEnabled = XmlRunSettingsUtilities.IsInProcDataCollectionEnabled(testRunCriteria.TestRunSettings);
if (this.ShouldRunInNoIsolation(testRunCriteria.TestRunSettings, parallelLevel > 1, isDataCollectorEnabled || isInProcDataCollectorEnabled))
{
var isTelemetryOptedIn = requestData.IsTelemetryOptedIn;
var newRequestData = this.GetRequestData(isTelemetryOptedIn);
return(new InProcessProxyExecutionManager(testHostManager, new TestHostManagerFactory(newRequestData)));
}
// SetupChannel ProxyExecutionManager with data collection if data collectors are specififed in run settings.
Func <IProxyExecutionManager> proxyExecutionManagerCreator = delegate
{
// Create a new HostManager, to be associated with individual ProxyExecutionManager(&POM)
var hostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(testRunCriteria.TestRunSettings);
hostManager?.Initialize(TestSessionMessageLogger.Instance, testRunCriteria.TestRunSettings);
if (testRunCriteria.TestHostLauncher != null)
{
hostManager.SetCustomLauncher(testRunCriteria.TestHostLauncher);
}
var requestSender = new TestRequestSender(requestData.ProtocolConfig, hostManager.GetTestHostConnectionInfo());
return(isDataCollectorEnabled ? new ProxyExecutionManagerWithDataCollection(requestData, requestSender, hostManager, new ProxyDataCollectionManager(testRunCriteria.TestRunSettings))
: new ProxyExecutionManager(requestData, requestSender, hostManager));
};
// parallelLevel = 1 for desktop should go via else route.
if (parallelLevel > 1 || !testHostManager.Shared)
{
return(new ParallelProxyExecutionManager(requestData, proxyExecutionManagerCreator, parallelLevel, sharedHosts: testHostManager.Shared));
}
else
{
return(proxyExecutionManagerCreator());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyExecutionManager"/> class.
/// </summary>
///
/// <param name="testSessionInfo">The test session info.</param>
/// <param name="debugEnabledForTestSession">
/// A flag indicating if debugging should be enabled or not.
/// </param>
public ProxyExecutionManager(TestSessionInfo testSessionInfo, bool debugEnabledForTestSession)
{
// Filling in test session info and proxy information.
this.testSessionInfo = testSessionInfo;
this.ProxyOperationManager = TestSessionPool.Instance.TakeProxy(this.testSessionInfo);
// This should be set to enable debugging when we have test session info available.
this.debugEnabledForTestSession = debugEnabledForTestSession;
this.testHostManager = this.ProxyOperationManager.TestHostManager;
this.dataSerializer = JsonDataSerializer.Instance;
this.isCommunicationEstablished = false;
this.requestData = this.ProxyOperationManager.RequestData;
this.fileHelper = new FileHelper();
}
/// <summary>
/// Fetches the DiscoveryManager for this engine. This manager would provide all functionality required for discovery.
/// </summary>
/// <param name="testHostManager"></param>
/// <returns>ITestDiscoveryManager object that can do discovery</returns>
public IProxyDiscoveryManager GetDiscoveryManager(ITestRuntimeProvider testHostManager, DiscoveryCriteria discoveryCriteria)
{
int parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(discoveryCriteria.Sources.Count(), discoveryCriteria.RunSettings);
Func <IProxyDiscoveryManager> proxyDiscoveryManagerCreator = () => new ProxyDiscoveryManager(testHostManager);
if (!testHostManager.Shared)
{
return(new ParallelProxyDiscoveryManager(proxyDiscoveryManagerCreator, parallelLevel, sharedHosts: testHostManager.Shared));
}
else
{
return(proxyDiscoveryManagerCreator());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyExecutionManager"/> class.
/// </summary>
///
/// <remarks>
/// Constructor with dependency injection. Used for unit testing.
/// </remarks>
///
/// <param name="requestData">The request data for common services and data for run.</param>
/// <param name="requestSender">Request sender instance.</param>
/// <param name="testHostManager">Test host manager instance.</param>
/// <param name="dataSerializer">Data serializer instance.</param>
/// <param name="fileHelper">File helper instance.</param>
internal ProxyExecutionManager(
IRequestData requestData,
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager,
IDataSerializer dataSerializer,
IFileHelper fileHelper)
{
this.testHostManager = testHostManager;
this.dataSerializer = dataSerializer;
this.isCommunicationEstablished = false;
this.requestData = requestData;
this.fileHelper = fileHelper;
// Create a new proxy operation manager.
this.ProxyOperationManager = new ProxyOperationManager(requestData, requestSender, testHostManager, this);
}
public void GetDiscoveryManagerShouldReturnsParallelDiscoveryManagerIfTestHostIsNotShared()
{
string settingXml =
@"<RunSettings>
<RunConfiguration>
<InIsolation>true</InIsolation>
</RunConfiguration >
</RunSettings>";
var discoveryCriteria = new DiscoveryCriteria(new List <string> {
"1.dll"
}, 100, settingXml);
this.testableTestRuntimeProvider = new TestableRuntimeProvider(false);
Assert.IsNotNull(this.testEngine.GetDiscoveryManager(this.mockRequestData.Object, this.testableTestRuntimeProvider, discoveryCriteria, this.protocolConfig));
Assert.IsInstanceOfType(this.testEngine.GetDiscoveryManager(this.mockRequestData.Object, this.testableTestRuntimeProvider, discoveryCriteria, this.protocolConfig), typeof(ParallelProxyDiscoveryManager));
}
public void GetExecutionManagerShouldReturnParallelExecutionManagerIfHostIsNotShared()
{
string settingXml =
@"<RunSettings>
<RunConfiguration>
<InIsolation>true</InIsolation>
</RunConfiguration >
</RunSettings>";
this.testableTestRuntimeProvider = new TestableRuntimeProvider(false);
var testRunCriteria = new TestRunCriteria(new List <string> {
"1.dll", "2.dll"
}, 100, false, settingXml);
Assert.IsNotNull(this.testEngine.GetExecutionManager(this.mockRequestData.Object, this.testableTestRuntimeProvider, testRunCriteria));
Assert.IsInstanceOfType(this.testEngine.GetExecutionManager(this.mockRequestData.Object, this.testableTestRuntimeProvider, testRunCriteria), typeof(ParallelProxyExecutionManager));
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyOperationManagerWithDataCollection"/>
/// class.
/// </summary>
///
/// <param name="requestData">The request data.</param>
/// <param name="requestSender">The request sender.</param>
/// <param name="testHostManager">The test host manager.</param>
/// <param name="proxyDataCollectionManager">The data collection proxy.</param>
public ProxyOperationManagerWithDataCollection(
IRequestData requestData,
ITestRequestSender requestSender,
ITestRuntimeProvider testHostManager,
IProxyDataCollectionManager proxyDataCollectionManager)
: base(
requestData,
requestSender,
testHostManager)
{
this.ProxyDataCollectionManager = proxyDataCollectionManager;
this.DataCollectionRunEventsHandler = new DataCollectionRunEventsHandler();
this.requestData = requestData;
this.dataCollectionEnvironmentVariables = new Dictionary <string, string>();
testHostManager.HostLaunched += this.TestHostLaunchedHandler;
}
/// <inheritdoc/>
public IProxyDiscoveryManager GetDiscoveryManager(
IRequestData requestData,
ITestRuntimeProvider testHostManager,
DiscoveryCriteria discoveryCriteria)
{
var parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(
discoveryCriteria.Sources.Count(),
discoveryCriteria.RunSettings);
// Collecting IsParallel enabled.
requestData.MetricsCollection.Add(
TelemetryDataConstants.ParallelEnabledDuringDiscovery,
parallelLevel > 1 ? "True" : "False");
if (this.ShouldRunInNoIsolation(discoveryCriteria.RunSettings, parallelLevel > 1, false))
{
var isTelemetryOptedIn = requestData.IsTelemetryOptedIn;
var newRequestData = this.GetRequestData(isTelemetryOptedIn);
return(new InProcessProxyDiscoveryManager(
testHostManager,
new TestHostManagerFactory(newRequestData)));
}
Func <IProxyDiscoveryManager> proxyDiscoveryManagerCreator = () =>
{
var hostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(discoveryCriteria.RunSettings);
hostManager?.Initialize(TestSessionMessageLogger.Instance, discoveryCriteria.RunSettings);
return(new ProxyDiscoveryManager(
requestData,
new TestRequestSender(requestData.ProtocolConfig, hostManager),
hostManager));
};
return(testHostManager.Shared
? proxyDiscoveryManagerCreator()
: new ParallelProxyDiscoveryManager(
requestData,
proxyDiscoveryManagerCreator,
parallelLevel,
sharedHosts: testHostManager.Shared));
}
