private void InitOrRefreshEnvironment(IRunSettings runSettings, IMessageLogger messageLogger, IRunContext runContext)
{
if (_settings == null || _settings.GetType() == typeof(SettingsWrapper)) // the latter prevents test settings and logger from being replaced
{
CommonFunctions.CreateEnvironment(runSettings, messageLogger, out _logger, out _settings, runContext.SolutionDirectory);
}
}
private Dictionary<string, PythonProjectSettings> GetSourceToSettings(IRunSettings settings) {
var doc = Read(settings.SettingsXml);
XPathNodeIterator nodes = doc.CreateNavigator().Select("/RunSettings/Python/TestCases/Project");
Dictionary<string, PythonProjectSettings> res = new Dictionary<string, PythonProjectSettings>();
foreach (XPathNavigator project in nodes) {
PythonProjectSettings projSettings = new PythonProjectSettings(
project.GetAttribute("home", ""),
project.GetAttribute("workingDir", ""),
project.GetAttribute("interpreter", ""),
project.GetAttribute("pathEnv", ""),
project.GetAttribute("nativeDebugging", "").IsTrue()
);
foreach (XPathNavigator environment in project.Select("Environment/Variable")) {
projSettings.Environment[environment.GetAttribute("name", "")] = environment.GetAttribute("value", "");
}
string djangoSettings = project.GetAttribute("djangoSettingsModule", "");
if (!String.IsNullOrWhiteSpace(djangoSettings)) {
projSettings.Environment["DJANGO_SETTINGS_MODULE"] = djangoSettings;
}
foreach (XPathNavigator searchPath in project.Select("SearchPaths/Search")) {
projSettings.SearchPath.Add(searchPath.GetAttribute("value", ""));
}
foreach (XPathNavigator test in project.Select("Test")) {
string testFile = test.GetAttribute("file", "");
Debug.Assert(!string.IsNullOrWhiteSpace(testFile));
res[testFile] = projSettings;
}
}
return res;
}
private void InitOrRefreshTestEnvironment(IRunSettings runSettings, IMessageLogger messageLogger)
{
if (_testEnvironment == null || _testEnvironment.Options.GetType() == typeof(SettingsWrapper))
{
_testEnvironment = CreateTestEnvironment(runSettings, messageLogger);
}
}
public TestRunner(IEnumerable <string> sources, IRunSettings runSettings, ITestExecutionRecorder recorder)
{
RunSettings = RunSettings;
sink = new TestCaseDiscoverySink();
new MSTestDiscoverer().DiscoverTests(sources, this, this, sink);
this.recorder = recorder;
}
public static void CreateEnvironment(IRunSettings runSettings, IMessageLogger messageLogger, out ILogger logger, out SettingsWrapper settings, string solutionDir = null)
{
if (string.IsNullOrWhiteSpace(solutionDir))
{
solutionDir = null;
}
var settingsProvider = SafeGetRunSettingsProvider(runSettings, messageLogger);
var ourRunSettings = GetRunSettingsContainer(settingsProvider, messageLogger);
foreach (RunSettings projectSettings in ourRunSettings.ProjectSettings)
{
projectSettings.GetUnsetValuesFrom(ourRunSettings.SolutionSettings);
}
var testSettings = runSettings.GetSettings(GoogleTestConstants.TestPropertySettingsName) as TestPropertySettingsProvider;
var settingsWrapper = new SettingsWrapper(ourRunSettings, testSettings?.TestPropertySettings, solutionDir);
var loggerAdapter = new VsTestFrameworkLogger(messageLogger, () => settingsWrapper.OutputMode,
() => settingsWrapper.TimestampMode, () => settingsWrapper.SeverityMode, () => settingsWrapper.PrefixOutputWithGta);
settingsWrapper.RegexTraitParser = new RegexTraitParser(loggerAdapter);
settingsWrapper.HelperFilesCache = new HelperFilesCache(loggerAdapter);
LogWarningsForDeprecatedSettings(ourRunSettings, loggerAdapter);
settings = settingsWrapper;
logger = loggerAdapter;
SpeedupThreadPoolHack(logger);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestSourceHost"/> class.
/// </summary>
/// <param name="sourceFileName"> The source file name. </param>
/// <param name="runSettings"> The run-settings provided for this session. </param>
/// <param name="frameworkHandle"> The handle to the test platform. </param>
public TestSourceHost(string sourceFileName, IRunSettings runSettings, IFrameworkHandle frameworkHandle)
{
this.sourceFileName = sourceFileName;
// Set the environment context.
this.SetContext(sourceFileName);
}
public static void CreateEnvironment(IRunSettings runSettings, IMessageLogger messageLogger, out ILogger logger, out SettingsWrapper settings)
{
RunSettingsProvider settingsProvider;
try
{
settingsProvider = runSettings.GetSettings(GoogleTestConstants.SettingsName) as RunSettingsProvider;
}
catch (Exception e)
{
settingsProvider = null;
messageLogger.SendMessage(TestMessageLevel.Error, $"ERROR: Visual Studio test framework failed to provide settings; using default settings. Error message: {e.Message}");
}
RunSettingsContainer ourRunSettings = settingsProvider?.SettingsContainer ?? new RunSettingsContainer();
foreach (RunSettings projectSettings in ourRunSettings.ProjectSettings)
{
projectSettings.GetUnsetValuesFrom(ourRunSettings.SolutionSettings);
}
var settingsWrapper = new SettingsWrapper(ourRunSettings);
var loggerAdapter = new VsTestFrameworkLogger(messageLogger, () => settingsWrapper.DebugMode, () => settingsWrapper.TimestampOutput);
var regexParser = new RegexTraitParser(loggerAdapter);
settingsWrapper.RegexTraitParser = regexParser;
settings = settingsWrapper;
logger = loggerAdapter;
}
/// <summary>
/// Get the tests from the parameter source
/// </summary>
/// <param name="source"> The source. </param>
/// <param name="logger"> The logger. </param>
/// <param name="discoverySink"> The discovery Sink. </param>
/// <param name="runSettings"> The run settings. </param>
internal virtual void DiscoverTestsInSource(
string source,
IMessageLogger logger,
ITestCaseDiscoverySink discoverySink,
IRunSettings runSettings)
{
ICollection <string> warnings;
var testElements = this.assemblyEnumeratorWrapper.GetTests(source, runSettings, out warnings);
// log the warnings
foreach (var warning in warnings)
{
PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo(
"MSTestDiscoverer: Warning during discovery from {0}. {1} ",
source,
warning);
logger.SendMessage(TestMessageLevel.Warning, warning);
}
// No tests found => nothing to do
if (testElements == null || testElements.Count == 0)
{
return;
}
PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo(
"MSTestDiscoverer: Found {0} tests from source {1}",
testElements.Count,
source);
this.SendTestCases(source, testElements, discoverySink);
}
private void InitOrRefreshEnvironment(IRunSettings runSettings, IMessageLogger messageLogger)
{
if (_settings == null || _settings.GetType() == typeof(SettingsWrapper))
{
CommonFunctions.CreateEnvironment(runSettings, messageLogger, out _logger, out _settings);
}
}
public static void CreateEnvironment(IRunSettings runSettings, IMessageLogger messageLogger, out ILogger logger, out SettingsWrapper settings, string solutionDir = null)
{
if (string.IsNullOrWhiteSpace(solutionDir))
{
solutionDir = null;
}
var settingsProvider = SafeGetRunSettingsProvider(runSettings, messageLogger);
var ourRunSettings = GetRunSettingsContainer(settingsProvider, messageLogger);
foreach (RunSettings projectSettings in ourRunSettings.ProjectSettings)
{
projectSettings.GetUnsetValuesFrom(ourRunSettings.SolutionSettings);
}
var settingsWrapper = new SettingsWrapper(ourRunSettings, solutionDir);
var loggerAdapter = new VsTestFrameworkLogger(messageLogger, () => settingsWrapper.DebugMode, () => settingsWrapper.TimestampOutput);
var regexParser = new RegexTraitParser(loggerAdapter);
settingsWrapper.RegexTraitParser = regexParser;
settings = settingsWrapper;
logger = loggerAdapter;
}
public InternalDiscoveryContext(string runSettings, string testCaseFilter)
{
this.runSettings = new InternalRunSettings(runSettings);
if (testCaseFilter != null)
{
filter = TestCaseFilterFactory.ParseTestFilter(testCaseFilter);
}
}
public UnitTestSettings(IRunSettings runSettings, bool isBeingDebugged = false)
{
var xml = XDocument.Parse(runSettings.SettingsXml);
var jsUnitTestRoot = xml.Descendants("JavaScriptUnitTest");
this.TestSource = jsUnitTestRoot.Descendants("TestSource").FirstOrDefault()?.Value;
this.TestFrameworksLocation = jsUnitTestRoot.Descendants("TestFrameworkRoot").FirstOrDefault()?.Value;
this.IsBeingDebugged = isBeingDebugged;
}
public RunSettings(IRunSettings runSettings)
{
if (String.IsNullOrEmpty(runSettings.SettingsXml))
{
return;
}
_document = XDocument.Parse(runSettings.SettingsXml);
}
/// <summary>
/// Returns true if the console should be shown. This is the default
/// unless a <ShowConsole value="false" /> element exists under
/// RunSettings/Python.
/// </summary>
private static bool ShouldShowConsole(IRunSettings settings) {
var doc = Read(settings.SettingsXml);
try {
var node = doc.CreateNavigator().SelectSingleNode("/RunSettings/Python/ShowConsole[@value='false']");
return node == null;
} catch (Exception ex) {
Debug.Fail(ex.ToUnhandledExceptionMessage(typeof(TestExecutor)));
return true;
}
}
public static void Validate <TStepId, TData>(this IRunSettings <TStepId, TData> settings, ITransactionContext <TStepId, TData> transactionContext)
{
if (!Enum.IsDefined(typeof(RunMode), settings.Mode))
{
throw new ArgumentException(string.Format(
"Transaction '{0}': unknown run mode '{1}'.",
transactionContext.Info.Name,
settings.Mode));
}
}
internal TestSourceHost(string sourceFileName, IRunSettings runSettings, IFrameworkHandle frameworkHandle, IAppDomain appDomain)
{
this.sourceFileName = sourceFileName;
this.runSettings = runSettings;
this.frameworkHandle = frameworkHandle;
this.appDomain = appDomain;
// Set the environment context.
this.SetContext(sourceFileName);
}
private void InitTestEnvironment(IRunSettings runSettings, IMessageLogger messageLogger)
{
if (TestEnvironment == null || TestEnvironment.Options.GetType() == typeof(Options))
{
var settingsProvider = runSettings.GetSettings(GoogleTestConstants.SettingsName) as RunSettingsProvider;
RunSettings ourRunSettings = settingsProvider != null ? settingsProvider.Settings : new RunSettings();
ILogger loggerAdapter = new VsTestFrameworkLogger(messageLogger);
TestEnvironment = new TestEnvironment(new Options(ourRunSettings, loggerAdapter), loggerAdapter);
}
}
public static string GetSolutionDirectory(IRunSettings settings)
{
XPathDocument document = new XPathDocument(new StringReader(settings.SettingsXml));
XPathNavigator navigator = document.CreateNavigator();
if (navigator.MoveToFollowing("SolutionDirectory", ""))
{
return(navigator.Value);
}
return("");
}
public virtual void before_each()
{
autoSubstitute = new AutoSubstitute();
repository = autoSubstitute.Resolve <SettingsRepository>();
discoveryContext = autoSubstitute.Resolve <IDiscoveryContext>();
runSettings = autoSubstitute.Resolve <IRunSettings>();
discoveryContext.RunSettings.Returns(runSettings);
}
/// <summary>
/// Discovers the tests available from the provided sources.
/// </summary>
/// <param name="sources"> The sources. </param>
/// <param name="logger"> The logger. </param>
/// <param name="discoverySink"> The discovery Sink. </param>
/// <param name="runSettings"> The run settings. </param>
internal void DiscoverTests(
IEnumerable <string> sources,
IMessageLogger logger,
ITestCaseDiscoverySink discoverySink,
IRunSettings runSettings)
{
foreach (var source in sources)
{
this.DiscoverTestsInSource(source, logger, discoverySink, runSettings);
}
}
internal static TestEnvironment CreateTestEnvironment(IRunSettings runSettings, IMessageLogger messageLogger)
{
var settingsProvider = runSettings.GetSettings(GoogleTestConstants.SettingsName) as RunSettingsProvider;
RunSettings ourRunSettings = settingsProvider != null ? settingsProvider.Settings : new RunSettings();
var settingsWrapper = new SettingsWrapper(ourRunSettings);
var loggerAdapter = new VsTestFrameworkLogger(messageLogger, settingsWrapper);
TestEnvironment testEnvironment = new TestEnvironment(settingsWrapper, loggerAdapter);
settingsWrapper.RegexTraitParser = new RegexTraitParser(testEnvironment);
return(testEnvironment);
}
/// <summary>
/// Returns true if this is a dry run. Dry runs require a
/// <DryRun value="true" /> element under RunSettings/Python.
/// </summary>
internal static bool IsDryRun(IRunSettings settings)
{
var doc = TestUtils.Read(settings.SettingsXml);
try {
var node = doc.CreateNavigator().SelectSingleNode("/RunSettings/Python/DryRun[@value='true']");
return(node != null);
} catch (Exception ex) {
Debug.Fail(ex.ToUnhandledExceptionMessage(typeof(UnittestTestExecutor)));
return(false);
}
}
/// <summary>
/// Returns true if this is a dry run. Dry runs require a
/// <DryRun value="true" /> element under RunSettings/Python.
/// </summary>
private static bool IsDryRun(IRunSettings settings)
{
var doc = new XPathDocument(new StringReader(settings.SettingsXml));
try {
var node = doc.CreateNavigator().SelectSingleNode("/RunSettings/Python/DryRun[@value='true']");
return(node != null);
} catch (Exception ex) {
Debug.Fail(ex.ToUnhandledExceptionMessage(typeof(TestExecutor)));
return(false);
}
}
internal override void DiscoverTestsInSource(
string source,
IMessageLogger logger,
ITestCaseDiscoverySink discoverySink,
IRunSettings runSettings)
{
var testCase1 = new TestCase("A", new System.Uri("executor://testExecutor"), source);
var testCase2 = new TestCase("B", new System.Uri("executor://testExecutor"), source);
discoverySink.SendTestCase(testCase1);
discoverySink.SendTestCase(testCase2);
}
internal TestSourceHost(string sourceFileName, IRunSettings runSettings, IFrameworkHandle frameworkHandle, IAppDomain appDomain)
{
this.sourceFileName = sourceFileName;
this.runSettings = runSettings;
this.frameworkHandle = frameworkHandle;
this.appDomain = appDomain;
// Set the environment context.
this.SetContext(sourceFileName);
// Set isAppDomainCreationDisabled flag
this.isAppDomainCreationDisabled = (this.runSettings != null) && MSTestAdapterSettings.IsAppDomainCreationDisabled(this.runSettings.SettingsXml);
}
public static void CreateEnvironment(IRunSettings runSettings, IMessageLogger messageLogger, out ILogger logger, out SettingsWrapper settings)
{
var settingsProvider = runSettings.GetSettings(GoogleTestConstants.SettingsName) as RunSettingsProvider;
RunSettingsContainer ourRunSettings = settingsProvider != null ? settingsProvider.SettingsContainer : new RunSettingsContainer();
var settingsWrapper = new SettingsWrapper(ourRunSettings);
var loggerAdapter = new VsTestFrameworkLogger(messageLogger, () => settingsWrapper.DebugMode, () => settingsWrapper.TimestampOutput);
var regexParser = new RegexTraitParser(loggerAdapter);
settingsWrapper.RegexTraitParser = regexParser;
settings = settingsWrapper;
logger = loggerAdapter;
}
/// <summary>
/// Loads settings from the runsettings in the discovery context.
/// Returns default settings otherwise.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public static CatchAdapterSettings LoadSettings(IRunSettings runSettings)
{
CatchAdapterSettings settings = new CatchAdapterSettings();
if (runSettings != null)
{
var provider = runSettings.GetSettings(CatchAdapterSettings.XmlRoot) as CatchSettingsProvider;
if (provider != null && provider.Settings != null)
{
settings = provider.Settings;
}
}
return(settings);
}
private static RunSettingsProvider SafeGetRunSettingsProvider(IRunSettings runSettings, IMessageLogger messageLogger)
{
try
{
return(runSettings.GetSettings(GoogleTestConstants.SettingsName) as RunSettingsProvider);
}
catch (Exception e)
{
string errorMessage =
$"ERROR: Visual Studio test framework failed to provide settings. Error message: {e.Message}";
// if fallback settings are configured, we do not want to make the tests fail
var level = AreFallbackSettingsConfigured() ? TestMessageLevel.Informational : TestMessageLevel.Error;
messageLogger.SendMessage(level, errorMessage);
return(null);
}
}
internal Task Run(IEnumerable <TestCase> tests, IRunSettings runSettings, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
if (IsRunning)
{
throw new InvalidOperationException("Test run already running");
}
token = new TestRunCancellationToken();
if (cancellationToken.CanBeCanceled)
{
cancellationToken.Register(() => token.Cancel());
}
settings = runSettings;
MSTestSettings.PopulateSettings(this);
return(System.Threading.Tasks.Task.Run(() => {
new TestExecutionManager().RunTests(tests, this, this, token);
token = null;
}));
}
static void DiscoverTests(IEnumerable<string> sources, IMessageLogger logger, ITestCaseDiscoverySink discoverySink, IRunSettings settings) {
var sourcesSet = new HashSet<string>(sources, StringComparer.OrdinalIgnoreCase);
var executorUri = new Uri(PythonConstants.TestExecutorUriString);
// Test list is sent to us via our run settings which we use to smuggle the
// data we have in our analysis process.
var doc = new XPathDocument(new StringReader(settings.SettingsXml));
foreach (var t in TestReader.ReadTests(doc, sourcesSet, m => {
logger?.SendMessage(TestMessageLevel.Warning, m);
})) {
var tc = new TestCase(t.FullyQualifiedName, executorUri, t.SourceFile) {
DisplayName = t.DisplayName,
LineNumber = t.LineNo,
CodeFilePath = t.FileName
};
discoverySink.SendTestCase(tc);
}
}
private void SetAdapterLoggingSettings(IMessageLogger messageLogger, IRunSettings runSettings)
{
var discoveryMessageLogger = messageLogger as TestSessionMessageLogger;
if (discoveryMessageLogger != null && runSettings != null)
{
#if Todo
// Todo: Enable this when RunSettings is enabled.
IRunConfigurationSettingsProvider runConfigurationSettingsProvider =
(IRunConfigurationSettingsProvider)runSettings.GetSettings(ObjectModel.Constants.RunConfigurationSettingsName);
if (runConfigurationSettingsProvider != null &&
runConfigurationSettingsProvider.Settings != null)
{
discoveryMessageLogger.TreatTestAdapterErrorsAsWarnings
= runConfigurationSettingsProvider.Settings.TreatTestAdapterErrorsAsWarnings;
}
#endif
}
}
private void InitOrRefreshTestEnvironment(IRunSettings runSettings, IMessageLogger messageLogger)
{
if (_testEnvironment == null || _testEnvironment.Options.GetType() == typeof(SettingsWrapper))
_testEnvironment = CreateTestEnvironment(runSettings, messageLogger);
}
public MockRunContext(IRunSettings runSettings) {
_runSettings = runSettings;
}
public MockDiscoveryContext(IRunSettings runSettings) {
_runSettings = runSettings;
}
internal static TestEnvironment CreateTestEnvironment(IRunSettings runSettings, IMessageLogger messageLogger)
{
var settingsProvider = runSettings.GetSettings(GoogleTestConstants.SettingsName) as RunSettingsProvider;
RunSettings ourRunSettings = settingsProvider != null ? settingsProvider.Settings : new RunSettings();
var settingsWrapper = new SettingsWrapper(ourRunSettings);
var loggerAdapter = new VsTestFrameworkLogger(messageLogger, settingsWrapper);
TestEnvironment testEnvironment = new TestEnvironment(settingsWrapper, loggerAdapter);
settingsWrapper.RegexTraitParser = new RegexTraitParser(testEnvironment);
return testEnvironment;
}
