gherkin.ast.Step Java Examples

private synchronized void createTestStep(PickleStepTestStep testStep) {
    String stepName = testStep.getStepText();
    TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile.get(), testStep.getStepLine());
    if (astNode != null) {
        Step step = (Step) astNode.node;
        try {
            String name = stepName == null || stepName.isEmpty() 
                    ? step.getText().replace("<", "&lt;").replace(">", "&gt;")
                    : stepName;
            ExtentTest t = scenarioThreadLocal.get()
                    .createNode(new GherkinKeyword(step.getKeyword().trim()), step.getKeyword() + name, testStep.getCodeLocation());
            stepTestThreadLocal.set(t);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    if (!testStep.getStepArgument().isEmpty()) {
        Argument argument = testStep.getStepArgument().get(0);
        if (argument instanceof PickleString) {
            createDocStringMap((PickleString)argument);
        } else if (argument instanceof PickleTable) {
            List<PickleRow> rows = ((PickleTable) argument).getRows();
            stepTestThreadLocal.get().pass(MarkupHelper.createTable(getPickleTable(rows)).getMarkup());
        }
    }
}
 

private void createTestCases(Scenario scenario, Feature feature) {
    for (ScenarioDefinition scenarioDef : feature.getChildren()) {
        String scenDefName = scenarioDef.getName();
        TestCase testCase = updateInfo(createTestCase(scenario, scenDefName), scenarioDef);
        testCase.clearSteps();
        for (Step step : scenarioDef.getSteps()) {
            String reusableName = convert(step.getText());
            TestCase reusable = updateInfo(createReusable(create("StepDefinitions"), reusableName), step);
            if (reusable != null) {
                reusable.addNewStep()
                        .setInput(getInputField(testCase.getName(), step.getText()))
                        .setDescription(getDescription(step));
            }
            testCase.addNewStep()
                    .asReusableStep("StepDefinitions", reusableName)
                    .setDescription(getDescription(step));
        }
        if (scenarioDef instanceof ScenarioOutline) {
            ScenarioOutline scOutline = (ScenarioOutline) scenarioDef;
            createTestData(testCase, scOutline.getExamples());
        }
    }
}
 

private TestCase updateInfo(TestCase tc, Step step) {
    if (tc != null) {
        DataItem tcInfo = pModel().getData().find(tc.getName(), tc.getScenario().getName())
                .orElseGet(() -> {
                    DataItem di = DataItem.createTestCase(tc.getName(), tc.getScenario().getName());
                    pModel().addData(di);
                    return di;
                });

        tcInfo.getAttributes().update(Attribute.create("feature.children.step.line", step.getLocation().getLine()));
        tcInfo.getAttributes().update(Attribute.create("feature.children.step.text", step.getText()));
        tcInfo.getAttributes().update(Attribute.create("feature.children.step.argument", step.getArgument()));
        tcInfo.getAttributes().update(Attribute.create("feature.children.step.keyword", step.getKeyword()));
        pModel().addData(tcInfo);
    }
    return tc;
}
 

@Override
public void stepFailed(Step s, Throwable t) {
    // The additional " " is expected
    if (!"When ".equals(s.getKeyword())) {
        if (CommandLineOptions.hasOption("error")) {
            StringWriter errors = new StringWriter();
            t.printStackTrace(new PrintWriter(errors));
            reporter.report("    Step " + s.getText() + " " + Style.red("failed") + ":\n"
                    + errors.toString());
        }
        else {
            reporter.report("    Step " + s.getText() + " " + Style.red("failed")
                    + ":    \n" + t.getMessage());
        }
    }
}
 

private void processScenarioDefinition(Map<Integer, AstNode> nodeMap, ScenarioDefinition child, AstNode currentParent) {
    AstNode childNode = new AstNode(child, currentParent);
    nodeMap.put(child.getLocation().getLine(), childNode);
    for (Step step : child.getSteps()) {
        nodeMap.put(step.getLocation().getLine(), new AstNode(step, childNode));
    }
    if (child instanceof ScenarioOutline) {
        processScenarioOutlineExamples(nodeMap, (ScenarioOutline) child, childNode);
    }
}
 

private synchronized void addOutlineStepsToReport(ScenarioOutline scenarioOutline) {
    for (Step step : scenarioOutline.getSteps()) {
        if (step.getArgument() != null) {
            Node argument = step.getArgument();
            if (argument instanceof DocString) {
                createDocStringMap((DocString)argument);
            } else if (argument instanceof DataTable) {
                
            }
        }
    }
}
 

private void processScenarioDefinition(final Map<Integer, AstNode> nodeMap, final ScenarioDefinition child,
                                       final AstNode currentParent) {
    final AstNode childNode = new AstNode(child, currentParent);
    nodeMap.put(child.getLocation().getLine(), childNode);
    for (Step step : child.getSteps()) {
        nodeMap.put(step.getLocation().getLine(), createAstNode(step, childNode));
    }
    if (child instanceof ScenarioOutline) {
        processScenarioOutlineExamples(nodeMap, (ScenarioOutline) child, childNode);
    }
}
 

private String getDescription(Step step) {
    if (step.getArgument() != null && step.getArgument() instanceof DocString) {
        return ((DocString) step.getArgument()).getContent();
    }
    return step.getKeyword() + " " + step.getText();
}
 

@Override
public void stepCompleted(Step s) {
}
 

@Override
public void stepStarting(Step s) {
}