AnnotationBuilder.java

  1. package org.jbehave.core.configuration;

  3. import java.io.ByteArrayInputStream;
  4. import java.io.IOException;
  5. import java.lang.reflect.Constructor;
  6. import java.util.ArrayList;
  7. import java.util.List;
  8. import java.util.Properties;

  10. import com.thoughtworks.paranamer.Paranamer;

  12. import org.apache.commons.lang3.StringUtils;
  13. import org.jbehave.core.ConfigurableEmbedder;
  14. import org.jbehave.core.Embeddable;
  15. import org.jbehave.core.annotations.Configure;
  16. import org.jbehave.core.annotations.UsingEmbedder;
  17. import org.jbehave.core.annotations.UsingPaths;
  18. import org.jbehave.core.annotations.UsingSteps;
  19. import org.jbehave.core.embedder.Embedder;
  20. import org.jbehave.core.embedder.EmbedderControls;
  21. import org.jbehave.core.embedder.StoryControls;
  22. import org.jbehave.core.failures.FailureStrategy;
  23. import org.jbehave.core.failures.PendingStepStrategy;
  24. import org.jbehave.core.io.PathCalculator;
  25. import org.jbehave.core.io.ResourceLoader;
  26. import org.jbehave.core.io.StoryFinder;
  27. import org.jbehave.core.io.StoryLoader;
  28. import org.jbehave.core.io.StoryPathResolver;
  29. import org.jbehave.core.model.TableTransformers;
  30. import org.jbehave.core.parsers.StepPatternParser;
  31. import org.jbehave.core.parsers.StoryParser;
  32. import org.jbehave.core.reporters.StepdocReporter;
  33. import org.jbehave.core.reporters.StoryReporter;
  34. import org.jbehave.core.reporters.StoryReporterBuilder;
  35. import org.jbehave.core.reporters.ViewGenerator;
  36. import org.jbehave.core.steps.CandidateSteps;
  37. import org.jbehave.core.steps.InjectableStepsFactory;
  38. import org.jbehave.core.steps.InstanceStepsFactory;
  39. import org.jbehave.core.steps.ParameterControls;
  40. import org.jbehave.core.steps.ParameterConverters;
  41. import org.jbehave.core.steps.ParameterConverters.ParameterConverter;
  42. import org.jbehave.core.steps.ScanningStepsFactory;
  43. import org.jbehave.core.steps.StepCollector;
  44. import org.jbehave.core.steps.StepFinder;
  45. import org.jbehave.core.steps.StepMonitor;

  47. /**
  48.  * Allows the building of {@link Configuration}, {@link CandidateSteps} and
  49.  * {@link Embedder} from an annotated class.
  50.  * 
  51.  * @author Cristiano Gavião
  52.  * @author Mauro Talevi
  53.  */
  54. public class AnnotationBuilder {

  56.     private final AnnotationMonitor annotationMonitor;

  58.     private final Class<?> annotatedClass;
  59.     private final AnnotationFinder finder;

  61.     public AnnotationBuilder(Class<?> annotatedClass) {
  62.         this(annotatedClass, new PrintStreamAnnotationMonitor());
  63.     }

  65.     public AnnotationBuilder(Class<?> annotatedClass, AnnotationMonitor annotationMonitor) {
  66.         this.annotationMonitor = annotationMonitor;
  67.         this.annotatedClass = annotatedClass;
  68.         this.finder = new AnnotationFinder(annotatedClass);
  69.     }

  71.     public Class<?> annotatedClass() {
  72.         return annotatedClass;
  73.     }

  75.     /**
  76.      * Builds a Configuration instance based on annotation {@link Configure}
  77.      * found in the annotated object instance
  78.      * 
  79.      * @return A Configuration instance
  80.      */
  81.     public Configuration buildConfiguration() throws AnnotationRequired {

  83.         if (!finder.isAnnotationPresent(Configure.class)) {
  84.             // not using annotation configuration, default to most useful
  85.             // configuration
  86.             return new MostUsefulConfiguration();
  87.         }

  89.         Configuration configuration = configurationElement(finder, "using", Configuration.class);
  90.         configuration.useKeywords(configurationElement(finder, "keywords", Keywords.class));
  91.         configuration.useFailureStrategy(configurationElement(finder, "failureStrategy", FailureStrategy.class));
  92.         configuration.usePendingStepStrategy(configurationElement(finder, "pendingStepStrategy",
  93.                 PendingStepStrategy.class));
  94.         configuration.useParanamer(configurationElement(finder, "paranamer", Paranamer.class));
  95.         configuration.useStoryControls(configurationElement(finder, "storyControls", StoryControls.class));
  96.         configuration.useStepCollector(configurationElement(finder, "stepCollector", StepCollector.class));
  97.         configuration.useStepdocReporter(configurationElement(finder, "stepdocReporter", StepdocReporter.class));
  98.         configuration.useStepFinder(configurationElement(finder, "stepFinder", StepFinder.class));
  99.         configuration.useStepMonitor(configurationElement(finder, "stepMonitor", StepMonitor.class));
  100.         configuration.useStepPatternParser(configurationElement(finder, "stepPatternParser", StepPatternParser.class));
  101.         configuration.useStoryLoader(configurationElement(finder, "storyLoader", StoryLoader.class));
  102.         configuration.useStoryParser(configurationElement(finder, "storyParser", StoryParser.class));
  103.         configuration.useStoryPathResolver(configurationElement(finder, "storyPathResolver", StoryPathResolver.class));
  104.         configuration
  105.                 .useDefaultStoryReporter(configurationElement(finder, "defaultStoryReporter", StoryReporter.class));
  106.         configuration.useStoryReporterBuilder(configurationElement(finder, "storyReporterBuilder",
  107.                 StoryReporterBuilder.class));
  108.         configuration.useViewGenerator(configurationElement(finder, "viewGenerator", ViewGenerator.class));
  109.         configuration.useTableTransformers(configurationElement(finder, "tableTransformers", TableTransformers.class));
  110.         configuration.useParameterConverters(
  111.                 parameterConverters(finder, configuration.storyLoader(), configuration.tableTransformers()));
  112.         configuration.useParameterControls(configurationElement(finder, "parameterControls", ParameterControls.class));
  113.         configuration.usePathCalculator(configurationElement(finder, "pathCalculator", PathCalculator.class));
  114.         return configuration;
  115.     }

  117.     /**
  118.      * Builds CandidateSteps using annotation {@link UsingSteps} found in the
  119.      * annotated object instance and using the configuration build by
  120.      * {@link #buildConfiguration()}
  121.      * 
  122.      * @return A List of CandidateSteps instances
  123.      */
  124.     public List<CandidateSteps> buildCandidateSteps() {
  125.         return buildCandidateSteps(buildConfiguration());
  126.     }

  128.     /**
  129.      * Builds CandidateSteps using annotation {@link UsingSteps} found in the
  130.      * annotated object instance and the configuration provided
  131.      * 
  132.      * @param configuration the Configuration
  133.      * @return A List of CandidateSteps instances
  134.      */
  135.     public List<CandidateSteps> buildCandidateSteps(Configuration configuration) {
  136.         return buildStepsFactory(configuration).createCandidateSteps();
  137.     }

  139.     /**
  140.      * Builds the {@link InjectableStepsFactory} using annotation
  141.      * {@link UsingSteps} found in the annotated object instance and the
  142.      * configuration provided
  143.      * 
  144.      * @param configuration the Configuration
  145.      * @return A {@link InjectableStepsFactory}
  146.      */
  147.     public InjectableStepsFactory buildStepsFactory(Configuration configuration) {
  148.         List<Object> stepsInstances = new ArrayList<>();
  149.         InjectableStepsFactory factory = null;
  150.         if (finder.isAnnotationPresent(UsingSteps.class)) {
  151.             List<Class<Object>> stepsClasses = finder.getAnnotatedClasses(
  152.                     UsingSteps.class, Object.class, "instances");
  153.             if (!stepsClasses.isEmpty()) {
  154.                 for (Class<Object> stepsClass : stepsClasses) {
  155.                     stepsInstances.add(instanceOf(Object.class, stepsClass));
  156.                 }
  157.                 factory = new InstanceStepsFactory(configuration,
  158.                         stepsInstances);
  159.             }
  160.             List<String> packages = finder.getAnnotatedValues(UsingSteps.class,
  161.                     String.class, "packages");
  162.             if (!packages.isEmpty()) {
  163.                 String matchingNames = finder.getAnnotatedValue(UsingSteps.class,
  164.                         String.class, "matchingNames");
  165.                 String notMatchingNames = finder.getAnnotatedValue(UsingSteps.class,
  166.                         String.class, "notMatchingNames");
  167.                 factory = new ScanningStepsFactory(configuration,
  168.                         packages.toArray(new String[packages.size()]))
  169.                         .matchingNames(matchingNames).notMatchingNames(notMatchingNames);
  170.             }
  171.         } else {
  172.             annotationMonitor.annotationNotFound(UsingSteps.class, annotatedClass);
  173.         }

  175.         if (factory == null) {
  176.             factory = new InstanceStepsFactory(configuration);
  177.         }
  178.         return factory;
  179.     }

  181.     public Embedder buildEmbedder() {
  182.         if (!finder.isAnnotationPresent(UsingEmbedder.class)) {
  183.             return defaultEmbedder();
  184.         }

  186.         boolean batch = control(finder, "batch");
  187.         boolean skip = control(finder, "skip");
  188.         boolean generateViewAfterStories = control(finder, "generateViewAfterStories");
  189.         boolean ignoreFailureInStories = control(finder, "ignoreFailureInStories");
  190.         boolean ignoreFailureInView = control(finder, "ignoreFailureInView");
  191.         boolean verboseFailures = control(finder, "verboseFailures");
  192.         boolean verboseFiltering = control(finder, "verboseFiltering");
  193.         String storyTimeouts = finder.getAnnotatedValue(UsingEmbedder.class, String.class, "storyTimeouts");
  194.         boolean failOnStoryTimeout = control(finder, "failOnStoryTimeout");
  195.         int threads = finder.getAnnotatedValue(UsingEmbedder.class, Integer.class, "threads");
  196.         Embedder embedder = embedder();
  197.         EmbedderControls embedderControls = embedder.embedderControls();
  198.         embedderControls.doBatch(batch).doSkip(skip).doGenerateViewAfterStories(generateViewAfterStories)
  199.                 .doIgnoreFailureInStories(ignoreFailureInStories).doIgnoreFailureInView(ignoreFailureInView)
  200.                 .doVerboseFailures(verboseFailures).doVerboseFiltering(verboseFiltering)
  201.                 .doFailOnStoryTimeout(failOnStoryTimeout).useThreads(threads);
  202.         if (StringUtils.isNotBlank(storyTimeouts)) {
  203.             embedderControls.useStoryTimeouts(storyTimeouts);
  204.         }
  205.         Configuration configuration = buildConfiguration();
  206.         embedder.useConfiguration(configuration);
  207.         embedder.useStepsFactory(buildStepsFactory(configuration));

  209.         List<String> metaFilters = finder.getAnnotatedValues(UsingEmbedder.class, String.class, "metaFilters");
  210.         if (!metaFilters.isEmpty()) {
  211.             embedder.useMetaFilters(metaFilters);
  212.         }
  213.         Properties systemProperties = loadProperties(finder.getAnnotatedValue(UsingEmbedder.class, String.class,
  214.                 "systemProperties"));
  215.         if (!systemProperties.isEmpty()) {
  216.             embedder.useSystemProperties(systemProperties);
  217.         }
  218.         return embedder;
  219.     }

  221.     @SuppressWarnings("unchecked")
  222.     protected Embedder embedder() {
  223.         return instanceOf(Embedder.class,
  224.                 (Class<? extends Embedder>) finder.getAnnotatedValue(UsingEmbedder.class, Class.class, "embedder"));
  225.     }
  226.     
  227.     protected Embedder defaultEmbedder() {
  228.         return new Embedder();
  229.     }

  231.     public AnnotationFinder finder() {
  232.         return finder;
  233.     }
  234.     
  235.     public List<String> findPaths() {
  236.         if (!finder.isAnnotationPresent(UsingPaths.class)) {
  237.             return new ArrayList<>();
  238.         }

  240.         String searchIn = finder.getAnnotatedValue(UsingPaths.class, String.class, "searchIn");
  241.         List<String> includes = finder.getAnnotatedValues(UsingPaths.class, String.class, "includes");
  242.         List<String> excludes = finder.getAnnotatedValues(UsingPaths.class, String.class, "excludes");
  243.         return storyFinder().findPaths(searchIn, includes, excludes);
  244.     }

  246.     @SuppressWarnings("unchecked")
  247.     private StoryFinder storyFinder() {
  248.         return instanceOf(StoryFinder.class,
  249.                 (Class<? extends StoryFinder>) finder.getAnnotatedValue(UsingPaths.class, Class.class, "storyFinder"));
  250.     }

  252.     private boolean control(AnnotationFinder finder, String name) {
  253.         return finder.getAnnotatedValue(UsingEmbedder.class, Boolean.class, name);
  254.     }

  256.     private <T> T configurationElement(AnnotationFinder finder, String name, Class<T> type) {
  257.         Class<T> implementation = elementImplementation(finder, name);
  258.         return instanceOf(type, implementation);
  259.     }

  261.     @SuppressWarnings("unchecked")
  262.     protected <T> Class<T> elementImplementation(AnnotationFinder finder, String name) {
  263.         return finder.getAnnotatedValue(Configure.class, Class.class, name);
  264.     }

  266.     private Properties loadProperties(String systemPropertiesCSV) {
  267.         Properties properties = new Properties();
  268.         try {
  269.             properties.load(new ByteArrayInputStream(systemPropertiesCSV.replace(",", "\n").getBytes()));
  270.         } catch (IOException e) {
  271.             // return empty map
  272.         }
  273.         return properties;
  274.     }

  276.     protected ParameterConverters parameterConverters(AnnotationFinder annotationFinder,
  277.             ResourceLoader resourceLoader, TableTransformers tableTransformers) {
  278.         ParameterConverters parameterConverters = new ParameterConverters(resourceLoader, tableTransformers);
  279.         for (Class<ParameterConverter> converterClass : annotationFinder.getAnnotatedClasses(Configure.class,
  280.                 ParameterConverter.class, "parameterConverters")) {
  281.             parameterConverters.addConverters(instanceOf(ParameterConverter.class, converterClass));
  282.         }
  283.         return parameterConverters;
  284.     }

  286.     protected <T, V extends T> T instanceOf(Class<T> type, Class<V> ofClass) {
  287.         try { 
  288.             // by classloader constructor
  289.             try {
  290.                 Constructor<V> constructor =
  291.                         ofClass.getConstructor(ClassLoader.class);
  292.                 return constructor.newInstance(annotatedClass.getClassLoader());
  293.             } catch (NoSuchMethodException ns) {
  294.                 // fall-back to another approach of object construction
  295.             }
  296.             // by class constructor
  297.             try {
  298.                 Constructor<V> constructor =
  299.                         ofClass.getConstructor(Class.class);
  300.                 return constructor.newInstance(annotatedClass);
  301.             } catch (NoSuchMethodException ns) {
  302.                 // fall-back to another approach of object construction
  303.             }                 
  304.             // by class instance
  305.             return ofClass.newInstance();
  306.         } catch (Exception e) {
  307.             annotationMonitor.elementCreationFailed(ofClass, e);
  308.             throw new InstantiationFailed(ofClass, type, e);
  309.         }
  310.     }

  312.     protected AnnotationMonitor annotationMonitor() {
  313.         return annotationMonitor;
  314.     }

  316.     protected AnnotationFinder annotationFinder() {
  317.         return finder;
  318.     }

  320.     public Object embeddableInstance() {
  321.         return injectEmbedder(buildEmbedder(), annotatedClass);
  322.     }

  324.     protected Object injectEmbedder(Embedder embedder, Class<?> annotatedClass) {
  325.         try {
  326.             Object instance = annotatedClass.newInstance();
  327.             if (instance instanceof Embeddable) {
  328.                 Embeddable embeddable = (Embeddable) instance;
  329.                 embeddable.useEmbedder(embedder);
  330.             }
  331.             if (instance instanceof ConfigurableEmbedder) {
  332.                 ConfigurableEmbedder configurableEmbedder = (ConfigurableEmbedder) instance;
  333.                 configurableEmbedder.useConfiguration(embedder.configuration());
  334.                 configurableEmbedder.useStepsFactory(embedder.stepsFactory());
  335.             }
  336.             return instance;
  337.         } catch (Exception e) {
  338.             annotationMonitor.elementCreationFailed(annotatedClass, e);
  339.             throw new InstantiationFailed(annotatedClass, e);
  340.         }
  341.     }

  343.     @SuppressWarnings("serial")
  344.     public static class InstantiationFailed extends RuntimeException {

  346.         public InstantiationFailed(Class<?> ofClass, Class<?> type, Throwable cause) {
  347.             super("Failed to instantiate " + ofClass + " of type " + type, cause);
  348.         }

  350.         public InstantiationFailed(Class<?> ofClass, Throwable cause) {
  351.             super("Failed to instantiate " + ofClass, cause);
  352.         }

  354.     }

  356. }
Created with JaCoCo 0.8.10.202304240956