protected override void HandleTestSkipped(MessageHandlerArgs<ITestSkipped> args)
{
var testSkipped = args.Message;
AppVeyorUpdateTest(GetFinishedTestName(testSkipped.Test.DisplayName), "xUnit", assemblyFileName, "Skipped",
Convert.ToInt64(testSkipped.ExecutionTime * 1000), null, null, null);
base.HandleTestSkipped(args);
}
void HandleTestStarting(MessageHandlerArgs<ITestStarting> args)
{
var testName = args.Message.Test.DisplayName;
lock (testMethods)
if (testMethods.ContainsKey(testName))
testName = $"{testName} {testMethods[testName]}";
AppVeyorAddTest(testName, "xUnit", assemblyFileName, "Running", null, null, null, null);
}
protected override void HandleTestFailed(MessageHandlerArgs<ITestFailed> args)
{
var testFailed = args.Message;
AppVeyorUpdateTest(GetFinishedTestName(testFailed.Test.DisplayName), "xUnit", assemblyFileName, "Failed",
Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output);
base.HandleTestFailed(args);
}
void HandleTestSkipped(MessageHandlerArgs<ITestSkipped> args)
{
if (TestRunState == TestRunState.NoTests)
TestRunState = TestRunState.Success;
var testSkipped = args.Message;
var testResult = testSkipped.ToTdNetTestResult(TestState.Ignored, totalTests);
testResult.Message = testSkipped.Reason;
TestListener.TestFinished(testResult);
}
void HandleTestPassed(MessageHandlerArgs<ITestPassed> args)
{
if (TestRunState == TestRunState.NoTests)
TestRunState = TestRunState.Success;
var testPassed = args.Message;
var testResult = testPassed.ToTdNetTestResult(TestState.Passed, totalTests);
TestListener.TestFinished(testResult);
WriteOutput(testPassed.Test.DisplayName, testPassed.Output);
}
void HandleDiagnosticMessage(MessageHandlerArgs<IDiagnosticMessage> args)
{
lock (consoleLock)
{
if (!noColor)
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($" {assemblyDisplayName}: {args.Message.Message}");
if (!noColor)
Console.ResetColor();
}
}
void HandleTestFailed(MessageHandlerArgs<ITestFailed> args)
{
TestRunState = TestRunState.Failure;
var testFailed = args.Message;
var testResult = testFailed.ToTdNetTestResult(TestState.Failed, totalTests);
testResult.Message = ExceptionUtility.CombineMessages(testFailed);
testResult.StackTrace = ExceptionUtility.CombineStackTraces(testFailed);
TestListener.TestFinished(testResult);
WriteOutput(testFailed.Test.DisplayName, testFailed.Output);
}
protected virtual void TestAssemblyExecutionFinished(MessageHandlerArgs <ITestAssemblyFinished> args)
{
lock (Logger.LockObject)
{
try
{
Bridge.Context.LaunchReporter.Finish(new FinishLaunchRequest {
EndTime = DateTime.UtcNow
});
Logger.LogMessage("Waiting to finish sending results to Report Portal server...");
var stopWatch = Stopwatch.StartNew();
Bridge.Context.LaunchReporter.FinishTask.Wait();
Logger.LogMessage($"Results are sent to Report Portal server. Sync duration: {stopWatch.Elapsed}");
}
catch (Exception exp)
{
Logger.LogError(exp.ToString());
}
}
}
void HandleTestAssemblyStarting(MessageHandlerArgs <ITestAssemblyStarting> args)
{
lock (clientLock)
{
assembliesInFlight++;
// Look for the TFM attrib to disambiguate
var attrib = args.Message.TestAssembly.Assembly.GetCustomAttributes("System.Runtime.Versioning.TargetFrameworkAttribute").FirstOrDefault();
var arg = attrib?.GetConstructorArguments().FirstOrDefault() as string;
var assemblyFileName = Path.GetFileName(args.Message.TestAssembly.Assembly.AssemblyPath);
if (arg != null)
{
assemblyFileName = $"{assemblyFileName} ({arg})";
}
assemblyNames[args.Message.TestAssembly.Assembly.Name] = Tuple.Create(assemblyFileName, new Dictionary <string, int>(StringComparer.OrdinalIgnoreCase));
if (client == null)
{
client = new AppVeyorClient(Logger, baseUri);
}
}
}
public void HandleHelp(MessageHandlerArgs msgArgs, string[] helpArgs)
{
StringBuilder builder = new StringBuilder();
builder.Append("My avaiable commands are: ");
foreach (string command in this.cowSayConfig.CowFileInfoList.CommandList.Keys)
{
builder.Append(command + ", ");
}
// Remove ',' and space.
builder.Remove(builder.Length - 2, builder.Length - 2);
// Limit our help message.
if (builder.Length >= 451)
{
builder.Remove(450, builder.Length);
}
msgArgs.Writer.SendMessage(
builder.ToString(),
msgArgs.Channel
);
}
void HandleDiagnosticMessage(MessageHandlerArgs <IDiagnosticMessage> args)
{
lock (consoleLock)
{
if (!noColor)
{
ConsoleHelper.SetForegroundColor(displayColor);
}
if (assemblyDisplayName != null)
{
Console.WriteLine($" {assemblyDisplayName}: {args.Message.Message}");
}
else
{
Console.WriteLine($" {args.Message.Message}");
}
if (!noColor)
{
ConsoleHelper.ResetColor();
}
}
}
void HandleTestSkipped(MessageHandlerArgs <ITestSkipped> args)
{
blameWriter.Write(" [SKIPPED]");
completed = true;
}
private static void OnDiagnosticMessageEvent(MessageHandlerArgs <IDiagnosticMessage> args)
{
WriteErrorLine(args.Message.Message);
}
private static void Execution_TestFinishedEvent(MessageHandlerArgs <ITestFinished> args)
{
lock (consoleLock)
Console.WriteLine($"{args.Message.Test.DisplayName} finished");
}
protected virtual void HandleTestCleanupFailure(MessageHandlerArgs <ITestCleanupFailure> args)
{
var cleanupFailure = args.Message;
LogError($"Test Cleanup Failure ({cleanupFailure.Test.DisplayName})", cleanupFailure);
}
protected virtual void HandleTestCollectionStarting(MessageHandlerArgs<ITestCollectionStarting> args)
{
var testCollectionStarting = args.Message;
logger.LogImportantMessage($"##teamcity[testSuiteStarted name='{Escape(displayNameFormatter.DisplayName(testCollectionStarting.TestCollection))}' flowId='{ToFlowId(testCollectionStarting.TestCollection.DisplayName)}']");
}
protected virtual void HandleTestFailed(MessageHandlerArgs<ITestFailed> args)
{
var testFailed = args.Message;
logger.LogImportantMessage($"##teamcity[testFailed name='{Escape(displayNameFormatter.DisplayName(testFailed.Test))}' details='{Escape(ExceptionUtility.CombineMessages(testFailed))}|r|n{Escape(ExceptionUtility.CombineStackTraces(testFailed))}' flowId='{ToFlowId(testFailed.TestCollection.DisplayName)}']");
LogFinish(testFailed);
}
protected virtual void HandleTestAssemblyCleanupFailure(MessageHandlerArgs<ITestAssemblyCleanupFailure> args)
{
var cleanupFailure = args.Message;
LogError($"Test Assembly Cleanup Failure ({cleanupFailure.TestAssembly.Assembly.AssemblyPath})", cleanupFailure);
}
protected virtual void HandleTestCollectionCleanupFailure(MessageHandlerArgs<ITestCollectionCleanupFailure> args)
{
var cleanupFailure = args.Message;
LogError($"Test Collection Cleanup Failure ({cleanupFailure.TestCollection.DisplayName})", cleanupFailure);
}
protected virtual void HandleErrorMessage(MessageHandlerArgs<IErrorMessage> args)
{
var error = args.Message;
LogError("FATAL ERROR", error);
}
protected virtual void HandleTestSkipped(MessageHandlerArgs<ITestSkipped> args)
{
var testSkipped = args.Message;
logger.LogImportantMessage($"##teamcity[testIgnored name='{Escape(displayNameFormatter.DisplayName(testSkipped.Test))}' message='{Escape(testSkipped.Reason)}' flowId='{ToFlowId(testSkipped.TestCollection.DisplayName)}']");
LogFinish(testSkipped);
}
protected virtual void HandleTestPassed(MessageHandlerArgs<ITestPassed> args)
{
var testPassed = args.Message;
LogFinish(testPassed);
}
public void TestSetup()
{
this.ircConfig = TestHelpers.GetTestIrcConfig();
this.ircWriter = new Mock <IIrcWriter>(MockBehavior.Strict);
this.responseReceived = null;
}
protected virtual void HandleTestPassed(MessageHandlerArgs <ITestPassed> args)
{
var testPassed = args.Message;
LogFinish(testPassed);
}
void Discovery_DiscoveryCompleteMessageEvent(MessageHandlerArgs <IDiscoveryCompleteMessage> args) => Finished.Set();
protected virtual void HandleTestAssemblyCleanupFailure(MessageHandlerArgs <ITestAssemblyCleanupFailure> args)
{
var cleanupFailure = args.Message;
LogError($"Test Assembly Cleanup Failure ({cleanupFailure.TestAssembly.Assembly.AssemblyPath})", cleanupFailure);
}
protected virtual void HandleTestMethodCleanupFailure(MessageHandlerArgs<ITestMethodCleanupFailure> args)
{
var cleanupFailure = args.Message;
LogError($"Test Method Cleanup Failure ({cleanupFailure.TestMethod.Method.Name})", cleanupFailure);
}
private void OnDiscoveryCompleteMessageEvent(MessageHandlerArgs <IDiscoveryCompleteMessage> args)
{
Finished.Set();
}
protected virtual void HandleErrorMessage(MessageHandlerArgs <IErrorMessage> args)
{
var error = args.Message;
LogError("FATAL ERROR", error);
}
/// <summary>
/// Handles the get users command, which queries the server for the user list.
/// </summary>
private void HandleGetUsersCommand(MessageHandlerArgs args)
{
args.Writer.SendRawCmd("NAMES " + args.Channel);
this.isQueried[args.Channel] = true;
}
protected virtual void HandleTestCollectionStarting(MessageHandlerArgs <ITestCollectionStarting> args)
{
var testCollectionStarting = args.Message;
logger.LogImportantMessage($"##teamcity[testSuiteStarted name='{Escape(displayNameFormatter.DisplayName(testCollectionStarting.TestCollection))}' flowId='{ToFlowId(testCollectionStarting.TestCollection.DisplayName)}']");
}
void HandleTestStarting(MessageHandlerArgs <ITestStarting> args)
{
var test = conversions[args.Message.TestCase];
sink?.SendTestStarted(test);
}
static void Diagnostics_DiagnosticMessageEvent(MessageHandlerArgs <IDiagnosticMessage> args)
{
var message = args.Message;
WriteErrorLine(message.Message);
}
void HandleTestAssemblyStarting(MessageHandlerArgs <ITestAssemblyStarting> args)
{
assemblyFileName = Path.GetFileName(args.Message.TestAssembly.Assembly.AssemblyPath);
client = new AppVeyorClient(Logger, baseUri);
}
void HandleTestSkipped(MessageHandlerArgs <ITestSkipped> args)
{
MakeTestResultViewModel(args.Message, TestState.Skipped);
}
void HandleTestAssemblyStarting(MessageHandlerArgs<ITestAssemblyStarting> args)
{
assemblyFileName = Path.GetFileName(args.Message.TestAssembly.Assembly.AssemblyPath);
client = new AppVeyorClient(Logger, baseUri);
}
void HandleTestAssemblyFinished(MessageHandlerArgs <ITestAssemblyFinished> args)
{
client.WaitOne(CancellationToken.None);
}
/// <summary>
/// The function that is called
/// </summary>
/// <param name="writer">The writer that can be written to.</param>
/// <param name="args">The response from the server.</param>
private void MessageFunction(MessageHandlerArgs args)
{
Assert.AreSame(this.ircWriter.Object, args.Writer);
this.responseReceived = args;
}
void HandleTestAssemblyFinished(MessageHandlerArgs<ITestAssemblyFinished> args)
{
client.WaitOne(CancellationToken.None);
}
void HandleTestPassed(MessageHandlerArgs <ITestPassed> args)
{
blameWriter.Write(" [PASSED]");
completed = true;
}
private void HandleTestCaseDiscoveryMessage(MessageHandlerArgs <ITestCaseDiscoveryMessage> args)
{
// some my stuff
}
/// <summary>
/// Handles the "list plugin" command.
/// </summary>
private void HandlePluginListCommand(MessageHandlerArgs args)
{
args.Writer.SendMessage(this.pluginListResponse, args.Channel);
}
void HandleTestFailed(MessageHandlerArgs <ITestFailed> args)
{
blameWriter.Write(" [FAILED]");
completed = true;
}
/// <summary>
/// Handles help message.
/// </summary>
public void HandleHelp(MessageHandlerArgs msgArgs, string[] helpArgs)
{
msgArgs.Writer.SendMessage(this.About, msgArgs.Channel);
}
