public void TestStarted(TestRunDto testRun)
{
Action.Safe(() =>
{
TestRunsRepository.AddNewTestRun(testRun);
});
}
public static void TestStarted(TestRunDto testRun)
{
lock (Lock)
{
_reporter.TestStarted(testRun);
}
}
public ItemInfoDto SaveTestRun(TestRunDto testRunDto, TestOutputDto testOutputDto)
{
var testOutput = testOutputDto.Map();
var testRun = testRunDto.Map(testOutput.TestOutputInfo.ToDto());
var imgFolder = _locationsProvider.GetScreenshotFolderPath(testRun.TestInfo.Guid);
if (Directory.Exists(imgFolder))
{
var imgFiles = new DirectoryInfo(imgFolder).GetFiles("*.json");
_logger.Info($"Checking unassigned img files: {imgFiles.Length} file found");
foreach (var imgFile in imgFiles)
{
var img = Path.Combine(imgFolder, imgFile.Name).LoadTestScreenshot();
if (imgFile.CreationTime > testRun.TestInfo.Start)
{
_logger.Info($"New img file found: {imgFile.CreationTime}, {imgFile.Name}");
testRun.Screenshots.Add(img.TestScreenshotInfo);
}
}
}
var testOutputFullPath = testOutput.Save(_locationsProvider.GetTestOutputFolderPath(testRun.TestInfo.Guid));
_logger.Info($"Test output was saved: '{testOutputFullPath}'");
_logger.Debug($"Test run data was saved correctly: {JsonConvert.SerializeObject(testOutput, Formatting.Indented)}");
var testRunFullPath = testRun.Save(_locationsProvider.GetTestFolderPath(testRun.TestInfo.Guid));
_logger.Info($"Test run was saved: '{testRunFullPath}'");
var testRunsInfoFullPath = testRun.TestInfo.SaveTestInfo(_locationsProvider);
_logger.Info($"Test runs Info was saved: '{testRunsInfoFullPath}'");
_logger.Debug($"Test run data was saved correctly: {JsonConvert.SerializeObject(testRun, Formatting.Indented)}");
return(testRun.TestInfo.ToDto());
}
public ItemInfoDto SaveTestRun(TestRunDto testRun, TestOutputDto testOutput)
{
var res = _dataWriterService.SaveTestRun(testRun, testOutput);
_cache.SaveTestRun(testRun, testOutput);
return(res);
}
public TestRunDto UpdateTestRunOnScenarioEnd(TestRunDto tr, Exception testError, string testOutput, FeatureContext fc, ScenarioContext sc,
out TestOutputDto testOutputDto)
{
var finishDt = DateTime.Now;
var tc = sc.TryGetTestContext();
var nameForGuid = GetFullNameForGuid(tc, sc, fc);
var guid = nameForGuid.ToMd5HashGuid().ToString();
tr.TestInfo.Guid = Guid.Parse(guid);
tr.TestInfo.Finish = finishDt;
tr.FullName = GetFullName(tc, sc, fc);
testOutputDto = new TestOutputDto
{
Output = testOutput,
SuiteOutput = "",
TestOutputInfo = new SimpleItemInfoDto
{
Date = finishDt,
ItemName = "Test output"
}
};
tr.Output = testOutputDto.TestOutputInfo;
tr.Result = testError == null ? "Passed" : (testError is AssertFailedException ? "Failed" : "Error");
tr.TestMessage = testError?.Message ?? "";
tr.TestStackTrace = testError?.StackTrace ?? "";
tr.TestData.AddRange(TestDataHelper.GetTestData());
return(tr);
}
public void OnTestFinished(TestRunDto testRun)
{
CurrentRun.RunSummary.Total++;
switch (testRun.TestResult)
{
case TestResult.Passed:
CurrentRun.RunSummary.Success++;
break;
case TestResult.Failed:
CurrentRun.RunSummary.Failures++;
break;
case TestResult.Broken:
CurrentRun.RunSummary.Errors++;
break;
case TestResult.Ignored:
CurrentRun.RunSummary.Ignored++;
break;
case TestResult.Inconclusive:
CurrentRun.RunSummary.Inconclusive++;
break;
case TestResult.Unknown:
CurrentRun.RunSummary.Unknown++;
break;
default:
CurrentRun.RunSummary.Unknown++;
break;
}
CurrentRun.TestsInfo.Add(testRun.TestInfo);
}
public void OnScenarioEnd()
{
lock (Lock)
{
var te = _engine.ScenarioContext?.TestError;
var testOutput = _outputWriter.GetOutput();
var fc = _engine.FeatureContext;
var sc = _engine.ScenarioContext;
var finish = DateTime.Now;
_currentTestRun.TestInfo.Finish = finish;
var testOutputDto = new TestOutputDto
{
Output = testOutput,
SuiteOutput = "",
TestOutputInfo = new SimpleItemInfoDto
{
Date = finish,
ItemName = "Test output"
}
};
_currentTestRun.Output = testOutputDto.TestOutputInfo;
_currentTestRun = GhprPluginHelper.TestExecutionEngineHelper.UpdateTestRunOnScenarioEnd(
_currentTestRun, te, testOutputDto, fc, sc);
ReporterManager.TestFinished(_currentTestRun, testOutputDto);
_runner.OnScenarioEnd();
_outputWriter.Flush();
}
}
public TestRunDto Process(TestRunDto testRunDtoWhenStarted, TestRunDto testRunDtoWhenFinished, Guid runGuid)
{
var finalTestRunDto = testRunDtoWhenFinished;
if (finalTestRunDto.TestInfo.Guid.Equals(Guid.Empty))
{
finalTestRunDto.TestInfo.Guid = finalTestRunDto.FullName.ToMd5HashGuid();
}
finalTestRunDto.Screenshots
.AddRange(testRunDtoWhenStarted.Screenshots.Where(
s => !finalTestRunDto.Screenshots.Any(ts => ts.Date.Equals(s.Date))));
finalTestRunDto.TestData
.AddRange(testRunDtoWhenStarted.TestData.Where(
s => !finalTestRunDto.TestData.Any(ts => ts.TestDataInfo.Date.Equals(s.TestDataInfo.Date))));
finalTestRunDto.Events.
AddRange(testRunDtoWhenStarted.Events.Where(
e => !finalTestRunDto.Events.Any(te => te.Comment.Equals(e.Comment))));
finalTestRunDto.TestInfo.Start = testRunDtoWhenStarted.TestInfo.Start.Equals(default(DateTime))
? finalTestRunDto.TestInfo.Start
: testRunDtoWhenStarted.TestInfo.Start;
finalTestRunDto.TestInfo.Finish = finalTestRunDto.TestInfo.Finish.Equals(default(DateTime))
? DateTime.Now
: finalTestRunDto.TestInfo.Finish;
finalTestRunDto.RunGuid = runGuid;
return(finalTestRunDto);
}
public void TestData()
{
var now = DateTime.Now;
var runGuid = Guid.NewGuid();
var testGuid = Guid.NewGuid();
var p = new TestRunDtoProcessor();
var testOnStart = new TestRunDto(testGuid, "Cool Test")
{
TestData = new List <TestDataDto>
{
new TestDataDto
{
Actual = "a1",
Expected = "e1",
Comment = "c1",
TestDataInfo = new SimpleItemInfoDto {
Date = now
}
},
new TestDataDto
{
Actual = "a2",
Expected = "e2",
Comment = "c2",
TestDataInfo = new SimpleItemInfoDto {
Date = now.AddSeconds(1)
}
}
}
};
var testOnFinish = new TestRunDto
{
TestData = new List <TestDataDto>
{
new TestDataDto
{
Actual = "a3",
Expected = "e3",
Comment = "c3",
TestDataInfo = new SimpleItemInfoDto {
Date = now.AddSeconds(2)
}
},
new TestDataDto
{
Actual = "a4",
Expected = "e4",
Comment = "c4",
TestDataInfo = new SimpleItemInfoDto {
Date = now.AddSeconds(3)
}
}
}
};
var finalTest = p.Process(testOnStart, testOnFinish, runGuid);
Assert.AreEqual(4, finalTest.TestData.Count);
Assert.AreEqual(0, finalTest.Screenshots.Count);
Assert.AreEqual(0, finalTest.Events.Count);
}
public void TestInfoTest2()
{
var now = DateTime.Now.AddSeconds(-3);
var runGuid = Guid.NewGuid();
var testGuid = Guid.NewGuid();
var p = new TestRunDtoProcessor();
var testOnStart = new TestRunDto(testGuid, "Cool Test")
{
TestInfo = new ItemInfoDto
{
ItemName = "item1"
}
};
var testOnFinish = new TestRunDto
{
TestInfo = new ItemInfoDto
{
Start = now.AddSeconds(4)
}
};
var finalTest = p.Process(testOnStart, testOnFinish, runGuid);
Assert.AreEqual(testOnFinish.TestInfo.Start, finalTest.TestInfo.Start);
Assert.True(finalTest.TestInfo.Finish > now);
}
public static void TestFinished(TestRunDto testRun, TestOutputDto testOutputDto)
{
lock (Lock)
{
_reporter.TestFinished(testRun, testOutputDto);
}
}
public void TestEvents()
{
var runGuid = Guid.NewGuid();
var testGuid = Guid.NewGuid();
var p = new TestRunDtoProcessor();
var testOnStart = new TestRunDto(testGuid, "Cool Test")
{
Events = new List <TestEventDto>
{
new TestEventDto("ev1")
{
Comment = "comment",
EventInfo = new SimpleItemInfoDto {
Date = DateTime.Now, ItemName = "item"
},
Finished = DateTime.Now,
Started = DateTime.Now.AddSeconds(-3)
},
new TestEventDto("ev2")
}
};
var testOnFinish = new TestRunDto
{
Events = new List <TestEventDto> {
new TestEventDto("ev3"), new TestEventDto("ev4")
}
};
var finalTest = p.Process(testOnStart, testOnFinish, runGuid);
Assert.AreEqual(0, finalTest.TestData.Count);
Assert.AreEqual(0, finalTest.Screenshots.Count);
Assert.AreEqual(4, finalTest.Events.Count);
}
public TestRunDto GetTestRunOnScenarioStart(ITestRunner runner, FeatureInfo fi, ScenarioInfo si, FeatureContext fc, ScenarioContext sc)
{
var className = TestContext.CurrentContext.Test.ClassName;
var testName = TestContext.CurrentContext.Test.Name;
var names = className.Split('.').ToList();
if (names.Count >= 2)
{
names.RemoveAt(names.Count - 1);
}
className = string.Join(".", names);
var fullName = $"{className}.{fi.Title}.{testName}";
var name = si.Title;
var guid = TestContext.CurrentContext.Test.FullName.ToMd5HashGuid().ToString();
var testRun = new TestRunDto(guid, name, fullName)
{
Categories = si.Tags,
TestInfo =
{
Start = DateTime.Now
}
};
return(testRun);
}
public void TestStarted(TestRunDto testRun)
{
Action.Safe(() =>
{
TestRunsRepository.AddNewTestRun(testRun);
Logger.Info($"Test '{testRun.Name}' (Guid: {testRun.TestInfo.Guid}) started");
});
}
public void TestFinished(TestRunDto testRun)
{
OnTestFinish(testRun);
if (ReporterSettings.RealTimeGeneration)
{
GenerateReport(DateTime.Now);
}
}
public TestRunDto UpdateTestRunOnScenarioEnd(TestRunDto tr, Exception testError, TestOutputDto testOutputDto, FeatureContext fc, ScenarioContext sc)
{
tr.Result = TestContext.CurrentContext.Result.Outcome.ToString();
tr.TestMessage = testError?.Message ?? "";
tr.TestStackTrace = testError?.StackTrace ?? "";
tr.TestData.AddRange(TestDataHelper.GetTestData());
return(tr);
}
public GhprTestCase()
{
Id = "";
ParentId = "";
GhprTestRun = new TestRunDto();
GhprTestOutput = new TestOutputDto();
GhprTestScreenshots = new List <TestScreenshotDto>();
}
public TestRunDto UpdateTestRunOnScenarioEnd(TestRunDto tr, Exception testError, TestOutputDto testOutputDto, FeatureContext fc,
ScenarioContext sc)
{
tr.Result = testError == null ? "Passed" : "Failed";
tr.TestMessage = testError?.Message ?? "";
tr.TestStackTrace = testError?.StackTrace ?? "";
return(tr);
}
public ItemInfoDto SaveTestRun(TestRunDto testRunDto, TestOutputDto testOutputDto)
{
//TODO: SAVE testOutputDto correctly!
var testRunEntity = testRunDto.Map();
Database.SaveTestRun(testRunEntity);
return(testRunEntity.Data.TestInfo.ToDto());
}
public void DeleteTestScreenshot(TestRunDto testRun, TestScreenshotDto testScreenshot)
{
var testScreenshotFullPath = _locationsProvider
.GetTestScreenshotFullPath(testRun.TestInfo.Guid, testScreenshot.TestScreenshotInfo.Date);
_logger.Debug($"Deleting Test screenshot: {testScreenshotFullPath}");
File.Delete(testScreenshotFullPath);
}
public void DeleteTestOutput(TestRunDto testRun, TestOutputDto testOutput)
{
var testOutputFullPath = _locationsProvider.GetTestOutputFullPath(testRun.TestInfo.Guid,
testRun.TestInfo.Finish);
_logger.Debug($"Deleting Test Output: {testOutputFullPath}");
File.Delete(testOutputFullPath);
}
public void TestFinished(TestRunDto testRun, TestOutputDto testOutputDto)
{
OnTestFinish(testRun, testOutputDto);
Logger.Info($"Test '{testRun.Name}' (Guid: {testRun.TestInfo.Guid}) finished");
if (ReporterSettings.RealTimeGeneration)
{
GenerateReport(DateTime.Now);
}
}
public void TestResultTest(string testResult, TestResult result)
{
var test = new TestRunDto
{
Result = testResult
};
Assert.AreEqual(result, test.TestResult);
}
private void OnTestFinish(TestRunDto testDtoWhenFinished)
{
Action.Safe(() =>
{
RunRepository.OnTestFinished(testDtoWhenFinished);
var testDtoWhenStarted = TestRunsRepository.ExtractCorrespondingTestRun(testDtoWhenFinished);
var finalTest = TestRunProcessor.Process(testDtoWhenStarted, testDtoWhenFinished, RunRepository.RunGuid);
DataService.SaveTestRun(finalTest);
});
}
public void TestProcessRunGuid()
{
var guid = Guid.NewGuid();
var p = new TestRunDtoProcessor();
var testOnStart = new TestRunDto();
var testOnFinish = new TestRunDto();
var finalTest = p.Process(testOnStart, testOnFinish, guid);
Assert.AreEqual(guid, finalTest.RunGuid);
}
public TestOutputDto GetTestOutput(TestRunDto testRunDto)
{
return(new TestOutputDto
{
Output = "output",
SuiteOutput = "suite output",
TestOutputInfo = new SimpleItemInfoDto {
Date = DateTime.Now, ItemName = "item"
}
});
}
private void OnTestFinish(TestRunDto testDtoWhenFinished, TestOutputDto testOutputDto)
{
Action.Safe(() =>
{
RunRepository.OnTestFinished(testDtoWhenFinished);
var testDtoWhenStarted = TestRunsRepository.ExtractCorrespondingTestRun(testDtoWhenFinished);
var finalTest = TestRunProcessor.Process(testDtoWhenStarted, testDtoWhenFinished, RunRepository.RunGuid);
Logger.Debug($"Saving test run '{finalTest.Name}' (Guid: {finalTest.TestInfo.Guid})");
DataWriterService.SaveTestRun(finalTest, testOutputDto);
});
}
public static string Save(this TestRunDto testRun, string path)
{
path.Create();
var fullPath = Path.Combine(path, NamesProvider.GetTestRunFileName(testRun.TestInfo.Finish));
using (var file = File.CreateText(fullPath))
{
var serializer = new JsonSerializer();
serializer.Serialize(file, testRun);
}
return(fullPath);
}
public TestRunDto GetTestRunOnScenarioStart(ITestRunner runner, FeatureInfo fi, ScenarioInfo si, FeatureContext fc,
ScenarioContext sc)
{
var fullName = $"Features.{fi.Title}.{si.Title}";
var name = si.Title;
var guid = fullName.ToMd5HashGuid();
var testRun = new TestRunDto(guid, name, fullName)
{
Categories = si.Tags
};
return(testRun);
}
public void DeleteTest(TestRunDto testRun)
{
var testFullPath = _locationsProvider.GetTestFullPath(testRun.TestInfo.Guid,
testRun.TestInfo.Finish);
_logger.Debug($"Deleting Test: {testFullPath}");
File.Delete(testFullPath);
_locationsProvider.GetTestFolderPath(testRun.TestInfo.Guid)
.DeleteItemsFromItemInfosFile(_locationsProvider.Paths.File.Tests, new List <ItemInfoDto>(1)
{
testRun.TestInfo
});
}
