StepCreator.java

  1. package org.jbehave.core.steps;

  3. import static java.util.Arrays.asList;
  4. import static org.jbehave.core.steps.AbstractStepResult.comment;
  5. import static org.jbehave.core.steps.AbstractStepResult.failed;
  6. import static org.jbehave.core.steps.AbstractStepResult.ignorable;
  7. import static org.jbehave.core.steps.AbstractStepResult.notPerformed;
  8. import static org.jbehave.core.steps.AbstractStepResult.pending;
  9. import static org.jbehave.core.steps.AbstractStepResult.skipped;
  10. import static org.jbehave.core.steps.AbstractStepResult.successful;
  11. import static org.jbehave.core.steps.ParameterConverters.ExamplesTableParametersConverter.isExamplesTableParameters;

  13. import java.lang.annotation.Annotation;
  14. import java.lang.reflect.AccessibleObject;
  15. import java.lang.reflect.InvocationTargetException;
  16. import java.lang.reflect.Method;
  17. import java.lang.reflect.Type;
  18. import java.util.ArrayList;
  19. import java.util.Collections;
  20. import java.util.HashMap;
  21. import java.util.List;
  22. import java.util.Map;
  23. import java.util.Map.Entry;
  24. import java.util.Optional;
  25. import java.util.function.Function;
  26. import java.util.regex.Matcher;
  27. import java.util.regex.Pattern;
  28. import java.util.stream.Collectors;
  29. import java.util.stream.Stream;

  31. import com.thoughtworks.paranamer.NullParanamer;
  32. import com.thoughtworks.paranamer.Paranamer;

  34. import org.apache.commons.lang3.builder.ToStringBuilder;
  35. import org.apache.commons.lang3.builder.ToStringStyle;
  36. import org.jbehave.core.annotations.AfterScenario.Outcome;
  37. import org.jbehave.core.annotations.Conditional;
  38. import org.jbehave.core.annotations.FromContext;
  39. import org.jbehave.core.annotations.Named;
  40. import org.jbehave.core.annotations.ToContext;
  41. import org.jbehave.core.condition.StepConditionMatchException;
  42. import org.jbehave.core.condition.StepConditionMatcher;
  43. import org.jbehave.core.configuration.Keywords;
  44. import org.jbehave.core.expressions.ExpressionResolver;
  45. import org.jbehave.core.failures.BeforeOrAfterFailed;
  46. import org.jbehave.core.failures.IgnoringStepsFailure;
  47. import org.jbehave.core.failures.RestartingScenarioFailure;
  48. import org.jbehave.core.failures.UUIDExceptionWrapper;
  49. import org.jbehave.core.model.ExamplesTable;
  50. import org.jbehave.core.model.Meta;
  51. import org.jbehave.core.model.Verbatim;
  52. import org.jbehave.core.parsers.StepMatcher;
  53. import org.jbehave.core.reporters.StoryReporter;
  54. import org.jbehave.core.steps.ParameterConverters.FromStringParameterConverter;
  55. import org.jbehave.core.steps.context.StepsContext;

  57. @SuppressWarnings("checkstyle:AvoidEscapedUnicodeCharacters")
  58. public class StepCreator {

  60.     public static final String PARAMETER_TABLE_START = "\uff3b";
  61.     public static final String PARAMETER_TABLE_END = "\uff3d";
  62.     public static final String PARAMETER_VERBATIM_START = "\u301a";
  63.     public static final String PARAMETER_VERBATIM_END = "\u301b";
  64.     public static final String PARAMETER_VALUE_START = "\uFF5F";
  65.     public static final String PARAMETER_VALUE_END = "\uFF60";
  66.     public static final String PARAMETER_VALUE_NEWLINE = "\u2424";
  67.     public static final UUIDExceptionWrapper NO_FAILURE = new UUIDExceptionWrapper("no failure");
  68.     private static final String NEWLINE = "\n";
  69.     private static final String SPACE = " ";
  70.     private static final String NONE = "";
  71.     private final Class<?> stepsType;
  72.     private final InjectableStepsFactory stepsFactory;
  73.     private final ParameterConverters parameterConverters;
  74.     private final ExpressionResolver expressionResolver;
  75.     private final ParameterControls parameterControls;
  76.     private final Pattern delimitedNamePattern;
  77.     private final StepMatcher stepMatcher;
  78.     private final StepsContext stepsContext;
  79.     private final boolean dryRun;
  80.     private StepMonitor stepMonitor;
  81.     private Paranamer paranamer = new NullParanamer();

  83.     public StepCreator(Class<?> stepsType, InjectableStepsFactory stepsFactory, StepsContext stepsContext,
  84.             ParameterConverters parameterConverters, ExpressionResolver expressionResolver,
  85.             ParameterControls parameterControls, StepMatcher stepMatcher, StepMonitor stepMonitor, boolean dryRun) {
  86.         this.stepsType = stepsType;
  87.         this.stepsFactory = stepsFactory;
  88.         this.stepsContext = stepsContext;
  89.         this.parameterConverters = parameterConverters;
  90.         this.expressionResolver = expressionResolver;
  91.         this.parameterControls = parameterControls;
  92.         this.stepMatcher = stepMatcher;
  93.         this.stepMonitor = stepMonitor;
  94.         this.delimitedNamePattern = Pattern.compile(parameterControls.nameDelimiterLeft() + "([\\w\\-\\h.]+?)"
  95.                 + parameterControls.nameDelimiterRight(), Pattern.DOTALL);
  96.         this.dryRun = dryRun;
  97.     }

  99.     public void useStepMonitor(StepMonitor stepMonitor) {
  100.         this.stepMonitor = stepMonitor;
  101.     }

  103.     public void useParanamer(Paranamer paranamer) {
  104.         this.paranamer = paranamer;
  105.     }

  107.     public Object stepsInstance() {
  108.         return stepsFactory.createInstanceOfType(stepsType);
  109.     }

  111.     public Step createBeforeOrAfterStep(Method method, Meta meta) {
  112.         return new BeforeOrAfterStep(method, meta);
  113.     }

  115.     public Step createAfterStepUponOutcome(final Method method, final Outcome outcome, Meta storyAndScenarioMeta) {
  116.         Step beforeOrAfterStep = createBeforeOrAfterStep(method, storyAndScenarioMeta);
  117.         return wrapStepUponOutcome(outcome, beforeOrAfterStep);
  118.     }

  120.     public Map<String, String> matchedParameters(final Method method, final String stepWithoutStartingWord,
  121.             final Map<String, String> namedParameters) {
  122.         Map<String, String> matchedParameters = new HashMap<>();
  123.         Matcher matcher = stepMatcher.matcher(stepWithoutStartingWord);
  124.         if (matcher.find()) {
  125.             // we've found a match, populate map
  126.             ParameterName[] parameterNames = parameterNames(method);
  127.             Type[] types = parameterTypes(method, parameterNames);

  129.             String[] values = parameterValuesForStep(matcher, namedParameters, types, parameterNames, false);
  130.             for (int i = 0; i < parameterNames.length; i++) {
  131.                 String name = parameterNames[i].name;
  132.                 if (name == null) {
  133.                     name = stepMatcher.parameterNames()[i];
  134.                 }
  135.                 matchedParameters.put(name, values[i]);
  136.             }
  137.         }
  138.         // else return empty map
  139.         return matchedParameters; 
  140.     }

  142.     /**
  143.      * Returns the {@link ParameterName} representations for the method,
  144.      * providing an abstraction that supports both annotated and non-annotated
  145.      * parameters.
  146.      * 
  147.      * @param method the Method
  148.      * @return The array of {@link ParameterName}s
  149.      */
  150.     private ParameterName[] parameterNames(Method method) {
  151.         ParameterName[] parameterNames;
  152.         if (method != null) {
  153.             String[] annotatedNames = annotatedParameterNames(method);
  154.             String[] paranamerNames = paranamerParameterNames(method);
  155.             String[] contextNames = contextParameterNames(method);

  157.             parameterNames = new ParameterName[annotatedNames.length];
  158.             for (int i = 0; i < annotatedNames.length; i++) {
  159.                 parameterNames[i] = parameterName(annotatedNames, paranamerNames, contextNames, i);
  160.             }
  161.         } else {
  162.             String[] stepMatcherParameterNames = stepMatcher.parameterNames();
  163.             parameterNames = new ParameterName[stepMatcherParameterNames.length];
  164.             for (int i = 0; i < stepMatcherParameterNames.length; i++) {
  165.                 parameterNames[i] = new ParameterName(stepMatcherParameterNames[i], false, false);
  166.             }
  167.         }
  168.         return parameterNames;
  169.     }

  171.     private ParameterName parameterName(String[] annotatedNames, String[] paranamerNames, String[] contextNames,
  172.             int i) {
  173.         boolean annotated = true;
  174.         boolean fromContext = false;

  176.         String name = contextNames[i];
  177.         if (name != null) {
  178.             fromContext = true;
  179.         } else {
  180.             name = annotatedNames[i];
  181.             if (name == null) {
  182.                 name = (paranamerNames.length > i ? paranamerNames[i] : null);
  183.                 annotated = false;
  184.             }
  185.         }
  186.         return new ParameterName(name, annotated, fromContext);
  187.     }

  189.     /**
  190.      * Extract parameter names using {@link Named}-annotated parameters
  191.      * 
  192.      * @param method the Method with {@link Named}-annotated parameters
  193.      * @return An array of annotated parameter names, which <b>may</b> include
  194.      *         <code>null</code> values for parameters that are not annotated
  195.      */
  196.     private String[] annotatedParameterNames(Method method) {
  197.         Annotation[][] parameterAnnotations = method.getParameterAnnotations();
  198.         String[] names = new String[parameterAnnotations.length];
  199.         for (int i = 0; i < parameterAnnotations.length; i++) {
  200.             for (Annotation annotation : parameterAnnotations[i]) {
  201.                 names[i] = annotationName(annotation);
  202.             }
  203.         }
  204.         return names;
  205.     }
  206.     
  207.     /**
  208.      * Extract parameter names using {@link FromContext}-annotated parameters
  209.      * 
  210.      * @param method the Method with {@link FromContext}-annotated parameters
  211.      * @return An array of annotated parameter names, which <b>may</b> include
  212.      *         <code>null</code> values for parameters that are not annotated
  213.      */
  214.     private String[] contextParameterNames(Method method) {
  215.         Annotation[][] parameterAnnotations = method.getParameterAnnotations();
  216.         String[] names = new String[parameterAnnotations.length];
  217.         for (int i = 0; i < parameterAnnotations.length; i++) {
  218.             for (Annotation annotation : parameterAnnotations[i]) {
  219.                 names[i] = contextName(annotation);
  220.             }
  221.         }
  222.         return names;
  223.     }

  225.     /**
  226.      * Returns either the value of the annotation, either {@link Named} or
  227.      * "javax.inject.Named".
  228.      * 
  229.      * @param annotation the Annotation
  230.      * @return The annotated value or <code>null</code> if no annotation is
  231.      *         found
  232.      */
  233.     private String annotationName(Annotation annotation) {
  234.         if (annotation.annotationType().isAssignableFrom(Named.class)) {
  235.             return ((Named) annotation).value();
  236.         } else if ("javax.inject.Named".equals(annotation.annotationType().getName())) {
  237.             return Jsr330Helper.getNamedValue(annotation);
  238.         } else {
  239.             return null;
  240.         }
  241.     }

  243.     /**
  244.      * Returns the value of the annotation {@link FromContext}.
  245.      * 
  246.      * @param annotation the Annotation
  247.      * @return The annotated value or <code>null</code> if no annotation is
  248.      *         found
  249.      */
  250.     private String contextName(Annotation annotation) {
  251.         if (annotation.annotationType().isAssignableFrom(FromContext.class)) {
  252.             return ((FromContext) annotation).value();
  253.         } else {
  254.             return null;
  255.         }
  256.     }

  258.     /**
  259.      * Extract parameter names using
  260.      * {@link Paranamer#lookupParameterNames(AccessibleObject, boolean)}
  261.      * 
  262.      * @param method the Method inspected by Paranamer
  263.      * @return An array of parameter names looked up by Paranamer
  264.      */
  265.     private String[] paranamerParameterNames(Method method) {
  266.         return paranamer.lookupParameterNames(method, false);
  267.     }

  269.     private Type[] parameterTypes(Method method, ParameterName[] parameterNames) {
  270.         if (method != null) {
  271.             return method.getGenericParameterTypes();
  272.         }
  273.         Type[] types = new Type[parameterNames.length];
  274.         for (int i = 0; i < types.length; i++) {
  275.             types[i] = String.class;
  276.         }
  277.         return types;
  278.     }

  280.     public Step createConditionalStep(final StepConditionMatcher stepConditionMatcher,
  281.             final Map<Method, ParametrisedStep> parametrisedSteps) {
  282.         return new ConditionalStep(stepConditionMatcher, parametrisedSteps);
  283.     }

  285.     public Step createParametrisedStep(final Method method, final String stepAsString,
  286.             final String stepWithoutStartingWord, final Map<String, String> namedParameters,
  287.             final List<Step> composedSteps) {
  288.         return new ParametrisedStep(stepAsString, method, stepWithoutStartingWord, namedParameters, composedSteps);
  289.     }

  291.     public Step createParametrisedStepUponOutcome(final Method method, final String stepAsString,
  292.             final String stepWithoutStartingWord, final Map<String, String> namedParameters,
  293.             final List<Step> composedSteps, Outcome outcome) {
  294.         Step parametrisedStep = createParametrisedStep(method, stepAsString, stepWithoutStartingWord, namedParameters,
  295.                 composedSteps);
  296.         return wrapStepUponOutcome(outcome, parametrisedStep);
  297.     }

  299.     private Step wrapStepUponOutcome(Outcome outcome, Step step) {
  300.         switch (outcome) {
  301.             case ANY:
  302.                 return new UponAnyStep(step);
  303.             case SUCCESS:
  304.                 return new UponSuccessStep(step);
  305.             case FAILURE:
  306.                 return new UponFailureStep(step);
  307.             default:
  308.                 return step;
  309.         }
  310.     }

  312.     private String parametrisedStep(String stepAsString, Map<String, String> namedParameters, Type[] types,
  313.             String[] parameterValues) {
  314.         String parametrisedStep = stepAsString;
  315.         // mark parameter values that are parsed
  316.         boolean hasTable = hasTable(types);
  317.         for (int position = 0; position < types.length; position++) {
  318.             parametrisedStep = markParsedParameterValue(parametrisedStep, types[position], parameterValues[position],
  319.                     hasTable);
  320.         }
  321.         // mark parameter values that are named
  322.         for (Entry<String, String> namedParameter : namedParameters.entrySet()) {
  323.             parametrisedStep = parameterControls.replaceAllDelimitedNames(parametrisedStep, namedParameter.getKey(),
  324.                     markedValue(namedParameter.getValue()));
  325.         }

  327.         return parametrisedStep;
  328.     }

  330.     private boolean hasTable(Type[] types) {
  331.         for (Type type : types) {
  332.             if (isTable(type)) {
  333.                 return true;
  334.             }
  335.         }
  336.         return false;
  337.     }

  339.     private String markParsedParameterValue(String stepText, Type type, String value, boolean hasTable) {
  340.         if (value != null) {
  341.             // only mark non-empty string as parameter (JBEHAVE-656)
  342.             if (value.trim().length() != 0) {
  343.                 if (isTable(type)) {
  344.                     return stepText.replace(value, markedTable(value));
  345.                 }
  346.                 if (isVerbatim(type)) {
  347.                     return stepText.replace(value, markedVerbatim(value));
  348.                 }
  349.                 String markedValue = markedValue(value);
  350.                 // identify parameter values to mark as padded by spaces to avoid duplicated replacements of overlapping
  351.                 // values (JBEHAVE-837)
  352.                 String leftPad = SPACE;
  353.                 String rightPad = stepText.endsWith(value) ? NONE : SPACE;
  354.                 return stepText.replace(pad(value, leftPad, rightPad), pad(markedValue, leftPad, rightPad));
  355.             }
  356.             if (!hasTable) {
  357.                 return stepText.replace(NEWLINE, PARAMETER_VALUE_NEWLINE);
  358.             }
  359.         }
  360.         return stepText;
  361.     }

  363.     private String markedTable(String value) {
  364.         return pad(value, PARAMETER_TABLE_START, PARAMETER_TABLE_END);
  365.     }

  367.     private String markedVerbatim(String value) {
  368.         return pad(value, PARAMETER_VERBATIM_START, PARAMETER_VERBATIM_END);
  369.     }

  371.     private String markedValue(String value) {
  372.         return pad(value, PARAMETER_VALUE_START, PARAMETER_VALUE_END);
  373.     }

  375.     private String pad(String value, String left, String right) {
  376.         return new StringBuilder().append(left).append(value).append(right).toString();
  377.     }

  379.     private boolean isTable(Type type) {
  380.         return isExamplesTable(type) || isExamplesTableParameters(type);
  381.     }

  383.     private boolean isVerbatim(Type type) {
  384.         return type instanceof Class && Verbatim.class.isAssignableFrom((Class<?>) type);
  385.     }

  387.     private boolean isExamplesTable(Type type) {
  388.         return type instanceof Class && ExamplesTable.class.isAssignableFrom((Class<?>) type);
  389.     }

  391.     private String[] parameterValuesForStep(Matcher matcher, Map<String, String> namedParameters, Type[] types,
  392.             ParameterName[] names, boolean overrideWithTableParameters) {
  393.         final String[] parameters = new String[types.length];
  394.         for (int position = 0; position < types.length; position++) {
  395.             parameters[position] = parameterForPosition(matcher, position, names, namedParameters,
  396.                     overrideWithTableParameters);
  397.         }
  398.         return parameters;
  399.     }

  401.     private String parameterForPosition(Matcher matcher, int position, ParameterName[] names,
  402.             Map<String, String> namedParameters, boolean overrideWithTableParameters) {
  403.         int namePosition = parameterPosition(names, position);
  404.         String parameter = null;

  406.         if (namePosition != -1) {
  407.             String name = names[position].name;
  408.             boolean annotated = names[position].annotated;
  409.             boolean fromContext = names[position].fromContext;

  411.             List<String> delimitedNames = Collections.emptyList();

  413.             if (isGroupName(name)) {
  414.                 parameter = matchedParameter(matcher, name);
  415.                 delimitedNames = delimitedNameFor(parameter);

  417.                 if (delimitedNames.isEmpty()) {
  418.                     monitorUsingNameForParameter(name, position, annotated);
  419.                 }
  420.             }

  422.             if (!delimitedNames.isEmpty()) {
  423.                 parameter = replaceAllDelimitedNames(delimitedNames, position, annotated, parameter, namedParameters);
  424.                 delimitedNames = delimitedNameFor(parameter);
  425.                 parameter = replaceAllDelimitedNames(delimitedNames, position, annotated, parameter, namedParameters);
  426.             } else if (overrideWithTableParameters && namedParameters.containsKey(name)) {
  427.                 parameter = namedParameters.get(name);
  428.                 if (parameter != null) {
  429.                     monitorUsingTableNameForParameter(name, position, annotated); 
  430.                 }
  431.             }
  432.             
  433.             if (fromContext && parameter == null) {
  434.                 parameter = name;
  435.                 stepMonitor.usingStepsContextParameter(parameter);
  436.             }

  438.         }

  440.         if (parameter == null) {
  441.             // This allows parameters to be in a different order.
  442.             position = position - numberOfPreviousFromContext(names, position);
  443.             stepMonitor.usingNaturalOrderForParameter(position);
  444.             parameter = matchedParameter(matcher, position);

  446.             String previousParameterValue;
  447.             do {
  448.                 previousParameterValue = parameter;

  450.                 for (String delimitedName : delimitedNameFor(parameter)) {
  451.                     parameter = replaceAllDelimitedNames(parameter, delimitedName, namedParameters);
  452.                 }
  453.             } while (parameter != null && !previousParameterValue.equals(parameter));
  454.         }

  456.         stepMonitor.foundParameter(parameter, position);

  458.         return parameter;
  459.     }

  461.     private String replaceAllDelimitedNames(List<String> delimitedNames, int position, boolean annotated,
  462.                                             String parameter, Map<String, String> namedParameters) {
  463.         String parameterWithDelimitedNames = parameter;
  464.         for (String delimitedName : delimitedNames) {
  465.             monitorUsingTableNameForParameter(delimitedName, position, annotated);
  466.             parameterWithDelimitedNames = replaceAllDelimitedNames(parameterWithDelimitedNames, delimitedName,
  467.                     namedParameters);
  468.         }
  469.         return parameterWithDelimitedNames;
  470.     }

  472.     private String replaceAllDelimitedNames(String parameterWithDelimitedNames, String delimitedName,
  473.             Map<String, String> namedParameters) {
  474.         if (namedParameters.containsKey(delimitedName)) {
  475.             return parameterControls.replaceAllDelimitedNames(parameterWithDelimitedNames, delimitedName,
  476.                     namedParameters.get(delimitedName));
  477.         }
  478.         return parameterWithDelimitedNames;
  479.     }

  481.     private int numberOfPreviousFromContext(ParameterName[] names, int currentPosition) {
  482.         int number = 0;

  484.         for (int i = currentPosition - 1; i >= 0; i--) {
  485.             if (names[i].fromContext) {
  486.                 number++;
  487.             }
  488.         }
  489.         
  490.         return number;
  491.     }

  493.     private void monitorUsingTableNameForParameter(String name, int position, boolean usingAnnotationNames) {
  494.         if (usingAnnotationNames) {
  495.             stepMonitor.usingTableAnnotatedNameForParameter(name, position);
  496.         } else {
  497.             stepMonitor.usingTableParameterNameForParameter(name, position);
  498.         }
  499.     }

  501.     private void monitorUsingNameForParameter(String name, int position, boolean usingAnnotationNames) {
  502.         if (usingAnnotationNames) {
  503.             stepMonitor.usingAnnotatedNameForParameter(name, position);
  504.         } else {
  505.             stepMonitor.usingParameterNameForParameter(name, position);
  506.         }
  507.     }

  509.     private List<String> delimitedNameFor(String parameter) {
  510.         List<String> delimitedNames = new ArrayList<>();
  511.         if (parameterControls.delimiterNamedParameters()) {
  512.             Matcher matcher = delimitedNamePattern.matcher(parameter);
  513.             while (matcher.find()) {
  514.                 delimitedNames.add(matcher.group(1));
  515.             }
  516.         }
  517.         return delimitedNames;
  518.     }

  520.     String matchedParameter(Matcher matcher, String name) {
  521.         String[] parameterNames = stepMatcher.parameterNames();
  522.         for (int i = 0; i < parameterNames.length; i++) {
  523.             String parameterName = parameterNames[i];
  524.             if (name.equals(parameterName)) {
  525.                 return matchedParameter(matcher, i);
  526.             }
  527.         }
  528.         throw new ParameterNotFound(name, parameterNames);
  529.     }

  531.     private String matchedParameter(Matcher matcher, int position) {
  532.         String[] parameterNames = stepMatcher.parameterNames();
  533.         int matchedPosition = position + 1;
  534.         if (matchedPosition <= parameterNames.length) {
  535.             return matcher.group(matchedPosition);
  536.         }
  537.         throw new ParameterNotFound(position, parameterNames);
  538.     }

  540.     private int parameterPosition(ParameterName[] names, int position) {
  541.         if (names.length == 0) {
  542.             return -1;
  543.         }
  544.         String positionName = names[position].name;
  545.         for (int i = 0; i < names.length; i++) {
  546.             String name = names[i].name;
  547.             if (name != null && name.equals(positionName)) {
  548.                 return i;
  549.             }
  550.         }
  551.         return -1;
  552.     }

  554.     private boolean isGroupName(String name) {
  555.         String[] groupNames = stepMatcher.parameterNames();
  556.         for (String groupName : groupNames) {
  557.             if (name.equals(groupName)) {
  558.                 return true;
  559.             }
  560.         }
  561.         return false;
  562.     }

  564.     public static Step createPendingStep(final String stepAsString, String previousNonAndStep) {
  565.         return new PendingStep(stepAsString, previousNonAndStep);
  566.     }

  568.     public static Step createIgnorableStep(final String stepAsString) {
  569.         return new IgnorableStep(stepAsString);
  570.     }

  572.     public static Step createComment(final String stepAsString) {
  573.         return new Comment(stepAsString);
  574.     }

  576.     private void storeOutput(Object object, Method method) {
  577.         ToContext annotation = method.getAnnotation(ToContext.class);
  578.         if (annotation != null) {
  579.             stepsContext.put(annotation.value(), object, annotation.retentionLevel());
  580.         }
  581.     }

  583.     /**
  584.      * This is a different class, because the @Inject jar may not be in the
  585.      * classpath.
  586.      */
  587.     public static class Jsr330Helper {

  589.         private static String getNamedValue(Annotation annotation) {
  590.             return ((javax.inject.Named) annotation).value();
  591.         }

  593.     }

  595.     @SuppressWarnings("serial")
  596.     public static class ParameterNotFound extends RuntimeException {

  598.         public ParameterNotFound(String name, String[] parameters) {
  599.             super("Parameter not found for name '" + name + "' amongst '" + asList(parameters) + "'");
  600.         }

  602.         public ParameterNotFound(int position, String[] parameters) {
  603.             super("Parameter not found for position '" + position + "' amongst '" + asList(parameters) + "'");
  604.         }
  605.     }

  607.     public abstract static class AbstractStep implements Step {

  609.         @Override
  610.         public String asString(Keywords keywords) {
  611.             return toString();
  612.         }

  614.         @Override
  615.         public String toString() {
  616.             return ToStringBuilder.reflectionToString(this, ToStringStyle.SIMPLE_STYLE);
  617.         }

  619.         @Override
  620.         public List<Step> getComposedSteps() {
  621.             return Collections.emptyList();
  622.         }
  623.     }

  625.     public abstract static class ReportingAbstractStep extends AbstractStep {

  627.         private final StepExecutionType stepExecutionType;
  628.         private final String stepAsString;

  630.         public ReportingAbstractStep(StepExecutionType stepExecutionType, String stepAsString) {
  631.             this.stepExecutionType = stepExecutionType;
  632.             this.stepAsString = stepAsString;
  633.         }

  635.         @Override
  636.         public final StepResult perform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailure) {
  637.             storyReporter.beforeStep(new org.jbehave.core.model.Step(stepExecutionType, getStepAsString()));
  638.             return perform(storyFailure);
  639.         }

  641.         protected abstract StepResult perform(UUIDExceptionWrapper storyFailure);

  643.         @Override
  644.         public String asString(Keywords keywords) {
  645.             return stepAsString;
  646.         }

  648.         protected String getStepAsString() {
  649.             return stepAsString;
  650.         }
  651.     }

  653.     static class DelegatingStep extends AbstractStep {
  654.         private final Step step;

  656.         DelegatingStep(Step step) {
  657.             this.step = step;
  658.         }

  660.         @Override
  661.         public StepResult perform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  662.             return step.perform(storyReporter, storyFailureIfItHappened);
  663.         }

  665.         @Override
  666.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  667.             return step.doNotPerform(storyReporter, storyFailureIfItHappened);
  668.         }

  670.         @Override
  671.         public String asString(Keywords keywords) {
  672.             return step.asString(keywords);
  673.         }

  675.         @Override
  676.         public List<Step> getComposedSteps() {
  677.             return step.getComposedSteps();
  678.         }
  679.     }

  681.     private class BeforeOrAfterStep extends ReportingAbstractStep {
  682.         private final Method method;
  683.         private final Meta meta;

  685.         public BeforeOrAfterStep(Method method, Meta meta) {
  686.             super(StepExecutionType.EXECUTABLE, method.getName());
  687.             this.method = method;
  688.             this.meta = meta;
  689.         }

  691.         @Override
  692.         public StepResult perform(UUIDExceptionWrapper storyFailureIfItHappened) {
  693.             ParameterConverters paramConvertersWithExceptionInjector = paramConvertersWithExceptionInjector(
  694.                     storyFailureIfItHappened);
  695.             MethodInvoker methodInvoker = new MethodInvoker(method, paramConvertersWithExceptionInjector, paranamer,
  696.                     meta);
  697.             Timer timer = new Timer().start();
  698.             try {
  699.                 Object outputObject = methodInvoker.invoke();
  700.                 storeOutput(outputObject, method);
  701.                 return successful(method).setTimings(timer.stop());
  702.             } catch (InvocationTargetException e) {
  703.                 return failed(method, new UUIDExceptionWrapper(new BeforeOrAfterFailed(method, e.getCause())))
  704.                         .setTimings(timer.stop());
  705.             } catch (Throwable t) {
  706.                 return failed(method, new UUIDExceptionWrapper(new BeforeOrAfterFailed(method, t)))
  707.                         .setTimings(timer.stop());
  708.             }
  709.         }

  711.         private ParameterConverters paramConvertersWithExceptionInjector(
  712.                 UUIDExceptionWrapper storyFailureIfItHappened) {
  713.             return parameterConverters.newInstanceAdding(new UUIDExceptionWrapperInjector(storyFailureIfItHappened));
  714.         }

  716.         @Override
  717.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  718.             return perform(storyReporter, storyFailureIfItHappened);
  719.         }

  721.         @SuppressWarnings("checkstyle:AbbreviationAsWordInName")
  722.         private class UUIDExceptionWrapperInjector extends FromStringParameterConverter<UUIDExceptionWrapper> {
  723.             private final UUIDExceptionWrapper storyFailureIfItHappened;

  725.             public UUIDExceptionWrapperInjector(UUIDExceptionWrapper storyFailureIfItHappened) {
  726.                 this.storyFailureIfItHappened = storyFailureIfItHappened;
  727.             }

  729.             @Override
  730.             public boolean canConvertTo(Type type) {
  731.                 return UUIDExceptionWrapper.class == type;
  732.             }

  734.             @Override
  735.             public UUIDExceptionWrapper convertValue(String value, Type type) {
  736.                 return storyFailureIfItHappened;
  737.             }
  738.         }

  740.         @Override
  741.         public String asString(Keywords keywords) {
  742.             return method.getName() + ";" + meta.asString(keywords);
  743.         }
  744.     }

  746.     class UponAnyStep extends DelegatingStep {

  748.         UponAnyStep(Step step) {
  749.             super(step);
  750.         }

  752.         @Override
  753.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  754.             return perform(storyReporter, storyFailureIfItHappened);
  755.         }
  756.     }

  758.     class UponSuccessStep extends DelegatingStep {

  760.         UponSuccessStep(Step step) {
  761.             super(step);
  762.         }

  764.         @Override
  765.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  766.             return skipped();
  767.         }
  768.     }

  770.     class UponFailureStep extends DelegatingStep {

  772.         UponFailureStep(Step step) {
  773.             super(step);
  774.         }

  776.         @Override
  777.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  778.             return super.perform(storyReporter, storyFailureIfItHappened);
  779.         }

  781.         @Override
  782.         public StepResult perform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  783.             return skipped();
  784.         }
  785.     }

  787.     public class ConditionalStep extends AbstractStep {

  789.         private final StepConditionMatcher stepConditionMatcher;
  790.         private final Map<Method, ParametrisedStep> parametrisedSteps;

  792.         public ConditionalStep(StepConditionMatcher stepConditionMatcher,
  793.                 Map<Method, ParametrisedStep> parametrisedSteps) {
  794.             this.stepConditionMatcher = stepConditionMatcher;
  795.             this.parametrisedSteps = parametrisedSteps;
  796.         }

  798.         @Override
  799.         public StepResult perform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  800.             return performConditionalStep(storyReporter, step -> step.perform(storyReporter, storyFailureIfItHappened));
  801.         }

  803.         @Override
  804.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  805.             return performConditionalStep(storyReporter,
  806.                     step -> step.doNotPerform(storyReporter, storyFailureIfItHappened));
  807.         }

  809.         private StepResult performConditionalStep(StoryReporter storyReporter,
  810.                 Function<ParametrisedStep, StepResult> invoker) {

  812.             try {
  813.                 Map<Method, Conditional> unmatchedSteps = new HashMap<>();
  814.                 Map<Method, Conditional> matchedSteps = new HashMap<>();

  816.                 for (Method method : parametrisedSteps.keySet()) {
  817.                     Conditional conditional = Optional.ofNullable(method.getAnnotation(Conditional.class))
  818.                             .orElseGet(() -> method.getDeclaringClass().getAnnotation(Conditional.class));

  820.                     Map<Method, Conditional> target = stepConditionMatcher.matches(conditional.condition(),
  821.                             conditional.value()) ? matchedSteps : unmatchedSteps;
  822.                     target.put(method, conditional);

  824.                 }

  826.                 if (matchedSteps.isEmpty()) {
  827.                     String message = getStepName() + System.lineSeparator()
  828.                             + "None of the following steps were matched any condition:" + System.lineSeparator()
  829.                             + formatSteps(unmatchedSteps);
  830.                     return reportPending(storyReporter, message);
  831.                 } else if (matchedSteps.size() > 1) {
  832.                     String message = getStepName() + System.lineSeparator()
  833.                             + "More than one conditional step matched the condition:" + System.lineSeparator()
  834.                             + formatSteps(matchedSteps);
  835.                     return reportPending(storyReporter, message);
  836.                 }

  838.                 return invoker.apply(parametrisedSteps.get(matchedSteps.keySet().iterator().next()));
  839.             } catch (StepConditionMatchException e) {
  840.                 return reportPending(storyReporter, getStepName() + System.lineSeparator() + e.getMessage());
  841.             }
  842.         }

  844.         private StepResult reportPending(StoryReporter storyReporter, String message) {
  845.             Step pendingStep = createPendingStep(message, null);
  846.             return pendingStep.perform(storyReporter, null);
  847.         }

  849.         private String formatSteps(Map<Method, Conditional> matchedSteps) {
  850.             return matchedSteps.entrySet().stream()
  851.                     .map(e -> formatStep(e.getKey(), e.getValue()))
  852.                     .collect(Collectors.joining(System.lineSeparator()));
  853.         }

  855.         private String formatStep(Method method, Conditional condition) {
  856.             return method.getDeclaringClass() + "." + method.getName() + " (condition: " + condition.condition() + " "
  857.                     + condition.value() + ")";
  858.         }

  860.         private String getStepName() {
  861.             return parametrisedSteps.values().iterator().next().asString(null);
  862.         }
  863.     }

  865.     public class ParametrisedStep extends ReportingAbstractStep {
  866.         private String parametrisedStep;
  867.         private final Method method;
  868.         private final String stepWithoutStartingWord;
  869.         private final Map<String, String> namedParameters;
  870.         private final List<Step> composedSteps;

  872.         public ParametrisedStep(String stepAsString, Method method, String stepWithoutStartingWord,
  873.                 Map<String, String> namedParameters, List<Step> composedSteps) {
  874.             super(StepExecutionType.EXECUTABLE, stepAsString);
  875.             this.method = method;
  876.             this.stepWithoutStartingWord = stepWithoutStartingWord;
  877.             this.namedParameters = namedParameters;
  878.             this.composedSteps = composedSteps;
  879.         }

  881.         @Override
  882.         public List<Step> getComposedSteps() {
  883.             return composedSteps;
  884.         }

  886.         @Override
  887.         public StepResult perform(UUIDExceptionWrapper storyFailure) {
  888.             String stepAsString = getStepAsString();
  889.             Timer timer = new Timer().start();
  890.             try {
  891.                 Object[] convertedParameters = parametriseStep();
  892.                 stepMonitor.beforePerforming(parametrisedStep, dryRun, method);
  893.                 if (!dryRun && method != null) {
  894.                     Object outputObject = method.invoke(stepsInstance(), convertedParameters);
  895.                     storeOutput(outputObject, method);
  896.                 }
  897.                 return successful(stepAsString).withParameterValues(parametrisedStep)
  898.                         .setTimings(timer.stop());
  899.             } catch (ParameterNotFound e) {
  900.                 // step parametrisation failed, return pending StepResult
  901.                 return pending(new PendingStep(stepAsString, null)).withParameterValues(parametrisedStep);
  902.             } catch (InvocationTargetException e) {
  903.                 if (e.getCause() instanceof RestartingScenarioFailure) {
  904.                     throw (RestartingScenarioFailure) e.getCause();
  905.                 }
  906.                 if (e.getCause() instanceof IgnoringStepsFailure) {
  907.                     throw (IgnoringStepsFailure) e.getCause();
  908.                 }
  909.                 Throwable failureCause = e.getCause();
  910.                 if (failureCause instanceof UUIDExceptionWrapper) {
  911.                     failureCause = failureCause.getCause();
  912.                 }
  913.                 return failed(stepAsString, new UUIDExceptionWrapper(stepAsString, failureCause)).withParameterValues(
  914.                         parametrisedStep).setTimings(timer.stop());
  915.             } catch (Throwable t) {
  916.                 return failed(stepAsString, new UUIDExceptionWrapper(stepAsString, t)).withParameterValues(
  917.                         parametrisedStep).setTimings(timer.stop());
  918.             } finally {
  919.                 stepMonitor.afterPerforming(parametrisedStep, dryRun, method);
  920.             }
  921.         }

  923.         @Override
  924.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  925.             storyReporter.beforeStep(
  926.                     new org.jbehave.core.model.Step(StepExecutionType.NOT_PERFORMED, getStepAsString()));
  927.             try {
  928.                 parametriseStep();
  929.             } catch (Throwable t) {
  930.                 // step parametrisation failed, but still return
  931.                 // notPerformed StepResult
  932.             }
  933.             return notPerformed(getStepAsString()).withParameterValues(parametrisedStep);
  934.         }

  936.         @Override
  937.         public String asString(Keywords keywords) {
  938.             if (parametrisedStep == null) {
  939.                 parametriseStep();
  940.             }
  941.             return parametrisedStep;
  942.         }

  944.         private Object[] parametriseStep() {
  945.             Matcher matcher = stepMatcher.matcher(stepWithoutStartingWord);
  946.             matcher.find();
  947.             ParameterName[] names = parameterNames(method);
  948.             Type[] types = parameterTypes(method, names);
  949.             String[] parameterValues = parameterValuesForStep(matcher, namedParameters, types, names, true);
  950.             Object[] convertedParameters;
  951.             if (method == null) {
  952.                 convertedParameters = parameterValues;
  953.             } else {
  954.                 convertedParameters = convertParameterValues(parameterValues, types, names);
  955.             }
  956.             addNamedParametersToExamplesTables(convertedParameters);
  957.             parametrisedStep = parametrisedStep(getStepAsString(), namedParameters, types, parameterValues);
  958.             return convertedParameters;
  959.         }

  961.         private Object[] convertParameterValues(String[] parameterValues, Type[] types, ParameterName[] names) {
  962.             final Object[] parameters = new Object[parameterValues.length];
  963.             for (int i = 0; i < parameterValues.length; i++) {
  964.                 String parameterValue = parameterValues[i];
  965.                 if (names[i].fromContext) {
  966.                     parameters[i] = stepsContext.get(parameterValue);
  967.                 } else {
  968.                     String expressionEvaluationResult = parameterValue != null
  969.                             ? String.valueOf(expressionResolver.resolveExpressions(dryRun, parameterValue)) : null;
  970.                     parameters[i] = parameterConverters.convert(expressionEvaluationResult, types[i]);
  971.                 }
  972.             }
  973.             return parameters;
  974.         }

  976.         private void addNamedParametersToExamplesTables(Object[] convertedParameters) {
  977.             Stream.of(convertedParameters)
  978.                     .filter(ExamplesTable.class::isInstance)
  979.                     .map(ExamplesTable.class::cast)
  980.                     .forEach(examplesTable -> examplesTable.withNamedParameters(namedParameters));
  981.         }
  982.     }

  984.     public static class PendingStep extends ReportingAbstractStep {
  985.         private final String previousNonAndStep;
  986.         private Method method;
  987.         private String pendingMethod;

  989.         public PendingStep(String stepAsString, String previousNonAndStep) {
  990.             super(StepExecutionType.PENDING, stepAsString);
  991.             this.previousNonAndStep = previousNonAndStep;
  992.         }

  994.         @Override
  995.         protected StepResult perform(UUIDExceptionWrapper storyFailure) {
  996.             return pending(this);
  997.         }

  999.         @Override
  1000.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  1001.             return perform(storyReporter, storyFailureIfItHappened);
  1002.         }

  1004.         public String stepAsString() {
  1005.             return getStepAsString();
  1006.         }

  1008.         public String previousNonAndStepAsString() {
  1009.             return previousNonAndStep;
  1010.         }

  1012.         public void annotatedOn(Method method) {
  1013.             this.method = method;
  1014.         }

  1016.         public boolean annotated() {
  1017.             return method != null;
  1018.         }

  1020.         public String getPendingMethod() {
  1021.             return pendingMethod;
  1022.         }

  1024.         public void setPendingMethod(String pendingMethod) {
  1025.             this.pendingMethod = pendingMethod;
  1026.         }
  1027.     }

  1029.     public static class IgnorableStep extends ReportingAbstractStep {

  1031.         public IgnorableStep(String stepAsString) {
  1032.             super(StepExecutionType.IGNORABLE, stepAsString);
  1033.         }

  1035.         @Override
  1036.         protected StepResult perform(UUIDExceptionWrapper storyFailure) {
  1037.             return ignorable(getStepAsString());
  1038.         }

  1040.         @Override
  1041.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  1042.             return perform(storyReporter, storyFailureIfItHappened);
  1043.         }
  1044.     }

  1046.     public static class Comment extends ReportingAbstractStep {

  1048.         public Comment(String stepAsString) {
  1049.             super(StepExecutionType.COMMENT, stepAsString);
  1050.         }

  1052.         @Override
  1053.         protected StepResult perform(UUIDExceptionWrapper storyFailure) {
  1054.             return comment(getStepAsString());
  1055.         }

  1057.         @Override
  1058.         public StepResult doNotPerform(StoryReporter storyReporter, UUIDExceptionWrapper storyFailureIfItHappened) {
  1059.             return perform(storyReporter, storyFailureIfItHappened);
  1060.         }
  1061.     }

  1063.     public static enum StepExecutionType {
  1064.         EXECUTABLE,
  1065.         PENDING,
  1066.         IGNORABLE,
  1067.         COMMENT,
  1068.         NOT_PERFORMED;
  1069.     }

  1071.     private class MethodInvoker {
  1072.         private final Method method;
  1073.         private final ParameterConverters parameterConverters;
  1074.         private final Paranamer paranamer;
  1075.         private final Meta meta;
  1076.         private final Type[] parameterTypes;
  1077.         
  1078.         public MethodInvoker(Method method, ParameterConverters parameterConverters, Paranamer paranamer, Meta meta) {
  1079.             this.method = method;
  1080.             this.parameterConverters = parameterConverters;
  1081.             this.paranamer = paranamer;
  1082.             this.meta = meta;
  1083.             this.parameterTypes = method.getGenericParameterTypes();
  1084.         }

  1086.         public Object invoke() throws InvocationTargetException, IllegalAccessException {
  1087.             return method.invoke(stepsInstance(), parameterValuesFrom(meta));
  1088.         }

  1090.         private Parameter[] methodParameters() {
  1091.             Parameter[] parameters = new Parameter[parameterTypes.length];
  1092.             String[] annotatedNames = annotatedParameterNames(method);
  1093.             String[] paranamerNames = paranamer.lookupParameterNames(method, false);

  1095.             for (int position = 0; position < parameterTypes.length; position++) {
  1096.                 String name = parameterNameFor(position, annotatedNames, paranamerNames);
  1097.                 parameters[position] = new Parameter(position, parameterTypes[position], name);
  1098.             }

  1100.             return parameters;
  1101.         }

  1103.         private String parameterNameFor(int position, String[] annotatedNames, String[] paranamerNames) {
  1104.             String annotatedName = nameByPosition(annotatedNames, position);
  1105.             String paranamerName = nameByPosition(paranamerNames, position);
  1106.             if (annotatedName != null) {
  1107.                 return annotatedName;
  1108.             } else if (paranamerName != null) {
  1109.                 return paranamerName;
  1110.             }
  1111.             return null;
  1112.         }

  1114.         private String nameByPosition(String[] names, int position) {
  1115.             return position < names.length ? names[position] : null;
  1116.         }

  1118.         private Object[] parameterValuesFrom(Meta meta) {
  1119.             Object[] values = new Object[parameterTypes.length];
  1120.             for (Parameter parameter : methodParameters()) {
  1121.                 values[parameter.position] = parameterConverters.convert(parameter.valueFrom(meta), parameter.type);
  1122.             }
  1123.             return values;
  1124.         }

  1126.         private class Parameter {
  1127.             private final int position;
  1128.             private final Type type;
  1129.             private final String name;

  1131.             public Parameter(int position, Type type, String name) {
  1132.                 this.position = position;
  1133.                 this.type = type;
  1134.                 this.name = name;
  1135.             }

  1137.             public String valueFrom(Meta meta) {
  1138.                 if (name == null) {
  1139.                     return null;
  1140.                 }
  1141.                 return meta.getProperty(name);
  1142.             }
  1143.         }
  1144.     }

  1146.     private static class ParameterName {
  1147.         private String name;
  1148.         private boolean annotated;
  1149.         private boolean fromContext;

  1151.         private ParameterName(String name, boolean annotated, boolean fromContext) {
  1152.             this.name = name;
  1153.             this.annotated = annotated;
  1154.             this.fromContext = fromContext;
  1155.         }
  1156.     }
  1157. }
Created with JaCoCo 0.8.10.202304240956