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