public void Will_set_line_position_to_zero_when_no_matching_file_position()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + JsonStreamEvents.TestDoneEventJson;
var referencedFile = new ReferencedFile
{
IsFileUnderTest = true,
Path = "inputTestFile",
FilePositions = new FilePositions()
};
var context = new TestContext
{
TestHarnessPath = "htmlTestFile",
ReferencedFiles = new[] { referencedFile }
};
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
TestCase result = null;
callback.Setup(x => x.TestFinished(It.Is <TestContext>(testContext => testContext == context), It.IsAny <TestCase>())).Callback <TestContext, TestCase>((c, t) => result = t);
reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
Assert.NotNull(result);
Assert.Equal("module", result.ModuleName);
Assert.Equal("test", result.TestName);
Assert.Equal(0, result.Line);
Assert.Equal(0, result.Column);
}
public void Will_put_test_case_in_summary()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + @"
#_#TestDone#_# {""type"":""TestDone"",""testCase"":{""moduleName"":""module"",""testName"":""test"",""testResults"":[{""message"":""bad"",""passed"":false,""actual"":4,""expected"":5}]}}
";
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object).TestFileSummaries[0];
Assert.Equal(1, summary.Tests.Count);
Assert.Equal(1, summary.Tests[0].TestResults.Count);
Assert.Equal("file", summary.Tests[0].InputTestFile);
Assert.Equal("module", summary.Tests[0].ModuleName);
Assert.Equal("test", summary.Tests[0].TestName);
Assert.False(summary.Tests[0].ResultsAllPassed);
Assert.False(summary.Tests[0].TestResults[0].Passed);
Assert.Equal("4", summary.Tests[0].TestResults[0].Actual);
Assert.Equal("5", summary.Tests[0].TestResults[0].Expected);
Assert.Equal("bad", summary.Tests[0].TestResults[0].Message);
}
public void Will_place_not_found_test_in_first_context_given_no_matches_and_no_current_file_match()
{
// This case covers the scenario where the test names are not found in filePosition map
// what should happen is when we hit the first one we don't know which file it is from so we *assume* the first
// one. Then when we find the same test name again we realize we can't assign it to the current file
// so we assign it to the next
var reader = new TestableTestCaseStreamReader();
var jsonFile1 = JsonStreamEvents.BuildTestEventFile(Tuple.Create("", "test1"));
var jsonFile2 = JsonStreamEvents.BuildTestEventFile(Tuple.Create("", "test1"));
var json = jsonFile1 + jsonFile2;
var context = reader.BuildContext(Tuple.Create("file1", "testNoMatch", 1, 1), Tuple.Create("file2", "testNoMatch", 2, 2));
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summaries = reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
Assert.Equal(1, summaries.TestFileSummaries[0].Tests.Count);
Assert.Equal("file1", summaries.TestFileSummaries[0].Tests[0].InputTestFile);
Assert.Equal("test1", summaries.TestFileSummaries[0].Tests[0].TestName);
Assert.Equal(1, summaries.TestFileSummaries[1].Tests.Count);
Assert.Equal("file2", summaries.TestFileSummaries[1].Tests[0].InputTestFile);
Assert.Equal("test1", summaries.TestFileSummaries[1].Tests[0].TestName);
}
public void Will_throw_argument_null_exception_if_context_is_null()
{
var reader = new TestableTestCaseStreamReader();
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, new StreamReader(new MemoryStream()), 1000);
var model = Record.Exception(() => reader.ClassUnderTest.Read(processStream, new TestOptions(), null, null)) as ArgumentNullException;
Assert.NotNull(model);
}
public void Will_fire_file_started_event()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson;
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
callback.Verify(x => x.FileStarted(context));
}
public void Will_supress_internal_log_event()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + string.Format(JsonStreamEvents.LogEventJsonTemplate, "!!_!! log");
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
TestLog result = null;
callback.Setup(x => x.FileLog(context, It.IsAny <TestLog>())).Callback <TestContext, TestLog>((c, t) => result = t);
reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
Assert.Null(result);
}
public void Will_fire_file_finished_event()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + JsonStreamEvents.TestDoneEventJson + JsonStreamEvents.FileDoneEventJson;
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
TestFileSummary result = null;
callback.Setup(x => x.FileFinished(context, It.IsAny <TestFileSummary>())).Callback <TestContext, TestFileSummary>((c, t) => result = t);;
reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
Assert.NotNull(result);
Assert.Equal(10, result.TimeTaken);
}
public void Will_put_logs_in_summary()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + string.Format(JsonStreamEvents.LogEventJsonTemplate, "hi") + string.Format(JsonStreamEvents.LogEventJsonTemplate, "bye");
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object).TestFileSummaries[0];
Assert.Equal(2, summary.Logs.Count);
Assert.Equal("file", summary.Logs[0].InputTestFile);
Assert.Equal("hi", summary.Logs[0].Message);
Assert.Equal("bye", summary.Logs[1].Message);
}
public void Will_set_timed_out_after_test_file_timeout_and_kill_process()
{
var reader = new TestableTestCaseStreamReader();
var context = reader.BuildContext("file");
var stream = new WaitingStreamReader(new MemoryStream(Encoding.UTF8.GetBytes("")), 10000);
var process = new Mock <IProcessWrapper>();
var processStream = new ProcessStreamStringSource(process.Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions {
TestFileTimeoutMilliseconds = 200
}, context, callback.Object);
Assert.NotNull(summary);
Assert.True(summary.TimedOut);
process.Verify(x => x.Kill());
}
public void Will_put_coverage_object_in_summary()
{
var reader = new TestableTestCaseStreamReader();
var context = reader.BuildContext("file");
var coverageEngine = new Mock <ICoverageEngine>();
coverageEngine.Setup(ce => ce.DeserializeCoverageObject(It.IsAny <string>(), context))
.Returns(new CoverageData());
context.CoverageEngine = coverageEngine.Object;
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + JsonStreamEvents.CoverageEventJson;
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object).TestFileSummaries[0];
Assert.NotNull(summary.CoverageObject);
}
public void Will_fire_log_event_if_file_is_not_already_known()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.LogEventJson + JsonStreamEvents.TestStartEventJson;
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
TestLog result = null;
callback.Setup(x => x.FileLog(context, It.IsAny <TestLog>())).Callback <TestContext, TestLog>((c, t) => result = t);
reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
Assert.NotNull(result);
Assert.Equal("log", result.Message);
Assert.Equal("file", result.InputTestFile);
}
public void Will_set_empty_coverage_object_when_coverage_is_enabled()
{
var reader = new TestableTestCaseStreamReader();
var json = @"";
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions {
CoverageOptions = new CoverageOptions {
Enabled = true
}
}, context, callback.Object).TestFileSummaries[0];
Assert.NotNull(summary.CoverageObject);
}
public ProcessResult <TestCaseStreamReadResult> RunExecutableAndProcessOutput(string exePath, string arguments, Func <ProcessStreamStringSource, TestCaseStreamReadResult> streamProcessor, int streamTimeout, IDictionary <string, string> environmentVars)
{
Process p = InvokeProcess(exePath, arguments, environmentVars);
ChutzpahTracer.TraceInformation("Started headless browser: {0} with PID: {1} using args: {2}", exePath, p.Id, arguments);
// Output will be null if the stream reading times out
var processStream = new ProcessStreamStringSource(new ProcessWrapper(p), p.StandardOutput, streamTimeout);
var output = streamProcessor(processStream);
p.WaitForExit(5000);
ChutzpahTracer.TraceInformation("Ended headless browser: {0} with PID: {1} using args: {2}", exePath, p.Id, arguments);
return(new ProcessResult <TestCaseStreamReadResult>(output.TimedOut ? (int)TestProcessExitCode.Timeout : p.ExitCode, output));
}
public void Will_fire_test_started_event()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson;
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
TestCase result = null;
callback.Setup(x => x.TestStarted(It.IsAny <TestCase>())).Callback <TestCase>(t => result = t);
reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
Assert.NotNull(result);
Assert.Equal("module", result.ModuleName);
Assert.Equal("test", result.TestName);
Assert.Equal("file", result.InputTestFile);
}
public void Will_supress_errors_after_timeout_when_killing_process()
{
var reader = new TestableTestCaseStreamReader();
var context = reader.BuildContext("file");
var stream = new WaitingStreamReader(new MemoryStream(Encoding.UTF8.GetBytes("")), 10000);
var process = new Mock <IProcessWrapper>();
var processStream = new ProcessStreamStringSource(process.Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
process.Setup(x => x.Kill()).Throws(new InvalidOperationException());
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions {
TestFileTimeoutMilliseconds = 200
}, context, callback.Object).TestFileSummaries[0];
Assert.NotNull(summary);
process.Verify(x => x.Kill());
}
public void Will_recover_after_malformed_json()
{
var reader = new TestableTestCaseStreamReader();
var json = @"
#_#Log#_# ""type"":""Log"",""Log"":{""message"":""hi""}}
"
+ string.Format(JsonStreamEvents.LogEventJsonTemplate, "bye") + JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson;
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object).TestFileSummaries[0];
Assert.Equal(1, summary.Logs.Count);
Assert.Equal("file", summary.Logs[0].InputTestFile);
Assert.Equal("bye", summary.Logs[0].Message);
}
public void Will_put_error_in_summary()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + JsonStreamEvents.ErrorEventJson;
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
var summary = reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object).TestFileSummaries[0];
Assert.Equal(1, summary.Errors.Count);
Assert.Equal("file", summary.Errors[0].InputTestFile);
Assert.Equal("error", summary.Errors[0].Message);
Assert.Equal("errorFile", summary.Errors[0].Stack[0].File);
Assert.Equal("errorFunc", summary.Errors[0].Stack[0].Function);
Assert.Equal("22", summary.Errors[0].Stack[0].Line);
}
public void Will_fire_error_event()
{
var reader = new TestableTestCaseStreamReader();
var json = JsonStreamEvents.FileStartEventJson + JsonStreamEvents.TestStartEventJson + JsonStreamEvents.ErrorEventJson;
var context = reader.BuildContext("file");
var stream = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(json)));
var processStream = new ProcessStreamStringSource(new Mock <IProcessWrapper>().Object, stream, 1000);
var callback = new Mock <ITestMethodRunnerCallback>();
TestError result = null;
callback.Setup(x => x.FileError(context, It.IsAny <TestError>())).Callback <TestContext, TestError>((c, t) => result = t);
reader.ClassUnderTest.Read(processStream, new TestOptions(), context, callback.Object);
Assert.NotNull(result);
Assert.Equal("file", result.InputTestFile);
Assert.Equal("error", result.Message);
Assert.Equal("errorFile", result.Stack[0].File);
Assert.Equal("errorFunc", result.Stack[0].Function);
Assert.Equal("22", result.Stack[0].Line);
}
