public void Handle(TestRunEvent message)
{
// Filter the message here
if (message.Test != _test)
{
return;
}
// Continue on with processing
if (message.IsRunning)
{
_view.MarkAsExecuting();
}
else
{
_view.MarkNotExecuting();
}
if (message.Completed)
{
ChangeModeTo(Mode.Results);
}
_header.Update();
}
public void Regression_EmptyListDoesNotCrashFixer()
{
var eIn = new TestRunEvent();
var eOut = eIn.ToCompactJson().ParseJsonTo <TestRunEvent>();
Assert.AreEqual(eIn, eOut);
}
public void Handle(TestRunEvent message)
{
Icon icon = Icon.Unknown;
Test test = message.Test;
switch (message.State)
{
case TestState.Queued:
icon = Icon.Pending;
break;
case TestState.Executing:
icon = Icon.Pending;
if (test.HasResult())
{
icon = test.WasSuccessful() ? Icon.RunningSuccess : Icon.RunningFailure;
}
break;
case TestState.NotQueued:
if (message.Test.HasResult())
{
icon = message.Test.WasSuccessful() ? Icon.Success : Icon.Failed;
}
break;
}
updateIcon(message.Test, icon);
ResetFilter();
}
public void Equality_Default()
{
var a = new TestRunEvent();
var b = new TestRunEvent();
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public void DefaultValues()
{
var sut = new TestRunEvent();
Assert.AreEqual(false, sut.WasAborted);
Assert.AreEqual(Sets.NewHashSet <TestCaseResult>(), sut.Tests);
Assert.AreNotEqual(0, sut.GetHashCode());
Assert.AreNotEqual(1, sut.GetHashCode());
}
public void ResultsAndDurationsAreSetAndPropagatedCorrectly()
{
var testEvent = new TestRunEvent
{
Tests =
{
new TestCaseResult
{
TestMethod = TestMethod1,
Result = TestResult.Success,
Duration = TimeSpan.FromSeconds(0.1)
},
new TestCaseResult
{
TestMethod = TestMethod2,
Result = TestResult.Failed,
Duration = TimeSpan.FromSeconds(0.2)
}
}
};
var sut = new TestRunIntervalTransformer(_context);
sut.ProcessEvent(testEvent);
var actual = sut.SignalEndOfEventStream().First();
Assert.AreEqual("TestProj1", actual.ProjectName);
Assert.AreEqual(1, actual.TestClasses.Count);
Assert.AreEqual(TimeSpan.FromSeconds(0.3), actual.Duration);
Assert.AreEqual(TestResult.Failed, actual.Result);
Assert.AreEqual("Test.TestClass", actual.TestClasses[0].TestClassName);
Assert.AreEqual(TimeSpan.FromSeconds(0.3), actual.TestClasses[0].Duration);
Assert.AreEqual(2, actual.TestClasses[0].TestMethods.Count);
Assert.AreEqual(TestResult.Failed, actual.TestClasses[0].Result);
foreach (var method in actual.TestClasses[0].TestMethods)
{
if (method.TestMethodName == "Test")
{
Assert.AreEqual(TestResult.Success, method.Result);
Assert.AreEqual(TimeSpan.FromSeconds(0.1), method.Duration);
}
else if (method.TestMethodName == "Test2")
{
Assert.AreEqual(TestResult.Failed, method.Result);
Assert.AreEqual(TimeSpan.FromSeconds(0.2), method.Duration);
}
else
{
Assert.Fail();
}
}
}
public void Equality_DifferentWasAborted()
{
var a = new TestRunEvent
{
WasAborted = true
};
var b = new TestRunEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void SettingValues()
{
var sut = new TestRunEvent
{
WasAborted = true,
Tests =
{
new TestCaseResult()
}
};
Assert.AreEqual(true, sut.WasAborted);
Assert.AreEqual(Sets.NewHashSet(new TestCaseResult()), sut.Tests);
}
public void Equality_DifferentTests()
{
var a = new TestRunEvent
{
Tests =
{
new TestCaseResult()
}
};
var b = new TestRunEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
private void process(TestRunEvent e)
{
foreach (var tr in e.Tests)
{
object t = new TestEvent();
var te = CreateEventData <TestEvent>(e, ref t);
te.Details = tr.TestMethod.FullName;
te.MethodName = te.Details;
te.Result = tr.Result.ToString("G");
te.TestStatus = te.Result;
te.TriggeredAt = tr.StartTime ?? te.TriggeredAt;
te.Duration = tr.Duration.TotalMilliseconds.ToString();
_baseContext.Events.Add(te);
}
}
public void TransformsTestResultCorrectly()
{
var testEvent = new TestRunEvent
{
Tests = { new TestCaseResult {
TestMethod = TestMethod1
} }
};
var sut = new TestRunIntervalTransformer(_context);
sut.ProcessEvent(testEvent);
var actual = sut.SignalEndOfEventStream().First();
Assert.AreEqual("TestProj1", actual.ProjectName);
Assert.AreEqual(1, actual.TestClasses.Count);
Assert.AreEqual("Test.TestClass", actual.TestClasses[0].TestClassName);
Assert.AreEqual(1, actual.TestClasses[0].TestMethods.Count);
Assert.AreEqual("Test", actual.TestClasses[0].TestMethods[0].TestMethodName);
}
public void Equality_ReallyTheSame()
{
var a = new TestRunEvent
{
WasAborted = true,
Tests =
{
new TestCaseResult()
}
};
var b = new TestRunEvent
{
WasAborted = true,
Tests =
{
new TestCaseResult()
}
};
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public void SplitsUpEventsWithMultipleProjects()
{
var testEvent = new TestRunEvent
{
Tests =
{
new TestCaseResult {
TestMethod = TestMethod1
},
new TestCaseResult {
TestMethod = TestMethodInOtherProject
}
}
};
var sut = new TestRunIntervalTransformer(_context);
sut.ProcessEvent(testEvent);
var actual = sut.SignalEndOfEventStream();
Assert.AreEqual(2, actual.Count());
}
