private void displayTestRunMessage(TestRunMessage message)
{
lock (_outputLock)
{
writeToOutput(message.Results.Assembly);
var status = string.Format("{0} tests, {1} failed, {2} ignored", message.Results.All.Count(), message.Results.Failed.Count(), message.Results.Ignored.Count());
writeToOutput(status);
foreach (var test in message.Results.Passed)
{
writeToOutput(string.Format("({0}) {1} {2}", test.Runner, test.DisplayName, test.Status));
}
foreach (var test in message.Results.Ignored)
{
writeToOutput(string.Format("({0}) {1} {2}", test.Runner, test.DisplayName, test.Status));
}
foreach (var test in message.Results.Failed)
{
writeToOutput(string.Format("({0}) {1} {2}", test.Runner, test.DisplayName, test.Status));
}
if (message.Results.All.Count() > 10)
{
writeToOutput(status);
}
writeToOutput("");
}
}
public void Should_subscribe_to_testrun_messages()
{
var message = new TestRunMessage(new TestRunResults("", "", false, null));
_bus.Publish(message);
waitForAsyncCall();
_resultMerger.HasMergedTestResults.ShouldBeTrue();
_view.TestRunMessage.ShouldBeTheSameAs(message);
}
public void SendTestRunMessage(TestRunMessageEventArgs ev)
{
if (ev == null)
{
throw new ArgumentNullException(nameof(ev));
}
TestRunMessage?.Invoke(this, ev);
}
public void Should_be_able_to_consume_testrun_messages()
{
var consumer = new RunMessageConsumer(_bus);
var message = new TestRunMessage(new TestRunResults("", "", false, TestRunner.NUnit, new TestResult[] { }));
_bus.Publish <TestRunMessage>(message);
waitForAsyncCall();
consumer.TestRunMessageEventWasCalled.ShouldBeTrue();
}
public void Should_subscribe_to_testrun_messages()
{
var message = new TestRunMessage(new TestRunResults("", "", false, TestRunner.NUnit, null));
_bus.Publish(message);
waitForAsyncCall(() => { return(_view.TestRunMessage != null); });
_resultMerger.HasMergedTestResults.ShouldBeTrue();
_view.TestRunMessage.ShouldBeTheSameAs(message);
}
private static void LogTestRunMessage(TestRunMessage testRunMessage)
{
if (testRunMessage.MessageType == MessageType.Critical || testRunMessage.MessageType == MessageType.Error)
{
Console.ForegroundColor = ConsoleColor.Red;
}
if (testRunMessage.MessageType == MessageType.Warning)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "MessageType: {0} , Source: {1}, Message: {2}", testRunMessage.MessageType, testRunMessage.MessageSource, testRunMessage.Message));
Console.ForegroundColor = ConsoleColor.White;
}
public void Consume(TestRunMessage message)
{
if (!isConnected())
{
return;
}
var state = "succeeded";
if (message.Results.Failed.Length > 0)
{
state = "failed";
}
_client.Send(
string.Format("autotest.net testrun \"{0}\" {1} {2}",
message.Results.Assembly,
message.Results.Runner.ToString(),
state));
}
public void RecievingTestRunMessage(TestRunMessage message)
{
var assembly = message.Results.Assembly;
var failed = message.Results.Failed;
var ignored = message.Results.Ignored;
if (failed.Length > 0 || ignored.Length > 0)
{
_logger.InfoFormat("Test(s) {0} for assembly {1}", failed.Length > 0 ? "failed" : "was ignored", Path.GetFileName(assembly));
foreach (var test in failed)
{
_logger.InfoFormat(" {0} -> {1}: {2}", test.Status, test.DisplayName, test.Message);
}
foreach (var test in ignored)
{
_logger.InfoFormat(" {0} -> {1}: {2}", test.Status, test.DisplayName, test.Message);
}
}
}
private void updateView(TestRunMessage message)
{
_syncContext.Post((s) =>
{
lock (_padLock)
{
if (_newRunInitialized == true)
{
treeViewLastRun.Nodes.Clear();
_testCount = 0;
}
message.Results.All
.Select(x => new CacheTestMessage(message.Results.Assembly, x))
.GroupBy(x => getFixture(x)).ToList()
.ForEach(x =>
{
var node = treeViewLastRun.Nodes.Add(string.Format("{0} ({1}) - {2} ms", x.Key, x.Count(), x.Sum(y => y.Test.TimeSpent.TotalMilliseconds)));
x.ToList()
.ForEach(y =>
{
var child = node.Nodes.Add(string.Format("{0} ({1}) - {2} ms", getTestName(y.Test.DisplayName), y.Test.Runner, y.Test.TimeSpent.TotalMilliseconds));
child.ImageIndex = getImageIndex(y.Test.Status);
child.SelectedImageIndex = child.ImageIndex;
child.Tag = y;
});
node.ImageIndex = x.Max(y => getImageIndex(y.Test.Status));
node.SelectedImageIndex = node.ImageIndex;
if (radioButtonExpanded.Checked)
{
node.ExpandAll();
}
_testCount += x.Count();
});
labelTestCount.Text = _testCount.ToString();
_newRunInitialized = false;
}
}, null);
}
public void Should_serialize_test_run_message()
{
var testResults = new TestResult[] { new TestResult(TestRunner.NUnit, TestRunStatus.Passed, "Test name", "message", new IStackLine[] { new StackLineMessage("method name", "file", 13) }, 34) };
var results = new TestRunResults("project 1", "assembly", false, TestRunner.NUnit, testResults);
results.SetTimeSpent(new TimeSpan(12345));
var message = new TestRunMessage(results);
var output = serializeDeserialize <TestRunMessage>(message);
output.Results.Project.ShouldEqual("project 1");
output.Results.Assembly.ShouldEqual("assembly");
output.Results.IsPartialTestRun.ShouldBeFalse();
output.Results.TimeSpent.ShouldEqual(new TimeSpan(12345));
output.Results.All.Length.ShouldEqual(1);
output.Results.All[0].Runner.ShouldEqual(TestRunner.NUnit);
output.Results.All[0].Status.ShouldEqual(TestRunStatus.Passed);
output.Results.All[0].Name.ShouldEqual("Test name");
output.Results.All[0].Message.ShouldEqual("message");
output.Results.All[0].StackTrace[0].Method.ShouldEqual("method name");
output.Results.All[0].StackTrace[0].File.ShouldEqual("file");
output.Results.All[0].StackTrace[0].LineNumber.ShouldEqual(13);
output.Results.All[0].TimeSpent.TotalMilliseconds.ShouldEqual(34);
}
public void RecievingTestRunMessage(TestRunMessage message)
{
_testRunMessage = message;
}
public void RecievingTestRunMessage(TestRunMessage message)
{
_syncContext.Post(m => relistFromCache(), null);
}
public void RecievingTestRunMessage(TestRunMessage message)
{
var assembly = message.Results.Assembly;
var failed = message.Results.Failed;
var ignored = message.Results.Ignored;
if (failed.Length > 0 || ignored.Length > 0)
{
_logger.InfoFormat("Test(s) {0} for assembly {1}", failed.Length > 0 ? "failed" : "was ignored", Path.GetFileName(assembly));
foreach (var test in failed)
_logger.InfoFormat(" {0} -> {1}: {2}", test.Status, test.Name, test.Message);
foreach (var test in ignored)
_logger.InfoFormat(" {0} -> {1}: {2}", test.Status, test.Name, test.Message);
}
}
public void RecievingTestRunMessage(TestRunMessage message)
{
Debug.WriteDetail("handling test run");
trySend(buildCacheMessage());
trySend(message);
}
public void RecievingTestRunMessage(TestRunMessage message)
{
_testRunMessage = message;
}
public void RecievingTestRunMessage(TestRunMessage message)
{
_syncContext.Post(m => relistFromCache(), null);
}
public void OnTestRunMessage(TestRunMessageEventArgs e) => TestRunMessage?.Invoke(this, e);
public TestRunMessageEventArgs(TestRunMessage message)
{
Message = message;
}
public void RecievingTestRunMessage(TestRunMessage message)
{
_onCacheUpdate.Invoke(_resultsCache);
}
public TestRunMessageEventArgs(TestRunMessage message)
{
Message = message;
}
public void Should_be_able_to_consume_testrun_messages()
{
var consumer = new RunMessageConsumer(_bus);
var message = new TestRunMessage(new TestRunResults("", "", false, new TestResult[] {}));
_bus.Publish<TestRunMessage>(message);
waitForAsyncCall();
consumer.TestRunMessageEventWasCalled.ShouldBeTrue();
}
public void RecievingTestRunMessage(TestRunMessage message)
{
_onCacheUpdate.Invoke(_resultsCache);
}
