protected override void execute(IWebElement element, IDictionary<string, object> cellValues, IStep step, ITestContext context)
{
// TODO -- StoryTeller needs to pull this all inside the Cell
if (!cellValues.ContainsKey(_cell.Key))
{
// already caught as a syntax error
return;
}
var handler = ElementHandlers.FindHandler(element);
var expectedValue = cellValues[_cell.Key];
var matchingHandler = handler as IMatchingHandler ?? new BasicMatchingHandler(handler, context);
if (matchingHandler.MatchesData(element, expectedValue))
{
context.IncrementRights();
}
else
{
context.ResultsFor(step).MarkFailure(_cell.Key);
context.IncrementWrongs();
}
context.ResultsFor(step).SetActual(_cell.Key, handler.GetData(CurrentContext, element));
}
protected override void execute(IWebElement element, IDictionary <string, object> cellValues, IStep step, ITestContext context)
{
// TODO -- StoryTeller needs to pull this all inside the Cell
if (!cellValues.ContainsKey(_cell.Key))
{
// already caught as a syntax error
return;
}
var handler = ElementHandlers.FindHandler(element);
var expectedValue = cellValues[_cell.Key];
var matchingHandler = handler as IMatchingHandler ?? new BasicMatchingHandler(handler, context);
if (matchingHandler.MatchesData(element, expectedValue))
{
context.IncrementRights();
}
else
{
context.ResultsFor(step).MarkFailure(_cell.Key);
context.IncrementWrongs();
}
context.ResultsFor(step).SetActual(_cell.Key, handler.GetData(CurrentContext, element));
}
void ITestStream.StartParagraph(Paragraph paragraph, IStep step)
{
_paragraphResults = _context.ResultsFor(step);
_paragraphResults.MoveFirst();
var tag = new ParagraphTag(paragraph, step);
_document.Push(tag);
}
public override void Execute(IStep step, ITestContext context)
{
step.Set(_returnCell.Key, true);
context.ResultsFor(step).SetActual(_returnCell.Key, false);
_method.Call(_target, step, context,
value => _returnCell.RecordActual(value, step, context));
}
public static void Call(this MethodInfo method, object target, IStep step, ITestContext context,
Action <object> callback)
{
IEnumerable <Cell> cells = method.GetArgumentCells();
var arguments = new object[cells.Count()];
int i = 0;
foreach (Cell cell in cells)
{
cell.ReadArgument(context, step, x => arguments[i] = x);
i++;
}
var results = context.ResultsFor(step);
if (results.HasErrors())
{
return;
}
try
{
object val = method.Invoke(target, arguments);
if (method.HasReturn())
{
callback(val);
}
}
catch (Exception e)
{
Exception ex = e.InnerException ?? e;
results.CaptureException(ex.ToString());
context.IncrementExceptions();
}
}
public Results(SentenceTag tag, ITestContext context)
{
_tag = tag;
_context = context;
_results = _context.ResultsFor(tag._step);
_step = tag._step;
}
public void WriteResults(ITestContext context)
{
context.ResultsFor(_step).ForExceptionText(writeExceptionText);
rows().Each(row => writeResultsRow(row, context));
_headerRow.FirstChild().AddClass("left-cell");
}
public void WriteResults(ITestContext context)
{
context.ResultsFor(_step).ForExceptionText(writeExceptionText);
rows().Each(row => writeResultsRow(row, context));
_headerRow.FirstChild().AddClass("left-cell");
}
public void WriteResults(ITestContext context)
{
// This code Dru. If there's an exception in the results, call
// back to the writeExceptionText(string) method to write in
// the exception
context.ResultsFor(_step).ForExceptionText(writeExceptionText);
rows().Each(row => writeResultsRow(row, context));
}
public void Execute(IStep step, ITestContext context)
{
var results = context.ResultsFor(step);
_grammars.ForEach(g =>
{
context.PerformAction(step, g.Execute);
results.MoveFrame();
});
}
private void checkExpectedAgainstActual(object expected, object actual, ITestContext context, IStep step)
{
if (context.Matches(expected, actual))
{
context.IncrementRights();
}
else
{
context.ResultsFor(step).MarkFailure(_key);
context.IncrementWrongs();
}
}
public void Execute(IStep containerStep, ITestContext context)
{
var actualObjects = findTheObjects(containerStep, context);
var actualRows = buildActualRows(actualObjects);
var expectedRows = buildExpectedRows(context, containerStep);
var matcher = new SetRowMatcher(expectedRows, actualRows, context);
IList<SetRow> results = Ordered ? matcher.CompareOrdered() : matcher.Compare();
markCounts(context, results);
context.ResultsFor(containerStep).SetResult(results, _leafName);
}
private void verifyTheActualValue(IStep step, object actual, string rawExpected, ITestContext context)
{
try
{
object expected = context.Finder.FromString(rawExpected, _type);
checkExpectedAgainstActual(expected, actual, context, step);
}
catch (Exception e)
{
context.ResultsFor(step).MarkExceptionField(e.ToString(), _key);
context.IncrementSyntaxErrors();
}
}
private void writeVerificationResultRow(SetRow setRow, ITestContext context, bool ordered)
{
AddBodyRow(row =>
{
if (ordered)
{
row.Cell(setRow.ActualOrder == 0 ? string.Empty : setRow.ActualOrder.ToString());
}
_table.Cells.Each(cell =>
{
var display = context.GetDisplay(setRow.Values[cell.Key]);
row.Cell(display);
});
switch (setRow.Result)
{
case SetMatch.Match:
row.AddClass(HtmlClasses.PASS);
break;
case SetMatch.Extra:
row.AddClass(HtmlClasses.FAIL);
var firstChild = row.FirstChild();
firstChild.Text("Extra: " + firstChild.Text());
break;
case SetMatch.Missing:
row.AddClass(HtmlClasses.FAIL);
var tag = row.FirstChild();
tag.Text("Missing: " + tag.Text());
break;
case SetMatch.OutOfOrder:
row.AddClass(HtmlClasses.FAIL);
string text = "Expected {0} but was {1}".ToFormat(setRow.ExpectedOrder, setRow.ActualOrder);
row.FirstChild().Text(text);
break;
}
row.FirstChild().AddClass("left-cell");
});
if (setRow.Step != null)
{
context.ResultsFor(setRow.Step).ForExceptionText(writeExceptionText);
}
}
public override void Execute(IStep containerStep, ITestContext context)
{
Cell cell = GetCell();
object target = context.CurrentObject;
try
{
object actual = _accessor.GetValue(target);
cell.RecordActual(actual, containerStep, context);
}
catch (Exception e)
{
context.ResultsFor(containerStep).MarkExceptionField(e.ToString(), cell.Key);
context.IncrementExceptions();
}
}
public void Execute(IStep containerStep, ITestContext context)
{
var actualObjects = findTheObjects(containerStep, context);
var actualRows = buildActualRows(actualObjects);
var expectedRows = buildExpectedRows(context, containerStep);
var valueMatcher = new RowValueMatcher(context);
_comparer.Columns.Each(x => x.ConfigureMatcher(valueMatcher));
var matcher = new SetRowMatcher(expectedRows, actualRows, valueMatcher);
IList <SetRow> results = Ordered ? matcher.CompareOrdered() : matcher.Compare();
markCounts(context, results);
context.ResultsFor(containerStep).SetResult(results, _leafName);
}
public void WriteSetVerificationResults(SetVerification verification, ITestContext context)
{
if (verification.Ordered)
{
_headerRow.InsertFirst(new HtmlTag("th").Text("Order"));
}
var results = context.ResultsFor(_step);
results.ForExceptionText(writeExceptionText);
var rows = results.GetResult<IList<SetRow>>(_table.LeafName) ?? new List<SetRow>();
// TODO -- order this the right way
rows.Each(x =>
{
writeVerificationResultRow(x, context, verification.Ordered);
});
}
public void RecordActual(object actual, IStep step, ITestContext context)
{
var results = context.ResultsFor(step);
results.SetActual(_key, actual);
string rawExpected = GetRawExpected(step);
if (rawExpected == null)
{
context.IncrementSyntaxErrors();
results.MarkMissingValue(_key);
return;
}
verifyTheActualValue(step, actual, rawExpected, context);
}
public void WriteResults(ITestContext context)
{
write(new Results(this, context));
var results = context.ResultsFor(_step);
if (results.HasErrors())
{
AddClass(HtmlClasses.EXCEPTION);
Next = new ExceptionTag(results.ExceptionText);
}
else
{
if (_sentence.IsFact)
{
var success = (bool)results.GetActual(_sentence.ResultCell.Key);
var className = success ? HtmlClasses.PASS : HtmlClasses.FAIL;
AddClass(className);
}
}
}
private void writeResultsRow(IStep step, ITestContext context)
{
AddBodyRow(row =>
{
StepResults results = context.ResultsFor(step);
results.Collapse();
_writer.DisplayCells.Each(cell =>
{
var tag = new CellTag(cell, step);
tag.TagName("td");
row.Append(tag);
tag.WriteResults(results, context);
});
row.FirstChild().AddClass("left-cell");
results.ForExceptionText(writeExceptionText);
});
}
private void readArgument(Action <object> continuation, IStep step, ITestContext context)
{
var results = context.ResultsFor(step);
string rawValue = step.Get(_key) ?? _defaultValue;
if (rawValue.IsEmpty())
{
if (IsBooleanResult())
{
step.Set(_key, true);
continuation(true);
return;
}
results.MarkMissingValue(_key);
context.IncrementSyntaxErrors();
return;
}
try
{
object value = context.Finder.FromString(rawValue, _type);
continuation(value);
} // TODO -- eliminate duplication
catch (FormatException)
{
context.IncrementSyntaxErrors();
results.MarkFormatFailure(_key);
}
catch (Exception ex)
{
if (ex.InnerException is FormatException)
{
context.IncrementSyntaxErrors();
results.MarkFormatFailure(_key);
}
}
}
public void WriteSetVerificationResults(SetVerification verification, ITestContext context)
{
if (verification.Ordered)
{
_headerRow.InsertFirst(new HtmlTag("th").Text("Order"));
}
var results = context.ResultsFor(_step);
results.ForExceptionText(writeExceptionText);
var rows = results.GetResult <IList <SetRow> >(_table.LeafName) ?? new List <SetRow>();
// TODO -- order this the right way
rows.Each(x =>
{
writeVerificationResultRow(x, context, verification.Ordered);
});
_headerRow.FirstChild().AddClass("left-cell");
}
public void WriteResults(ITestContext context)
{
write(new Results(this, context));
var results = context.ResultsFor(_step);
if (results.HasErrors())
{
AddClass(HtmlClasses.EXCEPTION);
Next = new ExceptionTag(results.ExceptionText);
}
else
{
if (_sentence.IsFact)
{
var raw = results.GetActual(_sentence.ResultCell.Key);
var success = raw == null ? false : (bool)raw;
var className = success ? HtmlClasses.PASS : HtmlClasses.FAIL;
AddClass(className);
}
}
}
private void writeResultsRow(IStep step, ITestContext context)
{
AddBodyRow(row =>
{
_table.Cells.Each(cell =>
{
StepResults results = context.ResultsFor(step);
var tag = new CellTag(cell, _step);
tag.WriteResults(results, context);
// Ditto this line of code
results.ForExceptionText(writeExceptionText);
row.Cell().Child(tag);
});
});
}
private void writeVerificationResultRow(SetRow setRow, ITestContext context, bool ordered)
{
AddBodyRow(row =>
{
if (ordered)
{
row.Cell(setRow.ActualOrder == 0 ? string.Empty : setRow.ActualOrder.ToString());
}
_table.Cells.Each(cell =>
{
var display = context.GetDisplay(setRow.Values[cell.Key]);
row.Cell(display);
});
switch (setRow.Result)
{
case SetMatch.Match:
row.AddClass(HtmlClasses.PASS);
break;
case SetMatch.Extra:
row.AddClass(HtmlClasses.FAIL);
var firstChild = row.FirstChild();
firstChild.Text("Extra: " + firstChild.Text());
break;
case SetMatch.Missing:
row.AddClass(HtmlClasses.FAIL);
var tag = row.FirstChild();
tag.Text("Missing: " + tag.Text());
break;
case SetMatch.OutOfOrder:
row.AddClass(HtmlClasses.FAIL);
string text = "Expected {0} but was {1}".ToFormat(setRow.ExpectedOrder, setRow.ActualOrder);
row.FirstChild().Text(text);
break;
}
row.FirstChild().AddClass("left-cell");
});
if (setRow.Step != null)
{
context.ResultsFor(setRow.Step).ForExceptionText(writeExceptionText);
}
}
private void writeResultsRow(IStep step, ITestContext context)
{
AddBodyRow(row =>
{
StepResults results = context.ResultsFor(step);
results.Collapse();
_writer.DisplayCells.Each(cell =>
{
var tag = new CellTag(cell, step);
tag.TagName("td");
row.Append(tag);
tag.WriteResults(results, context);
});
row.FirstChild().AddClass("left-cell");
results.ForExceptionText(writeExceptionText);
});
}
public void WriteResults(ITestContext context)
{
context.ResultsFor(_section).ForExceptionText(text => _body.Append(new ExceptionTag(text)));
}
public void ReadActual(ITestContext context, IStep step)
{
ReadArgument(context, step, x => context.ResultsFor(step).SetActual(_key, x));
}
public void WriteResults(ITestContext context)
{
context.ResultsFor(_step).ForExceptionText(text => Child(new ExceptionTag(text)));
}
public void WriteResults(ITestContext context)
{
context.ResultsFor(_step).ForExceptionText(text => Append(new ExceptionTag(text)));
}
public Results(SentenceTag tag, ITestContext context)
{
_tag = tag;
_context = context;
_results = _context.ResultsFor(tag._step);
_step = tag._step;
}
