private void addOutlineStepsToReport(ScenarioOutline scenarioOutline) { for (Step step : scenarioOutline.getSteps()) { Map<String, Object> stepMap = new HashMap<String, Object>(); stepMap.put("name", step.getText()); stepMap.put("keyword", step.getKeyword()); if (step.getArgument() != null) { Node argument = step.getArgument(); if (argument instanceof DocString) { stepMap.put("doc_string", createDocStringMap((DocString)argument)); } else if (argument instanceof DataTable) { stepMap.put("rows", createDataTableList((DataTable)argument)); } } jsFunctionCall("step", stepMap); } }
private StepNode processScenarioDefinition(Map<Integer, StepNode> stepMap, StepNode initialPreviousNode, ScenarioDefinition child) { StepNode previousNode = initialPreviousNode; for (Step step : child.getSteps()) { StepNode stepNode = new StepNode(step, previousNode); stepMap.put(step.getLocation().getLine(), stepNode); previousNode = stepNode; } return previousNode; }
private void printScenarioOutline(ScenarioOutline scenarioOutline) { out.println(); printTags(scenarioOutline.getTags(), SCENARIO_INDENT); out.println(SCENARIO_INDENT + getScenarioDefinitionText(scenarioOutline) + " " + getLocationText(currentFeatureFile, scenarioOutline.getLocation().getLine())); printDescription(scenarioOutline.getDescription()); for (Step step : scenarioOutline.getSteps()) { out.println(STEP_INDENT + formats.get("skipped").text(step.getKeyword() + step.getText())); } }
private void addSteps(List<Step> replacementSteps) { for (Step replacementStep : replacementSteps) { addStep(step.getLocation(), replacementStep.getKeyword(), replacementStep.getText(), replacementStep.getArgument()); } }
private PickleStep pickleStep(Step step) { return new PickleStep( step.getText(), createPickleArguments(step.getArgument()), singletonList(pickleStepLocation(step)) ); }
private String getStepKeyword(PickleStepTestStep testStep) { TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testStep.getStepLine()); if (astNode != null) { Step step = (Step) astNode.node; return step.getKeyword(); } else { return ""; } }
private PickleLocation pickleStepLocation(Step step) { return new PickleLocation( step.getLocation().getLine(), step.getLocation().getColumn() + (step.getKeyword() != null ? SymbolCounter.countSymbols(step.getKeyword()) : 0) ); }
/** * Check the step for the need to replace the fragment * * @param step step to check * @param language step's language * @return returns true if the step needs to be replaced with a fragment */ static boolean isStepFragmentRequire(Step step, String language) { String regex = getFragmentStepRegex(language); return Pattern.matches(regex, step.getText()); }
static List<Map<String, String>> getDataTable(Step step) { List<Map<String, String>> dataTableAsListOfMaps = new ArrayList<>(); Node argument = step.getArgument(); if (!(argument instanceof DataTable)) { return dataTableAsListOfMaps; } DataTable dataTable = (DataTable) step.getArgument(); for (int i = FIRST_ROW_INDEX; i < dataTable.getRows().size(); i++) { Map<String, String> dataTableRow = new HashMap<>(); List<TableRow> rows = dataTable.getRows(); for (int j = 0; j < rows.get(HEADER_INDEX).getCells().size(); j++) { String key = rows.get(HEADER_INDEX).getCells().get(j).getValue(); List<TableCell> cells = dataTable.getRows().get(i).getCells(); String value = cells.get(j).getValue(); dataTableRow.put(key, value); } dataTableAsListOfMaps.add(dataTableRow); } return dataTableAsListOfMaps; }
private void addStep(Location location, String keyword, String text, Node argument) { Step replacedStep = new Step(location, keyword, text, argument); replacedSteps.add(replacedStep); } }
private Step concreteStep(Step abstractStep, Map<String, String> parameters) { String text = abstractStep.getText(); for (Entry<String, String> entry : parameters.entrySet()) { String target = String.format("<%s>", entry.getKey()); String replacement = entry.getValue(); text = text.replace(target, replacement); } return new Step( abstractStep.getLocation(), abstractStep.getKeyword(), text, abstractStep.getArgument()); } }
String stepText = interpolate(scenarioOutlineStep.getText(), variableCells, valueCells); createPickleArguments(scenarioOutlineStep.getArgument(), variableCells, valueCells), asList( pickleLocation(values.getLocation()),
private void setTableScenarioOutline() { List<Step> steps = currentScenarioDefinition.getSteps(); StringBuffer scenarioOutlineBuffer = new StringBuffer(); for (Step step : steps) { scenarioOutlineBuffer.append(step.getKeyword()).append(step.getText()).append("\n\r"); } String scenarioOutline = scenarioOutlineBuffer.toString(); if (table != null) { table.setScenarioOutline(scenarioOutline); } }
private Map<String, Object> createTestStep(PickleStepTestStep testStep) { Map<String, Object> stepMap = new HashMap<String, Object>(); stepMap.put("name", testStep.getStepText()); if (!testStep.getStepArgument().isEmpty()) { Argument argument = testStep.getStepArgument().get(0); if (argument instanceof PickleString) { stepMap.put("doc_string", createDocStringMap((PickleString)argument)); } else if (argument instanceof PickleTable) { stepMap.put("rows", createDataTableList((PickleTable)argument)); } } TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testStep.getStepLine()); if (astNode != null) { Step step = (Step) astNode.node; stepMap.put("keyword", step.getKeyword()); } return stepMap; }
/** * Find the name of the scenario (fragment) to substitute for this step * * @param step step to substitute * @param language step's language * @return name of the scenario (fragment) to substitute */ static String getFragmentName(Step step, String language) { String regex = getFragmentStepRegex(language); Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(step.getText()); matcher.find(); return matcher.group(1); }
static DataTable applyToArgument(Map<String, String> dataTableAsMap, Step fragmentStep) { DataTable dataTable = (DataTable) fragmentStep.getArgument(); List<TableRow> resultTableRows = new ArrayList<>(); for (TableRow row : dataTable.getRows()) { List<TableCell> resultCells = new ArrayList<>(); for (TableCell cell : row.getCells()) { TableCell resultCell = new TableCell(cell.getLocation(), applyToText(dataTableAsMap, cell.getValue())); resultCells.add(resultCell); } resultTableRows.add(new TableRow(row.getLocation(), resultCells)); } return new DataTable(resultTableRows); } }
stepArg = node.getSingle(RuleType.DocString, null); return new Step(getLocation(stepLine, 0), stepLine.matchedKeyword, stepLine.matchedText, stepArg);
public static String step(Step step) { return step.getKeyword() + withEscapedParameterFields(step.getText()) + " " + renderedArgument(step.getArgument()); }
List<Step> replaceWith(List<Step> replacementSteps) { List<Map<String, String>> dataTable = FragmentDataTableUtils.getDataTable(step); if (dataTable.isEmpty()) { addSteps(replacementSteps); return replacedSteps; } for (Map<String, String> dataTableRow : dataTable) { for (Step replacementStep : replacementSteps) { String text = FragmentDataTableUtils.applyToText(dataTableRow, replacementStep.getText()); DataTable argument = null; if (replacementStep.getArgument() != null) { argument = FragmentDataTableUtils.applyToArgument(dataTableRow, replacementStep); } addStep(step.getLocation(), replacementStep.getKeyword(), text, argument); } } return replacedSteps; }
public void replaceDataPlaceholders(List<CucumberFeature> cucumberFeatures) throws DataException, IllegalAccessException { for (CucumberFeature cucumberFeature : cucumberFeatures) { featureDataTagValue = "$" + Props.get("data.initial.collection"); GherkinDocument gherkinDocument = cucumberFeature.getGherkinFeature(); Feature feature = gherkinDocument.getFeature(); setFeatureDataTag(parseTags(feature.getTags())); List<ScenarioDefinition> featureChildren = feature.getChildren(); for (ScenarioDefinition scenarioDefinition : featureChildren) { List<Tag> currentScenarioTags = getScenarioTags(scenarioDefinition); setCurrentScenarioTag(parseTags(currentScenarioTags)); List<Step> steps = scenarioDefinition.getSteps(); if (scenarioDefinition instanceof ScenarioOutline) { List<Examples> examples = ((ScenarioOutline) scenarioDefinition).getExamples(); FieldUtils.writeField(scenarioDefinition, "examples", replaceExamplesPlaceholders(examples), true); } for (Step step : steps) { FieldUtils.writeField(step, "argument", replaceArgumentPlaceholders(step.getArgument()), true); FieldUtils.writeField(step, "text", replaceDataPlaceholders(step.getText()), true); } } } }