public void RaiseTestRunStartShouldInvokeRegisteredEventHandler() { bool testRunStartReceived = false; TestRunStartEventArgs receivedEventArgs = null; EventWaitHandle waitHandle = new AutoResetEvent(false); TestRunCriteria testRunCriteria = new TestRunCriteria(new List <string> { @"x:dummy\foo.dll" }, 10) { TestCaseFilter = "Name=Test1" }; TestRunStartEventArgs testRunStartEventArgs = new TestRunStartEventArgs(testRunCriteria); // Register for the test run start event. loggerEvents.TestRunStart += (sender, e) => { testRunStartReceived = true; receivedEventArgs = e; waitHandle.Set(); }; loggerEvents.EnableEvents(); // Send the test run start event. loggerEvents.RaiseTestRunStart(testRunStartEventArgs); var waitSuccess = waitHandle.WaitOne(500); Assert.IsTrue(waitSuccess, "Event must be raised within timeout."); Assert.IsTrue(testRunStartReceived); Assert.IsNotNull(receivedEventArgs); Assert.AreEqual(receivedEventArgs, testRunStartEventArgs); Assert.AreEqual("Name=Test1", receivedEventArgs.TestRunCriteria.TestCaseFilter); }
private void Events_TestRunStart(object sender, TestRunStartEventArgs e) { var requestNewLaunch = new StartLaunchRequest { Name = _config.GetValue(ConfigurationPath.LaunchName, "VsTest Launch"), Description = _config.GetValue(ConfigurationPath.LaunchDescription, ""), StartTime = DateTime.UtcNow }; if (_config.GetValue(ConfigurationPath.LaunchDebugMode, false)) { requestNewLaunch.Mode = LaunchMode.Debug; } requestNewLaunch.Tags = _config.GetValues(ConfigurationPath.LaunchTags, new List <string>()).ToList(); // see wether we need use external launch var launchId = _config.GetValue <string>("Launch:Id", ""); if (string.IsNullOrEmpty(launchId)) { _launchReporter = new LaunchReporter(Bridge.Service); } else { _launchReporter = new LaunchReporter(Bridge.Service, launchId); } _launchReporter.Start(requestNewLaunch); }
public void StartShouldExtractFrameworkForTestRun() { var startedEvent = new TestRunStartEventArgs(this.testRunCriteria); var config = this.testRun.Start(startedEvent); Assert.AreEqual(".NETCoreApp,Version=v5.0", config.TargetFramework); }
/// <summary> /// Raises the test run start event to enabled loggers. /// </summary> /// <param name="args">Arguments to be raised.</param> internal void RaiseTestRunStart(TestRunStartEventArgs args) { ValidateArg.NotNull <TestRunStartEventArgs>(args, "args"); CheckDisposed(); this.SafeInvokeAsync(() => this.TestRunStart, args, 0, "InternalTestLoggerEvents.SendTestRunStart"); }
public void StartShouldExtractAssemblyPathForTestRun() { var startedEvent = new TestRunStartEventArgs(this.testRunCriteria); var config = this.testRun.Start(startedEvent); Assert.IsNotNull(config); Assert.AreEqual("/tmp/test.dll", config.AssemblyPath); }
/// <summary> /// Handles test run start event. /// </summary> /// <param name="e">TestRunStart event args.</param> public void HandleTestRunStart(TestRunStartEventArgs e) { if (this.isDisposed) { EqtTrace.Warning("TestLoggerManager.HandleTestRunStart: Ignoring as the object is disposed."); return; } this.loggerEvents.RaiseTestRunStart(e); }
public void StartShouldRecordStartTimeOfTestRun() { var startedEvent = new TestRunStartEventArgs(this.testRunCriteria); var config = this.testRun.Start(startedEvent); Assert.AreEqual( DateTime.Now.Date, config.StartTime.ToLocalTime().Date); }
public void RaiseTestRunStartShouldThrowExceptionIfAlreadyDisposed() { var loggerEvents = GetDisposedLoggerEvents(); TestRunCriteria testRunCriteria = new TestRunCriteria(new List <string> { @"x:dummy\foo.dll" }, 10, false, string.Empty, TimeSpan.MaxValue, null, "Name=Test1", null); TestRunStartEventArgs testRunStartEventArgs = new TestRunStartEventArgs(testRunCriteria); Assert.ThrowsException <ObjectDisposedException>(() => { loggerEvents.RaiseTestRunStart(testRunStartEventArgs); }); }
/// <summary> /// Called when a test run start is received /// </summary> private void TestRunStartHandler(object sender, TestRunStartEventArgs e) { ValidateArg.NotNull <object>(sender, "sender"); ValidateArg.NotNull <TestRunStartEventArgs>(e, "e"); // Print all test containers. Output.WriteLine(string.Format(CultureInfo.CurrentCulture, CommandLineResources.TestSourcesDiscovered, CommandLineOptions.Instance.Sources.Count()), OutputLevel.Information); if (verbosityLevel == Verbosity.Detailed) { foreach (var source in CommandLineOptions.Instance.Sources) { Output.WriteLine(source, OutputLevel.Information); } } }
public void RaiseTestRunStartShouldThrowExceptionIfAlreadyDisposed() { var loggerEvents = GetDisposedLoggerEvents(); TestRunCriteria testRunCriteria = new TestRunCriteria(new List <string> { @"x:dummy\foo.dll" }, 10) { TestCaseFilter = "Name=Test1" }; TestRunStartEventArgs testRunStartEventArgs = new TestRunStartEventArgs(testRunCriteria); Assert.ThrowsException <ObjectDisposedException>(() => { loggerEvents.RaiseTestRunStart(testRunStartEventArgs); }); }
public void TestRunRequestRaiseShouldInvokeTestRunStartHandlerOfLoggersOnlyIfRegistered() { counter = 0; waitHandle.Reset(); TestRunCriteria testRunCriteria = new TestRunCriteria(new List <string> { @"x:dummy\foo.dll" }, 10) { TestCaseFilter = "Name=Test1" }; TestRunStartEventArgs testRunStartEventArgs = new TestRunStartEventArgs(testRunCriteria); // mock for ITestRunRequest var testRunRequest = new Mock <ITestRunRequest>(); // setup TestLogger TestLoggerManager.Instance.AddLogger(new Uri(loggerUri), new Dictionary <string, string>()); TestLoggerManager.Instance.EnableLogging(); // Register TestRunRequest object TestLoggerManager.Instance.RegisterTestRunEvents(testRunRequest.Object); //Raise an event on mock object testRunRequest.Raise( m => m.OnRunStart += null, testRunStartEventArgs); // Assertions when test run events registered waitHandle.WaitOne(); Assert.AreEqual(counter, 1); // Unregister TestRunRequest object TestLoggerManager.Instance.UnregisterTestRunEvents(testRunRequest.Object); //Raise an event on mock object testRunRequest.Raise( m => m.OnRunStart += null, testRunStartEventArgs); // Assertions when test run events unregistered Assert.AreEqual(counter, 1); }
/// <summary> /// Called when a test starts. /// </summary> internal void TestRunStartHandler(object sender, TestRunStartEventArgs e) { if (this.outputFilePath.Contains(AssemblyToken)) { string assemblyPath = e.TestRunCriteria.AdapterSourceMap["_none_"].First(); string assemblyName = Path.GetFileNameWithoutExtension(assemblyPath); this.outputFilePath = this.outputFilePath.Replace(AssemblyToken, assemblyName); } if (this.outputFilePath.Contains(FrameworkToken)) { XmlDocument runSettings = new XmlDocument(); runSettings.LoadXml(e.TestRunCriteria.TestRunSettings); XmlNode x = runSettings.GetElementsByTagName("TargetFrameworkVersion")[0]; string framework = x.InnerText; framework = framework.Replace(",Version=v", string.Empty).Replace(".", string.Empty); this.outputFilePath = this.outputFilePath.Replace(FrameworkToken, framework); } }
private void Events_TestRunStart(object sender, TestRunStartEventArgs e) { var requestNewLaunch = new StartLaunchRequest { Name = _config.GetValue(ConfigurationPath.LaunchName, "VsTest Launch"), Description = _config.GetValue(ConfigurationPath.LaunchDescription, ""), StartTime = DateTime.UtcNow }; if (_config.GetValue(ConfigurationPath.LaunchDebugMode, false)) { requestNewLaunch.Mode = LaunchMode.Debug; } requestNewLaunch.Tags = _config.GetValues(ConfigurationPath.LaunchTags, new List <string>()).ToList(); _launchReporter = new LaunchReporter(Bridge.Service, _config, null); _launchReporter.Start(requestNewLaunch); }
public static TestRunConfiguration Start(this ITestRun testRun, TestRunStartEventArgs startedEvent) { // Extract assembly path and adapter from test run criteria // TODO validate if the testcase filter or running specific tests is going to break this! var assemblyPath = startedEvent.TestRunCriteria.Sources.First(); // Extract target framework from run settings var runSettings = new XmlDocument(); runSettings.LoadXml(startedEvent.TestRunCriteria.TestRunSettings); var framework = runSettings .GetElementsByTagName("TargetFrameworkVersion")[0] .InnerText; return(new TestRunConfiguration { AssemblyPath = assemblyPath, TargetFramework = framework, StartTime = DateTime.UtcNow }); }
private void Events_TestRunStart(object sender, TestRunStartEventArgs e) { try { var apiUri = _config.GetValue <string>(ConfigurationPath.ServerUrl); var apiProject = _config.GetValue <string>(ConfigurationPath.ServerProject); var apiToken = _config.GetValue <string>(ConfigurationPath.ServerAuthenticationUuid); var apiService = new Service(new Uri(apiUri), apiProject, apiToken); var requestNewLaunch = new StartLaunchRequest { Name = _config.GetValue(ConfigurationPath.LaunchName, "VsTest Launch"), Description = _config.GetValue(ConfigurationPath.LaunchDescription, ""), StartTime = DateTime.UtcNow, RerunOfLaunchUuid = Environment.GetEnvironmentVariable("DTA.RerunIterationCount") != null ? this._config.Properties["RerunOfLaunchUuid"].ToString() : null, }; if (_config.GetValue(ConfigurationPath.LaunchDebugMode, false)) { requestNewLaunch.Mode = LaunchMode.Debug; } requestNewLaunch.Attributes = _config.GetKeyValues("Launch:Attributes", new List <KeyValuePair <string, string> >()).Select(a => new ItemAttribute { Key = a.Key, Value = a.Value }).ToList(); _launchReporter = new LaunchReporter(apiService, _config, null); _launchReporter.Start(requestNewLaunch); } catch (Exception exp) { var error = $"Unexpected exception in {nameof(Events_TestRunStart)}: {exp}"; TraceLogger.Error(error); Console.WriteLine(error); throw; } }
private void TestRunStartHandler(object sender, TestRunStartEventArgs e) { TestLoggerManagerTests.counter++; TestLoggerManagerTests.waitHandle.Set(); }
private void CreateTestRun(object sender, TestRunStartEventArgs e) { _runId = _testManager.GetTestRun(); }
/// <summary> /// Called when a test run starts. /// </summary> private void TestRunStartHandler(object sender, TestRunStartEventArgs e) { this.loggerEvents.RaiseTestRunStart(e); }
public void OnTestRunStart(TestRunStartEventArgs e) => TestRunStart?.Invoke(this, e);
private void TestRunStartHandler(object sender, TestRunStartEventArgs e) { _testRun.Started = DateTime.UtcNow; }
/// <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); } this.executionStartTime = DateTime.UtcNow; // Collecting Number of sources Sent For Execution var numberOfSources = (uint)(testRunCriteria.Sources != null ? testRunCriteria.Sources.Count <string>() : 0); this.requestData.MetricsCollection.Add(TelemetryDataConstants.NumberOfSourcesSentForRun, numberOfSources); if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("TestRunRequest.ExecuteAsync: Starting run with settings:{0}", this.testRunCriteria); } if (EqtTrace.IsVerboseEnabled) { // 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(); var testRunStartEvent = new TestRunStartEventArgs(this.testRunCriteria); this.LoggerManager.HandleTestRunStart(testRunStartEvent); this.OnRunStart.SafeInvoke(this, testRunStartEvent, "TestRun.TestRunStart"); int processId = this.ExecutionManager.StartTestRun(this.testRunCriteria, this); if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("TestRunRequest.ExecuteAsync: Started."); } return(processId); } catch { this.State = TestRunState.Pending; throw; } } }