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