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