public void SetupChannelShouldCallSetupClientIfRunnerIsClient()
{
var connectionInfo = new TestHostConnectionInfo
{
Endpoint = IPAddress.Loopback + ":0",
Role = ConnectionRole.Host,
Transport = Transport.Sockets
};
ProtocolConfig protocolConfig = new ProtocolConfig {
Version = 2
};
var mockCommunicationManager = new Mock <ICommunicationManager>();
mockCommunicationManager.Setup(mc => mc.SetupClientAsync(new IPEndPoint(IPAddress.Loopback, 0)));
mockCommunicationManager.Setup(mc => mc.WaitForServerConnection(It.IsAny <int>())).Returns(true);
var mockDataSerializer = new Mock <IDataSerializer>();
var testRequestSender = new TestRequestSender(mockCommunicationManager.Object, connectionInfo, mockDataSerializer.Object, new ProtocolConfig {
Version = 2
});
this.mockTestHostManager.Setup(thm => thm.GetTestHostConnectionInfo()).Returns(connectionInfo);
var message = new Message()
{
MessageType = MessageType.VersionCheck, Payload = protocolConfig.Version
};
mockCommunicationManager.Setup(mc => mc.ReceiveMessage()).Returns(message);
mockDataSerializer.Setup(ds => ds.DeserializePayload <int>(It.IsAny <Message>())).Returns(protocolConfig.Version);
var localTestOperationManager = new TestableProxyOperationManager(testRequestSender, this.mockTestHostManager.Object, this.connectionTimeout);
localTestOperationManager.SetupChannel(Enumerable.Empty <string>(), CancellationToken.None);
mockCommunicationManager.Verify(s => s.SetupClientAsync(It.IsAny <IPEndPoint>()), Times.Once);
}
/// <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 void SetupChannelShouldCallSetupClientIfRunnerIsClient()
{
var connectionInfo = new TestHostConnectionInfo
{
Endpoint = IPAddress.Loopback + ":124",
Role = ConnectionRole.Host,
Transport = Transport.Sockets
};
ProtocolConfig protocolConfig = new ProtocolConfig {
Version = 2
};
var mockCommunicationEndpoint = new Mock <ICommunicationEndPoint>();
mockCommunicationEndpoint.Setup(mc => mc.Start(connectionInfo.Endpoint)).Returns(connectionInfo.Endpoint).Callback(() =>
{
mockCommunicationEndpoint.Raise(
s => s.Connected += null,
mockCommunicationEndpoint.Object,
new ConnectedEventArgs(this.mockChannel.Object));
});
this.SetupChannelMessage(MessageType.VersionCheck, MessageType.VersionCheck, protocolConfig.Version);
var testRequestSender = new TestRequestSender(mockCommunicationEndpoint.Object, connectionInfo, mockDataSerializer.Object, new ProtocolConfig {
Version = 2
}, CLIENTPROCESSEXITWAIT);
this.mockTestHostManager.Setup(thm => thm.GetTestHostConnectionInfo()).Returns(connectionInfo);
var localTestOperationManager = new TestableProxyOperationManager(this.mockRequestData.Object, testRequestSender, this.mockTestHostManager.Object);
localTestOperationManager.SetupChannel(Enumerable.Empty <string>());
mockCommunicationEndpoint.Verify(s => s.Start(It.IsAny <string>()), Times.Once);
}
/// <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>
/// 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());
}
}
public void VersionCheckWithTestHostShouldBeAbleToReceiveProtocolErrorAndThrowException()
{
var mockCommunicationManager = new Mock <ICommunicationManager>();
var message = new Message()
{
MessageType = MessageType.ProtocolError, Payload = null
};
mockCommunicationManager.Setup(mc => mc.ReceiveMessage()).Returns(message);
var testRequestSender = new TestRequestSender(mockCommunicationManager.Object, this.mockDataSerializer.Object, this.protocolConfig);
var ex = Assert.ThrowsException <TestPlatformException>(() => testRequestSender.CheckVersionWithTestHost());
Assert.AreEqual("Protocol version check failed. Make sure test runner and host are compatible.", ex.Message);
}
public void VersionCheckWithTestHostShouldCheckVersionIfVersionCheckPassesReturnTrue()
{
var mockCommunicationManager = new Mock <ICommunicationManager>();
var message = new Message()
{
MessageType = MessageType.VersionCheck, Payload = this.protocolConfig.Version
};
mockCommunicationManager.Setup(mc => mc.ReceiveMessage()).Returns(message);
var testRequestSender = new TestRequestSender(mockCommunicationManager.Object, this.mockDataSerializer.Object, this.protocolConfig);
testRequestSender.CheckVersionWithTestHost();
mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.VersionCheck, this.protocolConfig.Version), Times.Once);
}
public void VersionCheckWithTestHostForInvalidMessageShouldThrowException()
{
var mockCommunicationManager = new Mock <ICommunicationManager>();
var message = new Message()
{
MessageType = MessageType.TestCasesFound, Payload = null
};
mockCommunicationManager.Setup(mc => mc.ReceiveMessage()).Returns(message);
var testRequestSender = new TestRequestSender(mockCommunicationManager.Object, this.mockDataSerializer.Object, this.protocolConfig);
var ex = Assert.ThrowsException <TestPlatformException>(() => testRequestSender.CheckVersionWithTestHost());
Assert.AreEqual("Unexpected message received. Expected MessageType : ProtocolVersion Actual MessageType: TestDiscovery.TestFound", ex.Message);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyDiscoveryManager"/> class.
/// </summary>
/// <param name="testRequestSender">Test request sender instance.</param>
/// <param name="testHostManager">Test host manager instance.</param>
public ProxyDiscoveryManager(TestRequestSender testRequestSender, ITestRuntimeProvider testHostManager)
: this(testRequestSender, testHostManager, CrossPlatEngine.Constants.ClientConnectionTimeout)
{
this.testHostManager = testHostManager;
}
/// <inheritdoc/>
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);
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 = () =>
{
if (testRunCriteria.TestSessionInfo != null)
{
try
{
// In case we have an active test session, data collection needs were
// already taken care of when first creating the session. As a consequence
// we always return this proxy instead of choosing between the vanilla
// execution proxy and the one with data collection enabled.
return(new ProxyExecutionManager(
testRunCriteria.TestSessionInfo,
testRunCriteria.DebugEnabledForTestSession));
}
catch (InvalidOperationException ex)
{
// If the proxy creation process based on test session info failed, then
// we'll proceed with the normal creation process as if no test session
// info was passed in in the first place.
//
// WARNING: This should not normally happen and it raises questions
// regarding the test session pool operation and consistency.
EqtTrace.Warning("ProxyExecutionManager failed: {0}", ex.ToString());
}
}
// Create a new host manager, 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);
return(isDataCollectorEnabled
? new ProxyExecutionManagerWithDataCollection(
requestData,
requestSender,
hostManager,
new ProxyDataCollectionManager(
requestData,
testRunCriteria.TestRunSettings,
GetSourcesFromTestRunCriteria(testRunCriteria)))
: new ProxyExecutionManager(
requestData,
requestSender,
hostManager));
};
// parallelLevel = 1 for desktop should go via else route.
return((parallelLevel > 1 || !testHostManager.Shared)
? new ParallelProxyExecutionManager(
requestData,
proxyExecutionManagerCreator,
parallelLevel,
sharedHosts: testHostManager.Shared)
: proxyExecutionManagerCreator());
}
