JUnit4DescriptionGenerator.java

  1. package org.jbehave.core.junit;

  3. import java.lang.annotation.Annotation;
  4. import java.lang.reflect.Method;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.List;
  8. import java.util.function.Function;

  10. import org.jbehave.core.annotations.AfterScenario.Outcome;
  11. import org.jbehave.core.annotations.ScenarioType;
  12. import org.jbehave.core.annotations.Scope;
  13. import org.jbehave.core.configuration.Configuration;
  14. import org.jbehave.core.configuration.Keywords;
  15. import org.jbehave.core.embedder.AllStepCandidates;
  16. import org.jbehave.core.embedder.PerformableTree;
  17. import org.jbehave.core.embedder.PerformableTree.ExamplePerformableScenario;
  18. import org.jbehave.core.embedder.PerformableTree.PerformableScenario;
  19. import org.jbehave.core.embedder.PerformableTree.PerformableStory;
  20. import org.jbehave.core.model.GivenStories;
  21. import org.jbehave.core.model.Lifecycle;
  22. import org.jbehave.core.model.Scenario;
  23. import org.jbehave.core.model.Story;
  24. import org.jbehave.core.steps.BeforeOrAfterStep;
  25. import org.jbehave.core.steps.ConditionalStepCandidate;
  26. import org.jbehave.core.steps.StepCandidate;
  27. import org.jbehave.core.steps.StepType;
  28. import org.junit.runner.Description;

  30. public class JUnit4DescriptionGenerator {

  32.     private final TextManipulator textManipulator = new TextManipulator();

  34.     private final Configuration configuration;
  35.     private final AllStepCandidates allStepCandidates;
  36.     private String previousNonAndStep;
  37.     private int testCases;

  39.     private final JUnit4Test junitTestMeta;

  41.     public JUnit4DescriptionGenerator(AllStepCandidates allStepCandidates, Configuration configuration) {
  42.         this.configuration = configuration;
  43.         this.allStepCandidates = allStepCandidates;
  44.         this.junitTestMeta = new JUnit4Test() {
  45.             @Override
  46.             public Class<? extends Annotation> annotationType() {
  47.                 return JUnit4Test.class;
  48.             }
  49.         };
  50.     }

  52.     public List<Description> createDescriptionsFrom(PerformableTree performableTree) {
  53.         List<Description> storyDescriptions = new ArrayList<>();
  54.         for (PerformableStory performableStory : performableTree.getRoot().getStories()) {
  55.             if (!performableStory.isExcluded()) {
  56.                 Story story = performableStory.getStory();
  57.                 Lifecycle lifecycle = story.getLifecycle();
  58.                 Description storyDescription = createDescriptionForStory(story);
  59.                 addBeforeOrAfterStep(allStepCandidates.getBeforeStorySteps(false), storyDescription,
  60.                         "@BeforeStory: ");
  61.                 addSteps(storyDescription, lifecycle.getBeforeSteps(Scope.STORY));
  62.                 if (story.hasGivenStories()) {
  63.                     insertGivenStories(story.getGivenStories(), storyDescription);
  64.                 }
  65.                 List<PerformableScenario> scenarios = performableStory.getScenarios();
  66.                 for (Description scenarioDescription : getScenarioDescriptions(lifecycle, scenarios)) {
  67.                     storyDescription.addChild(scenarioDescription);
  68.                 }
  69.                 addSteps(storyDescription, lifecycle.getAfterSteps(Scope.STORY, Outcome.ANY));
  70.                 addBeforeOrAfterStep(allStepCandidates.getAfterStorySteps(false), storyDescription,
  71.                         "@AfterStory: ");
  72.                 storyDescriptions.add(storyDescription);
  73.             }
  74.         }
  75.         return storyDescriptions;
  76.     }

  78.     public Description createDescriptionsFrom(Lifecycle lifecycle, PerformableScenario performableScenario) {
  79.         Scenario scenario = performableScenario.getScenario();
  80.         Description scenarioDescription = createDescriptionForScenario(scenario);
  81.         if (performableScenario.hasExamples() && !scenario.getGivenStories().requireParameters()) {
  82.             insertDescriptionForExamples(lifecycle, performableScenario, scenarioDescription);
  83.         } else {
  84.             addScenarioSteps(lifecycle, ScenarioType.NORMAL, scenario, scenarioDescription);
  85.         }
  86.         return scenarioDescription;
  87.     }

  89.     private void addScenarioSteps(Lifecycle lifecycle, ScenarioType scenarioType, Scenario scenario,
  90.             Description scenarioDescription) {
  91.         addBeforeOrAfterScenarioStep(allStepCandidates::getBeforeScenarioSteps, scenarioType, scenarioDescription,
  92.                 "@BeforeScenario: ");
  93.         addSteps(scenarioDescription, lifecycle.getBeforeSteps(Scope.SCENARIO));
  94.         if (scenario.hasGivenStories()) {
  95.             insertGivenStories(scenario.getGivenStories(), scenarioDescription);
  96.         }
  97.         addScenarioSteps(lifecycle, scenarioDescription, scenario);
  98.         addSteps(scenarioDescription, lifecycle.getAfterSteps(Scope.SCENARIO, Outcome.ANY));
  99.         addBeforeOrAfterScenarioStep(allStepCandidates::getAfterScenarioSteps, scenarioType, scenarioDescription,
  100.                 "@AfterScenario: ");
  101.     }

  103.     private void addScenarioSteps(Lifecycle lifecycle, Description scenarioDescription, Scenario scenario) {
  104.         List<String> beforeSteps = lifecycle.getBeforeSteps(Scope.STEP);
  105.         List<String> afterSteps = lifecycle.getAfterSteps(Scope.STEP);
  106.         previousNonAndStep = null;
  107.         String tempPreviousNonAndStep = null;
  108.         for (String scenarioStep : scenario.getSteps()) {
  109.             addSteps(scenarioDescription, beforeSteps);
  110.             previousNonAndStep = tempPreviousNonAndStep;
  111.             addStep(scenarioDescription, scenarioStep);
  112.             tempPreviousNonAndStep = previousNonAndStep;
  113.             addSteps(scenarioDescription, afterSteps);
  114.         }
  115.     }

  117.     private void addBeforeOrAfterScenarioStep(Function<ScenarioType, List<BeforeOrAfterStep>> stepsProvider,
  118.             ScenarioType scenarioType, Description description, String stepName) {
  119.         List<BeforeOrAfterStep> beforeOrAfterSteps = new ArrayList<>();
  120.         beforeOrAfterSteps.addAll(stepsProvider.apply(scenarioType));
  121.         beforeOrAfterSteps.addAll(stepsProvider.apply(ScenarioType.ANY));
  122.         addBeforeOrAfterStep(beforeOrAfterSteps, description, stepName);
  123.     }

  125.     private void addBeforeOrAfterStep(List<BeforeOrAfterStep> beforeOrAfterSteps, Description description,
  126.             String stepPrefix) {
  127.         beforeOrAfterSteps.forEach(steps -> {
  128.             testCases++;
  129.             Method method = steps.getMethod();
  130.             String stepName = uniquify(stepPrefix + steps.getMethod().getName());
  131.             Description testDescription = Description.createTestDescription(method.getDeclaringClass(), stepName,
  132.                     junitTestMeta);
  133.             description.addChild(testDescription);
  134.         });
  135.     }

  137.     public String uniquify(String string) {
  138.         return textManipulator.uniquify(string);
  139.     }

  141.     public int getTestCases() {
  142.         return testCases;
  143.     }

  145.     private void insertGivenStories(GivenStories givenStories, Description parentDescription) {
  146.         for (String path : givenStories.getPaths()) {
  147.             addGivenStory(parentDescription, path);
  148.         }
  149.     }

  151.     private void addGivenStory(Description parentDescription, String path) {
  152.         parentDescription.addChild(Description.createSuiteDescription(uniquify(getFilename(path)), junitTestMeta));
  153.         testCases++;
  154.     }

  156.     private String getFilename(String path) {
  157.         return path.substring(path.lastIndexOf('/') + 1).split("#")[0];
  158.     }

  160.     private void insertDescriptionForExamples(Lifecycle lifecycle, PerformableScenario performableScenario,
  161.             Description scenarioDescription) {
  162.         Scenario scenario = performableScenario.getScenario();
  163.         for (ExamplePerformableScenario examplePerformableScenario : performableScenario.getExamples()) {
  164.             Description exampleRowDescription = Description.createSuiteDescription(
  165.                     configuration.keywords().examplesTableRow() + " " + examplePerformableScenario.getParameters());
  166.             scenarioDescription.addChild(exampleRowDescription);
  167.             addScenarioSteps(lifecycle, ScenarioType.EXAMPLE, scenario, exampleRowDescription);
  168.         }
  169.     }

  171.     private void addSteps(Description description, List<String> steps) {
  172.         previousNonAndStep = null;
  173.         steps.forEach(step -> addStep(description, step));
  174.     }

  176.     private void addStep(Description description, String step) {
  177.         String stringStepOneLine = stripLinebreaks(step);
  178.         StepCandidate matchingStep = findMatchingStep(step);
  179.         if (matchingStep == null) {
  180.             addNonExistingStep(description, stringStepOneLine, step);
  181.         } else {
  182.             addExistingStep(description, stringStepOneLine, matchingStep);
  183.         }
  184.     }

  186.     private void addExistingStep(Description description, String stringStepOneLine, StepCandidate matchingStep) {
  187.         if (matchingStep.isComposite()) {
  188.             addCompositeSteps(description, stringStepOneLine, matchingStep);
  189.         } else if (matchingStep instanceof ConditionalStepCandidate) {
  190.             addConditionalStep(description, stringStepOneLine);
  191.         } else {
  192.             addRegularStep(description, stringStepOneLine, matchingStep);
  193.         }
  194.     }

  196.     private void addNonExistingStep(Description description, String stringStepOneLine, String stepAsString) {
  197.         Keywords keywords = configuration.keywords();
  198.         if (keywords.isIgnorableStep(stepAsString)) {
  199.             if (isStep(keywords.stepWithoutStartingWord(stepAsString, StepType.IGNORABLE))) {
  200.                 addIgnorableStep(description, stringStepOneLine);
  201.             }
  202.         } else {
  203.             addPendingStep(description, stringStepOneLine);
  204.         }
  205.     }

  207.     private boolean isStep(String stepAsString) {
  208.         Keywords keywords = configuration.keywords();
  209.         for (String stepStartingWord : keywords.startingWordsByType().values()) {
  210.             if (keywords.stepStartsWithWord(stepAsString, stepStartingWord)) {
  211.                 return true;
  212.             }
  213.         }
  214.         return false;
  215.     }

  217.     private void addIgnorableStep(Description description, String stringStep) {
  218.         testCases++;
  219.         description.addChild(Description.createSuiteDescription(stringStep));
  220.     }

  222.     private void addPendingStep(Description description, String stringStep) {
  223.         testCases++;
  224.         description.addChild(Description.createSuiteDescription(uniquify("[PENDING] " + stringStep)));
  225.     }

  227.     private void addConditionalStep(Description description, String stringStep) {
  228.         testCases++;
  229.         description.addChild(Description.createSuiteDescription(uniquify(stringStep)));
  230.     }

  232.     private void addRegularStep(Description description, String stringStep, StepCandidate step) {
  233.         testCases++;
  234.         // JUnit and the Eclipse JUnit view needs to be touched/fixed in order to make the JUnit view jump to the
  235.         // corresponding test method accordingly. For now we have to live, that we end up in the correct class.
  236.         description.addChild(Description.createTestDescription(step.getStepsType(), uniquify(stringStep),
  237.                 junitTestMeta));
  238.     }

  240.     private void addCompositeSteps(Description description, String stringStep, StepCandidate step) {
  241.         Description testDescription = Description.createSuiteDescription(uniquify(stringStep), junitTestMeta);
  242.         addSteps(testDescription, Arrays.asList(step.composedSteps()));
  243.         description.addChild(testDescription);
  244.     }

  246.     private List<Description> getScenarioDescriptions(Lifecycle lifecycle,
  247.             List<PerformableScenario> performableScenarios) {
  248.         List<Description> scenarioDescriptions = new ArrayList<>();
  249.         for (PerformableScenario scenario : performableScenarios) {
  250.             if (!scenario.isExcluded()) {
  251.                 scenarioDescriptions.add(createDescriptionsFrom(lifecycle, scenario));
  252.             }
  253.         }
  254.         return scenarioDescriptions;
  255.     }

  257.     private StepCandidate findMatchingStep(String stringStep) {
  258.         for (StepCandidate step : allStepCandidates.getRegularSteps()) {
  259.             if (step.matches(stringStep, previousNonAndStep)) {
  260.                 if (step.getStepType() != StepType.AND) {
  261.                     previousNonAndStep = step.getStartingWord() + " ";
  262.                 }
  263.                 return step;
  264.             }
  265.         }
  266.         return null;
  267.     }

  269.     private String stripLinebreaks(String stringStep) {
  270.         if (stringStep.indexOf('\n') != -1) {
  271.             return stringStep.substring(0, stringStep.indexOf('\n'));
  272.         }
  273.         return stringStep;
  274.     }

  276.     private Description createDescriptionForStory(Story story) {
  277.         return Description.createSuiteDescription(uniquify(story.getName()));
  278.     }

  280.     private Description createDescriptionForScenario(Scenario scenario) {
  281.         return Description.createSuiteDescription(
  282.                 configuration.keywords().scenario() + " " + uniquify(scenario.getTitle()));
  283.     }

  285.     public @interface JUnit4Test {
  286.     }
  287. }
Created with JaCoCo 0.8.10.202304240956