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