Coverage Report - org.jbehave.mojo.AbstractEmbedderMojo
 
Classes in this File Line Coverage Branch Coverage Complexity
AbstractEmbedderMojo
0%
0/47
0%
0/10
1.229
AbstractEmbedderMojo$MavenEmbedderMonitor
0%
0/53
0%
0/4
1.229
 
 1  
 package org.jbehave.mojo;
 2  
 
 3  
 import java.io.File;
 4  
 import java.util.Arrays;
 5  
 import java.util.List;
 6  
 import java.util.Properties;
 7  
 
 8  
 import org.apache.commons.lang.ArrayUtils;
 9  
 import org.apache.maven.plugin.AbstractMojo;
 10  
 import org.jbehave.core.ConfigurableEmbedder;
 11  
 import org.jbehave.core.InjectableEmbedder;
 12  
 import org.jbehave.core.embedder.Embedder;
 13  
 import org.jbehave.core.embedder.EmbedderClassLoader;
 14  
 import org.jbehave.core.embedder.EmbedderControls;
 15  
 import org.jbehave.core.embedder.EmbedderMonitor;
 16  
 import org.jbehave.core.embedder.MetaFilter;
 17  
 import org.jbehave.core.embedder.UnmodifiableEmbedderControls;
 18  
 import org.jbehave.core.failures.BatchFailures;
 19  
 import org.jbehave.core.io.StoryFinder;
 20  
 import org.jbehave.core.junit.AnnotatedEmbedderRunner;
 21  
 import org.jbehave.core.model.Meta;
 22  
 import org.jbehave.core.model.Story;
 23  
 import org.jbehave.core.model.StoryMaps;
 24  
 import org.jbehave.core.reporters.ReportsCount;
 25  
 
 26  
 /**
 27  
  * Abstract mojo that holds all the configuration parameters to specify and load
 28  
  * stories.
 29  
  * 
 30  
  * @requiresDependencyResolution
 31  
  */
 32  0
 public abstract class AbstractEmbedderMojo extends AbstractMojo {
 33  
 
 34  
     static final String TEST_SCOPE = "test";
 35  
 
 36  
     /**
 37  
      * @parameter expression="${project.build.sourceDirectory}"
 38  
      * @required
 39  
      */
 40  
     String sourceDirectory;
 41  
 
 42  
     /**
 43  
      * @parameter expression="${project.build.testSourceDirectory}"
 44  
      * @required
 45  
      */
 46  
     String testSourceDirectory;
 47  
 
 48  
     /**
 49  
      * The scope of the mojo classpath, either "compile" or "test"
 50  
      * 
 51  
      * @parameter default-value="compile"
 52  
      */
 53  
     String scope;
 54  
 
 55  
     /**
 56  
      * Include filters, relative to the root source directory determined by the
 57  
      * scope
 58  
      * 
 59  
      * @parameter
 60  
      */
 61  
     List<String> includes;
 62  
 
 63  
     /**
 64  
      * Exclude filters, relative to the root source directory determined by the
 65  
      * scope
 66  
      * 
 67  
      * @parameter
 68  
      */
 69  
     List<String> excludes;
 70  
 
 71  
     /**
 72  
      * Compile classpath.
 73  
      * 
 74  
      * @parameter expression="${project.compileClasspathElements}"
 75  
      * @required
 76  
      * @readonly
 77  
      */
 78  
     List<String> compileClasspathElements;
 79  
 
 80  
     /**
 81  
      * Test classpath.
 82  
      * 
 83  
      * @parameter expression="${project.testClasspathElements}"
 84  
      * @required
 85  
      * @readonly
 86  
      */
 87  
     List<String> testClasspathElements;
 88  
 
 89  
     /**
 90  
      * The boolean flag to skip stories
 91  
      * 
 92  
      * @parameter default-value="false"
 93  
      */
 94  0
     boolean skip = false;
 95  
 
 96  
     /**
 97  
      * The boolean flag to run in batch mode
 98  
      * 
 99  
      * @parameter default-value="false"
 100  
      */
 101  0
     boolean batch = false;
 102  
 
 103  
     /**
 104  
      * The boolean flag to ignore failure in stories
 105  
      * 
 106  
      * @parameter default-value="false"
 107  
      */
 108  0
     boolean ignoreFailureInStories = false;
 109  
 
 110  
     /**
 111  
      * The boolean flag to ignore failure in view
 112  
      * 
 113  
      * @parameter default-value="false"
 114  
      */
 115  0
     boolean ignoreFailureInView = false;
 116  
 
 117  
     /**
 118  
      * The boolean flag to generate view after stories are run
 119  
      * 
 120  
      * @parameter default-value="true"
 121  
      */
 122  0
     boolean generateViewAfterStories = true;
 123  
 
 124  
     /**
 125  
      * The story timeout in secs
 126  
      * 
 127  
      * @parameter default-value="300"
 128  
      */
 129  
     long storyTimeoutInSecs;
 130  
 
 131  
     /**
 132  
      * The number of threads
 133  
      * 
 134  
      * @parameter default-value="1"
 135  
      */
 136  0
     int threads = 1;
 137  
 
 138  
     /**
 139  
      * The embedder class
 140  
      * 
 141  
      * @parameter default-value="org.jbehave.core.embedder.Embedder"
 142  
      */
 143  0
     String embedderClass = Embedder.class.getName();
 144  
 
 145  
     /**
 146  
      * The class that is injected with the embedder
 147  
      * 
 148  
      * @parameter
 149  
      */
 150  
     String injectableEmbedderClass;
 151  
 
 152  
     /**
 153  
      * The annotated embedder runner class
 154  
      * 
 155  
      * @parameter default-value="org.jbehave.core.junit.AnnotatedEmbedderRunner"
 156  
      */
 157  0
     protected String annotatedEmbedderRunnerClass = AnnotatedEmbedderRunner.class.getName();
 158  
 
 159  
     /**
 160  
      * Used to find story paths and class names
 161  
      * 
 162  
      * @parameter
 163  
      */
 164  0
     String storyFinderClass = StoryFinder.class.getName();
 165  
 
 166  
     /**
 167  
      * The meta filter
 168  
      * 
 169  
      * @parameter
 170  
      */
 171  
     String[] metaFilters;
 172  
 
 173  
     /**
 174  
      * The system properties
 175  
      * 
 176  
      * @parameter
 177  
      */
 178  0
     Properties systemProperties = new Properties();
 179  
 
 180  
     /**
 181  
      * The class loader
 182  
      */
 183  
     private EmbedderClassLoader classLoader;
 184  
 
 185  
     /**
 186  
      * Determines if the scope of the mojo classpath is "test"
 187  
      * 
 188  
      * @return A boolean <code>true</code> if test scoped
 189  
      */
 190  
     boolean isTestScope() {
 191  0
         return TEST_SCOPE.equals(scope);
 192  
     }
 193  
 
 194  
     String searchDirectory() {
 195  0
         if (isTestScope()) {
 196  0
             return testSourceDirectory;
 197  
         }
 198  0
         return sourceDirectory;
 199  
     }
 200  
 
 201  
     /**
 202  
      * Returns the EmbedderClassLoader with the classpath element of the
 203  
      * selected scope.
 204  
      * 
 205  
      * @return An EmbedderClassLoader
 206  
      */
 207  
     protected EmbedderClassLoader classLoader() {
 208  0
         if (classLoader == null) {
 209  0
             classLoader = new EmbedderClassLoader(classpathElements());
 210  
         }
 211  0
         return classLoader;
 212  
     }
 213  
 
 214  
     List<String> classpathElements() {
 215  0
         List<String> classpathElements = compileClasspathElements;
 216  0
         if (isTestScope()) {
 217  0
             classpathElements = testClasspathElements;
 218  
         }
 219  0
         return classpathElements;
 220  
     }
 221  
 
 222  
     /**
 223  
      * Finds story paths, using the {@link #newStoryFinder()}, in the
 224  
      * {@link #searchDirectory()} given specified {@link #includes} and
 225  
      * {@link #excludes}.
 226  
      * 
 227  
      * @return A List of story paths found
 228  
      */
 229  
     protected List<String> storyPaths() {
 230  0
         getLog().debug("Searching for story paths including " + includes + " and excluding " + excludes);
 231  0
         List<String> storyPaths = newStoryFinder().findPaths(searchDirectory(), includes, excludes);
 232  0
         getLog().info("Found story paths: " + storyPaths);
 233  0
         return storyPaths;
 234  
     }
 235  
 
 236  
     /**
 237  
      * Finds class names, using the {@link #newStoryFinder()}, in the
 238  
      * {@link #searchDirectory()} given specified {@link #includes} and
 239  
      * {@link #excludes}.
 240  
      * 
 241  
      * @return A List of class names found
 242  
      */
 243  
     protected List<String> classNames() {
 244  0
         getLog().debug("Searching for class names including " + includes + " and excluding " + excludes);
 245  0
         List<String> classNames = newStoryFinder().findClassNames(searchDirectory(), includes, excludes);
 246  0
         getLog().info("Found class names: " + classNames);
 247  0
         return classNames;
 248  
     }
 249  
 
 250  
     /**
 251  
      * Creates an instance of StoryFinder, using the {@link #storyFinderClass}
 252  
      * 
 253  
      * @return A StoryFinder
 254  
      */
 255  
     protected StoryFinder newStoryFinder() {
 256  0
         return classLoader().newInstance(StoryFinder.class, storyFinderClass);
 257  
     }
 258  
 
 259  
     /**
 260  
      * Creates an instance of Embedder, either using
 261  
      * {@link #injectableEmbedderClass} (if set) or defaulting to
 262  
      * {@link #embedderClass}.
 263  
      * 
 264  
      * @return An Embedder
 265  
      */
 266  
     protected Embedder newEmbedder() {
 267  0
         Embedder embedder = null;
 268  0
         EmbedderClassLoader classLoader = classLoader();
 269  0
         if (injectableEmbedderClass != null) {
 270  0
             embedder = classLoader.newInstance(InjectableEmbedder.class, injectableEmbedderClass).injectedEmbedder();
 271  
         } else {
 272  0
             embedder = classLoader.newInstance(Embedder.class, embedderClass);
 273  
         }
 274  0
         embedder.useClassLoader(classLoader);
 275  0
         embedder.useSystemProperties(systemProperties);
 276  0
         EmbedderMonitor embedderMonitor = embedderMonitor();
 277  0
         embedder.useEmbedderMonitor(embedderMonitor);
 278  0
         if (ArrayUtils.isNotEmpty(metaFilters)) {
 279  0
             embedder.useMetaFilters(Arrays.asList(metaFilters));
 280  
         }
 281  0
         embedder.useEmbedderControls(embedderControls());
 282  0
         return embedder;
 283  
     }
 284  
 
 285  
     protected EmbedderMonitor embedderMonitor() {
 286  0
         return new MavenEmbedderMonitor();
 287  
     }
 288  
 
 289  
     protected EmbedderControls embedderControls() {
 290  0
         return new UnmodifiableEmbedderControls(new EmbedderControls().doBatch(batch).doSkip(skip)
 291  
                 .doGenerateViewAfterStories(generateViewAfterStories).doIgnoreFailureInStories(ignoreFailureInStories)
 292  
                 .doIgnoreFailureInView(ignoreFailureInView).useStoryTimeoutInSecs(storyTimeoutInSecs)
 293  
                 .useThreads(threads));
 294  
     }
 295  
 
 296  0
     protected class MavenEmbedderMonitor implements EmbedderMonitor {
 297  
 
 298  
         public void batchFailed(BatchFailures failures) {
 299  0
             getLog().warn("Failed to run batch " + failures);
 300  0
         }
 301  
 
 302  
         public void embeddableFailed(String name, Throwable cause) {
 303  0
             getLog().warn("Failed to run embeddable " + name, cause);
 304  0
         }
 305  
 
 306  
         public void embeddableNotConfigurable(String name) {
 307  0
             getLog().warn("Embeddable " + name + " must be an instance of " + ConfigurableEmbedder.class);
 308  0
         }
 309  
 
 310  
         public void embeddablesSkipped(List<String> classNames) {
 311  0
             getLog().info("Skipped embeddables " + classNames);
 312  0
         }
 313  
 
 314  
         public void metaNotAllowed(Meta meta, MetaFilter filter) {
 315  0
             getLog().info(meta + " excluded by filter '" + filter.asString() + "'");
 316  0
         }
 317  
 
 318  
         public void runningEmbeddable(String name) {
 319  0
             getLog().info("Running embeddable " + name);
 320  0
         }
 321  
 
 322  
         public void runningStory(String path) {
 323  0
             getLog().info("Running story " + path);
 324  0
         }
 325  
 
 326  
         public void storiesSkipped(List<String> storyPaths) {
 327  0
             getLog().info("Skipped stories " + storyPaths);
 328  0
         }
 329  
 
 330  
         public void storyFailed(String path, Throwable cause) {
 331  0
             getLog().warn("Failed to run story " + path, cause);
 332  0
         }
 333  
 
 334  
         public void annotatedInstanceNotOfType(Object annotatedInstance, Class<?> type) {
 335  0
             getLog().warn("Annotated instance " + annotatedInstance + " not of type " + type);
 336  0
         }
 337  
 
 338  
         public void generatingReportsView(File outputDirectory, List<String> formats, Properties viewProperties) {
 339  0
             getLog().info(
 340  
                     "Generating reports view to '" + outputDirectory + "' using formats '" + formats + "'"
 341  
                             + " and view properties '" + viewProperties + "'");
 342  0
         }
 343  
 
 344  
         public void reportsViewGenerationFailed(File outputDirectory, List<String> formats, Properties viewProperties,
 345  
                 Throwable cause) {
 346  0
             String message = "Failed to generate reports view to '" + outputDirectory + "' using formats '" + formats
 347  
                     + "'" + " and view properties '" + viewProperties + "'";
 348  0
             getLog().warn(message, cause);
 349  0
         }
 350  
 
 351  
         public void reportsViewGenerated(ReportsCount count) {
 352  0
             getLog().info(
 353  
                     "Reports view generated with " + count.getStories() + " stories (of which "
 354  
                             + count.getStoriesPending() + " pending) containing " + "" + count.getScenarios()
 355  
                             + " scenarios (of which  " + count.getScenariosFailed() + " failed and "
 356  
                             + count.getScenariosPending() + " pending)");
 357  0
             if (count.getStoriesNotAllowed() > 0 || count.getScenariosNotAllowed() > 0) {
 358  0
                 getLog().info(
 359  
                         "Meta filters did not allow " + count.getStoriesNotAllowed() + " stories and  "
 360  
                                 + count.getScenariosNotAllowed() + " scenarios");
 361  
             }
 362  0
         }
 363  
 
 364  
         public void reportsViewNotGenerated() {
 365  0
             getLog().info("Reports view not generated");
 366  0
         }
 367  
 
 368  
         public void mappingStory(String storyPath, List<String> metaFilters) {
 369  0
             getLog().info("Mapping story " + storyPath + " with meta filters " + metaFilters);
 370  0
         }
 371  
 
 372  
         public void generatingMapsView(File outputDirectory, StoryMaps storyMaps, Properties viewProperties) {
 373  0
             getLog().info(
 374  
                     "Generating maps view to '" + outputDirectory + "' using story maps '" + storyMaps + "'"
 375  
                             + " and view properties '" + viewProperties + "'");
 376  0
         }
 377  
 
 378  
         public void mapsViewGenerationFailed(File outputDirectory, StoryMaps storyMaps, Properties viewProperties,
 379  
                 Throwable cause) {
 380  0
             getLog().warn(
 381  
                     "Failed to generate maps view to '" + outputDirectory + "' using story maps '" + storyMaps + "'"
 382  
                             + " and view properties '" + viewProperties + "'", cause);
 383  0
         }
 384  
 
 385  
         public void generatingNavigatorView(File outputDirectory, Properties viewProperties) {
 386  0
             getLog().info(
 387  
                     "Generating navigator view to '" + outputDirectory + "' using view properties '" + viewProperties
 388  
                             + "'");
 389  0
         }
 390  
 
 391  
         public void navigatorViewGenerationFailed(File outputDirectory, Properties viewProperties, Throwable cause) {
 392  0
             getLog().warn(
 393  
                     "Failed to generate navigator view to '" + outputDirectory + "' using view properties '"
 394  
                             + viewProperties + "'", cause);
 395  0
         }
 396  
 
 397  
         public void navigatorViewNotGenerated() {
 398  0
             getLog().warn(
 399  
                     "Navigator view not generated, as the CrossReference has not been declared in the StoryReporterBuilder");
 400  0
         }
 401  
 
 402  
         public void processingSystemProperties(Properties properties) {
 403  0
             getLog().info("Processing system properties " + properties);
 404  0
         }
 405  
 
 406  
         public void systemPropertySet(String name, String value) {
 407  0
             getLog().info("System property '" + name + "' set to '" + value + "'");
 408  0
         }
 409  
 
 410  
         public void storyTimeout(long durationInSecs, Story story) {
 411  0
             getLog().warn("Story " + story.getPath() + " has timed out after " + durationInSecs + " seconds");
 412  0
         }
 413  
 
 414  
         public void usingThreads(int threads) {
 415  0
             getLog().info("Using " + threads + " threads");
 416  0
         }
 417  
 
 418  
         @Override
 419  
         public String toString() {
 420  0
             return this.getClass().getSimpleName();
 421  
         }
 422  
 
 423  
     }
 424  
 }