private void SetContext()
{
this.testRunCache = new TestRunCache(this.testExecutionContext.FrequencyOfRunStatsChangeEvent, this.testExecutionContext.RunStatsChangeEventTimeout, this.OnCacheHit);
this.runContext = new RunContext();
this.runContext.RunSettings = RunSettingsUtilities.CreateAndInitializeRunSettings(this.runSettings);
this.runContext.KeepAlive = this.testExecutionContext.KeepAlive;
this.runContext.InIsolation = this.testExecutionContext.InIsolation;
this.runContext.IsDataCollectionEnabled = this.testExecutionContext.IsDataCollectionEnabled;
this.runContext.IsBeingDebugged = this.testExecutionContext.IsDebug;
var runConfig = XmlRunSettingsUtilities.GetRunConfigurationNode(this.runSettings);
this.runContext.TestRunDirectory = RunSettingsUtilities.GetTestResultsDirectory(runConfig);
this.runContext.SolutionDirectory = RunSettingsUtilities.GetSolutionDirectory(runConfig);
this.runConfiguration = runConfig;
this.frameworkHandle = new FrameworkHandle(
this.testCaseEventsHandler,
this.testRunCache,
this.testExecutionContext,
this.testRunEventsHandler);
this.frameworkHandle.TestRunMessage += this.OnTestRunMessage;
this.executorUrisThatRanTests = new List <string>();
}
public void InitializeShouldAddDefaultSettingsIfNotPresent()
{
// Arrange.
var fileName = "C:\\temp\\r.runsettings";
var settingsXml = "<RunSettings></RunSettings>";
var executor = new TestableRunSettingsArgumentExecutor(
CommandLineOptions.Instance,
this.settingsProvider,
settingsXml);
// Setup mocks.
var mockFileHelper = new Mock <IFileHelper>();
mockFileHelper.Setup(fh => fh.Exists(It.IsAny <string>())).Returns(true);
executor.FileHelper = mockFileHelper.Object;
// Act.
executor.Initialize(fileName);
// Assert.
Assert.IsNotNull(this.settingsProvider.ActiveRunSettings);
RunConfiguration runConfiguration =
XmlRunSettingsUtilities.GetRunConfigurationNode(this.settingsProvider.ActiveRunSettings.SettingsXml);
Assert.AreEqual(runConfiguration.ResultsDirectory, Constants.DefaultResultsDirectory);
Assert.AreEqual(runConfiguration.TargetFrameworkVersion.ToString(), Framework.DefaultFramework.ToString());
Assert.AreEqual(runConfiguration.TargetPlatform, Constants.DefaultPlatform);
}
/// <summary>
/// The create discovery request.
/// </summary>
/// <param name="requestData">Request data.</param>
/// <param name="discoveryCriteria"> The discovery criteria. </param>
/// <param name="options">Test platform options.</param>
/// <returns> The <see cref="IDiscoveryRequest"/>. </returns>
/// <exception cref="ArgumentNullException"> Throws if parameter is null. </exception>
public IDiscoveryRequest CreateDiscoveryRequest(IRequestData requestData, DiscoveryCriteria discoveryCriteria, TestPlatformOptions options)
{
if (discoveryCriteria == null)
{
throw new ArgumentNullException(nameof(discoveryCriteria));
}
// Update cache with Extension Folder's files
this.AddExtensionAssemblies(discoveryCriteria.RunSettings);
// Update extension assemblies from source when design mode is false.
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(discoveryCriteria.RunSettings);
if (runConfiguration.DesignMode == false)
{
this.AddExtensionAssembliesFromSource(discoveryCriteria.Sources);
}
// Initialize loggers
var loggerManager = this.TestEngine.GetLoggerManager(requestData);
loggerManager.Initialize(discoveryCriteria.RunSettings);
var testHostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(discoveryCriteria.RunSettings);
ThrowExceptionIfTestHostManagerIsNull(testHostManager, discoveryCriteria.RunSettings);
testHostManager.Initialize(TestSessionMessageLogger.Instance, discoveryCriteria.RunSettings);
var discoveryManager = this.TestEngine.GetDiscoveryManager(requestData, testHostManager, discoveryCriteria);
discoveryManager.Initialize(options?.SkipDefaultAdapters ?? false);
return(new DiscoveryRequest(requestData, discoveryCriteria, discoveryManager, loggerManager));
}
internal static void AddDataCollectorToRunSettings(string argument, IRunSettingsProvider runSettingsManager)
{
EnabledDataCollectors.Add(argument.ToLower());
var settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
if (settings == null)
{
runSettingsManager.AddDefaultRunSettings();
settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings) ?? new DataCollectionRunSettings();
var inProcDataCollectionRunSettings = XmlRunSettingsUtilities.GetInProcDataCollectionRunSettings(settings)
?? new DataCollectionRunSettings(
Constants.InProcDataCollectionRunSettingsName,
Constants.InProcDataCollectorsSettingName,
Constants.InProcDataCollectorSettingName);
// Add data collectors if not already present, enable if already present.
EnableDataCollectorUsingFriendlyName(argument, dataCollectionRunSettings);
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
if (string.Equals(argument, CoverletConstants.CoverletDataCollectorFriendlyName, StringComparison.OrdinalIgnoreCase))
{
// Add inproc data collector to runsetings if coverlet code coverage is enabled
EnableCoverletInProcDataCollector(argument, inProcDataCollectionRunSettings);
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.InProcDataCollectionRunSettingsName, inProcDataCollectionRunSettings.ToXml().InnerXml);
}
}
public void FakesDataCollectorSettingsShouldBeInserted()
{
string runSettingsXml = @"<RunSettings><RunConfiguration></RunConfiguration></RunSettings>";
var doc = new XmlDocument();
using (var xmlReader = XmlReader.Create(
new StringReader(runSettingsXml),
new XmlReaderSettings()
{
CloseInput = true
}))
{
doc.Load(xmlReader);
}
var dataCollectorNode2 = new DataCollectorSettings()
{
AssemblyQualifiedName = FakesUtilities.FakesMetadata.DataCollectorAssemblyQualifiedName,
Uri = new Uri(FakesUtilities.FakesMetadata.DataCollectorUriV2),
FriendlyName = FakesUtilities.FakesMetadata.FriendlyName,
IsEnabled = true,
Configuration = doc.FirstChild as XmlElement
};
FakesUtilities.InsertOrReplaceFakesDataCollectorNode(doc, dataCollectorNode2);
Assert.IsTrue(XmlRunSettingsUtilities.ContainsDataCollector(doc, FakesUtilities.FakesMetadata.DataCollectorUriV2));
}
/// <summary>
/// Log Enabled Data Collectors
/// </summary>
private void LogEnabledDataCollectors()
{
if (!this.requestData.IsTelemetryOptedIn)
{
return;
}
var dataCollectionSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(this.settingsXml);
if (dataCollectionSettings == null || !dataCollectionSettings.IsCollectionEnabled)
{
return;
}
var enabledDataCollectors = new List <DataCollectorSettings>();
foreach (var settings in dataCollectionSettings.DataCollectorSettingsList)
{
if (settings.IsEnabled)
{
if (enabledDataCollectors.Any(dcSettings => string.Equals(dcSettings.FriendlyName, settings.FriendlyName, StringComparison.OrdinalIgnoreCase)))
{
// If Uri or assembly qualified type name is repeated, consider data collector as duplicate and ignore it.
continue;
}
enabledDataCollectors.Add(settings);
}
}
var dataCollectors = enabledDataCollectors.Select(x => new { x.FriendlyName, x.Uri }.ToString());
this.requestData.MetricsCollection.Add(TelemetryDataConstants.DataCollectorsEnabled, string.Join(",", dataCollectors.ToArray()));
}
public void GetTestRunParametersReturns3EntryOn3TestRunParameter()
{
string settingsXml =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<RunSettings>
<RunConfiguration>
<ResultsDirectory>.\TestResults</ResultsDirectory>
<TargetPlatform>x86</TargetPlatform>
<TargetFrameworkVersion>Framework40</TargetFrameworkVersion>
</RunConfiguration>
<TestRunParameters>
<Parameter name=""webAppUrl"" value=""http://localhost"" />
<Parameter name=""webAppUserName"" value=""Admin"" />
<Parameter name=""webAppPassword"" value=""Password"" />
</TestRunParameters>
</RunSettings>";
Dictionary <string, object> trp = XmlRunSettingsUtilities.GetTestRunParameters(settingsXml);
Assert.IsNotNull(trp);
Assert.AreEqual(3, trp.Count);
// Verify Parameter Values.
Assert.IsTrue(trp.ContainsKey("webAppUrl"));
Assert.AreEqual(trp["webAppUrl"], "http://localhost");
Assert.IsTrue(trp.ContainsKey("webAppUserName"));
Assert.AreEqual(trp["webAppUserName"], "Admin");
Assert.IsTrue(trp.ContainsKey("webAppPassword"));
Assert.AreEqual(trp["webAppPassword"], "Password");
}
public void GetTestRunParametersReturnsEmptyDictionaryOnNullRunSettings()
{
Dictionary <string, object> trp = XmlRunSettingsUtilities.GetTestRunParameters(null);
Assert.IsNotNull(trp);
Assert.AreEqual(0, trp.Count);
}
/// <summary>
/// The create discovery request.
/// </summary>
/// <param name="discoveryCriteria"> The discovery criteria. </param>
/// <param name="protocolConfig"> Protocol related information. </param>
/// <returns> The <see cref="IDiscoveryRequest"/>. </returns>
/// <exception cref="ArgumentNullException"> Throws if parameter is null. </exception>
public IDiscoveryRequest CreateDiscoveryRequest(DiscoveryCriteria discoveryCriteria, ProtocolConfig protocolConfig)
{
if (discoveryCriteria == null)
{
throw new ArgumentNullException(nameof(discoveryCriteria));
}
// Update cache with Extension Folder's files
this.AddExtensionAssemblies(discoveryCriteria.RunSettings);
// Update and initialize loggers only when DesignMode is false
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(discoveryCriteria.RunSettings);
if (runConfiguration.DesignMode == false)
{
this.AddExtensionAssembliesFromSource(discoveryCriteria.Sources);
// Initialize loggers
TestLoggerManager.Instance.InitializeLoggers();
}
var testHostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(discoveryCriteria.RunSettings);
testHostManager.Initialize(TestSessionMessageLogger.Instance, discoveryCriteria.RunSettings);
var requestData = new RequestData(new MetricsCollection());
var discoveryManager = this.TestEngine.GetDiscoveryManager(requestData, testHostManager, discoveryCriteria, protocolConfig);
discoveryManager.Initialize();
return(new DiscoveryRequest(requestData, discoveryCriteria, discoveryManager));
}
/// <summary>
/// Loads all the inproc data collector dlls
/// </summary>
private void InitializeInProcDataCollectors(string runSettings)
{
try
{
// Check if runsettings contains in-proc datacollector element
var inProcDataCollectionRunSettings = XmlRunSettingsUtilities.GetInProcDataCollectionRunSettings(runSettings);
var inProcDataCollectionSettingsPresentInRunSettings = inProcDataCollectionRunSettings?.IsCollectionEnabled ?? false;
// Verify if it has any valid in-proc datacollectors or just a dummy element
inProcDataCollectionSettingsPresentInRunSettings = inProcDataCollectionSettingsPresentInRunSettings &&
inProcDataCollectionRunSettings.DataCollectorSettingsList.Any();
// Initialize if we have atleast one
if (inProcDataCollectionSettingsPresentInRunSettings)
{
this.inProcDataCollectorSettingsCollection = inProcDataCollectionRunSettings.DataCollectorSettingsList;
var interfaceTypeInfo = typeof(InProcDataCollection).GetTypeInfo();
foreach (var inProcDc in this.inProcDataCollectorSettingsCollection)
{
var inProcDataCollector = this.CreateDataCollector(inProcDc, interfaceTypeInfo);
this.inProcDataCollectors[inProcDataCollector.AssemblyQualifiedName] = inProcDataCollector;
}
}
}
catch (Exception ex)
{
EqtTrace.Error("InProcDataCollectionExtensionManager: Error occured while Initializing the datacollectors : {0}", ex);
}
finally
{
this.IsInProcDataCollectionEnabled = this.inProcDataCollectors.Any();
}
}
/// <summary>
/// The create test run request.
/// </summary>
/// <param name="testRunCriteria"> The test run criteria. </param>
/// <param name="protocolConfig"> Protocol related information. </param>
/// <returns> The <see cref="ITestRunRequest"/>. </returns>
/// <exception cref="ArgumentNullException"> Throws if parameter is null. </exception>
public ITestRunRequest CreateTestRunRequest(TestRunCriteria testRunCriteria, ProtocolConfig protocolConfig)
{
if (testRunCriteria == null)
{
throw new ArgumentNullException(nameof(testRunCriteria));
}
this.AddExtensionAssemblies(testRunCriteria.TestRunSettings);
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(testRunCriteria.TestRunSettings);
// Update and initialize loggers only when DesignMode is false
if (runConfiguration.DesignMode == false)
{
this.AddExtensionAssembliesFromSource(testRunCriteria);
// Initialize loggers
TestLoggerManager.Instance.InitializeLoggers();
}
var testHostManager = this.testHostProviderManager.GetTestHostManagerByRunConfiguration(testRunCriteria.TestRunSettings);
testHostManager.Initialize(TestSessionMessageLogger.Instance, testRunCriteria.TestRunSettings);
if (testRunCriteria.TestHostLauncher != null)
{
testHostManager.SetCustomLauncher(testRunCriteria.TestHostLauncher);
}
var executionManager = this.TestEngine.GetExecutionManager(testHostManager, testRunCriteria, protocolConfig);
executionManager.Initialize();
return(new TestRunRequest(testRunCriteria, executionManager));
}
/// <summary>
/// The get data collector launcher.
/// </summary>
/// <returns>
/// The <see cref="IDataCollectionLauncher"/>.
/// </returns>
internal static IDataCollectionLauncher GetDataCollectorLauncher(IProcessHelper processHelper, string settingsXml)
{
// Always launch datacollector.exe if code coverage is configured.
if (!string.IsNullOrWhiteSpace(settingsXml))
{
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settingsXml);
foreach (var dataCollectorSettings in dataCollectionRunSettings.DataCollectorSettingsList)
{
if (dataCollectorSettings.FriendlyName.ToLower().Equals("code coverage"))
{
return(new DefaultDataCollectionLauncher());
}
}
}
// Target Framework of DataCollection process and Runner should be same.
var currentProcessPath = processHelper.GetCurrentProcessFileName();
if (currentProcessPath.EndsWith("dotnet", StringComparison.OrdinalIgnoreCase) ||
currentProcessPath.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
{
return(new DotnetDataCollectionLauncher());
}
return(new DefaultDataCollectionLauncher());
}
private bool UpdateRunSettingsIfRequired(string runsettingsXml, List <string> sources, IBaseTestEventsRegistrar registrar, out string updatedRunSettingsXml)
{
bool settingsUpdated = false;
updatedRunSettingsXml = runsettingsXml;
IDictionary <string, Architecture> sourcePlatforms = new Dictionary <string, Architecture>();
IDictionary <string, Framework> sourceFrameworks = new Dictionary <string, Framework>();
if (!string.IsNullOrEmpty(runsettingsXml))
{
// TargetFramework is full CLR. Set DesignMode based on current context.
using (var stream = new StringReader(runsettingsXml))
using (var reader = XmlReader.Create(stream, XmlRunSettingsUtilities.ReaderSettings))
{
var document = new XmlDocument();
document.Load(reader);
var navigator = document.CreateNavigator();
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettingsXml);
var loggerRunSettings = XmlRunSettingsUtilities.GetLoggerRunSettings(runsettingsXml) ?? new LoggerRunSettings();
settingsUpdated |= this.UpdateFramework(document, navigator, sources, sourceFrameworks, registrar, out Framework chosenFramework);
settingsUpdated |= this.UpdatePlatform(document, navigator, sources, sourcePlatforms, out Architecture chosenPlatform);
this.CheckSourcesForCompatibility(chosenFramework, chosenPlatform, sourcePlatforms, sourceFrameworks, registrar);
settingsUpdated |= this.UpdateDesignMode(document, runConfiguration);
settingsUpdated |= this.UpdateCollectSourceInformation(document, runConfiguration);
settingsUpdated |= this.UpdateTargetDevice(navigator, document, runConfiguration);
settingsUpdated |= this.AddOrUpdateConsoleLogger(document, runConfiguration, loggerRunSettings);
updatedRunSettingsXml = navigator.OuterXml;
}
}
return(settingsUpdated);
}
private void UpdateConfigurationElement()
{
var frameWork = XmlRunSettingsUtilities.GetRunConfigurationNode(this.SettingsXml).TargetFrameworkVersion;
if (this.ConfigurationElement == null)
{
var doc = new XmlDocument();
using (
var xmlReader = XmlReader.Create(
new StringReader(DefaultConfigurationSettings),
new XmlReaderSettings {
CloseInput = true, DtdProcessing = DtdProcessing.Prohibit
}))
{
doc.Load(xmlReader);
}
this.ConfigurationElement = doc.DocumentElement;
}
// Add Framework config, since it could be required by DataCollector, to determine whether they support this Framework or not
if (frameWork != null)
{
AppendChildNodeOrInnerText(this.ConfigurationElement.OwnerDocument, this.ConfigurationElement, "Framework", "", frameWork.Name);
}
}
private static bool IsNetCoreFramework(string runSettingsXml)
{
var config = XmlRunSettingsUtilities.GetRunConfigurationNode(runSettingsXml);
return(config.TargetFramework.Name.IndexOf("netstandard", StringComparison.OrdinalIgnoreCase) >= 0 ||
config.TargetFramework.Name.IndexOf("netcoreapp", StringComparison.OrdinalIgnoreCase) >= 0);
}
public void OtherRunsettingsShouldNotBeChanged()
{
string runSettingsXml = @"<RunSettings><RunConfiguration><TargetFrameworkVersion>FrameworkCore10</TargetFrameworkVersion></RunConfiguration></RunSettings>";
var doc = new XmlDocument();
using (var xmlReader = XmlReader.Create(
new StringReader(runSettingsXml),
new XmlReaderSettings()
{
CloseInput = true
}))
{
doc.Load(xmlReader);
}
var dataCollectorNode2 = new DataCollectorSettings()
{
AssemblyQualifiedName = FakesUtilities.FakesMetadata.DataCollectorAssemblyQualifiedName,
Uri = new Uri(FakesUtilities.FakesMetadata.DataCollectorUriV2),
FriendlyName = FakesUtilities.FakesMetadata.FriendlyName,
IsEnabled = true,
Configuration = doc.CreateElement("Configuration")
};
FakesUtilities.InsertOrReplaceFakesDataCollectorNode(doc, dataCollectorNode2);
Assert.IsTrue(XmlRunSettingsUtilities.ContainsDataCollector(doc, FakesUtilities.FakesMetadata.DataCollectorUriV2));
XmlNodeList nodes = doc.SelectNodes("//RunSettings/RunConfiguration/TargetFrameworkVersion");
Assert.AreEqual(nodes[0].InnerText, "FrameworkCore10");
}
private bool TryUpdateDesignMode(string runsettingsXml, out string updatedRunSettingsXml)
{
updatedRunSettingsXml = runsettingsXml;
// If user is already setting DesignMode via runsettings or CLI args; we skip. We also skip if the target framework
// is not known or current run is targeted to netcoreapp (since it is a breaking change; user may be running older
// NET.Test.Sdk; we will remove this constraint in 15.1).
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettingsXml);
if (runConfiguration.DesignModeSet || !runConfiguration.TargetFrameworkSet ||
runConfiguration.TargetFrameworkVersion.Name.IndexOf("netstandard", StringComparison.OrdinalIgnoreCase) >= 0 ||
runConfiguration.TargetFrameworkVersion.Name.IndexOf("netcoreapp", StringComparison.OrdinalIgnoreCase) >= 0)
{
return(false);
}
// TargetFramework is full CLR. Set DesignMode based on current context.
using (var stream = new StringReader(runsettingsXml))
using (var reader = XmlReader.Create(stream, XmlRunSettingsUtilities.ReaderSettings))
{
var document = new XmlDocument();
document.Load(reader);
var navigator = document.CreateNavigator();
InferRunSettingsHelper.UpdateDesignMode(navigator, this.commandLineOptions.IsDesignMode);
updatedRunSettingsXml = navigator.OuterXml;
}
return(true);
}
/// <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(ITestHostManager testHostManager, TestRunCriteria testRunCriteria)
{
var distinctSources = GetDistinctNumberOfSources(testRunCriteria);
int parallelLevel = this.VerifyParallelSettingAndCalculateParallelLevel(distinctSources, testRunCriteria.TestRunSettings);
var runconfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(testRunCriteria.TestRunSettings);
var architecture = runconfiguration.TargetPlatform;
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, this.GetDataCollectionManager(architecture, 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());
}
}
/// <summary>
/// Tries to embed the Fakes data collector settings for the given run settings.
/// </summary>
/// <param name="runSettings">runsettings</param>
/// <param name="sources">test sources</param>
/// <returns>true if runSettings was modified; false otherwise.</returns>
private static bool TryAddFakesDataCollectorSettings(
XmlDocument runSettings,
IEnumerable <string> sources,
FrameworkVersion framework)
{
// If user provided fakes settings don't do anything
if (XmlRunSettingsUtilities.ContainsDataCollector(runSettings.CreateNavigator(), FakesMetadata.DataCollectorUri))
{
return(false);
}
// A new Fakes Congigurator API makes the decision to add the right datacollector uri to the configuration
// There now exist two data collector URIs to support two different scenarios. The new scenario involves
// using the CLRIE profiler, and the old involves using the Intellitrace profiler (which isn't supported in
// .NET Core scenarios). The old API still exists for fallback measures.
var crossPlatformConfigurator = TryGetFakesCrossPlatformDataCollectorConfigurator();
if (crossPlatformConfigurator != null)
{
var sourceTFMMap = CreateDictionary(sources, framework);
var fakesSettings = crossPlatformConfigurator(sourceTFMMap);
// if no fakes, return settings unchanged
if (fakesSettings == null)
{
return(false);
}
XmlRunSettingsUtilities.InsertDataCollectorsNode(runSettings.CreateNavigator(), fakesSettings);
return(true);
}
return(AddFallbackFakesSettings(runSettings, sources, framework));
}
/// <summary>
/// Execute the test run asynchronously
/// </summary>
/// <returns>The process id of test host.</returns>
public int ExecuteAsync()
{
EqtTrace.Verbose("TestRunRequest.ExecuteAsync: Starting.");
lock (this.syncObject)
{
if (this.disposed)
{
throw new ObjectDisposedException("testRunRequest");
}
if (this.State != TestRunState.Pending)
{
throw new InvalidOperationException(ClientResources.InvalidStateForExecution);
}
EqtTrace.Info("TestRunRequest.ExecuteAsync: Starting run with settings:{0}", this.testRunCriteria);
// Waiting for warm up to be over.
EqtTrace.Verbose("TestRunRequest.ExecuteAsync: Wait for the first run request is over.");
this.State = TestRunState.InProgress;
// Reset the run completion event
// (This needs to be done before queuing the test run because if the test run finishes fast then runCompletion event can
// remain in non-signaled state even though run is actually complete.
this.runCompletionEvent.Reset();
try
{
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(this.TestRunCriteria.TestRunSettings);
this.testSessionTimeout = runConfiguration.TestSessionTimeout;
if (testSessionTimeout > 0)
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(String.Format("TestRunRequest.ExecuteAsync: TestSessionTimeout is {0} milliseconds.", testSessionTimeout));
}
this.timer = new Timer(this.OnTestSessionTimeout, null, TimeSpan.FromMilliseconds(testSessionTimeout), TimeSpan.FromMilliseconds(0));
}
this.runRequestTimeTracker = new Stopwatch();
// Start the stop watch for calculating the test run time taken overall
this.runRequestTimeTracker.Start();
int processId = this.ExecutionManager.StartTestRun(this.testRunCriteria, this);
EqtTrace.Info("TestRunRequest.ExecuteAsync: Started.");
return(processId);
}
catch
{
this.State = TestRunState.Pending;
throw;
}
}
}
public void CreateDefaultRunSettingsShouldReturnABasicRunSettings()
{
var defaultRunSettings = XmlRunSettingsUtilities.CreateDefaultRunSettings().CreateNavigator().OuterXml;
var expectedRunSettings =
"<RunSettings>\r\n <DataCollectionRunSettings>\r\n <DataCollectors />\r\n </DataCollectionRunSettings>\r\n</RunSettings>";
Assert.AreEqual(expectedRunSettings, defaultRunSettings);
}
/// <inheritdoc/>
public IDictionary <string, string> InitializeDataCollectors(string settingsXml)
{
if (string.IsNullOrEmpty(settingsXml) && EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("DataCollectionManager.InitializeDataCollectors : Runsettings is null or empty.");
}
ValidateArg.NotNull(settingsXml, "settingsXml");
var sessionId = new SessionId(Guid.NewGuid());
var dataCollectionContext = new DataCollectionContext(sessionId);
this.dataCollectionEnvironmentContext = DataCollectionEnvironmentContext.CreateForLocalEnvironment(dataCollectionContext);
this.attachmentManager.Initialize(sessionId, sourceDirectory, this.messageSink);
// Enviornment variables are passed to testhost process, through ProcessStartInfo.EnvironmentVariables, which handles the key in a case-insensitive manner, which is translated to lowercase.
// Therefore, using StringComparer.OrdinalIgnoreCase so that same keys with different cases are treated as same.
var executionEnvironmentVariables = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(settingsXml);
sourceDirectory = RunSettingsUtilities.GetTestResultsDirectory(runConfiguration);
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settingsXml);
this.isDataCollectionEnabled = dataCollectionRunSettings.IsCollectionEnabled;
// If dataCollectionRunSettings is null, that means datacollectors are not configured.
if (dataCollectionRunSettings == null || !dataCollectionRunSettings.IsCollectionEnabled)
{
return(executionEnvironmentVariables);
}
// Get settings for each data collector, load and initialize the data collectors.
var enabledDataCollectorsSettings = this.GetDataCollectorsEnabledForRun(dataCollectionRunSettings);
if (enabledDataCollectorsSettings == null || enabledDataCollectorsSettings.Count == 0)
{
return(executionEnvironmentVariables);
}
foreach (var dataCollectorSettings in enabledDataCollectorsSettings)
{
this.LoadAndInitialize(dataCollectorSettings);
}
// Once all data collectors have been initialized, query for environment variables
bool unloadedAnyCollector;
var dataCollectorEnvironmentVariables = this.GetEnvironmentVariables(out unloadedAnyCollector);
foreach (var variable in dataCollectorEnvironmentVariables.Values)
{
executionEnvironmentVariables.Add(variable.Name, variable.Value);
}
return(executionEnvironmentVariables);
}
/// <inheritdoc/>
public void Initialize(IMessageLogger logger, string runsettingsXml)
{
this.messageLogger = logger;
this.hostExitedEventRaised = false;
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettingsXml);
this.architecture = runConfiguration.TargetPlatform;
}
private bool UpdateRunSettingsIfRequired(string runsettingsXml, List <string> sources, IBaseTestEventsRegistrar registrar, out string updatedRunSettingsXml)
{
bool settingsUpdated = false;
updatedRunSettingsXml = runsettingsXml;
IDictionary <string, Architecture> sourcePlatforms = new Dictionary <string, Architecture>();
IDictionary <string, Framework> sourceFrameworks = new Dictionary <string, Framework>();
if (!string.IsNullOrEmpty(runsettingsXml))
{
// TargetFramework is full CLR. Set DesignMode based on current context.
using (var stream = new StringReader(runsettingsXml))
using (var reader = XmlReader.Create(stream, XmlRunSettingsUtilities.ReaderSettings))
{
var document = new XmlDocument();
document.Load(reader);
var navigator = document.CreateNavigator();
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettingsXml);
var loggerRunSettings = XmlRunSettingsUtilities.GetLoggerRunSettings(runsettingsXml) ?? new LoggerRunSettings();
settingsUpdated |= this.UpdateFramework(document, navigator, sources, sourceFrameworks, registrar, out Framework chosenFramework);
// Choose default architecture based on the framework
// For .NET core, the default platform architecture should be based on the process.
Architecture defaultArchitecture = Architecture.X86;
if (chosenFramework.Name.IndexOf("netstandard", StringComparison.OrdinalIgnoreCase) >= 0 ||
chosenFramework.Name.IndexOf("netcoreapp", StringComparison.OrdinalIgnoreCase) >= 0 ||
chosenFramework.Name.IndexOf("net5", StringComparison.OrdinalIgnoreCase) >= 0)
{
#if NETCOREAPP
// We are running in vstest.console that is either started via dotnet.exe or via vstest.console.exe .NET Core
// executable. For AnyCPU dlls this should resolve 32-bit SDK when running from 32-bit dotnet process and
// 64-bit SDK when running from 64-bit dotnet process.
defaultArchitecture = Environment.Is64BitProcess ? Architecture.X64 : Architecture.X86;
#else
// We are running in vstest.console.exe that was built against .NET Framework. This console prefers 32-bit
// because it needs to run as 32-bit to be compatible with QTAgent. It runs as 32-bit both under VS and
// in Developer console. Set the default architecture based on the OS architecture, to find 64-bit dotnet SDK
// when running AnyCPU dll on 64-bit system, and 32-bit SDK when running AnyCPU dll on 32-bit OS.
// We want to find 64-bit SDK because it is more likely to be installed.
defaultArchitecture = Environment.Is64BitOperatingSystem ? Architecture.X64 : Architecture.X86;
#endif
}
settingsUpdated |= this.UpdatePlatform(document, navigator, sources, sourcePlatforms, defaultArchitecture, out Architecture chosenPlatform);
this.CheckSourcesForCompatibility(chosenFramework, chosenPlatform, defaultArchitecture, sourcePlatforms, sourceFrameworks, registrar);
settingsUpdated |= this.UpdateDesignMode(document, runConfiguration);
settingsUpdated |= this.UpdateCollectSourceInformation(document, runConfiguration);
settingsUpdated |= this.UpdateTargetDevice(navigator, document, runConfiguration);
settingsUpdated |= this.AddOrUpdateConsoleLogger(document, runConfiguration, loggerRunSettings);
updatedRunSettingsXml = navigator.OuterXml;
}
}
return(settingsUpdated);
}
public string CreateDefaultRunsettingsFile()
{
XmlDocument tmp = XmlRunSettingsUtilities.CreateDefaultRunSettings() as XmlDocument;
RunConfiguration runConfiguration = new RunConfiguration();
XmlNode node = tmp.ImportNode(runConfiguration.ToXml(), true);
tmp.LastChild.AppendChild(node);
return(tmp.InnerXml);
}
public object GetXmlConfigurationNode(string defaultRunsettingsXml)
{
if (string.IsNullOrEmpty(defaultRunsettingsXml))
{
defaultRunsettingsXml = File.ReadAllText(this.GetConfigValue(Contracts.Constants.DefaultRunsettingsFile));
}
return(XmlRunSettingsUtilities.GetRunConfigurationNode(defaultRunsettingsXml));
}
/// <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));
}
public void ExecuteShouldInitializeDefaultRunsettings()
{
var mockOutput = new MockOutput();
var exitCode = new Executor(mockOutput, this.mockTestPlatformEventSource.Object).Execute(null);
RunConfiguration runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(RunSettingsManager.Instance.ActiveRunSettings.SettingsXml);
Assert.AreEqual(Constants.DefaultResultsDirectory, runConfiguration.ResultsDirectory);
Assert.AreEqual(Framework.DefaultFramework.ToString(), runConfiguration.TargetFramework.ToString());
Assert.AreEqual(Constants.DefaultPlatform, runConfiguration.TargetPlatform);
}
public void AddDefaultRunSettingsShouldNotChangeSpecifiedSettings()
{
this.runSettingsProvider.UpdateRunSettings("<RunSettings>\r\n <RunConfiguration>\r\n <TargetPlatform>X64</TargetPlatform>\r\n </RunConfiguration>\r\n</RunSettings>");
this.runSettingsProvider.AddDefaultRunSettings();
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(this.runSettingsProvider.ActiveRunSettings.SettingsXml);
Assert.AreEqual(runConfiguration.TargetPlatform, Architecture.X64);
}
public void AddDefaultRunSettingsShouldSetDefaultSettingsForEmptySettings()
{
this.runSettingsProvider.AddDefaultRunSettings();
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(this.runSettingsProvider.ActiveRunSettings.SettingsXml);
Assert.AreEqual(runConfiguration.ResultsDirectory, Constants.DefaultResultsDirectory);
Assert.AreEqual(runConfiguration.TargetFrameworkVersion.ToString(), Framework.DefaultFramework.ToString());
Assert.AreEqual(runConfiguration.TargetPlatform, Constants.DefaultPlatform);
}
