public void Handle(TestCaseResultServerEvent message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
switch (message.ResultType)
{
case ResultType.Ignored:
"I".WrapConsoleMessageWithColor(Settings.ConsoleColorInformation, false);
break;
case ResultType.Passed:
".".WrapConsoleMessageWithColor(Settings.ConsoleColorInformation, false);
break;
case ResultType.Failed:
case ResultType.SystemGeneratedFailure:
WriteOutError(message);
break;
default:
"Unknown TestCaseResultServerEvent (to StatLight) - {0}".FormatWith(message.ResultType)
.WrapConsoleMessageWithColor(Settings.ConsoleColorError, true);
break;
}
}
private Guid GetGuidForItem(TestCaseResultServerEvent testCaseResultServerEvent, HashType hashType)
{
IDictionary <TestCaseResultServerEvent, Guid> hash;
switch (hashType)
{
case HashType.ExecutionId:
hash = _executionIdHash;
break;
case HashType.TestId:
hash = _testIdHash;
break;
default:
throw new NotImplementedException();
}
Guid newGuid;
if (hash.ContainsKey(testCaseResultServerEvent))
{
newGuid = hash[testCaseResultServerEvent];
}
else
{
newGuid = _guidSequenceGenerator.GetNext();
hash.Add(testCaseResultServerEvent, newGuid);
}
return(newGuid);
}
private static void TranslateCoreInfo(ref TestCaseResultServerEvent resultServerEvent, TestExecutionMethodClientEvent message)
{
resultServerEvent.ClassName = message.ClassName;
resultServerEvent.NamespaceName = message.NamespaceName;
resultServerEvent.MethodName = message.MethodName;
resultServerEvent.PopulateMetadata(message.Metadata);
}
protected override void Because()
{
base.Because();
var message = new TestCaseResultServerEvent(ResultType.Passed);
publisher.Handle(message);
}
public void Handle(TestExecutionMethodFailedClientEvent message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
//_logger.Debug("Handle - TestExecutionMethodFailedClientEvent - {0}".FormatWith(message.FullMethodName));
Action action = () =>
{
if (_dialogAssertionMessageMatchmaker.WasEventAlreadyClosed(message))
{
// Don't include this as a "passed" test as we had to automatically close the dialog);)
return;
}
var msg = new TestCaseResultServerEvent(ResultType.Failed)
{
Finished = message.Finished,
Started = message.Started,
ExceptionInfo = message.ExceptionInfo,
OtherInfo = message.Description,
};
if (_currentReport != null)
{
msg.XapFilePath = _currentReport.XapPath;
}
TranslateCoreInfo(ref msg, message);
ReportIt(msg);
};
_eventMatchMacker.AddEvent(message, action);
}
public void Should_have_pulled_the_TestContext_WriteLine_information_and_be_in_the_correct_order()
{
TestCaseResultServerEvent testCaseResultServerEvent = TestReport
.TestResults
.Where(w => w.MethodName.Equals("Should_be_able_to_write_to_the_TestContext") && w.ClassName.Equals("MSTestTests"))
.Single();
testCaseResultServerEvent.Metadata.Count().ShouldBeGreaterThan(0, "Should have found some metadata");
var sb = new StringBuilder();
var allItems = testCaseResultServerEvent.Metadata.ToList();
bool failed = false;
for (int i = 0; i < allItems.Count; i++)
{
var value = allItems[i].Value;
if (value != "Test {0}".FormatWith(i))
{
sb.AppendLine("Expected: Test {0} But Was: {1}".FormatWith(i, value));
failed = true;
}
else
{
sb.AppendLine(value);
}
}
if (failed)
{
Assert.Fail(sb.ToString());
}
}
private static string GetErrorStackTrace(TestCaseResultServerEvent testCaseResultServerEvent)
{
if (testCaseResultServerEvent.ExceptionInfo != null)
{
return(testCaseResultServerEvent.ExceptionInfo.StackTrace ?? "");
}
return(testCaseResultServerEvent.OtherInfo ?? "");
}
private static string GetErrorMessage(TestCaseResultServerEvent r)
{
if (r.ExceptionInfo != null)
{
return(r.ExceptionInfo.FullMessage ?? "");
}
return(r.OtherInfo ?? "");
}
private void ReportFailureMessage(string messageValue)
{
var msg = new TestCaseResultServerEvent(ResultType.Failed)
{
OtherInfo = messageValue,
};
ReportIt(msg);
}
public static IEnumerable <string> ReadMetadata(this TestCaseResultServerEvent testCaseResultServerEvent, string property)
{
var data = testCaseResultServerEvent.Metadata.Where(w => w.Name == property);
if (data.Any())
{
return(data.Select(s => s.Value));
}
return(null);
}
private void OnTestCaseResultCreated(TestCaseResultServerEvent resultServerEvent)
{
lock (_sync)
{
IEnumerable <TestContextMessageClientEvent> testContextMessageClientEvents = _unhandledMessages.Where(x => x.FullTestName == resultServerEvent.FullMethodName());
foreach (var message in testContextMessageClientEvents.OrderBy(x => x.Order))
{
AppendTestContextMetadata(resultServerEvent, message);
}
_unhandledMessages.RemoveAll(x => x.FullTestName == resultServerEvent.FullMethodName());
}
}
public void Handle(TestExecutionMethodIgnoredClientEvent message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
//_logger.Debug("Handle - TestExecutionMethodIgnoredClientEvent - {0}".FormatWith(message.FullMethodName));
var msg = new TestCaseResultServerEvent(ResultType.Ignored)
{
MethodName = message.Message,
};
ReportIt(msg);
}
private void ReportFailureMessage(string messageValue)
{
var msg = new TestCaseResultServerEvent(ResultType.Failed)
{
OtherInfo = messageValue,
};
if (_currentReport != null)
{
msg.XapFilePath = _currentReport.XapPath;
}
ReportIt(msg);
}
private static XElement GetTestOwner(TestCaseResultServerEvent test, XNamespace ns)
{
var owners = test.Metadata.Where(i => i.Value == "Owner");
var items = new List <XElement>();
foreach (var owner in owners)
{
items.Add(new XElement(ns + "Owner",
new XAttribute("name", owner.Name)));
}
if (items.Count > 0)
{
return(new XElement(ns + "Owners", items));
}
return(null);
}
public void Handle(DialogAssertionServerEvent message)
{
Action <TestExecutionMethodBeginClientEvent> handler = m =>
{
var namespaceName = m.NamespaceName;
var className = m.ClassName;
var methodName = m.MethodName;
var msg = new TestCaseResultServerEvent(ResultType.Failed)
{
OtherInfo = message.Message,
NamespaceName = namespaceName,
ClassName = className,
MethodName = methodName,
};
if (_currentReport != null)
{
msg.XapFilePath = _currentReport.XapPath;
}
ReportIt(msg);
};
if (message.DialogType == DialogType.Assert)
{
_dialogAssertionMessageMatchmaker.AddAssertionHandler(message, handler);
}
else if (message.DialogType == DialogType.MessageBox)
{
var msg = new TestCaseResultServerEvent(ResultType.SystemGeneratedFailure)
{
OtherInfo = message.Message,
NamespaceName = "[StatLight]",
ClassName = "[CannotFigureItOut]",
MethodName = "[NotEnoughContext]",
};
if (_currentReport != null)
{
msg.XapFilePath = _currentReport.XapPath;
}
ReportIt(msg);
}
}
protected override void Because()
{
base.Because();
TestResultAggregator.Handle(new TestExecutionMethodBeginClientEvent
{
ClassName = "Class name test",
MethodName = "method name test",
NamespaceName = "namespace test",
});
TestResultAggregator.Handle(_testExecutionMethodPassedClientEvent);
_passedResultServerEvent =
TestResultAggregator
.CurrentReport
.TestResults.Where(w => w.ResultType == ResultType.Passed)
.Cast <TestCaseResultServerEvent>()
.FirstOrDefault();
}
protected override void Because()
{
base.Because();
TestResultAggregator.Handle(new TestExecutionMethodBeginClientEvent {
NamespaceName = "n", ClassName = "c", MethodName = "m0"
});
TestResultAggregator.Handle(new TestExecutionMethodPassedClientEvent {
NamespaceName = "n", ClassName = "c", MethodName = "m0"
});
TestResultAggregator.Handle(new DialogAssertionServerEvent(DialogType.MessageBox)
{
Message = "some message here"
});
_manufacturedFailedEvent = _manufacturedFailedEvents.FirstOrDefault();
}
protected override void Because()
{
base.Because();
TestResultAggregator.Handle(new TestExecutionMethodBeginClientEvent
{
ClassName = "Class name test",
MethodName = "method name test",
NamespaceName = "namespace test",
});
TestResultAggregator.Handle(_testExecutionMethodPassedClientEvent);
_passedResultServerEvent =
TestResultAggregator
.CurrentReport
.TestResults.Where(w => w.ResultType == ResultType.Passed)
.Cast<TestCaseResultServerEvent>()
.FirstOrDefault();
}
private static string GetErrorMessage(TestCaseResultServerEvent resultServerEvent)
{
var sb = new StringBuilder();
if (resultServerEvent.ExceptionInfo != null)
{
sb.Append(resultServerEvent.ExceptionInfo.FullMessage);
}
if (!string.IsNullOrEmpty(resultServerEvent.OtherInfo))
{
sb.Append(Environment.NewLine);
sb.Append(resultServerEvent.OtherInfo);
}
var rtn = sb.ToString();
return(string.IsNullOrEmpty(rtn) ? null : rtn);
}
public void Handle(TestCaseResultServerEvent message)
{
if (message.MethodName != null)
{
var testMethod = GetTestMethod(message.FullMethodName());
if (testMethod != null)
{
var taskResult = ToTaskResult(message.ResultType);
if (message.ExceptionInfo != null)
{
testMethod.Node.NotifyFinishedWithException(message.ExceptionInfo, taskResult);
}
else
{
testMethod.Node.NotifyFinished(null, taskResult);
}
}
}
}
public static void WriteOutError(TestCaseResultServerEvent message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
System.Console.WriteLine("");
"------------------ ".WrapConsoleMessageWithColor(Settings.ConsoleColorError, false);
"Test ".WrapConsoleMessageWithColor(Settings.ConsoleColorError, false);
"Failed".WrapConsoleMessageWithColor(Settings.ConsoleColorError, false);
" ------------------".WrapConsoleMessageWithColor(Settings.ConsoleColorError, true);
"Test Namespace: ".WrapConsoleMessageWithColor(Settings.ConsoleColorInformation, false);
message.NamespaceName.WrapConsoleMessageWithColor(Settings.ConsoleColorError, true);
"Test Class: ".WrapConsoleMessageWithColor(Settings.ConsoleColorInformation, false);
message.ClassName.WrapConsoleMessageWithColor(Settings.ConsoleColorError, true);
"Test Method: ".WrapConsoleMessageWithColor(Settings.ConsoleColorInformation, false);
message.MethodName.WrapConsoleMessageWithColor(Settings.ConsoleColorError, true);
if (!string.IsNullOrEmpty(message.OtherInfo))
{
"Other Info: ".WrapConsoleMessageWithColor(Settings.ConsoleColorInformation, false);
message.OtherInfo.WrapConsoleMessageWithColor(Settings.ConsoleColorError, true);
}
foreach (var metaData in message.Metadata)
{
"{0,-19}".FormatWith(metaData.Classification + ": ").WrapConsoleMessageWithColor(
Settings.ConsoleColorInformation, false);
(metaData.Name + " - ").WrapConsoleMessageWithColor(Settings.ConsoleColorInformation, false);
metaData.Value.WrapConsoleMessageWithColor(Settings.ConsoleColorError, true);
}
WriteExceptionInfo(message.ExceptionInfo);
"-------------------------------------------------"
.WrapConsoleMessageWithColor(ConsoleColor.DarkRed, true);
}
private static XElement GetResult(TestCaseResultServerEvent resultServerEvent)
{
Func <TestCaseResultServerEvent, string> formatName =
resultX => resultX.FullMethodName();
XElement otherInfoElement = null;
if (!string.IsNullOrEmpty(resultServerEvent.OtherInfo))
{
otherInfoElement = new XElement("otherInfo", resultServerEvent.OtherInfo);
}
XElement exceptionInfoElement = null;
if (resultServerEvent.ExceptionInfo != null)
{
exceptionInfoElement = FormatExceptionInfoElement(resultServerEvent.ExceptionInfo);
}
XElement metaData = null;
if (resultServerEvent.Metadata.Any())
{
metaData = new XElement("metaDataItems", from md in resultServerEvent.Metadata
select new XElement("metaData",
new XAttribute("classification", md.Classification),
new XAttribute("name", md.Name),
md.Value));
}
return(new XElement("test",
new XAttribute("name", formatName(resultServerEvent)),
new XAttribute("resulttype", resultServerEvent.ResultType),
new XAttribute("timeToComplete", resultServerEvent.TimeToComplete.ToString()),
exceptionInfoElement,
otherInfoElement,
metaData
));
}
private static XElement CreateTestCaseElement(TestCaseResultServerEvent resultServerEvent)
{
var element = new XElement("test-case",
new XAttribute("name", resultServerEvent.FullMethodName()),
new XAttribute("executed", resultServerEvent.ResultType == ResultType.Ignored ? "False" : "True"),
new XAttribute("time", resultServerEvent.TimeToComplete.ToString(@"hh\:mm\:ss\.ffff", CultureInfo.InvariantCulture)),
new XAttribute("result", resultServerEvent.ResultType == ResultType.Ignored ? "Ignored" : (resultServerEvent.ResultType == ResultType.Failed || resultServerEvent.ResultType == ResultType.SystemGeneratedFailure) ? "Failure" : "Success"));
if (resultServerEvent.ResultType != ResultType.Ignored)
{
element.Add(new XAttribute("success", resultServerEvent.ResultType == ResultType.Passed ? "True" : "False"));
}
if (resultServerEvent.ResultType == ResultType.Failed || resultServerEvent.ResultType == ResultType.SystemGeneratedFailure)
{
element.Add(new XElement("failure",
new XElement("message", GetErrorMessage(resultServerEvent)),
new XElement("stack-trace", new XCData(GetErrorStackTrace(resultServerEvent)))));
}
return(element);
}
public static bool HasExceptionInfoWithCriteria(this TestCaseResultServerEvent testt, Func <ExceptionInfo, bool> criteria)
{
return(testt.ExceptionInfo == null ? false : criteria(testt.ExceptionInfo));
}
public void Handle(TestCaseResultServerEvent message)
{
if (message == null) throw new ArgumentNullException("message");
var name = message.FullMethodName();
var durationMilliseconds = message.TimeToComplete.Milliseconds;
switch (message.ResultType)
{
case ResultType.Ignored:
WrapTestWithStartAndEnd(CommandFactory.TestIgnored(message.MethodName, string.Empty), message.MethodName, 0);
break;
case ResultType.Passed:
WrapTestWithStartAndEnd(() =>
{
}, name, durationMilliseconds);
break;
case ResultType.Failed:
var sb = new StringBuilder();
sb.Append("Test Namespace: ");
sb.AppendLine(message.NamespaceName);
sb.Append("Test Class: ");
sb.AppendLine(message.ClassName);
sb.Append("Test Method: ");
sb.AppendLine(message.MethodName);
if (!string.IsNullOrEmpty(message.OtherInfo))
{
sb.Append("Other Info: ");
sb.AppendLine(message.OtherInfo);
}
foreach (var metaData in message.Metadata)
{
sb.Append("{0,-17}".FormatWith(metaData.Classification + ": "));
sb.Append(metaData.Name + " - ");
sb.AppendLine(metaData.Value);
}
sb.AppendLine(message.ExceptionInfo.FullMessage);
var msg = sb.ToString();
WrapTestWithStartAndEnd(() => _messageWriter.Write(
CommandFactory.TestFailed(
name,
message.ExceptionInfo.FullMessage,
msg)),
name,
durationMilliseconds);
break;
case ResultType.SystemGeneratedFailure:
WrapTestWithStartAndEnd(() => _messageWriter.Write(
CommandFactory.TestFailed(
name,
"StatLight generated test failure",
message.OtherInfo)),
name,
durationMilliseconds);
break;
default:
"Unknown TestCaseResultServerEvent (to StatLight) - {0}".FormatWith(message.ResultType)
.WrapConsoleMessageWithColor(Settings.Default.ConsoleColorError, true);
break;
}
}
public void Handle(TestCaseResultServerEvent message)
{
Console.WriteLine("Hello From Class1");
}
private static void AppendTestContextMetadata(TestCaseResultServerEvent resultServerEvent, TestContextMessageClientEvent message)
{
resultServerEvent.PopulateMetadata(new[] { new MetaDataInfo("TestContextWriteMethod", "TestContextWriteMethod", message.Message), });
}
private static XElement GetResult(TestCaseResultServerEvent resultServerEvent)
{
Func<TestCaseResultServerEvent, string> formatName =
resultX => resultX.FullMethodName();
XElement otherInfoElement = null;
if (!string.IsNullOrEmpty(resultServerEvent.OtherInfo))
{
otherInfoElement = new XElement("otherInfo", resultServerEvent.OtherInfo);
}
XElement exceptionInfoElement = null;
if (resultServerEvent.ExceptionInfo != null)
{
exceptionInfoElement = FormatExceptionInfoElement(resultServerEvent.ExceptionInfo);
}
XElement metaData = null;
if (resultServerEvent.Metadata.Any())
{
metaData = new XElement("metaDataItems", from md in resultServerEvent.Metadata
select new XElement("metaData",
new XAttribute("classification", md.Classification),
new XAttribute("name", md.Name),
md.Value));
}
return new XElement("test",
new XAttribute("name", formatName(resultServerEvent)),
new XAttribute("resulttype", resultServerEvent.ResultType),
new XAttribute("timeToComplete", resultServerEvent.TimeToComplete.ToString()),
exceptionInfoElement,
otherInfoElement,
metaData
);
}
public void Handle(TestCaseResultServerEvent message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
var name = message.FullMethodName();
var durationMilliseconds = message.TimeToComplete.Milliseconds;
switch (message.ResultType)
{
case ResultType.Ignored:
WrapTestWithStartAndEnd(CommandFactory.TestIgnored(message.MethodName, string.Empty), message.MethodName, 0);
break;
case ResultType.Passed:
WrapTestWithStartAndEnd(() =>
{
}, name, durationMilliseconds);
break;
case ResultType.Failed:
var sb = new StringBuilder();
sb.Append("Test Namespace: ");
sb.AppendLine(message.NamespaceName);
sb.Append("Test Class: ");
sb.AppendLine(message.ClassName);
sb.Append("Test Method: ");
sb.AppendLine(message.MethodName);
if (!string.IsNullOrEmpty(message.OtherInfo))
{
sb.Append("Other Info: ");
sb.AppendLine(message.OtherInfo);
}
foreach (var metaData in message.Metadata)
{
sb.Append("{0,-17}".FormatWith(metaData.Classification + ": "));
sb.Append(metaData.Name + " - ");
sb.AppendLine(metaData.Value);
}
sb.AppendLine(message.ExceptionInfo.FullMessage);
var msg = sb.ToString();
WrapTestWithStartAndEnd(() => _messageWriter.Write(
CommandFactory.TestFailed(
name,
message.ExceptionInfo.FullMessage,
msg)),
name,
durationMilliseconds);
break;
case ResultType.SystemGeneratedFailure:
WrapTestWithStartAndEnd(() => _messageWriter.Write(
CommandFactory.TestFailed(
name,
"StatLight generated test failure",
message.OtherInfo)),
name,
durationMilliseconds);
break;
default:
"Unknown TestCaseResultServerEvent (to StatLight) - {0}".FormatWith(message.ResultType)
.WrapConsoleMessageWithColor(Settings.Default.ConsoleColorError, true);
break;
}
}
private void ReportIt(TestCaseResultServerEvent resultServerEvent)
{
OnTestCaseResultCreated(resultServerEvent);
_currentReport.AddResult(resultServerEvent);
_eventPublisher.SendMessage(resultServerEvent);
}
protected override void Because()
{
base.Because();
TestResultAggregator.Handle(new TestExecutionMethodBeginClientEvent { NamespaceName = "n", ClassName = "c", MethodName = "m0" });
TestResultAggregator.Handle(new TestExecutionMethodPassedClientEvent { NamespaceName = "n", ClassName = "c", MethodName = "m0" });
TestResultAggregator.Handle(new DialogAssertionServerEvent(DialogType.MessageBox) { Message = "some message here" });
_manufacturedFailedEvent = _manufacturedFailedEvents.FirstOrDefault();
}
public TestReport AddResult(TestCaseResultServerEvent resultServerEvent)
{
SetLastMessageReceivedTime();
_testCaseResults.Add(resultServerEvent);
return(this);
}
internal bool TryFindByFullName(string fullName, out TestCaseResultServerEvent testCaseResultServerEvent)
{
testCaseResultServerEvent = _testCaseResults.Where(w => w.FullMethodName() == fullName).SingleOrDefault();
return(testCaseResultServerEvent != null);
}
private Guid GetTestId(TestCaseResultServerEvent testCaseResultServerEvent)
{
return(GetGuidForItem(testCaseResultServerEvent, HashType.TestId));
}
