StepCandidate.java

  1. package org.jbehave.core.steps;

  3. import static java.text.MessageFormat.format;

  5. import java.lang.reflect.Method;
  6. import java.util.ArrayList;
  7. import java.util.HashMap;
  8. import java.util.List;
  9. import java.util.Map;

  11. import com.thoughtworks.paranamer.Paranamer;

  13. import org.apache.commons.lang3.StringUtils;
  14. import org.jbehave.core.annotations.AfterScenario.Outcome;
  15. import org.jbehave.core.annotations.Given;
  16. import org.jbehave.core.annotations.Pending;
  17. import org.jbehave.core.annotations.Then;
  18. import org.jbehave.core.annotations.When;
  19. import org.jbehave.core.configuration.Keywords;
  20. import org.jbehave.core.configuration.Keywords.StartingWordNotFound;
  21. import org.jbehave.core.parsers.StepMatcher;

  23. /**
  24.  * A StepCandidate is associated to a Java method annotated with {@link Given},
  25.  * {@link When}, {@link Then} in a steps instance class. The StepCandidate is
  26.  * responsible for matching the textual step against the pattern contained in
  27.  * the method annotation via the {@link StepMatcher} and for the creation of the
  28.  * matched executable step via the {@link StepCreator}.  The name of a StepCandidate
  29.  * is the combination of its starting word and its pattern.
  30.  */
  31. public class StepCandidate {

  33.     public static final String NAME_FORMAT = "{0} {1}";
  34.     private final String patternAsString;
  35.     private final Integer priority;
  36.     private final StepType stepType;
  37.     private final Method method;
  38.     private final Class<?> stepsType;
  39.     private final InjectableStepsFactory stepsFactory;
  40.     private final Keywords keywords;
  41.     private final StepMatcher stepMatcher;
  42.     private final StepCreator stepCreator;
  43.     private final String parameterPrefix;
  44.     private final String[] composedSteps;
  45.     private StepMonitor stepMonitor;

  47.     public StepCandidate(String patternAsString, int priority, StepType stepType, Method method, Class<?> stepsType,
  48.             InjectableStepsFactory stepsFactory, Keywords keywords, StepMatcher stepMatcher,
  49.             String parameterPrefixString, StepCreator stepCreator, String[] steps, StepMonitor stepMonitor) {
  50.         this.patternAsString = patternAsString;
  51.         this.priority = priority;
  52.         this.stepType = stepType;
  53.         this.method = method;
  54.         this.stepsType = stepsType;
  55.         this.stepsFactory = stepsFactory;
  56.         this.keywords = keywords;
  57.         this.stepMatcher = stepMatcher;
  58.         this.stepCreator = stepCreator;
  59.         this.parameterPrefix = parameterPrefixString;
  60.         this.composedSteps = steps;
  61.         this.stepMonitor = stepMonitor;
  62.     }

  64.     public Method getMethod() {
  65.         return method;
  66.     }

  68.     public String getName() {
  69.         return format(NAME_FORMAT, getStartingWord(), getPatternAsString());
  70.     }

  72.     public Integer getPriority() {
  73.         return priority;
  74.     }

  76.     public String getPatternAsString() {
  77.         return patternAsString;
  78.     }

  80.     public Object getStepsInstance() {
  81.         return stepsFactory != null ? stepsFactory.createInstanceOfType(stepsType) : null;
  82.     }

  84.     public Class<?> getStepsType() {
  85.         return stepsType;
  86.     }

  88.     public StepType getStepType() {
  89.         return stepType;
  90.     }

  92.     public String getStartingWord() {
  93.         return keywords.startingWordFor(stepType);
  94.     }

  96.     public String getParameterPrefix() {
  97.         return parameterPrefix;
  98.     }

  100.     public void useStepMonitor(StepMonitor stepMonitor) {
  101.         this.stepMonitor = stepMonitor;
  102.         this.stepCreator.useStepMonitor(stepMonitor);
  103.     }

  105.     public void useParanamer(Paranamer paranamer) {
  106.         this.stepCreator.useParanamer(paranamer);
  107.     }

  109.     public boolean isComposite() {
  110.         return composedSteps != null && composedSteps.length > 0;
  111.     }

  113.     public String[] composedSteps() {
  114.         return composedSteps;
  115.     }

  117.     public boolean ignore(String stepAsString) {
  118.         try {
  119.             String ignoreWord = keywords.startingWordFor(StepType.IGNORABLE);
  120.             return isIgnoredStep(stepAsString, ignoreWord);
  121.         } catch (StartingWordNotFound e) {
  122.             return false;
  123.         }
  124.     }

  126.     public boolean comment(String stepAsString) {
  127.         try {
  128.             String ignoreWord = keywords.startingWordFor(StepType.IGNORABLE);
  129.             return keywords.stepStartsWithWord(stepAsString, ignoreWord) && !isIgnoredStep(stepAsString, ignoreWord);
  130.         } catch (StartingWordNotFound e) {
  131.             return false;
  132.         }
  133.     }

  135.     private boolean isIgnoredStep(String stepAsString, String ignoreWord) {
  136.         for (Map.Entry<StepType, String> stepStartingWord : keywords.startingWordsByType().entrySet()) {
  137.             if (stepStartingWord.getKey() != StepType.IGNORABLE) {
  138.                 if (keywords.stepStartsWithWords(stepAsString, ignoreWord, stepStartingWord.getValue())) {
  139.                     return true;
  140.                 }
  141.             }
  142.         }
  143.         return false;
  144.     }

  146.     public boolean isPending() {
  147.         return method != null && method.isAnnotationPresent(Pending.class);
  148.     }

  150.     public boolean matches(String stepAsString) {
  151.         return matches(stepAsString, null);
  152.     }

  154.     public boolean matches(String step, String previousNonAndStep) {
  155.         try {
  156.             boolean matchesType = true;
  157.             if (keywords.isAndStep(step)) {
  158.                 if (previousNonAndStep == null) {
  159.                     // cannot handle AND step with no previous step
  160.                     matchesType = false;
  161.                 } else {
  162.                     // previous step type should match candidate step type
  163.                     matchesType = stepType == keywords.stepTypeFor(previousNonAndStep);
  164.                 }
  165.             }
  166.             stepMonitor.stepMatchesType(step, previousNonAndStep, matchesType, stepType, method, stepsType);
  167.             boolean matchesPattern = stepMatcher.matcher(stripStartingWord(step)).matches();
  168.             stepMonitor.stepMatchesPattern(step, matchesPattern, stepMatcher.pattern(), method, stepsType);
  169.             // must match both type and pattern
  170.             return matchesType && matchesPattern;
  171.         } catch (StartingWordNotFound e) {
  172.             return false;
  173.         }
  174.     }

  176.     public Step createMatchedStep(String stepAsString, Map<String, String> namedParameters, List<Step> composedSteps) {
  177.         return stepCreator.createParametrisedStep(method, stepAsString, stripStartingWord(stepAsString),
  178.                 namedParameters, composedSteps);
  179.     }

  181.     public Step createMatchedStepUponOutcome(String stepAsString, Map<String, String> namedParameters,
  182.             List<Step> composedSteps, Outcome outcome) {
  183.         return stepCreator.createParametrisedStepUponOutcome(method, stepAsString, stripStartingWord(stepAsString),
  184.                 namedParameters, composedSteps, outcome);
  185.     }

  187.     public void addComposedSteps(List<Step> steps, String stepAsString, Map<String, String> namedParameters,
  188.             List<StepCandidate> allCandidates) {
  189.         Map<String, String> matchedParameters = stepCreator.matchedParameters(method,
  190.                 keywords.stepWithoutStartingWord(stepAsString), namedParameters);

  192.         Map<String, String> mergedParameters = new HashMap<>(namedParameters);
  193.         mergedParameters.putAll(matchedParameters);

  195.         String previousNonAndStep = null;
  196.         for (String composedStep : composedSteps) {
  197.             addComposedStep(steps, composedStep, previousNonAndStep, mergedParameters, allCandidates);
  198.             if (!(keywords.isAndStep(composedStep) || keywords.isIgnorableStep(composedStep))) {
  199.                 // only update previous step if not AND or IGNORABLE step
  200.                 previousNonAndStep = composedStep;
  201.             }
  202.         }
  203.     }

  205.     private void addComposedStep(List<Step> steps, String composedStep, String previousNonAndStep,
  206.             Map<String, String> matchedParameters, List<StepCandidate> allCandidates) {
  207.         if (ignore(composedStep)) {
  208.             // ignorable steps are added so they can be reported
  209.             steps.add(StepCreator.createIgnorableStep(composedStep));
  210.         } else if (comment(composedStep)) {
  211.             // comments are added so they can be reported
  212.             steps.add(StepCreator.createComment(composedStep));
  213.         } else {
  214.             StepCandidate candidate = findComposedCandidate(composedStep, previousNonAndStep, allCandidates);
  215.             if (candidate != null) {
  216.                 List<Step> composedSteps = new ArrayList<>();
  217.                 if (candidate.isComposite()) {
  218.                     // candidate is itself composite: recursively add composed steps
  219.                     candidate.addComposedSteps(composedSteps, composedStep, matchedParameters, allCandidates);
  220.                 }
  221.                 steps.add(candidate.createMatchedStep(composedStep, matchedParameters, composedSteps));
  222.             } else {
  223.                 steps.add(StepCreator.createPendingStep(composedStep, previousNonAndStep));
  224.             }
  225.         }
  226.     }

  228.     private StepCandidate findComposedCandidate(String composedStep, String previousNonAndStep,
  229.             List<StepCandidate> allCandidates) {
  230.         StepType stepType;
  231.         if (keywords.isAndStep(composedStep)) {
  232.             if (previousNonAndStep != null) {
  233.                 stepType = keywords.stepTypeFor(previousNonAndStep);
  234.             } else {
  235.                 // cannot handle AND step with no previous step
  236.                 return null;
  237.             }
  238.         } else {
  239.             stepType = keywords.stepTypeFor(composedStep);
  240.         }
  241.         for (StepCandidate candidate : allCandidates) {
  242.             if (stepType == candidate.getStepType() && (StringUtils.endsWith(composedStep,
  243.                     candidate.getPatternAsString()) || candidate.matches(composedStep, previousNonAndStep))) {
  244.                 return candidate;
  245.             }
  246.         }
  247.         return null;
  248.     }

  250.     protected String stripStartingWord(String stepAsString) {
  251.         return keywords.stepWithoutStartingWord(stepAsString, stepType);
  252.     }

  254.     protected StepCreator getStepCreator() {
  255.         return stepCreator;
  256.     }

  258.     protected Keywords getKeywords() {
  259.         return keywords;
  260.     }

  262.     protected StepMatcher getStepMatcher() {
  263.         return stepMatcher;
  264.     }

  266.     protected StepMonitor getStepMonitor() {
  267.         return stepMonitor;
  268.     }

  270.     @Override
  271.     public String toString() {
  272.         return stepType + " " + patternAsString;
  273.     }

  275. }
Created with JaCoCo 0.8.10.202304240956