public override AssertionResult Assert()
{
var cellText = Parameters[0];
try
{
Waiter.Until(p => p.FindElement(By.LinkText(cellText))); //等待该元素出现
//在表格中查找
var targetLink = WebDriver.FindElement(By.ClassName("el-table__body"))?.FindElement(By.LinkText(cellText));
if (targetLink == null)
{
throw new Exception();
}
return(AssertionResult.Success("验证通过，存在" + cellText));
}
catch (Exception ex)
{
var screenShotAddress = WebDriver.ScreenShot();
return(AssertionResult.Fail("未找到该元素", "表格中存在" + cellText, screenShotAddress));
}
}
public void TestResultXml_AssertionResults()
{
TNode assertionResults = _testResult.ToXml(true).SelectSingleNode("assertions");
if (_expectedAssertions.Count == 0)
{
Assert.Null(assertionResults, "No <assertions> element expected");
return;
}
Assert.NotNull(assertionResults, "Expected <assertions> element");
var assertionNodes = assertionResults.SelectNodes("assertion");
Assert.NotNull(assertionNodes, "Empty <assertions> element");
Assert.AreEqual(_expectedAssertions.Count, assertionNodes.Count, "Wrong number of <assertion> elements");
for (int index = 0; index < _expectedAssertions.Count; index++)
{
AssertionResult expectedAssertion = _expectedAssertions[index];
TNode assertionNode = assertionNodes[index];
Assert.AreEqual(expectedAssertion.Status.ToString(), assertionNode.Attributes["result"]);
if (expectedAssertion.Message != null)
{
TNode messageNode = assertionNode.SelectSingleNode("message");
Assert.NotNull(messageNode);
Assert.That(messageNode.Value, Is.EqualTo(expectedAssertion.Message));
}
if (expectedAssertion.StackTrace != null)
{
TNode stackNode = assertionNode.SelectSingleNode("stack-trace");
Assert.NotNull(stackNode);
Assert.That(stackNode.Value, Is.EqualTo(expectedAssertion.StackTrace));
}
}
}
/// <summary>
/// Asserts that the function returns true.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override IEnumerable <AssertionResult> Assert(AssertionContext context)
{
dynamic obj = null;
Exception error = null;
try
{
obj = context.ResponseDeserialiser.GetResponse <dynamic>(context);
}
catch (Exception ex)
{
error = ex;
}
if (obj == null || error != null)
{
yield return(new AssertionResult(this, $"Failed to deserialise object."));
yield break;
}
AssertionResult result = null;
try
{
if (!_expression(obj))
{
result = new AssertionResult(this, _error);
}
}
catch (Exception ex)
{
result = new AssertionResult(this, ex.ToString());
}
if (result != null)
{
yield return(result);
}
}
public AssertionResult Assert()
{
if (!ObjectFactory.TryCreatingObject <T>(out var createdObject, _constructorInfo, _argumentValues))
{
return(AssertionResult.CreateFail(" Could not create Object to check Properties."));
}
var failingPropertyAssertions = _propertyAssertionBuilders.Select(f => f.Assert(createdObject)).Where(f => !f.IsSuccess).ToList();
if (!failingPropertyAssertions.Any())
{
return(AssertionResult.CreateSuccess());
}
var sb = new StringBuilder();
_propertyAssertionBuilders
.Select(f => f.Assert(createdObject))
.Where(f => !f.IsSuccess)
.ForEach(f => sb.AppendLineWithIndentation(f.Message, 4));
return(AssertionResult.CreateFail(sb.ToString()));
}
public void RecordAssertion(AssertionResult assertion)
{
_assertionResults.Add(assertion);
}
internal static string GetString(this AssertionResult result)
{
return($"[{result.CausedBy.RuleName}] {result.ErrorMessage}");
}
public TestAssertionWrapper(AssertionResult assertion)
{
_assertion = assertion;
}
public void Report(string message, string stackTrace)
{
AtataContext.Current.PendingFailureAssertionResults.Add(AssertionResult.ForWarning(message, stackTrace));
}
/// <summary>
/// Asserts that the function returns true.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override IEnumerable <AssertionResult> Assert(AssertionContext context)
{
if (string.IsNullOrEmpty(context.Response.Content))
{
yield return(new AssertionResult(this, $"Response was blank and could not assert as {_assertType}."));
yield break;
}
var obj = default(T);
Exception error = null;
try
{
obj = context.ResponseDeserialiser.GetResponse <T>(context);
}
catch (Exception ex)
{
error = ex;
}
if (obj == null)
{
yield return(new AssertionResult(this, $"Failed to deserialise response to {_assertType}"));
}
if (error != null)
{
yield return(new AssertionResult(this, string.Format(_expressionError, error)));
}
if (obj == null || error != null)
{
yield break;
}
AssertionResult result = null;
try
{
if (!_lambda(obj))
{
string errorMessage = _error;
// if we have a function to generate the error we use that instead
if (_errorMessage != null)
{
// now we need to be safe - an error here doesn't mean that the whole thing should not necessarily crash
try
{
errorMessage = _errorMessage(obj);
}
catch (Exception ex)
{
errorMessage =
$"Assertion failed and could not generate the message due to an exception on the custom error message function {ex.Message}";
}
}
result = new AssertionResult(this, errorMessage);
}
}
catch (Exception ex)
{
result = new AssertionResult(this, ex.ToString());
}
if (result != null)
{
yield return(result);
}
}
public ResolvedPolicyAssertion(AssertionResult result)
{
this.result = result;
}
private AssertionResult EvaluateResponse(ExecuteResult response)
{
AssertionResult result = new AssertionResult();
return(result);
}
