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) { // 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); }); }); }
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))); }