public bool CanTranslate(LogMessage message) { if (message.MessageType == LogMessageType.TestResult) { if (message.Is(TestGranularity.TestScenario) && message.DecoratorMatches(LogDecorator.TestOutcome, v => { switch ((TestOutcome)v) { case TestOutcome.Failed: case TestOutcome.Timeout: case TestOutcome.Inconclusive: //TODO: reproduce case TestOutcome.Error: return true; default: return false; } }) && message.DecoratorMatches(UnitTestLogDecorator.ScenarioResult, v => ((ScenarioResult)v).Exception != null) ) { return true; } } return false; }
protected override void ProcessRemainder(LogMessage message) { //DEBUG //var msg = TraceLogMessage(message); //Console.WriteLine(msg.Message); try { ClientEvent clientEvent; if (TryTranslateIntoClientEvent(message, out clientEvent)) { if (clientEvent != null) Server.PostMessage(clientEvent); } else { var traceClientEvent = TraceLogMessage(message); Server.PostMessage(traceClientEvent); } } catch (Exception ex) { var messageObject = new UnhandledExceptionClientEvent { Exception = ex, }; Server.PostMessage(messageObject); } }
/// <summary> /// Display a LogMessage in the debug output window. /// </summary> /// <param name="logMessage">Message object.</param> public override void Process(LogMessage logMessage) { if (logMessage == null) { throw new ArgumentNullException("logMessage"); } if ((logMessage.MessageType != LogMessageType.Debug) && !ShowEverything) { if (!ShowAllFailures) { return; } if (logMessage.HasDecorator(LogDecorator.TestOutcome)) { TestOutcome outcome = (TestOutcome)logMessage[LogDecorator.TestOutcome]; if (outcome == TestOutcome.Passed) { return; } } } // Skip Finishing messages, they're always duplicates if (logMessage.HasDecorator(LogDecorator.TestStage)) { if ((TestStage)logMessage[LogDecorator.TestStage] == TestStage.Finishing) { return; } } Debug.WriteLine(logMessage.ToString()); }
public override void Process(LogMessage logMessage) { if(isFirstMessage) { isFirstMessage = false; ProcessStartMessage(); } else if(logMessage.HasDecorator(LogDecorator.TestOutcome)) ProcessResultMessage(logMessage); }
/// <summary> /// Determines whether a log message meets a specific condition or set /// of conditions. /// </summary> /// <param name="message">The log message object.</param> /// <returns>Returns true if the condition is met.</returns> public static bool HasUnitTestOutcome(LogMessage message) { if (!IsUnitTestMessage(message)) { return false; } return message.HasDecorator(LogDecorator.TestOutcome); }
/// <summary> /// Determines whether a log message meets a specific condition or set /// of conditions. /// </summary> /// <param name="message">The log message object.</param> /// <returns>Returns true if the condition is met.</returns> public static bool IsIncorrectExceptionLogMessage(LogMessage message) { if (!IsUnitTestMessage(message)) { return false; } return message.HasDecorator(UnitTestLogDecorator.IncorrectExceptionMessage); }
/// <summary> /// Determines whether a log message meets a specific condition or set /// of conditions. /// </summary> /// <param name="message">The log message object.</param> /// <returns>Returns true if the condition is met.</returns> public static bool IsExceptionLogMessage(LogMessage message) { if (!IsUnitTestMessage(message)) { return false; } return message.HasDecorator(UnitTestLogDecorator.ActualException); }
public ClientEvent Translate(LogMessage message) { var testClass = (ITestClass)message.Decorators[UnitTestLogDecorator.TestClassMetadata]; var clientEventX = new TestExecutionClassBeginClientEvent { ClassName = testClass.Type.ClassNameIncludingParentsIfNested(), NamespaceName = testClass.Type.Namespace, }; return clientEventX; }
public ClientEvent Translate(LogMessage message) { var testMethod = (ITestMethod)message.Decorators[UnitTestLogDecorator.TestMethodMetadata]; var clientEventX = new TestExecutionMethodBeginClientEvent { Started = DateTime.Now, }; clientEventX.AssignTestExecutionMethodInfo(testMethod); return clientEventX; }
/// <summary> /// Process a UTF result message. /// </summary> /// <param name="logMessage">The log message object.</param> private void ProcessResult(LogMessage logMessage) { if (logMessage.HasDecorator(UnitTestLogDecorator.TestMethodMetadata)) { ScenarioResult sr = (ScenarioResult)logMessage[UnitTestLogDecorator.ScenarioResult]; if (sr.Result != TestOutcome.Passed) { _failures.Add(sr); } } }
public bool CanTranslate(LogMessage message) { if (message.MessageType == LogMessageType.TestInfrastructure) { if (message.Message.Equals("Initialization of UnitTestHarness", StringComparison.InvariantCultureIgnoreCase)) { return true; } } return false; }
public bool CanTranslate(LogMessage message) { if (message.MessageType == LogMessageType.TestResult) { if (message.Is(TestGranularity.TestScenario) && message.DecoratorMatches(LogDecorator.TestOutcome, v => (TestOutcome)v == TestOutcome.Passed) ) { return true; } } return false; }
public ClientEvent Translate(LogMessage message) { var scenarioResult = (ScenarioResult)message.Decorators[UnitTestLogDecorator.ScenarioResult]; var testMethod = (ITestMethod)message.Decorators[UnitTestLogDecorator.TestMethodMetadata]; var clientEventX = new TestExecutionMethodPassedClientEvent { Finished = scenarioResult.Finished, Started = scenarioResult.Started, }; clientEventX.AssignTestExecutionMethodInfo(testMethod); return clientEventX; }
public bool CanTranslate(LogMessage message) { if (message.MessageType == LogMessageType.TestExecution) { if (message.Is(TestGranularity.TestScenario) && message.DecoratorMatches(UnitTestLogDecorator.IgnoreMessage, v => (bool)v) ) { return true; } } return false; }
public static TraceClientEvent TraceLogMessage(LogMessage message) { const string newLine = "\n"; string msg = ""; msg += "MessageType={0}".FormatWith(message.MessageType); msg += newLine; msg += "Message={0}".FormatWith(message.Message); msg += newLine; msg += "Decorators:"; msg += newLine; msg += GetDecorators(message.Decorators); msg += newLine; return new TraceClientEvent { Message = msg }; }
public ClientEvent Translate(LogMessage message) { var testName = (string)message.Decorators[LogDecorator.NameProperty]; var clientEventX = new TestExecutionMethodIgnoredClientEvent { ClassName = null, NamespaceName = null, MethodName = testName, Message = testName, Started = DateTime.Now, }; return clientEventX; }
public bool CanTranslate(LogMessage message) { if (message.MessageType == LogMessageType.TestExecution) { if (message.Is(TestStage.Finishing) && message.Is(TestGranularity.Test) && message.DecoratorMatches(UnitTestLogDecorator.TestClassMetadata, v => v is ITestClass) ) { return true; } } return false; }
public bool CanTranslate(LogMessage message) { if (message.MessageType == LogMessageType.TestExecution) { if (message.Is(TestStage.Starting) && message.Is(TestGranularity.TestScenario) && message.DecoratorMatches(UnitTestLogDecorator.TestMethodMetadata, v => v is ITestMethod) ) { return true; } } return false; }
public ClientEvent Translate(LogMessage message) { var scenarioResult = (ScenarioResult)message.Decorators[UnitTestLogDecorator.ScenarioResult]; var testMethod = (ITestMethod)message.Decorators[UnitTestLogDecorator.TestMethodMetadata]; var clientEventX = new TestExecutionMethodFailedClientEvent { ExceptionInfo = new ExceptionInfo(new Exception("An expected exception was not thrown.")), Finished = scenarioResult.Finished, Started = scenarioResult.Started, }; clientEventX.AssignMetadata(testMethod.Method); clientEventX.AssignTestExecutionMethodInfo(testMethod); return clientEventX; }
public override void Process(LogMessage logMessage) { if (logMessage.HasDecorator(UnitTestLogDecorator.ScenarioResult)) { var result = (ScenarioResult)logMessage[UnitTestLogDecorator.ScenarioResult]; InvokeDomMethod("scenarioResult", result.Started.Ticks, result.Finished.Ticks, (result.TestClass != null) ? result.TestClass.Type.FullName : null, (result.TestMethod != null) ? result.TestMethod.Name : null, result.Result.ToString(), (result.Exception != null) ? result.Exception.ToString() : null); } }
public ClientEvent Translate(LogMessage message) { var scenarioResult = (ScenarioResult)message.Decorators[UnitTestLogDecorator.ScenarioResult]; var exception = scenarioResult.Exception; var testMethod = (ITestMethod)message.Decorators[UnitTestLogDecorator.TestMethodMetadata]; var clientEventX = new TestExecutionMethodFailedClientEvent { ExceptionInfo = exception, Finished = scenarioResult.Finished, Started = scenarioResult.Started, Description = GetDescriptionInfo(testMethod.Method) }; clientEventX.AssignTestExecutionMethodInfo(testMethod); return clientEventX; }
/// <summary> /// Determines whether a log message meets a specific condition or set /// of conditions. /// </summary> /// <param name="message">The log message object.</param> /// <returns>Returns true if the condition is met.</returns> public static bool IsUnitTestEndMessage(LogMessage message) { if (!IsUnitTestMessage(message)) { return false; } if (message.HasDecorator(LogDecorator.TestStage)) { TestStage ts = (TestStage)message[LogDecorator.TestStage]; return ts == TestStage.Finishing; } else { return false; } }
void ProcessResultMessage(LogMessage logMessage) { totalCount++; string testClassName = ((BaseTestClass)logMessage.Decorators[UnitTestLogDecorator.TestClassMetadata]).Type.ToString(); string testMethodName = (string)logMessage.Decorators[LogDecorator.NameProperty]; switch((TestOutcome)logMessage.Decorators[LogDecorator.TestOutcome]) { case TestOutcome.Passed: InvokeMethod("TestResult", testClassName, testMethodName, ""); passedCount++; break; case TestOutcome.Failed: string exceptionString = FormatException(((ScenarioResult)logMessage.Decorators[UnitTestLogDecorator.ScenarioResult]).Exception); InvokeMethod("TestResult", testClassName, testMethodName, exceptionString); break; default: break; } }
private void AppendToFile(LogMessage logMessage) { UTF8Encoding encoding = new UTF8Encoding(); var carriageReturnBytes = encoding.GetBytes(new[] { '\r', '\n' }); using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication()) { if (!store.DirectoryExists("TestResults")) { store.CreateDirectory("TestResults"); } using (IsolatedStorageFileStream isoStream = store.OpenFile(TESTRESULTFILENAME, FileMode.Append)) { var byteArray = encoding.GetBytes(logMessage.Message); isoStream.Write(byteArray, 0, byteArray.Length); isoStream.Write(carriageReturnBytes, 0, carriageReturnBytes.Length); } } }
public bool CanTranslate(LogMessage message) { if (message.MessageType == LogMessageType.TestResult) { if (message.Is(TestGranularity.TestScenario) && message.DecoratorMatches(LogDecorator.TestOutcome, v => { switch ((TestOutcome)v) { case TestOutcome.Failed: return true; default: return false; } }) ) { return true; } } return false; }
public override void Process(LogMessage logMessage) { if (logMessage.HasDecorator(LogDecorator.TestStage)) { var stage = (TestStage)logMessage[LogDecorator.TestStage]; if (stage == TestStage.Starting) { if (logMessage.HasDecorator(UnitTestLogDecorator.TestMethodMetadata)) { var methodInfo = (TestMethod)logMessage[UnitTestLogDecorator.TestMethodMetadata]; var wc = new WebClient(); wc.UploadStringAsync(new Uri(baseUrl, "/TestMethodStarting?method=" + methodInfo.Name), ""); } else if (logMessage.HasDecorator(UnitTestLogDecorator.TestClassMetadata)) { var classInfo = (TestClass)logMessage[UnitTestLogDecorator.TestClassMetadata]; var wc = new WebClient(); wc.UploadStringAsync(new Uri(baseUrl, "/TestClassStarting?class=" + classInfo.Type.FullName), ""); } } } if (logMessage.HasDecorator(UnitTestLogDecorator.ScenarioResult)) { var result = (ScenarioResult)logMessage[UnitTestLogDecorator.ScenarioResult]; var wc = new WebClient(); StringBuilder uri = new StringBuilder(); uri.Append("/TestMethodCompleted?result=" + result.Result); if (result.TestClass != null) { uri.Append("&class=").Append(result.TestClass.Type.FullName); } if (result.TestMethod != null) { uri.Append("&method=").Append(result.TestMethod.Name); } wc.UploadStringAsync(new Uri(baseUrl, uri.ToString()), ""); } }
protected override void Before_all_tests() { base.Before_all_tests(); var mockTestMethod = new MockTestMethod(); var mockTestClass = new MockTestClass(); var scenarioResult = new ScenarioResult( mockTestMethod, mockTestClass, TestOutcome.Passed, null); _logMessage = new LogMessage(LogMessageType.TestResult); _logMessage.Decorators.Add(UnitTestLogDecorator.IsUnitTestMessage, true); _logMessage.Decorators.Add(LogDecorator.NameProperty, "some_test_method_name_here"); _logMessage.Decorators.Add(LogDecorator.TestGranularity, TestGranularity.TestScenario); _logMessage.Decorators.Add(UnitTestLogDecorator.ScenarioResult, scenarioResult); _logMessage.Decorators.Add(UnitTestLogDecorator.TestMethodMetadata, mockTestMethod); _logMessage.Decorators.Add(UnitTestLogDecorator.TestClassMetadata, mockTestClass); _logMessage.Decorators.Add(LogDecorator.TestOutcome, TestOutcome.Passed); }
/// <summary> /// Perform any needed operations to log the message. /// </summary> /// <param name="logMessage">Instance of LogMessage type.</param> public virtual void Process(LogMessage logMessage) { // 1st: The more advanced conditionals. foreach (KeyValuePair<Func<LogMessage, bool>, Action<LogMessage>> pair in _conditionalHandlers) { if (pair.Value != null && pair.Key(logMessage)) { pair.Value(logMessage); return; } } // 2nd: The LogMessageType handlers. LogMessageType type = logMessage.MessageType; Action<LogMessage> action = null; if (_definedHandlers.TryGetValue(type, out action) && action != null) { action(logMessage); return; } // 3rd: Do nothing with the message, unless overloaded ProcessRemainder(logMessage); }
/// <summary> /// Decorate a log message with a value. /// </summary> /// <param name="message">The log message to decorate.</param> /// <param name="key">The key for this decoration.</param> /// <param name="value">The value of this decoration.</param> protected static void Decorate(LogMessage message, object key, object value) { message.Decorators[key] = value; }
/// <summary> /// Decorate the log message object with a name. /// </summary> /// <param name="message">The log message object.</param> /// <param name="name">Name property value.</param> protected static void DecorateNameProperty(LogMessage message, string name) { Decorate(message, LogDecorator.NameProperty, name); }
/// <summary> /// The run filter has been selected. /// </summary> /// <param name="logMessage">The log message object.</param> private void TestRunFilterSelected(LogMessage logMessage) { TestRunFilter filter = (TestRunFilter)logMessage[UnitTestLogDecorator.TestRunFilter]; TestListName = filter.TestRunName; }
/// <summary> /// Process [Bug(...)]. /// </summary> /// <param name="l">A KnownBugLogMessage object.</param> private void ProcessBug(LogMessage l) { _writer.AddPendingWriteLine(l.Message); }
/// <summary> /// Decorate the log message object with a test stage value. /// </summary> /// <param name="message">The log message object.</param> /// <param name="stage">Test stage value.</param> protected static void DecorateTestStage(LogMessage message, TestStage stage) { Decorate(message, LogDecorator.TestStage, stage); }
/// <summary> /// Decorate the log message object with a test outcome object. /// </summary> /// <param name="message">The log message object.</param> /// <param name="outcome">Test outcome object.</param> protected static void DecorateTestOutcome(LogMessage message, TestOutcome outcome) { Decorate(message, LogDecorator.TestOutcome, outcome); }
/// <summary> /// Decorate the log message object with a test granularity object. /// </summary> /// <param name="message">The log message object.</param> /// <param name="granularity">Test granularity object.</param> protected static void DecorateTestGranularity(LogMessage message, TestGranularity granularity) { Decorate(message, LogDecorator.TestGranularity, granularity); }
/// <summary> /// Sets the type of the log message. /// </summary> /// <param name="message">The log message object.</param> /// <param name="type">The new value to set the message type to.</param> protected static void SetType(LogMessage message, LogMessageType type) { message.MessageType = type; }
/// <summary> /// Record a test outcome. /// </summary> /// <param name="message">The accompanying message.</param> /// <param name="outcome">The outcome value.</param> public void TestResult(string message, TestOutcome outcome) { LogMessage m = Create(LogMessageType.TestResult, message); DecorateTestOutcome(m, outcome); }
/// <summary> /// Posts a log message to the test harness queue for processing. /// </summary> /// <param name="message">The log message object.</param> public void Enqueue(LogMessage message) { _testHarness.QueueLogMessage(message); }
/// <summary> /// Decorate the log message object with an Exception object. /// </summary> /// <param name="message">The log message object.</param> /// <param name="exception">The Exception.</param> protected static void DecorateException(LogMessage message, Exception exception) { Decorate(message, LogDecorator.ExceptionObject, exception); }