public void GetScreenshotFileName()
{
var creationDate = new DateTime(2018, 10, 25, 5, 45, 55);
var screenshotFileName = NamesProvider.GetScreenshotFileName(creationDate);
Assert.AreEqual($"img_{creationDate:yyyyMMdd_HHmmssfff}.json", screenshotFileName);
}
public void GetTestOutputFileName()
{
var finishDateTime = new DateTime(2018, 10, 25, 5, 45, 55);
var testOutputFileName = NamesProvider.GetTestOutputFileName(finishDateTime);
Assert.AreEqual($"test_output_{finishDateTime:yyyyMMdd_HHmmssfff}.json", testOutputFileName);
}
public void GetRunFileName()
{
var runGuid = Guid.NewGuid();
var runFileName = NamesProvider.GetRunFileName(runGuid);
Assert.AreEqual($"run_{runGuid.ToString("D").ToLower()}.json", runFileName);
}
public static List <GhprTestCase> GetTestRunsListFromFile(string path, ILogger logger)
{
try
{
var xmlString = File.ReadAllText(path);
var doc = new XmlDocument();
doc.LoadXml(xmlString);
XmlNode node = doc.DocumentElement;
var testCases = node?.SelectNodes(".//*/test-case")?.Cast <XmlNode>().ToList();
var list = testCases?.Select(n => TestRunHelper.GetTestAndOutput(n, logger)).ToList() ?? new List <GhprTestCase>();
var testSuites = node?.SelectNodes(".//*/test-suite")?.Cast <XmlNode>().ToList() ?? new List <XmlNode>();
var testInfoDtos = list.Select(d => d.GhprTestRun.TestInfo).ToList();
foreach (var testSuite in testSuites)
{
var testOutputs = TestRunHelper.GetOutputsFromSuite(testSuite, testInfoDtos);
foreach (var output in testOutputs)
{
var test = list.FirstOrDefault(t => t.GhprTestRun.TestInfo.Guid == output.Key.Guid &&
t.GhprTestRun.TestInfo.Finish == output.Key.Finish) ?? new GhprTestCase();
test.GhprTestOutput.Output = output.Value.Output;
test.GhprTestOutput.TestOutputInfo.ItemName =
NamesProvider.GetTestOutputFileName(test.GhprTestRun.TestInfo.Finish);
test.GhprTestOutput.SuiteOutput = output.Value.SuiteOutput;
}
}
return(list);
}
catch (Exception ex)
{
logger.Exception($"Exception in GetTestRunsListFromFile: {ex.Message}", ex);
return(null);
}
}
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 static ItemInfo MapTestRunInfo(this ItemInfoDto itemInfoDto)
{
var run = new ItemInfo
{
Guid = itemInfoDto.Guid,
Start = itemInfoDto.Start,
Finish = itemInfoDto.Finish,
ItemName = NamesProvider.GetTestRunFileName(itemInfoDto.Finish)
};
return(run);
}
public static TestOutput Map(this TestOutputDto testOutputDto)
{
var name = NamesProvider.GetTestOutputFileName(testOutputDto.TestOutputInfo.Date);
var testOutput = new TestOutput
{
SuiteOutput = testOutputDto.SuiteOutput,
Output = testOutputDto.Output,
TestOutputInfo = testOutputDto.TestOutputInfo.MapSimpleItemInfo(name)
};
return(testOutput);
}
public static string Save(this TestOutput testOutput, string path)
{
path.Create();
var fullPath = Path.Combine(path, NamesProvider.GetTestOutputFileName(testOutput.TestOutputInfo.Date));
using (var file = File.CreateText(fullPath))
{
var serializer = new JsonSerializer();
serializer.Serialize(file, testOutput);
}
return(fullPath);
}
public static TestScreenshot Map(this TestScreenshotDto testScreenshotDto)
{
var name = NamesProvider.GetScreenshotFileName(testScreenshotDto.TestScreenshotInfo.Date);
var testScreenshot = new TestScreenshot
{
TestScreenshotInfo = testScreenshotDto.TestScreenshotInfo.MapSimpleItemInfo(name),
Base64Data = testScreenshotDto.Base64Data,
TestGuid = testScreenshotDto.TestGuid,
Format = testScreenshotDto.Format
};
return(testScreenshot);
}
public void UpdateTestOutput(ItemInfoDto testInfo, TestOutputDto testOutput)
{
var outputFolderPath = _locationsProvider.GetTestOutputFolderPath(testInfo.Guid);
var outputFileName = NamesProvider.GetTestOutputFileName(testInfo.Finish);
var existingOutput = Path.Combine(outputFolderPath, outputFileName).LoadTestOutput();
_logger.Debug($"Loaded existing output: {JsonConvert.SerializeObject(existingOutput, Formatting.Indented)}");
existingOutput.SuiteOutput = testOutput.SuiteOutput;
existingOutput.Output = testOutput.Output;
File.Delete(Path.Combine(outputFolderPath, outputFileName));
_logger.Debug("Deleted old output");
existingOutput.Save(outputFolderPath);
_logger.Debug($"Saved updated output: {JsonConvert.SerializeObject(existingOutput, Formatting.Indented)}");
}
public static TestOutputDto GetTestOutput(XmlNode testNode, DateTime testFinishDate, ILogger logger)
{
var output = new TestOutputDto
{
SuiteOutput = "",
Output = testNode.SelectSingleNode("./output")?.InnerText ?? "",
TestOutputInfo = new SimpleItemInfoDto
{
Date = testFinishDate,
ItemName = NamesProvider.GetTestOutputFileName(testFinishDate)
}
};
return(output);
}
public static string Save(this TestScreenshotDto testScreenshot, string path)
{
path.Create();
var fullPath = Path.Combine(path, NamesProvider.GetScreenshotFileName(testScreenshot.TestScreenshotInfo.Date));
using (var file = File.CreateText(fullPath))
{
var serializer = new JsonSerializer();
serializer.Serialize(file, testScreenshot);
}
var fileInfo = new FileInfo(fullPath);
fileInfo.Refresh();
fileInfo.CreationTime = testScreenshot.TestScreenshotInfo.Date;
return(fullPath);
}
public ItemInfoDto SaveTestRun(TestRunDto testRun, TestOutputDto testOutput)
{
testRun.TestInfo.ItemName = NamesProvider.GetTestRunFileName(testRun.TestInfo.Finish);
testOutput.TestOutputInfo.ItemName = NamesProvider.GetTestOutputFileName(testRun.TestInfo.Finish);
testRun.Output.ItemName = testOutput.TestOutputInfo.ItemName;
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}");
if (testRun.Screenshots.All(s => s.Date != img.TestScreenshotInfo.Date))
{
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 output 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)}");
if (!_processedTests.ContainsKey(testRun.TestInfo.Guid))
{
_processedTests.Add(testRun.TestInfo.Guid, testRun.TestInfo);
}
return(testRun.TestInfo);
}
public SimpleItemInfoDto SaveScreenshot(TestScreenshotDto screenshot)
{
screenshot.TestScreenshotInfo.ItemName =
NamesProvider.GetScreenshotFileName(screenshot.TestScreenshotInfo.Date);
var testGuid = screenshot.TestGuid;
var path = _locationsProvider.GetScreenshotFolderPath(testGuid);
screenshot.Save(path);
_logger.Info($"Screenshot was saved: '{path}'");
_logger.Debug($"Screenshot data was saved correctly: {JsonConvert.SerializeObject(screenshot, Formatting.Indented)}");
if (_processedTests.ContainsKey(testGuid))
{
var testRun = _reader.GetTestRun(_processedTests[testGuid]);
if (testRun.Screenshots.All(s => s.Date != screenshot.TestScreenshotInfo.Date))
{
testRun.Screenshots.Add(screenshot.TestScreenshotInfo);
var output = _reader.GetTestOutput(testRun);
SaveTestRun(testRun, output);
}
}
return(screenshot.TestScreenshotInfo);
}
public ItemInfoDto SaveRun(RunDto run)
{
run.RunInfo.ItemName = NamesProvider.GetRunFileName(run.RunInfo.Guid);
var runGuid = run.RunInfo.Guid;
var fileName = NamesProvider.GetRunFileName(runGuid);
run.RunInfo.ItemName = fileName;
_locationsProvider.RunsFolderPath.Create();
var fullRunPath = _locationsProvider.GetRunFullPath(runGuid);
using (var file = File.CreateText(fullRunPath))
{
var serializer = new JsonSerializer();
serializer.Serialize(file, run);
}
_logger.Info($"Run was saved: '{fullRunPath}'");
var runsInfoFullPath = run.RunInfo.SaveRunInfo(_locationsProvider);
_logger.Info($"Runs Info was saved: '{runsInfoFullPath}'");
_logger.Debug($"Run data was saved correctly: {JsonConvert.SerializeObject(run, Formatting.Indented)}");
return(run.RunInfo);
}
public RunDto GetRun(Guid runGuid)
{
var run = _locationsProvider.RunsFolderPath.LoadRun(NamesProvider.GetRunFileName(runGuid));
return(run);
}
