public void RaiseTestRunMessageShouldInvokeRegisteredEventHandlerIfTestRunMessageEventArgsIsPassed()
{
EventWaitHandle waitHandle = new AutoResetEvent(false);
bool testMessageReceived = false;
TestRunMessageEventArgs eventArgs = null;
var message = "This is the test message";
// Register for the test message event.
loggerEvents.TestRunMessage += (sender, e) =>
{
testMessageReceived = true;
eventArgs = e;
waitHandle.Set();
};
loggerEvents.EnableEvents();
// Send the test mesage event.
loggerEvents.RaiseTestRunMessage(new TestRunMessageEventArgs(TestMessageLevel.Informational, message));
var waitSuccess = waitHandle.WaitOne(500);
Assert.IsTrue(waitSuccess, "Event must be raised within timeout.");
Assert.IsTrue(testMessageReceived);
Assert.IsNotNull(eventArgs);
Assert.AreEqual(message, eventArgs.Message);
Assert.AreEqual(TestMessageLevel.Informational, eventArgs.Level);
}
/// <summary>
/// Called when a test message is received.
/// </summary>
private void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
ValidateArg.NotNull <object>(sender, "sender");
ValidateArg.NotNull <TestRunMessageEventArgs>(e, "e");
switch (e.Level)
{
case TestMessageLevel.Informational:
Output.Information(e.Message);
break;
case TestMessageLevel.Warning:
Output.Warning(e.Message);
break;
case TestMessageLevel.Error:
this.testOutcome = TestOutcome.Failed;
Output.Error(e.Message);
break;
default:
Debug.Fail("ConsoleLogger.TestMessageHandler: The test message level is unrecognized: {0}", e.Level.ToString());
break;
}
}
/// <summary>
/// Called when a test message is received.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// Event args
/// </param>
internal void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
ValidateArg.NotNull(sender, "sender");
ValidateArg.NotNull(e, "e");
RunInfo runMessage;
switch (e.Level)
{
case TestMessageLevel.Informational:
this.AddRunLevelInformationalMessage(e.Message);
break;
case TestMessageLevel.Warning:
runMessage = new RunInfo(e.Message, null, Environment.MachineName, TrxLoggerObjectModel.TestOutcome.Warning);
this.runLevelErrorsAndWarnings.Add(runMessage);
break;
case TestMessageLevel.Error:
this.testRunOutcome = TrxLoggerObjectModel.TestOutcome.Failed;
runMessage = new RunInfo(e.Message, null, Environment.MachineName, TrxLoggerObjectModel.TestOutcome.Error);
this.runLevelErrorsAndWarnings.Add(runMessage);
break;
default:
Debug.Fail("TrxLogger.TestMessageHandler: The test message level is unrecognized: {0}", e.Level.ToString());
break;
}
}
/// <summary>
/// Handles the message level information like warnings, errors etc..
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
ValidateArg.NotNull(sender, "sender");
ValidateArg.NotNull(e, "e");
switch (e.Level)
{
case TestMessageLevel.Informational:
if (TestRunDetails.RunLevelMessageInformational == null)
{
TestRunDetails.RunLevelMessageInformational = new List <string>();
}
TestRunDetails.RunLevelMessageInformational.Add(e.Message);
break;
case TestMessageLevel.Warning:
case TestMessageLevel.Error:
if (TestRunDetails.RunLevelMessageErrorAndWarning == null)
{
TestRunDetails.RunLevelMessageErrorAndWarning = new List <string>();
}
TestRunDetails.RunLevelMessageErrorAndWarning.Add(e.Message);
break;
default:
EqtTrace.Info("htmlLogger.TestMessageHandler: The test message level is unrecognized: {0}",
e.Level.ToString());
break;
}
}
/// <summary>
/// Called when a test message is received.
/// </summary>
internal void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
lock (this.messagesGuard)
{
this.messages.Add(e.Message);
}
}
/// <summary>
/// Sends the test session logger warning and error messages to IDE;
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void TestRunMessageHandler(object sender, TestRunMessageEventArgs e)
{
// save into trace log and send the message to the IDE
//
// there is a mismatch between log levels that VS uses and that TP
// uses. In VS you can choose Trace level which will enable Test platform
// logs on Verbose level. Below we report Errors and warnings always to the
// IDE no matter what the level of VS logging is, but Info only when the Eqt trace
// info level is enabled (so only when VS enables Trace logging)
switch (e.Level)
{
case TestMessageLevel.Error:
EqtTrace.Error(e.Message);
SendTestMessage(e.Level, e.Message);
break;
case TestMessageLevel.Warning:
EqtTrace.Warning(e.Message);
SendTestMessage(e.Level, e.Message);
break;
case TestMessageLevel.Informational:
EqtTrace.Info(e.Message);
if (EqtTrace.IsInfoEnabled)
{
SendTestMessage(e.Level, e.Message);
}
break;
default:
throw new NotSupportedException($"Test message level '{e.Level}' is not supported.");
}
}
/// <summary>
/// Called when a test run message is sent.
/// </summary>
private void TestRunMessageHandler(object sender, TestRunMessageEventArgs e)
{
if (e.Level == TestMessageLevel.Error)
{
this.Outcome = TestOutcome.Failed;
}
}
public void TestRunMessageHandlerForMessageLevelErrorSetsOutcomeToFailed()
{
var messageArgs = new TestRunMessageEventArgs(TestMessageLevel.Error, "bad stuff");
mockTestRunRequest.Raise(tr => tr.TestRunMessage += null, messageArgs);
Assert.AreEqual(TestOutcome.Failed, resultAggregator.Outcome);
}
/// <summary>
/// Called when a test message is received.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// Event args
/// </param>
private void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
NotNull(sender, nameof(sender));
NotNull(e, nameof(e));
// Add code to handle message
}
/// <summary>
/// Called when a test message is received.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// Event args
/// </param>
private void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
this.NotNull(sender, "sender");
this.NotNull(e, "e");
// Add code to handle message
}
/// <summary>
/// Dispatch TestRunMessage event to listeners.
/// </summary>
/// <param name="level">Output level of the message being sent.</param>
/// <param name="message">Actual contents of the message</param>
public void HandleLogMessage(TestMessageLevel level, string message)
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("DiscoveryRequest.SendDiscoveryMessage: Starting.");
}
lock (this.syncObject)
{
if (this.disposed)
{
if (EqtTrace.IsWarningEnabled)
{
EqtTrace.Warning("DiscoveryRequest.SendDiscoveryMessage: Ignoring as the object is disposed.");
}
return;
}
var testRunMessageEvent = new TestRunMessageEventArgs(level, message);
this.LoggerManager.HandleDiscoveryMessage(testRunMessageEvent);
this.OnDiscoveryMessage.SafeInvoke(this, testRunMessageEvent, "DiscoveryRequest.OnTestMessageRecieved");
}
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("DiscoveryRequest.SendDiscoveryMessage: Completed.");
}
}
public void RaiseDiscoveryMessageShouldInvokeRegisteredEventHandler()
{
bool discoveryMessageReceived = false;
TestRunMessageEventArgs receivedEventArgs = null;
EventWaitHandle waitHandle = new AutoResetEvent(false);
string message = "This is the test message";
TestRunMessageEventArgs testRunMessageEventArgs = new TestRunMessageEventArgs(TestMessageLevel.Informational, message);
// Register for the discovery message event.
loggerEvents.DiscoveryMessage += (sender, e) =>
{
discoveryMessageReceived = true;
receivedEventArgs = e;
waitHandle.Set();
};
loggerEvents.EnableEvents();
// Send the discovery message event.
loggerEvents.RaiseDiscoveryMessage(testRunMessageEventArgs);
var waitSuccess = waitHandle.WaitOne(500);
Assert.IsTrue(waitSuccess, "Event must be raised within timeout.");
Assert.IsTrue(discoveryMessageReceived);
Assert.IsNotNull(receivedEventArgs);
Assert.AreEqual(receivedEventArgs, testRunMessageEventArgs);
Assert.AreEqual(message, receivedEventArgs.Message);
Assert.AreEqual(TestMessageLevel.Informational, receivedEventArgs.Level);
}
private void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
if (e.Message.Equals("TestRunMessage"))
{
TestLoggerManagerTests.counter++;
TestLoggerManagerTests.waitHandle.Set();
}
}
public void SendTestRunMessage(TestRunMessageEventArgs ev)
{
if (ev == null)
{
throw new ArgumentNullException(nameof(ev));
}
TestRunMessage?.Invoke(this, ev);
}
public void TestMessageHandlerShouldAddMessageWhenItIsInformation()
{
string message = "The information to test";
TestRunMessageEventArgs trme = new TestRunMessageEventArgs(TestMessageLevel.Informational, message);
this.testableTrxLogger.TestMessageHandler(new object(), trme);
Assert.IsTrue(this.testableTrxLogger.GetRunLevelInformationalMessage().Contains(message));
}
public void TestMessageHandlerShouldAddMessageInListIfItIsError()
{
string message = "The information to test";
TestRunMessageEventArgs trme = new TestRunMessageEventArgs(TestMessageLevel.Error, message);
this.testableTrxLogger.TestMessageHandler(new object(), trme);
Assert.AreEqual(this.testableTrxLogger.GetRunLevelErrorsAndWarnings().Count, 1);
}
/// <summary>
/// Raises a discovery message event to the enabled loggers.
/// </summary>
/// <param name="args">Arguments to be raised.</param>
internal void RaiseDiscoveryMessage(TestRunMessageEventArgs args)
{
ValidateArg.NotNull <TestRunMessageEventArgs>(args, "args");
this.CheckDisposed();
// Sending 0 size as this event is not expected to contain any data.
this.SafeInvokeAsync(() => this.DiscoveryMessage, args, 0, "InternalTestLoggerEvents.SendDiscoveryMessage");
}
/// <summary>
/// Handles discovery message event.
/// </summary>
/// <param name="e">TestRunMessage event args.</param>
public void HandleDiscoveryMessage(TestRunMessageEventArgs e)
{
if (this.isDisposed)
{
EqtTrace.Warning("TestLoggerManager.HandleDiscoveryMessage: Ignoring as the object is disposed.");
return;
}
this.loggerEvents.RaiseDiscoveryMessage(e);
}
/// <summary>
/// Sends the test session logger warning and error messages to IDE;
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void TestRunMessageHandler(object sender, TestRunMessageEventArgs e)
{
if (e.Level == TestMessageLevel.Error || e.Level == TestMessageLevel.Warning)
{
var payload = new TestMessagePayload {
MessageLevel = e.Level, Message = e.Message
};
this.communicationManager.SendMessage(MessageType.TestMessage, payload);
}
}
/// <summary>
/// Called when a test message is received. These messages are coming from the test
/// framework, and don't contain standard output produced by test code.
/// </summary>
internal void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
if (e.Level == TestMessageLevel.Informational)
{
this.stdOut.AppendLine(e.Message);
}
else
{
this.stdErr.AppendLine(e.Message);
}
}
public void TestMessageHandlerShouldAddMessageWhenItIsInformation()
{
const string message = "First message";
var testRunMessageEventArgs = new TestRunMessageEventArgs(TestMessageLevel.Informational, message);
this.htmlLogger.TestMessageHandler(new object(), testRunMessageEventArgs);
var actualMessage = this.htmlLogger.TestRunDetails.RunLevelMessageInformational.First();
Assert.AreEqual(message, actualMessage);
}
public void OnTestRunMessage(TestRunMessageEventArgs ev)
{
if (ev == null)
{
throw new ArgumentNullException(nameof(ev));
}
if (ev.Level == TestMessageLevel.Informational && !Strings.IsNullOrWhiteSpace(ev.Message))
{
_testCaseFilter.RegisterOutputMessage(ev.Message);
}
}
private void OnTestRunMessage(object sender, TestRunMessageEventArgs ev)
{
if (ev == null)
{
throw new ArgumentNullException(nameof(ev));
}
if (ev.Level == TestMessageLevel.Informational && !ev.Message.IsNullOrWhiteSpace())
{
_testCaseFilter.RegisterOutputMessage(ev.Message);
}
}
private void TestRunMessageHandler(object sender, TestRunMessageEventArgs e)
{
Match match = Regex.Match(e.Message, StartingMessagePattern);
if (match.Success && match.Groups.Count == 2)
{
string suiteName = match.Groups[1].Value;
WriteServiceMessage($"testSuiteStarted name='{suiteName}'");
suiteNames.Push(suiteName);
}
}
public void RaiseDiscoveryMessageShouldThrowExceptionIfAlreadyDisposed()
{
var loggerEvents = GetDisposedLoggerEvents();
string message = "This is the test message";
TestRunMessageEventArgs testRunMessageEventArgs = new TestRunMessageEventArgs(TestMessageLevel.Informational, message);
Assert.ThrowsException <ObjectDisposedException>(() =>
{
loggerEvents.RaiseDiscoveryMessage(testRunMessageEventArgs);
});
}
public void TestRunCompleteHandlerShouldReportFailedOutcomeIfTestRunIsAborted()
{
string message = "The information to test";
TestRunMessageEventArgs trme = new TestRunMessageEventArgs(TestMessageLevel.Error, message);
this.testableTrxLogger.TestMessageHandler(new object(), trme);
this.testableTrxLogger.TestRunCompleteHandler(new object(), new TestRunCompleteEventArgs(null, false, true, null, null, TimeSpan.Zero));
Assert.AreEqual(this.testableTrxLogger.TestResultOutcome, TrxLoggerObjectModel.TestOutcome.Failed);
}
/// <summary>
/// Raises a test run message event to the enabled loggers.
/// </summary>
/// <param name="args">Arguments to be raised.</param>
internal void RaiseTestRunMessage(TestRunMessageEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
this.CheckDisposed();
// Sending 0 size as this event is not expected to contain any data.
this.SafeInvokeAsync(() => this.TestRunMessage, args, 0, "InternalTestLoggerEvents.SendTestRunMessage");
}
public void MessageShouldStoreRunMessages()
{
var testRun = new TestRunBuilder().WithStore(this.store).Build();
var messageEvent = new TestRunMessageEventArgs(
TestMessageLevel.Informational,
"Dummy message");
testRun.Message(messageEvent);
testRun.Store.Pop(out _, out var messages);
Assert.AreEqual(1, messages.Count);
Assert.AreEqual(TestMessageLevel.Informational, messages[0].Level);
Assert.AreEqual("Dummy message", messages[0].Message);
}
public void TestMessageHandlerShouldAddMessageInListIfItIsWarningAndError()
{
const string message = "error message";
const string message2 = "warning message";
var testRunMessageEventArgs = new TestRunMessageEventArgs(TestMessageLevel.Error, message);
this.htmlLogger.TestMessageHandler(new object(), testRunMessageEventArgs);
var testRunMessageEventArgs2 = new TestRunMessageEventArgs(TestMessageLevel.Warning, message2);
this.htmlLogger.TestMessageHandler(new object(), testRunMessageEventArgs2);
Assert.AreEqual(message, this.htmlLogger.TestRunDetails.RunLevelMessageErrorAndWarning.First());
Assert.AreEqual(2, this.htmlLogger.TestRunDetails.RunLevelMessageErrorAndWarning.Count);
}
public void TestMessageHandlerShouldAddMessageWhenItIsInformation()
{
string message = "First message";
string message2 = "Second message";
TestRunMessageEventArgs trme = new TestRunMessageEventArgs(TestMessageLevel.Informational, message);
this.testableTrxLogger.TestMessageHandler(new object(), trme);
TestRunMessageEventArgs trme2 = new TestRunMessageEventArgs(TestMessageLevel.Informational, message2);
this.testableTrxLogger.TestMessageHandler(new object(), trme2);
string expectedMessage = message + Environment.NewLine + message2 + Environment.NewLine;
Assert.AreEqual(expectedMessage, this.testableTrxLogger.GetRunLevelInformationalMessage());
}
/// <summary>
/// Called when a test message is received.
/// </summary>
private void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
switch (e.Level)
{
case TestMessageLevel.Informational:
Console.WriteLine("Information: " + e.Message);
break;
case TestMessageLevel.Warning:
Console.WriteLine("Warning: " + e.Message);
break;
case TestMessageLevel.Error:
Console.WriteLine("Error: " + e.Message);
break;
default:
break;
}
}
/// <summary>
/// Called when a test message is received.
/// </summary>
private void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
try
{
switch (e.Level)
{
case TestMessageLevel.Informational:
_teamCityWriter.WriteMessage(e.Message);
break;
case TestMessageLevel.Warning:
_teamCityWriter.WriteWarning(e.Message);
break;
case TestMessageLevel.Error:
_teamCityWriter.WriteError(e.Message);
break;
}
}
catch (Exception ex)
{
_teamCityWriter.WriteError("TeamCity Logger Error", ex.ToString());
}
}
/// <summary>
/// Called when a test message is received.
/// </summary>
private static void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
try
{
switch (e.Level)
{
case TestMessageLevel.Informational:
Console.WriteLine("Information: " + e.Message);
break;
case TestMessageLevel.Warning:
Console.WriteLine("Warning: " + e.Message);
break;
case TestMessageLevel.Error:
Console.WriteLine("Error: " + e.Message);
break;
}
}
catch (Exception ex)
{
Console.WriteLine("##teamcity[message text='TeamCity Logger Error' errorDetails='{0}' status='ERROR']", FormatForTeamCity(ex.ToString()));
}
}
public void FireTestRunMessaage(TestRunMessageEventArgs e)
{
Debug.Assert(TestRunMessage != null, "TestRunMessage != null");
Debug.Assert(e != null, "e != null");
TestRunMessage(this, e);
}
/// <summary>
/// Called when a test message is received.
/// </summary>
private void TestMessageHandler(object sender, TestRunMessageEventArgs e)
{
switch (e.Level)
{
case TestMessageLevel.Informational:
break;
case TestMessageLevel.Warning:
break;
case TestMessageLevel.Error:
break;
default:
break;
}
}
