/// <summary>
/// Initializes a new instance of the <see cref="VerboseReporterMessageHandler" /> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public VerboseReporterMessageHandler(IRunnerLogger logger)
: base(logger)
{
Execution.TestStartingEvent += args =>
{
Guard.ArgumentNotNull(args);
Logger.LogMessage($" {Escape(args.Message.TestDisplayName)} [STARTING]");
};
Execution.TestFinishedEvent += args =>
{
Guard.ArgumentNotNull(args);
var metadata = MetadataCache.TryGetTestMetadata(args.Message);
if (metadata != null)
{
Logger.LogMessage($" {Escape(metadata.TestDisplayName)} [FINISHED] Time: {args.Message.ExecutionTime}s");
}
else
{
Logger.LogMessage($" <unknown test> [FINISHED] Time: {args.Message.ExecutionTime}s");
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="TeamCityReporterMessageHandler" /> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public TeamCityReporterMessageHandler(IRunnerLogger logger)
{
Guard.ArgumentNotNull(nameof(logger), logger);
this.logger = logger;
Diagnostics.ErrorMessageEvent += HandleErrorMessage;
Execution.TestAssemblyCleanupFailureEvent += HandleTestAssemblyCleanupFailure;
Execution.TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
Execution.TestAssemblyStartingEvent += HandleTestAssemblyStarting;
Execution.TestCaseCleanupFailureEvent += HandleTestCaseCleanupFailure;
Execution.TestCaseFinishedEvent += HandleTestCaseFinished;
Execution.TestCaseStartingEvent += HandleTestCaseStarting;
Execution.TestClassCleanupFailureEvent += HandleTestClassCleanupFailure;
Execution.TestClassFinishedEvent += HandleTestClassFinished;
Execution.TestClassStartingEvent += HandleTestClassStarting;
Execution.TestCollectionCleanupFailureEvent += HandleTestCollectionCleanupFailure;
Execution.TestCollectionFinishedEvent += HandleTestCollectionFinished;
Execution.TestCollectionStartingEvent += HandleTestCollectionStarting;
Execution.TestMethodCleanupFailureEvent += HandleTestMethodCleanupFailure;
Execution.TestMethodFinishedEvent += HandleTestMethodFinished;
Execution.TestMethodStartingEvent += HandleTestMethodStarting;
Execution.TestCleanupFailureEvent += HandleTestCleanupFailure;
Execution.TestFailedEvent += HandleTestFailed;
Execution.TestPassedEvent += HandleTestPassed;
Execution.TestSkippedEvent += HandleTestSkipped;
Execution.TestStartingEvent += HandleTestStarting;
}
public static void SendRequest(IRunnerLogger logger, string url, string method, object body)
{
using (var finished = new ManualResetEvent(false))
{
var request = WebRequest.CreateHttp(url);
request.Method = method;
request.ContentType = "application/json";
request.Accept = "application/json";
request.BeginGetRequestStream(requestResult =>
{
var bodyString = ToJson(body);
var bodyBytes = Encoding.UTF8.GetBytes(bodyString);
using (var postStream = request.EndGetRequestStream(requestResult))
{
postStream.Write(bodyBytes, 0, bodyBytes.Length);
postStream.Flush();
}
request.BeginGetResponse(responseResult =>
{
var response = (HttpWebResponse)request.EndGetResponse(responseResult);
if ((int)response.StatusCode >= 300)
{
logger.LogWarning($"When sending '{method} {url}', received status code '{response.StatusCode}'; request body: {bodyString}");
}
}, null);
}, null);
finished.WaitOne();
}
}
public IMessageSink CreateMessageHandler(IRunnerLogger logger)
{
var baseUri = EnvironmentHelper.GetEnvironmentVariable("APPVEYOR_API_URL");
return baseUri == null
? new DefaultRunnerReporterMessageHandler(logger)
: new AppVeyorReporterMessageHandler(logger, baseUri);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRunnerReporterWithTypesMessageHandler"/> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public DefaultRunnerReporterWithTypesMessageHandler(IRunnerLogger logger)
{
#if NET35 || NET452
defaultDirectory = Directory.GetCurrentDirectory();
#endif
Logger = logger;
Diagnostics.ErrorMessageEvent += HandleErrorMessage;
Execution.TestAssemblyCleanupFailureEvent += HandleTestAssemblyCleanupFailure;
Execution.TestClassCleanupFailureEvent += HandleTestClassCleanupFailure;
Execution.TestCaseCleanupFailureEvent += HandleTestCaseCleanupFailure;
Execution.TestCollectionCleanupFailureEvent += HandleTestCollectionCleanupFailure;
Execution.TestCleanupFailureEvent += HandleTestCleanupFailure;
Execution.TestFailedEvent += HandleTestFailed;
Execution.TestMethodCleanupFailureEvent += HandleTestMethodCleanupFailure;
Execution.TestPassedEvent += HandleTestPassed;
Execution.TestSkippedEvent += HandleTestSkipped;
Runner.TestAssemblyDiscoveryFinishedEvent += HandleTestAssemblyDiscoveryFinished;
Runner.TestAssemblyDiscoveryStartingEvent += HandleTestAssemblyDiscoveryStarting;
Runner.TestAssemblyExecutionFinishedEvent += HandleTestAssemblyExecutionFinished;
Runner.TestAssemblyExecutionStartingEvent += HandleTestAssemblyExecutionStarting;
Runner.TestExecutionSummaryEvent += HandleTestExecutionSummary;
}
public ReportPortalReporterMessageHandler(IRunnerLogger logger)
{
Logger = logger;
var jsonPath = Path.GetDirectoryName(new Uri(typeof(ReportPortalReporter).Assembly.CodeBase).LocalPath) + "/ReportPortal.config.json";
Logger.LogMessage($"ReportPortal json config: {jsonPath}");
_config = new ConfigurationBuilder().AddJsonFile(jsonPath).AddEnvironmentVariables().Build();
Bridge.Service = new Service(new Uri(_config.GetValue <string>(ConfigurationPath.ServerUrl)), _config.GetValue <string>(ConfigurationPath.ServerProject), _config.GetValue <string>(ConfigurationPath.ServerAuthenticationUuid));
Execution.TestAssemblyStartingEvent += TestAssemblyExecutionStarting;
Execution.TestAssemblyFinishedEvent += TestAssemblyExecutionFinished;
Execution.TestCollectionStartingEvent += HandleTestCollectionStarting;
Execution.TestCollectionFinishedEvent += HandleTestCollectionFinished;
Execution.TestStartingEvent += HandleTestStarting;
Execution.TestPassedEvent += HandlePassed;
Execution.TestSkippedEvent += HandleSkipped;
Execution.TestFailedEvent += HandleFailed;
Execution.TestOutputEvent += Execution_TestOutputEvent;
}
public static void SendRequest(IRunnerLogger logger, string url, string method, object body)
{
using (var finished = new ManualResetEvent(false))
{
var request = WebRequest.CreateHttp(url);
request.Method = method;
request.ContentType = "application/json";
request.Accept = "application/json";
request.BeginGetRequestStream(requestResult =>
{
var bodyString = ToJson(body);
var bodyBytes = Encoding.UTF8.GetBytes(bodyString);
using (var postStream = request.EndGetRequestStream(requestResult))
{
postStream.Write(bodyBytes, 0, bodyBytes.Length);
postStream.Flush();
}
request.BeginGetResponse(responseResult =>
{
var response = (HttpWebResponse)request.EndGetResponse(responseResult);
if ((int)response.StatusCode >= 300)
logger.LogWarning($"When sending '{method} {url}', received status code '{response.StatusCode}'; request body: {bodyString}");
}, null);
}, null);
finished.WaitOne();
}
}
public AppVeyorClient(IRunnerLogger logger, string baseUri)
{
this.logger = logger;
this.baseUri = $"{baseUri}/api/tests/batch";
workTask = Task.Run(RunLoop);
}
/// <summary>
/// Writes the default summary to the given logger. Can be used by other reporters who also wish to write the
/// standard summary information.
/// </summary>
/// <param name="logger">The logger used to send result messages to.</param>
/// <param name="executionSummary">The execution summary to display.</param>
public static void WriteDefaultSummary(IRunnerLogger logger, ITestExecutionSummary executionSummary)
{
logger.LogImportantMessage("=== TEST EXECUTION SUMMARY ===");
var totalTestsRun = executionSummary.Summaries.Sum(summary => summary.Value.Total);
var totalTestsFailed = executionSummary.Summaries.Sum(summary => summary.Value.Failed);
var totalTestsSkipped = executionSummary.Summaries.Sum(summary => summary.Value.Skipped);
var totalTime = executionSummary.Summaries.Sum(summary => summary.Value.Time).ToString("0.000s");
var totalErrors = executionSummary.Summaries.Sum(summary => summary.Value.Errors);
var longestAssemblyName = executionSummary.Summaries.Max(summary => summary.Key.Length);
var longestTotal = totalTestsRun.ToString().Length;
var longestFailed = totalTestsFailed.ToString().Length;
var longestSkipped = totalTestsSkipped.ToString().Length;
var longestTime = totalTime.Length;
var longestErrors = totalErrors.ToString().Length;
foreach (var summary in executionSummary.Summaries)
{
if (summary.Value.Total == 0)
{
logger.LogImportantMessage($" {summary.Key.PadRight(longestAssemblyName)} Total: {"0".PadLeft(longestTotal)}");
}
else
{
logger.LogImportantMessage($" {summary.Key.PadRight(longestAssemblyName)} Total: {summary.Value.Total.ToString().PadLeft(longestTotal)}, Errors: {summary.Value.Errors.ToString().PadLeft(longestErrors)}, Failed: {summary.Value.Failed.ToString().PadLeft(longestFailed)}, Skipped: {summary.Value.Skipped.ToString().PadLeft(longestSkipped)}, Time: {summary.Value.Time.ToString("0.000s").PadLeft(longestTime)}");
}
}
if (executionSummary.Summaries.Count > 1)
{
logger.LogImportantMessage($" {" ".PadRight(longestAssemblyName)} {"-".PadRight(longestTotal, '-')} {"-".PadRight(longestErrors, '-')} {"-".PadRight(longestFailed, '-')} {"-".PadRight(longestSkipped, '-')} {"-".PadRight(longestTime, '-')}");
logger.LogImportantMessage($" {"GRAND TOTAL:".PadLeft(longestAssemblyName + 8)} {totalTestsRun} {totalErrors} {totalTestsFailed} {totalTestsSkipped} {totalTime} ({executionSummary.ElapsedClockTime.TotalSeconds.ToString("0.000s")})");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRunnerReporterWithTypesMessageHandler"/> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public DefaultRunnerReporterWithTypesMessageHandler(IRunnerLogger logger)
{
#if !PLATFORM_DOTNET
defaultDirectory = Directory.GetCurrentDirectory();
#endif
Logger = logger;
Diagnostics.ErrorMessageEvent += HandleErrorMessage;
Execution.TestAssemblyCleanupFailureEvent += HandleTestAssemblyCleanupFailure;
Execution.TestClassCleanupFailureEvent += HandleTestClassCleanupFailure;
Execution.TestCaseCleanupFailureEvent += HandleTestCaseCleanupFailure;
Execution.TestCollectionCleanupFailureEvent += HandleTestCollectionCleanupFailure;
Execution.TestCleanupFailureEvent += HandleTestCleanupFailure;
Execution.TestFailedEvent += HandleTestFailed;
Execution.TestMethodCleanupFailureEvent += HandleTestMethodCleanupFailure;
Execution.TestPassedEvent += HandleTestPassed;
Execution.TestSkippedEvent += HandleTestSkipped;
Runner.TestAssemblyDiscoveryFinishedEvent += HandleTestAssemblyDiscoveryFinished;
Runner.TestAssemblyDiscoveryStartingEvent += HandleTestAssemblyDiscoveryStarting;
Runner.TestAssemblyExecutionFinishedEvent += HandleTestAssemblyExecutionFinished;
Runner.TestAssemblyExecutionStartingEvent += HandleTestAssemblyExecutionStarting;
Runner.TestExecutionSummaryEvent += HandleTestExecutionSummary;
}
public AppVeyorClient(IRunnerLogger logger, string baseUri)
{
this.logger = logger;
this.baseUri = $"{baseUri}/api/tests/batch";
workTask = Task.Run(RunLoop);
}
public TeamCityReporterMessageHandler(IRunnerLogger logger,
Func <string, string> flowIdMapper = null,
TeamCityDisplayNameFormatter displayNameFormatter = null)
{
this.logger = logger;
this.flowIdMapper = flowIdMapper ?? (_ => Guid.NewGuid().ToString("N"));
this.displayNameFormatter = displayNameFormatter ?? new TeamCityDisplayNameFormatter();
}
public TeamCityReporterMessageHandler(IRunnerLogger logger,
Func<string, string> flowIdMapper = null,
TeamCityDisplayNameFormatter displayNameFormatter = null)
{
this.logger = logger;
this.flowIdMapper = flowIdMapper ?? (_ => Guid.NewGuid().ToString("N"));
this.displayNameFormatter = displayNameFormatter ?? new TeamCityDisplayNameFormatter();
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRunnerReporterMessageHandler"/> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public DefaultRunnerReporterMessageHandler(IRunnerLogger logger)
{
#if NETFRAMEWORK
defaultDirectory = Directory.GetCurrentDirectory();
#endif
Logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRunnerReporterMessageHandler"/> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public DefaultRunnerReporterMessageHandler(IRunnerLogger logger)
{
#if !WINDOWS_PHONE_APP && !DOTNETCORE
defaultDirectory = Directory.GetCurrentDirectory();
#endif
Logger = logger;
}
public AppVeyorReporterMessageHandler(IRunnerLogger logger, string baseUri)
: base(logger)
{
this.baseUri = baseUri.TrimEnd('/');
TestAssemblyStartingEvent += HandleTestAssemblyStarting;
TestStartingEvent += HandleTestStarting;
TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
}
public QuietReporterMessageHandler(IRunnerLogger logger) : base(logger)
{
Runner.TestAssemblyDiscoveryStartingEvent -= HandleTestAssemblyDiscoveryStarting;
Runner.TestAssemblyDiscoveryFinishedEvent -= HandleTestAssemblyDiscoveryFinished;
Runner.TestAssemblyExecutionStartingEvent -= HandleTestAssemblyExecutionStarting;
Runner.TestAssemblyExecutionFinishedEvent -= HandleTestAssemblyExecutionFinished;
Runner.TestExecutionSummaryEvent -= HandleTestExecutionSummary;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRunnerReporterMessageHandler"/> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public DefaultRunnerReporterMessageHandler(IRunnerLogger logger)
{
#if !PLATFORM_DOTNET
defaultDirectory = Directory.GetCurrentDirectory();
#endif
Logger = logger;
}
public QuietReporterMessageHandler(IRunnerLogger logger) : base(logger)
{
Runner.TestAssemblyDiscoveryStartingEvent -= HandleTestAssemblyDiscoveryStarting;
Runner.TestAssemblyDiscoveryFinishedEvent -= HandleTestAssemblyDiscoveryFinished;
Runner.TestAssemblyExecutionStartingEvent -= HandleTestAssemblyExecutionStarting;
Runner.TestAssemblyExecutionFinishedEvent -= HandleTestAssemblyExecutionFinished;
Runner.TestExecutionSummaryEvent -= HandleTestExecutionSummary;
}
/// <inheritdoc />
public IMessageSink CreateMessageHandler(IRunnerLogger logger)
{
var baseUri = EnvironmentHelper.GetEnvironmentVariable("APPVEYOR_API_URL");
return(baseUri == null
? new DefaultRunnerReporterWithTypesMessageHandler(logger)
: new AppVeyorReporterMessageHandler(logger, baseUri));
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRunnerReporterMessageHandler"/> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public DefaultRunnerReporterMessageHandler(IRunnerLogger logger)
{
#if !WINDOWS_PHONE_APP
defaultDirectory = Directory.GetCurrentDirectory();
#endif
Logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRunnerReporterMessageHandler"/> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
public DefaultRunnerReporterMessageHandler(IRunnerLogger logger)
{
#if !PLATFORM_DOTNET
defaultDirectory = Directory.GetCurrentDirectory();
#endif
Logger = logger;
}
public AppVeyorReporterMessageHandler(IRunnerLogger logger, string baseUri)
: base(logger)
{
this.baseUri = baseUri.TrimEnd('/');
Execution.TestAssemblyStartingEvent += HandleTestAssemblyStarting;
Execution.TestStartingEvent += HandleTestStarting;
Execution.TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
}
/// <summary>
/// Logs an error message.
/// </summary>
/// <param name="logger">The logger</param>
/// <param name="message">The message to be logged</param>
public static void LogError(
this IRunnerLogger logger,
string message)
{
Guard.ArgumentNotNull(nameof(logger), logger);
Guard.ArgumentNotNull(nameof(message), message);
logger.LogError(StackFrameInfo.None, message);
}
/// <summary>
/// Initializes a new instance of the <see cref="RvtRunner" /> class.
/// </summary>
/// <param name="logger">The logger</param>
public RvtRunner([NotNull] IRunnerLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// Logs a high-priority message.
/// </summary>
/// <param name="logger">The logger</param>
/// <param name="message">The message to be logged</param>
public static void LogImportantMessage(
this IRunnerLogger logger,
string message)
{
Guard.ArgumentNotNull(logger);
Guard.ArgumentNotNull(message);
logger.LogImportantMessage(StackFrameInfo.None, message);
}
/// <summary>
/// Logs a high-priority formatted message.
/// </summary>
/// <param name="logger">The logger</param>
/// <param name="messageFormat">The format of the message to be logged</param>
/// <param name="args">The format arguments</param>
public static void LogImportantMessage(
this IRunnerLogger logger,
string messageFormat,
params object?[] args)
{
Guard.ArgumentNotNull(logger);
Guard.ArgumentNotNull(messageFormat);
logger.LogImportantMessage(StackFrameInfo.None, string.Format(messageFormat, args));
}
/// <summary>
/// Logs a formatted error message.
/// </summary>
/// <param name="logger">The logger</param>
/// <param name="messageFormat">The format of the message to be logged</param>
/// <param name="args">The format arguments</param>
public static void LogError(
this IRunnerLogger logger,
string messageFormat,
params object?[] args)
{
Guard.ArgumentNotNull(nameof(logger), logger);
Guard.ArgumentNotNull(nameof(messageFormat), messageFormat);
logger.LogError(StackFrameInfo.None, string.Format(messageFormat, args));
}
public VstsClient(IRunnerLogger logger, string baseUri, string accessToken, int buildId)
{
this.logger = logger;
this.baseUri = baseUri;
this.buildId = buildId;
client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
workTask = Task.Run(RunLoop);
}
/// <summary>
/// Logs a formatted warning message with stack frame.
/// </summary>
/// <param name="logger">The logger</param>
/// <param name="stackFrame">The stack frame information</param>
/// <param name="messageFormat">The format of the message to be logged</param>
/// <param name="args">The format arguments</param>
public static void LogWarning(
this IRunnerLogger logger,
StackFrameInfo stackFrame,
string messageFormat,
params object?[] args)
{
Guard.ArgumentNotNull(logger);
Guard.ArgumentNotNull(messageFormat);
logger.LogWarning(stackFrame, string.Format(messageFormat, args));
}
/// <summary>
/// Initializes a new instance of the <see cref="VstsReporterMessageHandler" /> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
/// <param name="baseUri">The base URI for talking to Azure DevOps/VSTS</param>
/// <param name="accessToken">The access token required to talk to Azure DevOps/VSTS</param>
/// <param name="buildId">The ID of build that's currently being run</param>
public VstsReporterMessageHandler(IRunnerLogger logger, string baseUri, string accessToken, int buildId)
: base(logger)
{
this.baseUri = baseUri;
this.accessToken = accessToken;
this.buildId = buildId;
Execution.TestAssemblyStartingEvent += HandleTestAssemblyStarting;
Execution.TestStartingEvent += HandleTestStarting;
Execution.TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
}
/// <summary>
/// Initializes a new instance of the <see cref="VstsReporterMessageHandler" /> class.
/// </summary>
/// <param name="logger">The logger used to report messages</param>
/// <param name="baseUri">The base URI for talking to Azure DevOps/VSTS</param>
/// <param name="accessToken">The access token required to talk to Azure DevOps/VSTS</param>
/// <param name="buildId">The ID of build that's currently being run</param>
public VstsReporterMessageHandler(
IRunnerLogger logger,
string baseUri,
string accessToken,
int buildId)
: base(logger)
{
this.baseUri = baseUri;
this.accessToken = accessToken;
this.buildId = buildId;
}
/// <inheritdoc/>
public ValueTask <_IMessageSink> CreateMessageHandler(
IRunnerLogger logger,
_IMessageSink diagnosticMessageSink)
{
var baseUri = Environment.GetEnvironmentVariable("APPVEYOR_API_URL");
return(new ValueTask <_IMessageSink>(
baseUri == null
? new DefaultRunnerReporterMessageHandler(logger)
: new AppVeyorReporterMessageHandler(logger, baseUri)
));
}
public static void LogAssemblyNode(XmlNode assemblyNode, IRunnerLogger logger)
{
Guard.ArgumentNotNull("assemblyNode", assemblyNode);
Guard.ArgumentNotNull("logger", logger);
int total = Int32.Parse(assemblyNode.Attributes["total"].Value, CultureInfo.InvariantCulture);
int failed = Int32.Parse(assemblyNode.Attributes["failed"].Value, CultureInfo.InvariantCulture);
int skipped = Int32.Parse(assemblyNode.Attributes["skipped"].Value, CultureInfo.InvariantCulture);
double time = Double.Parse(assemblyNode.Attributes["time"].Value, CultureInfo.InvariantCulture);
logger.AssemblyFinished(assemblyNode.Attributes["name"].Value, total, failed, skipped, time);
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegatingExecutionSummarySink"/> class.
/// </summary>
/// <param name="innerSink">The inner sink to pass messages to.</param>
/// <param name="cancelThunk"></param>
/// <param name="completionCallback"></param>
public DelegatingExecutionSummarySink(IMessageSinkWithTypes innerSink,
Func <bool> cancelThunk = null,
Action <string, ExecutionSummary> completionCallback = null,
IRunnerLogger logger = null)
{
Guard.ArgumentNotNull(nameof(innerSink), innerSink);
this.innerSink = innerSink;
this.cancelThunk = cancelThunk ?? (() => false);
this.completionCallback = completionCallback;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegatingXmlCreationSink"/> class.
/// </summary>
/// <param name="innerSink"></param>
/// <param name="assemblyElement"></param>
public DelegatingXmlCreationSink(IExecutionSink innerSink,
XElement assemblyElement, IRunnerLogger logger = null)
{
Guard.ArgumentNotNull(nameof(innerSink), innerSink);
Guard.ArgumentNotNull(nameof(assemblyElement), assemblyElement);
_logger = logger;
this.innerSink = innerSink;
this.assemblyElement = assemblyElement;
errorsElement = new XElement("errors");
assemblyElement.Add(errorsElement);
}
/// <inheritdoc/>
public ValueTask <_IMessageSink> CreateMessageHandler(
IRunnerLogger logger,
_IMessageSink?diagnosticMessageSink)
{
var collectionUri = Guard.NotNull("Environment variable SYSTEM_TEAMFOUNDATIONCOLLECTIONURI is not set", Environment.GetEnvironmentVariable("SYSTEM_TEAMFOUNDATIONCOLLECTIONURI"));
var teamProject = Guard.NotNull("Environment variable SYSTEM_TEAMPROJECT is not set", Environment.GetEnvironmentVariable("SYSTEM_TEAMPROJECT"));
var accessToken = Guard.NotNull("Environment variable VSTS_ACCESS_TOKEN is not set", Environment.GetEnvironmentVariable("VSTS_ACCESS_TOKEN"));
var buildId = Convert.ToInt32(Guard.NotNull("Environment variable BUILD_BUILDID is not set", Environment.GetEnvironmentVariable("BUILD_BUILDID")));
var baseUri = $"{collectionUri}{teamProject}/_apis/test/runs";
return(new(new VstsReporterMessageHandler(logger, baseUri, accessToken, buildId)));
}
public static void Transform(IRunnerLogger logger, string outputDisplayName, string resourceName, XNode xml, ITaskItem outputFile)
{
var xmlTransform = new System.Xml.Xsl.XslCompiledTransform();
using (var writer = XmlWriter.Create(outputFile.GetMetadata("FullPath"), new XmlWriterSettings {
Indent = true
}))
using (var xsltReader = XmlReader.Create(typeof(xunit).Assembly.GetManifestResourceStream("Xunit.Runner.MSBuild." + resourceName)))
using (var xmlReader = xml.CreateReader())
{
xmlTransform.Load(xsltReader);
xmlTransform.Transform(xmlReader, writer);
}
}
public static void SendRequest(IRunnerLogger logger, string url, HttpMethod method, object body)
{
if (previousErrors)
{
return;
}
lock (jsonMediaType)
{
using (var finished = new ManualResetEvent(false))
{
XunitWorkerThread.QueueUserWorkItem(async() =>
{
var bodyString = ToJson(body);
try
{
var bodyBytes = Encoding.UTF8.GetBytes(bodyString);
var request = new HttpRequestMessage(method, url);
request.Content = new ByteArrayContent(bodyBytes);
request.Content.Headers.ContentType = jsonMediaType;
request.Headers.Accept.Add(jsonMediaType);
using (var tcs = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
var response = await client.SendAsync(request, tcs.Token);
if (!response.IsSuccessStatusCode)
{
logger.LogWarning($"When sending '{method} {url}', received status code '{response.StatusCode}'; request body: {bodyString}");
previousErrors = true;
}
}
}
catch (Exception ex)
{
logger.LogError($"When sending '{method} {url}' with body '{bodyString}', exception was thrown: {ex.Message}");
previousErrors = true;
}
finally
{
finished.Set();
}
});
finished.WaitOne();
}
}
}
/// <inheritdoc />
public IMessageSink CreateMessageHandler(IRunnerLogger logger)
{
var accessToken = EnvironmentHelper.GetEnvironmentVariable("VSTS_ACCESS_TOKEN");
var collectionUri = EnvironmentHelper.GetEnvironmentVariable("SYSTEM_TEAMFOUNDATIONCOLLECTIONURI");
var teamProject = EnvironmentHelper.GetEnvironmentVariable("SYSTEM_TEAMPROJECT");
// Build ID is the ID associated with the build number, which we will use to associate the test run with
var buildId = Convert.ToInt32(EnvironmentHelper.GetEnvironmentVariable("BUILD_BUILDID"));
var baseUri = $"{collectionUri}{teamProject}/_apis/test/runs";
return(accessToken == null || collectionUri == null || teamProject == null
? new DefaultRunnerReporterWithTypesMessageHandler(logger)
: new VstsReporterMessageHandler(logger, baseUri, accessToken, buildId));
}
public static void SendRequest(IRunnerLogger logger, string url, HttpMethod method, object body)
{
if (previousErrors)
return;
lock (jsonMediaType)
{
using (var finished = new ManualResetEvent(false))
{
XunitWorkerThread.QueueUserWorkItem(async () =>
{
var bodyString = ToJson(body);
try
{
var bodyBytes = Encoding.UTF8.GetBytes(bodyString);
var request = new HttpRequestMessage(method, url);
request.Content = new ByteArrayContent(bodyBytes);
request.Content.Headers.ContentType = jsonMediaType;
request.Headers.Accept.Add(jsonMediaType);
using (var tcs = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
var response = await client.SendAsync(request, tcs.Token);
if (!response.IsSuccessStatusCode)
{
logger.LogWarning($"When sending '{method} {url}', received status code '{response.StatusCode}'; request body: {bodyString}");
previousErrors = true;
}
}
}
catch (Exception ex)
{
logger.LogError($"When sending '{method} {url}' with body '{bodyString}', exception was thrown: {ex.Message}");
previousErrors = true;
}
finally
{
finished.Set();
}
});
finished.WaitOne();
}
}
}
/// <summary>
/// Logs the assembly node by calling <see cref="IRunnerLogger.AssemblyFinished"/>.
/// </summary>
/// <param name="assemblyNode">The assembly node.</param>
/// <param name="logger">The logger.</param>
public static void LogAssemblyNode(XmlNode assemblyNode, IRunnerLogger logger)
{
int total = 0;
int failed = 0;
int skipped = 0;
double time = 0D;
if (assemblyNode != null)
{
total = Int32.Parse(assemblyNode.Attributes["total"].Value, CultureInfo.InvariantCulture);
failed = Int32.Parse(assemblyNode.Attributes["failed"].Value, CultureInfo.InvariantCulture);
skipped = Int32.Parse(assemblyNode.Attributes["skipped"].Value, CultureInfo.InvariantCulture);
time = Double.Parse(assemblyNode.Attributes["time"].Value, CultureInfo.InvariantCulture);
}
logger.AssemblyFinished(assemblyNode.Attributes["name"].Value, total, failed, skipped, time);
}
public JsonReporterMessageHandler(IRunnerLogger logger, Func<string, string> flowIdMapper)
{
this.flowIdMapper = flowIdMapper;
Diagnostics.ErrorMessageEvent += args => logger.LogImportantMessage(args.Message.ToJson());
Execution.TestAssemblyCleanupFailureEvent += args => logger.LogImportantMessage(args.Message.ToJson());
Execution.TestClassCleanupFailureEvent += args => logger.LogImportantMessage(args.Message.ToJson());
Execution.TestCaseCleanupFailureEvent += args => logger.LogImportantMessage(args.Message.ToJson());
Execution.TestCollectionCleanupFailureEvent += args => logger.LogImportantMessage(args.Message.ToJson());
Execution.TestCleanupFailureEvent += args => logger.LogImportantMessage(args.Message.ToJson());
Execution.TestMethodCleanupFailureEvent += args => logger.LogImportantMessage(args.Message.ToJson());
Execution.TestCollectionFinishedEvent += args => logger.LogImportantMessage(args.Message.ToJson(ToFlowId(args.Message.TestCollection.DisplayName)));
Execution.TestCollectionStartingEvent += args => logger.LogImportantMessage(args.Message.ToJson(ToFlowId(args.Message.TestCollection.DisplayName)));
Execution.TestFailedEvent += args => logger.LogImportantMessage(args.Message.ToJson(ToFlowId(args.Message.TestCollection.DisplayName)));
Execution.TestPassedEvent += args => logger.LogImportantMessage(args.Message.ToJson(ToFlowId(args.Message.TestCollection.DisplayName)));
Execution.TestSkippedEvent += args => logger.LogImportantMessage(args.Message.ToJson(ToFlowId(args.Message.TestCollection.DisplayName)));
Execution.TestStartingEvent += args => logger.LogImportantMessage(args.Message.ToJson(ToFlowId(args.Message.TestCollection.DisplayName)));
}
/// <summary>
/// Logs the class node by calling <see cref="IRunnerLogger.ClassFailed"/> (if the class failed).
/// The exception type was added in xUnit.net 1.1, so when the test assembly is linked against
/// xUnit.net versions prior to 1.1, the exception type will be null.
/// </summary>
/// <param name="classNode">The class node.</param>
/// <param name="logger">The logger.</param>
/// <returns>Returns true if the user wishes to continue running tests; returns false otherwise.</returns>
public static bool LogClassNode(XmlNode classNode, IRunnerLogger logger)
{
if (classNode.SelectSingleNode("failure") != null)
{
string exceptionType = null;
XmlNode failureNode = classNode.SelectSingleNode("failure");
// Exception type node was added in 1.1, so it might not be present
if (failureNode.Attributes["exception-type"] != null)
exceptionType = failureNode.Attributes["exception-type"].Value;
return logger.ClassFailed(classNode.Attributes["name"].Value,
exceptionType,
failureNode.SelectSingleNode("message").InnerText,
failureNode.SelectSingleNode("stack-trace").InnerText);
}
return true;
}
/// <summary>
/// Logs a result XML node. Maybe be any kind of XML node.
/// </summary>
/// <param name="node">The node to be logged.</param>
/// <param name="logger">The logger.</param>
/// <returns>Returns true if the user wishes to continue running tests; returns false otherwise.</returns>
public static bool LogNode(XmlNode node, IRunnerLogger logger)
{
switch (node.Name)
{
case "assembly":
LogAssemblyNode(node, logger);
return true;
case "class":
return LogClassNode(node, logger);
case "test":
return LogTestNode(node, logger);
case "start":
return LogStartNode(node, logger);
}
return true;
}
public static bool LogNode(XmlNode node, IRunnerLogger logger)
{
Guard.ArgumentNotNull("node", node);
Guard.ArgumentNotNull("logger", logger);
switch (node.Name)
{
case "assembly":
LogAssemblyNode(node, logger);
return true;
case "class":
return LogClassNode(node, logger);
case "test":
return LogTestNode(node, logger);
case "start":
return LogStartNode(node, logger);
}
return true;
}
public TeamCityReporterMessageHandler(IRunnerLogger logger,
Func<string, string> flowIdMapper = null,
TeamCityDisplayNameFormatter displayNameFormatter = null)
{
this.logger = logger;
this.flowIdMapper = flowIdMapper ?? (_ => Guid.NewGuid().ToString("N"));
this.displayNameFormatter = displayNameFormatter ?? new TeamCityDisplayNameFormatter();
Diagnostics.ErrorMessageEvent += HandleErrorMessage;
Execution.TestAssemblyCleanupFailureEvent += HandleTestAssemblyCleanupFailure;
Execution.TestCaseCleanupFailureEvent += HandleTestCaseCleanupFailure;
Execution.TestClassCleanupFailureEvent += HandleTestCaseCleanupFailure;
Execution.TestCollectionCleanupFailureEvent += HandleTestCollectionCleanupFailure;
Execution.TestCollectionFinishedEvent += HandleTestCollectionFinished;
Execution.TestCollectionStartingEvent += HandleTestCollectionStarting;
Execution.TestCleanupFailureEvent += HandleTestCleanupFailure;
Execution.TestFailedEvent += HandleTestFailed;
Execution.TestMethodCleanupFailureEvent += HandleTestMethodCleanupFailure;
Execution.TestPassedEvent += HandleTestPassed;
Execution.TestSkippedEvent += HandleTestSkipped;
Execution.TestStartingEvent += HandleTestStarting;
}
public IMessageSink CreateMessageHandler(IRunnerLogger logger)
{
return new AppVeyorReporterMessageHandler(logger);
}
public override bool Execute()
{
RemotingUtility.CleanUpRegisteredChannels();
if (TeamCity)
{
Log.LogError("The 'TeamCity' property is deprecated. Please set the 'Reporter' property to 'teamcity' instead.");
return false;
}
if (Verbose)
{
Log.LogError("The 'Verbose' property is deprecated. Please set the 'Reporter' property to 'verbose' instead.");
return false;
}
XElement assembliesElement = null;
var environment = string.Format("{0}-bit .NET {1}", IntPtr.Size * 8, Environment.Version);
if (NeedsXml)
assembliesElement = new XElement("assemblies");
switch (MaxParallelThreads)
{
case null:
case "default":
break;
case "unlimited":
maxThreadCount = 0;
break;
default:
int threadValue;
if (!int.TryParse(MaxParallelThreads, out threadValue) || threadValue < 0)
{
Log.LogError("MaxParallelThreads value '{0}' is invalid: must be 'default', 'unlimited', or a positive number", MaxParallelThreads);
return false;
}
maxThreadCount = threadValue;
break;
}
var originalWorkingFolder = Directory.GetCurrentDirectory();
using (AssemblyHelper.SubscribeResolve())
{
var reporters = GetAvailableRunnerReporters();
var reporter = reporters.FirstOrDefault(r => r.IsEnvironmentallyEnabled);
if (reporter == null && !string.IsNullOrWhiteSpace(Reporter))
{
reporter = reporters.FirstOrDefault(r => string.Equals(r.RunnerSwitch, Reporter, StringComparison.OrdinalIgnoreCase));
if (reporter == null)
{
var switchableReporters = reporters.Where(r => !string.IsNullOrWhiteSpace(r.RunnerSwitch)).Select(r => r.RunnerSwitch.ToLowerInvariant()).OrderBy(x => x).ToList();
if (switchableReporters.Count == 0)
Log.LogError("Reporter value '{0}' is invalid. There are no available reporters.", Reporter);
else
Log.LogError("Reporter value '{0}' is invalid. Available reporters: {1}", Reporter, string.Join(", ", switchableReporters));
return false;
}
}
if (reporter == null)
reporter = new DefaultRunnerReporter();
logger = new MSBuildLogger(Log);
reporterMessageHandler = reporter.CreateMessageHandler(logger);
if (!NoLogo)
Log.LogMessage(MessageImportance.High, "xUnit.net MSBuild Runner ({0})", environment);
var project = new XunitProject();
foreach (var assembly in Assemblies)
{
var assemblyFileName = assembly.GetMetadata("FullPath");
var configFileName = assembly.GetMetadata("ConfigFile");
if (configFileName != null && configFileName.Length == 0)
configFileName = null;
project.Add(new XunitProjectAssembly { AssemblyFilename = assemblyFileName, ConfigFilename = configFileName, ShadowCopy = ShadowCopy });
}
if (WorkingFolder != null)
Directory.SetCurrentDirectory(WorkingFolder);
var clockTime = Stopwatch.StartNew();
if (!parallelizeAssemblies.HasValue)
parallelizeAssemblies = project.All(assembly => assembly.Configuration.ParallelizeAssemblyOrDefault);
if (parallelizeAssemblies.GetValueOrDefault())
{
var tasks = project.Assemblies.Select(assembly => Task.Run(() => ExecuteAssembly(assembly)));
var results = Task.WhenAll(tasks).GetAwaiter().GetResult();
foreach (var assemblyElement in results.Where(result => result != null))
assembliesElement.Add(assemblyElement);
}
else
{
foreach (var assembly in project.Assemblies)
{
var assemblyElement = ExecuteAssembly(assembly);
if (assemblyElement != null)
assembliesElement.Add(assemblyElement);
}
}
clockTime.Stop();
if (completionMessages.Count > 0)
reporterMessageHandler.OnMessage(new TestExecutionSummary(clockTime.Elapsed, completionMessages.OrderBy(kvp => kvp.Key).ToList()));
}
Directory.SetCurrentDirectory(WorkingFolder ?? originalWorkingFolder);
if (NeedsXml)
{
if (Xml != null)
assembliesElement.Save(Xml.GetMetadata("FullPath"));
if (XmlV1 != null)
Transform("xUnit1.xslt", assembliesElement, XmlV1);
if (Html != null)
Transform("HTML.xslt", assembliesElement, Html);
if (NUnit != null)
Transform("NUnitXml.xslt", assembliesElement, NUnit);
}
return ExitCode == 0;
}
string ExecuteAssembly(string assemblyFilename, string configFilename, IRunnerLogger logger)
{
try
{
using (ExecutorWrapper wrapper = new ExecutorWrapper(assemblyFilename, configFilename, ShadowCopy))
{
Log.LogMessage(MessageImportance.High, "xunit.dll: Version {0}", wrapper.XunitVersion);
Log.LogMessage(MessageImportance.High, "Test assembly: {0}", assemblyFilename);
XmlTestRunner runner = new XmlTestRunner(wrapper, logger);
if (runner.RunAssembly() == TestRunnerResult.Failed)
ExitCode = -1;
return runner.Xml;
}
}
catch (Exception ex)
{
Exception e = ex;
while (e != null)
{
Log.LogError(e.GetType().FullName + ": " + e.Message);
foreach (string stackLine in e.StackTrace.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries))
Log.LogError(stackLine);
e = e.InnerException;
}
ExitCode = -1;
return "";
}
}
public AppVeyorReporterMessageHandler(IRunnerLogger logger) : base(logger) { }
public AppVeyorReporterMessageHandler(IRunnerLogger logger, string baseUri)
: base(logger)
{
this.baseUri = baseUri.TrimEnd('/');
}
public IMessageSink CreateMessageHandler(IRunnerLogger logger)
=> new TeamCityReporterMessageHandler(logger);
/// <summary>
/// Initializes a new instance of the <see cref="TestRunner"/> class.
/// </summary>
/// <param name="executorWrapper">The executor wrapper.</param>
/// <param name="logger">The logger.</param>
public TestRunner(IExecutorWrapper executorWrapper, IRunnerLogger logger)
{
wrapper = executorWrapper;
this.logger = logger;
}
public JsonReporterMessageHandler(IRunnerLogger logger)
: this(logger, _ => Guid.NewGuid().ToString("N"))
{ }
public QuietReporterMessageHandler(IRunnerLogger logger) : base(logger) { }
public IMessageSink CreateMessageHandler(IRunnerLogger logger)
{
throw new NotImplementedException();
}
public static int Main(string[] args)
{
try
{
var reporters = GetAvailableRunnerReporters();
if (args.Length == 0 || args[0] == "-?")
{
PrintHeader();
PrintUsage(reporters);
return 1;
}
AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
Console.CancelKeyPress += (sender, e) =>
{
if (!cancel)
{
Console.WriteLine("Canceling... (Press Ctrl+C again to terminate)");
cancel = true;
e.Cancel = true;
}
};
var defaultDirectory = Directory.GetCurrentDirectory();
if (!defaultDirectory.EndsWith(new string(new[] { Path.DirectorySeparatorChar }), StringComparison.Ordinal))
defaultDirectory += Path.DirectorySeparatorChar;
var commandLine = CommandLine.Parse(reporters, args);
if (commandLine.Debug)
Debugger.Launch();
logger = new ConsoleRunnerLogger(!commandLine.NoColor);
reporterMessageHandler = commandLine.Reporter.CreateMessageHandler(logger);
if (!commandLine.NoLogo)
PrintHeader();
var failCount = RunProject(commandLine.Project, commandLine.Serialize, commandLine.ParallelizeAssemblies,
commandLine.ParallelizeTestCollections, commandLine.MaxParallelThreads,
commandLine.DiagnosticMessages, commandLine.NoColor, commandLine.NoAppDomain,
commandLine.FailSkips);
if (commandLine.Wait)
{
Console.WriteLine();
Console.Write("Press any key to continue...");
Console.ReadKey();
Console.WriteLine();
}
return failCount;
}
catch (ArgumentException ex)
{
Console.WriteLine($"error: {ex.Message}");
return 1;
}
catch (BadImageFormatException ex)
{
Console.WriteLine(ex.Message);
return 1;
}
finally
{
Console.ResetColor();
}
}
public JsonReporterMessageHandler(IRunnerLogger logger, Func<string, string> flowIdMapper)
{
this.logger = logger;
this.flowIdMapper = flowIdMapper;
}
/// <inheritdoc/>
public virtual IMessageSink CreateMessageHandler(IRunnerLogger logger)
=> new DefaultRunnerReporterWithTypesMessageHandler(logger);
