public void Setup()
{
this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper();
this.discoveryEventHandler = new DiscoveryEventHandler();
this.discoveryEventHandler2 = new DiscoveryEventHandler2();
this.runEventHandler = new RunEventHandler();
}
public VsTestRunner(
StrykerOptions options,
OptimizationFlags flags,
ProjectInfo projectInfo,
ICollection <TestCase> testCasesDiscovered,
IFileSystem fileSystem = null,
IVsTestHelper helper = null,
ILogger logger = null,
IVsTestConsoleWrapper wrapper = null,
Func <int, IStrykerTestHostLauncher> hostBuilder = null)
{
_logger = logger ?? ApplicationLogging.LoggerFactory.CreateLogger <VsTestRunner>();
_fileSystem = fileSystem ?? new FileSystem();
_options = options;
_flags = flags;
_projectInfo = projectInfo;
_hostBuilder = hostBuilder ?? ((id) => new StrykerVsTestHostLauncher(id));
SetListOfTests(testCasesDiscovered);
_ownHelper = helper == null;
_vsTestHelper = helper ?? new VsTestHelper();
_vsTestConsole = wrapper ?? PrepareVsTestConsole();
_id = _count++;
if (testCasesDiscovered != null)
{
_discoveredTests = testCasesDiscovered;
DetectTestFramework(testCasesDiscovered);
}
InitializeVsTestConsole();
}
private IVsTestConsoleWrapper PrepareVsTestConsole()
{
if (_vsTestConsole != null)
{
try
{
_vsTestConsole.EndSession();
}
catch { /*Ignore exception. vsTestConsole has been disposed outside of our control*/ }
_vsTestConsole = null;
}
var vstestLogPath = Path.Combine(_options.OutputPath, "logs", "vstest-log.txt");
_fileSystem.Directory.CreateDirectory(Path.GetDirectoryName(vstestLogPath));
_logger.LogDebug("Logging vstest output to: {0}", vstestLogPath);
return(new VsTestConsoleWrapper(_vsTestHelper.GetCurrentPlatformVsTestToolPath(), new ConsoleParameters
{
TraceLevel = DetermineTraceLevel(),
LogFilePath = vstestLogPath
}));
}
public static async Task <IEnumerable <TestCase> > DiscoverTestsAsync(this IVsTestConsoleWrapper wrapper, string assemblyPath)
{
var handler = new TestDiscoveryEventsHandler();
wrapper.DiscoverTests(new[] { assemblyPath }, GetRunSettingsXml(assemblyPath), handler);
return(await handler.Task.ConfigureAwait(false));
}
public VsTestRunner(
StrykerOptions options,
OptimizationFlags flags,
ProjectInfo projectInfo,
ICollection <TestCase> testCasesDiscovered,
TestCoverageInfos mappingInfos,
IFileSystem fileSystem = null,
IVsTestHelper helper = null,
ILogger logger = null,
IVsTestConsoleWrapper wrapper = null,
Func <IDictionary <string, string>, int, IStrykerTestHostLauncher> hostBuilder = null)
{
_logger = logger ?? ApplicationLogging.LoggerFactory.CreateLogger <VsTestRunner>();
_fileSystem = fileSystem ?? new FileSystem();
_options = options;
_flags = flags;
_projectInfo = projectInfo;
_hostBuilder = hostBuilder ?? ((dico, id) => new StrykerVsTestHostLauncher(dico, id));
SetListOfTests(testCasesDiscovered);
_ownHelper = helper == null;
_vsTestHelper = helper ?? new VsTestHelper();
CoverageMutants = mappingInfos ?? new TestCoverageInfos();
_vsTestConsole = wrapper ?? PrepareVsTestConsole();
_id = _count++;
if (testCasesDiscovered != null)
{
_discoveredTests = testCasesDiscovered;
DetectTestFramework(testCasesDiscovered);
}
InitializeVsTestConsole();
_coverageEnvironment = new Dictionary <string, string>
{
{ CoverageCollector.ModeEnvironmentVariable, flags.HasFlag(OptimizationFlags.UseEnvVariable) ? CoverageCollector.EnvMode : CoverageCollector.PipeMode }
};
}
static IEnumerable <TestResult> RunSelectedTests(IVsTestConsoleWrapper consoleWrapper, IEnumerable <TestCase> testCases)
{
var waitHandle = new AutoResetEvent(false);
var handler = new RunEventHandler(waitHandle);
consoleWrapper.RunTests(testCases, null, handler);
waitHandle.WaitOne();
return(handler.TestResults);
}
static IEnumerable <TestResult> RunAllTests(IVsTestConsoleWrapper consoleWrapper, IEnumerable <string> sources)
{
var waitHandle = new AutoResetEvent(false);
var handler = new RunEventHandler(waitHandle);
consoleWrapper.RunTests(sources, DefaultRunSettings, handler);
waitHandle.WaitOne();
return(handler.TestResults);
}
public VsTestRunner(StrykerOptions options, ProjectInfo projectInfo, int?testCasesDiscovered)
{
_options = options;
_projectInfo = projectInfo;
_testCasesDiscovered = testCasesDiscovered;
_vsTestHelper = new VsTestHelper(options);
_vsTestConsole = PrepareVsTestConsole();
InitializeVsTestConsole();
}
public void TestInitialize()
{
this.consoleParameters = new ConsoleParameters();
this.mockRequestSender = new Mock <ITranslationLayerRequestSender>();
this.mockProcessManager = new Mock <IProcessManager>();
this.consoleWrapper = new VsTestConsoleWrapper(this.mockRequestSender.Object, this.mockProcessManager.Object, this.consoleParameters);
this.mockRequestSender.Setup(rs => rs.WaitForRequestHandlerConnection(It.IsAny <int>())).Returns(true);
this.mockRequestSender.Setup(rs => rs.InitializeCommunication()).Returns(100);
}
static IEnumerable <TestCase> DiscoverTests(IEnumerable <string> sources, IVsTestConsoleWrapper consoleWrapper)
{
var waitHandle = new AutoResetEvent(false);
var handler = new DiscoveryEventHandler(waitHandle);
consoleWrapper.DiscoverTests(sources, DefaultRunSettings, handler);
waitHandle.WaitOne();
return(handler.DiscoveredTestCases);
}
public static async Task <IEnumerable <TestResult> > RunTestsAsync(this IVsTestConsoleWrapper wrapper, string assemblyPath, IEnumerable <TestCase> testCases)
{
if (!testCases.Any())
{
throw new ArgumentException("Must provide at least one test case to run.", nameof(testCases));
}
var handler = new TestRunEventsHandler();
wrapper.RunTests(testCases, GetRunSettingsXml(assemblyPath), handler);
return(await handler.Task.ConfigureAwait(false));
}
public VsTestRunner(StrykerOptions options, ProjectInfo projectInfo, int?testCasesDiscovered, IFileSystem fileSystem = null)
{
_fileSystem = fileSystem ?? new FileSystem();
_options = options;
_projectInfo = projectInfo;
_testCasesDiscovered = testCasesDiscovered;
_vsTestHelper = new VsTestHelper(options);
_vsTestConsole = PrepareVsTestConsole();
InitializeVsTestConsole();
}
public VsTestRunner(StrykerOptions options, ProjectInfo projectInfo, IFileSystem fileSystem = null, ILogger logger = null)
{
_fileSystem = fileSystem ?? new FileSystem();
_logger = logger ?? ApplicationLogging.LoggerFactory.CreateLogger <VsTestRunner>();
_options = options;
_projectInfo = projectInfo;
_vsTestHelper = new VsTestHelper(options);
_vsTestConsole = PrepareVsTestConsole();
InitializeVsTestConsole();
}
static IEnumerable <TestResult> RunAllTestsWithTestCaseFilter(IVsTestConsoleWrapper consoleWrapper, IEnumerable <string> sources)
{
var waitHandle = new AutoResetEvent(false);
var handler = new RunEventHandler(waitHandle);
consoleWrapper.RunTests(sources, DefaultRunSettings, new TestPlatformOptions()
{
TestCaseFilter = "FullyQualifiedName=UnitTestProject.UnitTest.PassingTest"
}, handler);
waitHandle.WaitOne();
return(handler.TestResults);
}
private IRunResults RunTestSession(Dictionary <int, ITestGuids> mutantTestsMap,
bool runAllTests,
string runSettings,
Action <RunEventHandler> updateHandler = null,
int retries = 0)
{
using var eventHandler = new RunEventHandler(_vsTests, _logger, RunnerId);
void HandlerVsTestFailed(object sender, EventArgs e) => _vsTestFailed = true;
void HandlerUpdate(object sender, EventArgs e) => updateHandler?.Invoke(eventHandler);
var strykerVsTestHostLauncher = _hostBuilder(_id);
eventHandler.VsTestFailed += HandlerVsTestFailed;
eventHandler.ResultsUpdated += HandlerUpdate;
_aborted = false;
var options = new TestPlatformOptions {
TestCaseFilter = _options.TestCaseFilter
};
if (runAllTests)
{
_vsTestConsole.RunTestsWithCustomTestHost(_sources, runSettings, options, eventHandler,
strykerVsTestHostLauncher);
}
else
{
_vsTestConsole.RunTestsWithCustomTestHost(mutantTestsMap.SelectMany(m => m.Value.GetGuids()).Select(t => _vsTests[t].Case), runSettings,
options, eventHandler, strykerVsTestHostLauncher);
}
// Test host exited signal comes after the run completed
strykerVsTestHostLauncher.WaitProcessExit();
// At this point, run must have complete. Check signal for true
eventHandler.WaitEnd();
eventHandler.ResultsUpdated -= HandlerUpdate;
eventHandler.VsTestFailed -= HandlerVsTestFailed;
if (!_vsTestFailed || retries > 10)
{
return(eventHandler);
}
_vsTestConsole = PrepareVsTestConsole();
_vsTestFailed = false;
return(RunTestSession(mutantTestsMap, true, runSettings, updateHandler, ++retries));
}
private IEnumerable <TestResult> RunAllTests(IEnumerable <TestCase> testCases, Dictionary <string, string> envVars,
string runSettings, bool forCoverage, int retries = 0)
{
void Handler_VsTestFailed(object sender, EventArgs e)
{
_vsTestFailed = true;
}
using (var runCompleteSignal = new AutoResetEvent(false))
{
var eventHandler = new RunEventHandler(runCompleteSignal, _logger);
var strykerVsTestHostLauncher = _hostBuilder(envVars, _id);
eventHandler.VsTestFailed += Handler_VsTestFailed;
if (_flags.HasFlag(OptimizationFlags.AbortTestOnKill) && !forCoverage)
{
eventHandler.TestsFailed += Handler_TestsFailed;
}
if (testCases != null)
{
var finalTestCases = _discoveredTests.Where(discoveredTest => testCases.Any(test => test.Id == discoveredTest.Id));
_vsTestConsole.RunTestsWithCustomTestHost(finalTestCases, runSettings, eventHandler, strykerVsTestHostLauncher);
}
else
{
_vsTestConsole.RunTestsWithCustomTestHost(_sources, runSettings, eventHandler, strykerVsTestHostLauncher);
}
// Test host exited signal comes after the run complete
strykerVsTestHostLauncher.WaitProcessExit();
// At this point, run must have complete. Check signal for true
runCompleteSignal.WaitOne();
eventHandler.TestsFailed -= Handler_TestsFailed;
eventHandler.VsTestFailed -= Handler_VsTestFailed;
if (_vsTestFailed && retries <= 10)
{
_vsTestConsole = PrepareVsTestConsole();
_vsTestFailed = false;
return(RunAllTests(testCases, envVars, runSettings, forCoverage, ++retries));
}
return(eventHandler.TestResults);
}
}
public void EndSessionShouldEnsureVstestConsoleProcessDies(RunnerInfo runnerInfo)
{
var numOfProcesses = Process.GetProcessesByName("vstest.console").Length;
AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo);
this.Setup();
this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies(), this.GetDefaultRunSettings(), this.runEventHandler);
this.vstestConsoleWrapper?.EndSession();
// Assert
Assert.AreEqual(numOfProcesses, Process.GetProcessesByName("vstest.console").Length);
this.vstestConsoleWrapper = null;
}
public void TestInitialize()
{
this.consoleParameters = new ConsoleParameters();
this.mockRequestSender = new Mock <ITranslationLayerRequestSender>();
this.mockProcessManager = new Mock <IProcessManager>();
this.mockProcessHelper = new Mock <IProcessHelper>();
this.consoleWrapper = new VsTestConsoleWrapper(
this.mockRequestSender.Object,
this.mockProcessManager.Object,
this.consoleParameters,
new Mock <ITestPlatformEventSource>().Object,
this.mockProcessHelper.Object);
this.mockRequestSender.Setup(rs => rs.InitializeCommunicationAsync(It.IsAny <int>())).Returns(Task.FromResult(100));
}
private static IEnumerable <TestResult> RunTestsWithCustomTestHostLauncher(IVsTestConsoleWrapper consoleWrapper, List <string> list)
{
var runCompleteSignal = new AutoResetEvent(false);
var processExitedSignal = new AutoResetEvent(false);
var handler = new RunEventHandler(runCompleteSignal);
consoleWrapper.RunTestsWithCustomTestHost(list, DefaultRunSettings, handler, new CustomTestHostLauncher(() => processExitedSignal.Set()));
// Test host exited signal comes after the run complete
processExitedSignal.WaitOne();
// At this point, run must have complete. Check signal for true
Debug.Assert(runCompleteSignal.WaitOne());
return(handler.TestResults);
}
private IRunResults RunTestSession(IEnumerable <TestCase> testCases,
string runSettings,
Action <RunEventHandler> updateHandler = null,
int retries = 0)
{
using (var eventHandler = new RunEventHandler(_logger, RunnerId))
{
void HandlerVsTestFailed(object sender, EventArgs e) => _vsTestFailed = true;
void HandlerUpdate(object sender, EventArgs e) => updateHandler?.Invoke(eventHandler);
var strykerVsTestHostLauncher = _hostBuilder(_id);
eventHandler.VsTestFailed += HandlerVsTestFailed;
eventHandler.ResultsUpdated += HandlerUpdate;
_aborted = false;
if (testCases != null)
{
_vsTestConsole.RunTestsWithCustomTestHost(_discoveredTests.Where(discoveredTest => testCases.Any(test => test.Id == discoveredTest.Id)), runSettings, eventHandler, strykerVsTestHostLauncher);
}
else
{
_vsTestConsole.RunTestsWithCustomTestHost(_sources, runSettings, eventHandler, strykerVsTestHostLauncher);
}
// Test host exited signal comes after the run completed
strykerVsTestHostLauncher.WaitProcessExit();
// At this point, run must have complete. Check signal for true
eventHandler.WaitEnd();
eventHandler.ResultsUpdated -= HandlerUpdate;
eventHandler.VsTestFailed -= HandlerVsTestFailed;
if (!_vsTestFailed || retries > 10)
{
return(eventHandler);
}
_vsTestConsole = PrepareVsTestConsole();
_vsTestFailed = false;
return(RunTestSession(testCases, runSettings, updateHandler, ++retries));
}
}
public async Task EndSessionShouldEnsureVstestConsoleProcessDies(RunnerInfo runnerInfo)
{
var numOfProcesses = Process.GetProcessesByName("vstest.console").Length;
AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo);
this.Setup();
this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Take(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler);
this.vstestConsoleWrapper.RunTests(this.GetTestAssemblies().Skip(1), this.GetCodeCoverageRunSettings(1), this.runEventHandler);
Assert.AreEqual(6, this.runEventHandler.TestResults.Count);
Assert.AreEqual(2, this.runEventHandler.Attachments.Count);
await this.vstestConsoleWrapper.ProcessTestRunAttachmentsAsync(runEventHandler.Attachments, null, true, true, testRunAttachmentsProcessingEventHandler, CancellationToken.None);
// act
this.vstestConsoleWrapper?.EndSession();
// Assert
Assert.AreEqual(numOfProcesses, Process.GetProcessesByName("vstest.console").Length);
this.vstestConsoleWrapper = null;
}
public VsTestRunner(StrykerOptions options,
ProjectInfo projectInfo,
IDictionary <Guid, VsTestDescription> tests,
TestSet testSet,
IFileSystem fileSystem = null,
IVsTestHelper helper = null,
ILogger logger = null,
IVsTestConsoleWrapper wrapper = null,
Func <int, IStrykerTestHostLauncher> hostBuilder = null)
{
_logger = logger ?? ApplicationLogging.LoggerFactory.CreateLogger <VsTestRunner>();
_fileSystem = fileSystem ?? new FileSystem();
_options = options;
_projectInfo = projectInfo;
_hostBuilder = hostBuilder ?? (id => new StrykerVsTestHostLauncher(id));
SetListOfTests(tests);
_tests = testSet ?? new TestSet();
_ownHelper = helper == null;
_vsTestHelper = helper ?? new VsTestHelper();
_vsTestConsole = wrapper ?? PrepareVsTestConsole();
_id = count++;
InitializeVsTestConsole();
}
public VsTestRunner(StrykerOptions options,
OptimizationFlags flags,
ProjectInfo projectInfo,
ICollection <TestCase> testCasesDiscovered,
TestCoverageInfos mappingInfos,
IFileSystem fileSystem = null,
VsTestHelper helper = null)
{
_fileSystem = fileSystem ?? new FileSystem();
_options = options;
_flags = flags;
_projectInfo = projectInfo;
SetListOfTests(testCasesDiscovered);
_ownHelper = helper == null;
_vsTestHelper = helper ?? new VsTestHelper();
CoverageMutants = mappingInfos ?? new TestCoverageInfos();
_vsTestConsole = PrepareVsTestConsole();
_id = _count++;
InitializeVsTestConsole();
_coverageEnvironment = new Dictionary <string, string>
{
{ CoverageCollector.ModeEnvironmentVariable, flags.HasFlag(OptimizationFlags.UseEnvVariable) ? CoverageCollector.EnvMode : CoverageCollector.PipeMode }
};
}
public ExecutionPerfTests()
{
this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper();
this.runEventHandler = new RunEventHandler();
}
public RunSelectedTests()
{
this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper();
this.runEventHandler = new RunEventHandler();
this.discoveryEventHandler = new DiscoveryEventHandler();
}
/**********************************************************************/
#region Constructors
// If you think you need to use this, and you're not a Factory or Unit Test, you're wrongc
internal TestCaseDiscoveryManager(IVsTestConsoleWrapper vstest)
{
_vstest = vstest ?? throw new ArgumentNullException(nameof(vstest));
_discoveryCompletionSource.SetResult(0);
}
public DiscoverTests()
{
this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper();
this.discoveryEventHandler = new DiscoveryEventHandler();
this.discoveryEventHandler2 = new DiscoveryEventHandler2();
}
private void Setup()
{
this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper();
this.runEventHandler = new RunEventHandler();
this.testRunAttachmentsProcessingEventHandler = new TestRunAttachmentsProcessingEventHandler();
}
TestConsole(IVsTestConsoleWrapper wrapper, IDisposable assemblyResolver)
{
inner = wrapper ?? throw new ArgumentNullException(nameof(wrapper));
this.assemblyResolver = assemblyResolver ?? throw new ArgumentNullException(nameof(assemblyResolver));
}
private void Setup()
{
this.vstestConsoleWrapper = this.GetVsTestConsoleWrapper();
this.runEventHandler = new RunEventHandler();
}
