internal static void StopAllureLogging(TestContext.ResultAdapter testResult, string testUuid,
string testContainerUuid, ITest suite, bool updateStopTime, string ignoreReason)
{
var result = testResult;
var testMsg = result.Message;
var testStackTrace = result.StackTrace;
Logger.LogInProgress(
$"Entering stop allure logging for \"{testUuid}\"");
if (!string.IsNullOrEmpty(ignoreReason))
{
testMsg = ignoreReason;
}
AllureLifecycle.Instance.UpdateTestCase(testUuid, x =>
{
x.statusDetails.message = MakeGoodErrorMsg(testMsg);
x.statusDetails.trace = testStackTrace;
x.status = GetNUnitStatus(result.Outcome.Status);
});
AllureLifecycle.Instance.StopTestCase(testUuid,
updateStopTime);
AllureLifecycle.Instance.WriteTestCase(testUuid);
AllureLifecycle.Instance.UpdateTestContainer(
testContainerUuid,
q => q.children.Add(testUuid));
AllureLifecycle.Instance.StopTestContainer(
testContainerUuid, updateStopTime);
AllureLifecycle.Instance.WriteTestContainer(testContainerUuid);
Logger.LogInProgress($"Stopped allure logging for test {testUuid}, {testContainerUuid}, {ignoreReason}");
}
private static void AddInfoToIgnoredTest(ref TestContext.ResultAdapter testResult)
{
var type = testResult.Outcome.GetType();
var backingField = type.GetBackingField(nameof(ResultState.Status), true);
backingField.SetValue(testResult.Outcome, TestStatus.Skipped);
backingField = type.GetBackingField(nameof(ResultState.Label), true);
backingField.SetValue(testResult.Outcome, AllureConstants.TestWasIgnored);
}
public void AfterTest(ITest test)
{
TestContext.ResultAdapter result = TestContext.CurrentContext.Result;
TestContext.WriteLine($"{nameof(FlakyTestFailureToleranceAttribute)}: Result is {result.Outcome}");
if (result.Outcome != ResultState.Success &&
String.Equals(Environment.GetEnvironmentVariable("SCREENSHOT_TEST_FAILURE_TOLERANCE"), Boolean.TrueString, StringComparison.OrdinalIgnoreCase))
{
Assert.Ignore("This environment is too slow to run this test fixture - this test is skipped - this test is quite heavy and does not respond well in this environment");
}
}
/// <summary>
/// Used in conjunction with InjectTestStatus method.
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
public static List <object> CheckForTestStatusInjection(this TestContext.ResultAdapter result)
{
List <object> testResults = new List <object>();
try
{
TestStatus _testStatus = TestStatus.Inconclusive;
//var prefix = GetEnvVarPrefix();
var injStatusKey = GetEnvVarPrefix("_statusKey");
var injMsgKey = GetEnvVarPrefix("_msgKey");
string injStatus = string.Empty;
string injMsg = string.Empty;
if (BaseUtil.HashKeyExists(injStatusKey))
{
injStatus = BaseUtil.GetVar(injStatusKey, true);
injMsg = BaseUtil.GetVar(injMsgKey, true);
switch (injStatus)
{
case "Warning":
_testStatus = TestStatus.Warning;
break;
case "Failed":
_testStatus = TestStatus.Failed;
break;
case "Skipped":
_testStatus = TestStatus.Skipped;
break;
default:
_testStatus = TestStatus.Inconclusive;
break;
}
}
else
{
_testStatus = result.Outcome.Status;
}
testResults.Add(_testStatus);
testResults.Add(injMsg);
}
catch (Exception e)
{
log.Error(e.StackTrace);
}
return(testResults);
}
private static void AddInfoToIgnoredTest(ref TestContext.ResultAdapter testResult)
{
var backingField = testResult.Outcome.GetType()
.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).First(p =>
p.Name.EndsWith("__BackingField") && p.Name.Contains("<Status>"));
backingField.SetValue(testResult.Outcome, TestStatus.Skipped);
backingField = testResult.Outcome.GetType()
.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)
.First(p => p.Name.EndsWith("__BackingField") && p.Name.Contains("<Label>"));
backingField.SetValue(testResult.Outcome, AllureConstants.TestWasIgnored);
}
// "..\\..\\Logs\\Log.txt");
private string GetLogMessage(string testName, TestContext.ResultAdapter result)
{
switch (result.Outcome.Status)
{
case TestStatus.Passed:
case TestStatus.Inconclusive:
case TestStatus.Skipped:
return(CreateLogMessage(testName, result.Outcome.Status));
case TestStatus.Failed:
return(CreateLogMessageForFailedTest(testName, result.Message));
default:
return("");
}
}
public void UpdateTestStatus(TestContext.ResultAdapter result, TestStatus status = TestStatus.None)
{
if (status == TestStatus.None)
{
Result.Status = result.Outcome.Status.ToString();
Result.StackTrace = result.StackTrace;
Result.ErrorMessage = result.Message;
}
else
{
Result.Status = status.ToString();
}
Base.MongoDb.UpdateResult(this);
Base._testRun.UpdataResults();
}
private string GetCombinedFailureMessage(TestContext.ResultAdapter result, string tearDownFailure, string tearDownStackTrace)
{
var message = new StringBuilder()
.Append("The test failed and then failed to cleanup. Test failure is: ")
.AppendLine(result.Message)
.Append("Tear-down failure is: ")
.AppendLine(tearDownFailure)
.AppendLine("Test failure stack trace is: ")
.AppendLine(result.StackTrace);
if (!string.IsNullOrEmpty(tearDownStackTrace))
message.AppendLine("Tear-down failure stack trace is:")
.Append(tearDownStackTrace);
return message.ToString();
}
private static void FailIgnoredTests(Dictionary <ITest, string> dict, ITest suite)
{
lock (Locker)
{
foreach (var pair in dict)
{
pair.Key.Properties.Set(AllureConstants.TestIgnoreReason,
$"Test was ignored by reason: {pair.Value}");
var testResult = new TestContext.ResultAdapter(new TestCaseResult(new TestMethod(pair.Key.Method)));
AddInfoToIgnoredTest(ref testResult);
pair.Key.Properties.Set(AllureConstants.TestResult, testResult);
AllureLifecycle.Instance.Storage.ClearStepContext();
AllureLifecycle.Instance.Storage.CurrentThreadStepContext.AddLast(pair.Key.Properties
.Get(AllureConstants.TestUuid).ToString());
AllureLifecycle.Instance.StartStepAndStopIt(null, $"Test was ignored by reason: {pair.Value}",
Status.skipped);
AllureLifecycle.Instance.UpdateTestContainer(
pair.Key.Properties.Get(AllureConstants.TestContainerUuid).ToString(),
x => x.start = AllureLifecycle.ToUnixTimestamp());
AllureLifecycle.Instance.UpdateTestCase(pair.Key.Properties
.Get(AllureConstants.TestUuid).ToString(),
x =>
{
x.start = AllureLifecycle.ToUnixTimestamp();
x.labels.RemoveAll(q => q.name == "thread");
x.labels.Add(Label.Thread());
var subSuites = x.labels.Where(lbl => lbl.name.ToLower().Equals("subsuite")).ToList();
subSuites.ForEach(lbl => x.labels.Remove(lbl));
x.labels.Add(Label.SubSuite("Ignored tests/test-cases"));
});
Thread.Sleep(5);
StopAllureLogging(testResult, pair.Key.Properties
.Get(AllureConstants.TestUuid).ToString(), pair.Key.Properties
.Get(AllureConstants.TestContainerUuid).ToString(), suite, true, pair.Value);
}
}
}
public void AfterAll()
{
TestContext.ResultAdapter resultAdapter = TestContext.CurrentContext.Result;
if (resultAdapter.Outcome == ResultState.Success && (testInfo.Status == DifidoTestStatus.failure || testInfo.Status == DifidoTestStatus.error))
{
testStopwatch.Stop();
testInfo.DurationTime = testStopwatch.ElapsedMilliseconds;
report.EndTest(testInfo);
Assert.Fail("Test failed. See reports above for details.");
}
if (resultAdapter.Outcome == ResultState.Success)
{
testInfo.Status = DifidoTestStatus.success;
}
else if (resultAdapter.Outcome == ResultState.Error)
{
testInfo.Status = DifidoTestStatus.error;
report.Report(resultAdapter.Message, resultAdapter.StackTrace, DifidoTestStatus.error);
}
else if (resultAdapter.Outcome == ResultState.Failure)
{
testInfo.Status = DifidoTestStatus.failure;
report.Report(resultAdapter.Message, resultAdapter.StackTrace, DifidoTestStatus.failure);
}
else
{
testInfo.Status = DifidoTestStatus.warning;
}
testStopwatch.Stop();
testInfo.DurationTime = testStopwatch.ElapsedMilliseconds;
report.EndTest(testInfo);
}
public void GetCurrentResult()
{
Result = TestContext.CurrentContext.Result;
}
