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