Coverage Report - org.jbehave.mojo.AbstractEmbedderMojo
 
Classes in this File Line Coverage Branch Coverage Complexity
AbstractEmbedderMojo
97%
41/42
87%
7/8
1.2
AbstractEmbedderMojo$MavenEmbedderMonitor
87%
27/31
N/A
1.2
 
 1  
 package org.jbehave.mojo;
 2  
 
 3  
 import static java.util.Arrays.asList;
 4  
 
 5  
 import java.io.File;
 6  
 import java.util.List;
 7  
 import java.util.Properties;
 8  
 
 9  
 import org.apache.maven.plugin.AbstractMojo;
 10  
 import org.jbehave.core.InjectableEmbedder;
 11  
 import org.jbehave.core.embedder.Embedder;
 12  
 import org.jbehave.core.embedder.EmbedderClassLoader;
 13  
 import org.jbehave.core.embedder.EmbedderControls;
 14  
 import org.jbehave.core.embedder.EmbedderMonitor;
 15  
 import org.jbehave.core.embedder.MetaFilter;
 16  
 import org.jbehave.core.embedder.UnmodifiableEmbedderControls;
 17  
 import org.jbehave.core.failures.BatchFailures;
 18  
 import org.jbehave.core.io.StoryFinder;
 19  
 import org.jbehave.core.junit.AnnotatedEmbedderRunner;
 20  
 import org.jbehave.core.model.Meta;
 21  
 
 22  
 /**
 23  
  * Abstract mojo that holds all the configuration parameters to specify and load
 24  
  * stories.
 25  
  * 
 26  
  * @requiresDependencyResolution
 27  
  */
 28  14
 public abstract class AbstractEmbedderMojo extends AbstractMojo {
 29  
 
 30  
     static final String TEST_SCOPE = "test";
 31  
 
 32  
     /**
 33  
      * @parameter expression="${project.build.sourceDirectory}"
 34  
      * @required
 35  
      * @readonly
 36  
      */
 37  
     String sourceDirectory;
 38  
 
 39  
     /**
 40  
      * @parameter expression="${project.build.testSourceDirectory}"
 41  
      * @required
 42  
      * @readonly
 43  
      */
 44  
     String testSourceDirectory;
 45  
 
 46  
     /**
 47  
      * The scope of the mojo classpath, either "compile" or "test"
 48  
      * 
 49  
      * @parameter default-value="compile"
 50  
      */
 51  
     String scope;
 52  
 
 53  
     /**
 54  
      * Include filters, relative to the root source directory determined by the
 55  
      * scope
 56  
      * 
 57  
      * @parameter
 58  
      */
 59  
     List<String> includes;
 60  
 
 61  
     /**
 62  
      * Exclude filters, relative to the root source directory determined by the
 63  
      * scope
 64  
      * 
 65  
      * @parameter
 66  
      */
 67  
     List<String> excludes;
 68  
 
 69  
     /**
 70  
      * Compile classpath.
 71  
      * 
 72  
      * @parameter expression="${project.compileClasspathElements}"
 73  
      * @required
 74  
      * @readonly
 75  
      */
 76  
     List<String> compileClasspathElements;
 77  
 
 78  
     /**
 79  
      * Test classpath.
 80  
      * 
 81  
      * @parameter expression="${project.testClasspathElements}"
 82  
      * @required
 83  
      * @readonly
 84  
      */
 85  
     List<String> testClasspathElements;
 86  
 
 87  
     /**
 88  
      * The boolean flag to skip stories
 89  
      * 
 90  
      * @parameter default-value="false"
 91  
      */
 92  14
     boolean skip = false;
 93  
 
 94  
     /**
 95  
      * The boolean flag to run in batch mode
 96  
      * 
 97  
      * @parameter default-value="false"
 98  
      */
 99  14
     boolean batch = false;
 100  
 
 101  
     /**
 102  
      * The boolean flag to ignore failure in stories
 103  
      * 
 104  
      * @parameter default-value="false"
 105  
      */
 106  14
     boolean ignoreFailureInStories = false;
 107  
 
 108  
     /**
 109  
      * The boolean flag to ignore failure in view
 110  
      * 
 111  
      * @parameter default-value="false"
 112  
      */
 113  14
     boolean ignoreFailureInView = false;
 114  
 
 115  
     /**
 116  
      * The boolean flag to generate view after stories are run
 117  
      * 
 118  
      * @parameter default-value="true"
 119  
      */
 120  14
     boolean generateViewAfterStories = true;
 121  
 
 122  
     /**
 123  
      * The embedder class
 124  
      * 
 125  
      * @parameter default-value="org.jbehave.core.embedder.Embedder"
 126  
      */
 127  14
     String embedderClass = Embedder.class.getName();
 128  
 
 129  
     /**
 130  
      * The class that is injected with the embedder
 131  
      * 
 132  
      * @parameter
 133  
      */
 134  
     String injectableEmbedderClass;
 135  
 
 136  
     /**
 137  
      * The annotated embedder runner class
 138  
      * 
 139  
      * @parameter default-value="org.jbehave.core.junit.AnnotatedEmbedderRunner"
 140  
      */
 141  14
     protected String annotatedEmbedderRunnerClass = AnnotatedEmbedderRunner.class.getName();
 142  
 
 143  
     /**
 144  
      * Used to find story paths and class names
 145  
      * 
 146  
      * @parameter
 147  
      */
 148  14
     String storyFinderClass = StoryFinder.class.getName();
 149  
 
 150  
     /**
 151  
      * The meta filter
 152  
      * 
 153  
      * @parameter
 154  
      */
 155  14
     List<String> metaFilters = asList();
 156  
 
 157  
     /**
 158  
      * Determines if the scope of the mojo classpath is "test"
 159  
      * 
 160  
      * @return A boolean <code>true</code> if test scoped
 161  
      */
 162  
     boolean isTestScope() {
 163  12
         return TEST_SCOPE.equals(scope);
 164  
     }
 165  
 
 166  
     String searchDirectory() {
 167  5
         if (isTestScope()) {
 168  1
             return testSourceDirectory;
 169  
         }
 170  4
         return sourceDirectory;
 171  
     }
 172  
 
 173  
     /**
 174  
      * Creates the EmbedderClassLoader with the classpath element of the
 175  
      * selected scope
 176  
      * 
 177  
      * @return A EmbedderClassLoader
 178  
      */
 179  
     protected EmbedderClassLoader createClassLoader() {
 180  6
         return new EmbedderClassLoader(classpathElements());
 181  
     }
 182  
 
 183  
     List<String> classpathElements() {
 184  7
         List<String> classpathElements = compileClasspathElements;
 185  7
         if (isTestScope()) {
 186  1
             classpathElements = testClasspathElements;
 187  
         }
 188  7
         return classpathElements;
 189  
     }
 190  
 
 191  
     /**
 192  
      * Finds story paths, using the {@link #newStoryFinder()}, in the
 193  
      * {@link #searchDirectory()} given specified {@link #includes} and
 194  
      * {@link #excludes}.
 195  
      * 
 196  
      * @return A List of story paths found
 197  
      */
 198  
     protected List<String> storyPaths() {
 199  2
         getLog().debug("Searching for story paths including " + includes + " and excluding " + excludes);
 200  2
         List<String> storyPaths = newStoryFinder().findPaths(searchDirectory(), includes, excludes);
 201  2
         getLog().info("Found story paths: " + storyPaths);
 202  2
         return storyPaths;
 203  
     }
 204  
 
 205  
     /**
 206  
      * Finds class names, using the {@link #newStoryFinder()}, in the
 207  
      * {@link #searchDirectory()} given specified {@link #includes} and
 208  
      * {@link #excludes}.
 209  
      * 
 210  
      * @return A List of class names found
 211  
      */
 212  
     protected List<String> classNames() {
 213  2
         getLog().debug("Searching for class names including " + includes + " and excluding " + excludes);
 214  2
         List<String> classNames = newStoryFinder().findClassNames(searchDirectory(), includes, excludes);
 215  2
         getLog().info("Found class names: " + classNames);
 216  2
         return classNames;
 217  
     }
 218  
 
 219  
     /**
 220  
      * Creates an instance of StoryFinder, using the {@link #storyFinderClass}
 221  
      * 
 222  
      * @return A StoryFinder
 223  
      */
 224  
     protected StoryFinder newStoryFinder() {
 225  5
         return createClassLoader().newInstance(StoryFinder.class, storyFinderClass);
 226  
     }
 227  
 
 228  
     /**
 229  
      * Creates an instance of Embedder, either using
 230  
      * {@link #injectableEmbedderClass} (if set) or defaulting to
 231  
      * {@link #embedderClass}.
 232  
      * 
 233  
      * @return An Embedder
 234  
      */
 235  
     protected Embedder newEmbedder() {
 236  5
         Embedder embedder = null;
 237  5
         EmbedderClassLoader classLoader = createClassLoader();
 238  5
         if (injectableEmbedderClass != null) {
 239  1
             embedder = classLoader.newInstance(InjectableEmbedder.class, injectableEmbedderClass).injectedEmbedder();
 240  
         } else {
 241  4
             embedder = classLoader.newInstance(Embedder.class, embedderClass);
 242  
         }
 243  5
         EmbedderMonitor embedderMonitor = embedderMonitor();
 244  5
         embedder.useEmbedderMonitor(embedderMonitor);
 245  5
         if ( !metaFilters.isEmpty() ) {
 246  0
             embedder.useMetaFilters(metaFilters);
 247  
         }
 248  5
         embedder.useEmbedderControls(embedderControls());
 249  5
         return embedder;
 250  
     }
 251  
 
 252  
     protected EmbedderMonitor embedderMonitor() {
 253  5
         return new MavenEmbedderMonitor();
 254  
     }
 255  
 
 256  
     protected EmbedderControls embedderControls() {
 257  5
         return new UnmodifiableEmbedderControls(new EmbedderControls().doBatch(batch).doSkip(skip)
 258  
                 .doGenerateViewAfterStories(generateViewAfterStories).doIgnoreFailureInStories(ignoreFailureInStories)
 259  
                 .doIgnoreFailureInView(ignoreFailureInView));
 260  
     }
 261  
 
 262  14
     protected class MavenEmbedderMonitor implements EmbedderMonitor {
 263  
 
 264  
         public void batchFailed(BatchFailures failures) {
 265  1
             getLog().warn("Failed to run batch " + failures);
 266  1
         }
 267  
 
 268  
         public void embeddableFailed(String name, Throwable cause) {
 269  1
             getLog().warn("Failed to run embeddable " + name, cause);
 270  1
         }
 271  
 
 272  
         public void embeddablesSkipped(List<String> classNames) {
 273  1
             getLog().info("Skipped embeddables " + classNames);
 274  1
         }
 275  
 
 276  
         public void metaNotAllowed(Meta meta, MetaFilter filter) {
 277  0
             getLog().info(meta + " not allowed by filter '" + filter.asString() + "'");
 278  0
         }
 279  
 
 280  
         public void runningEmbeddable(String name) {
 281  1
             getLog().info("Running embeddable " + name);
 282  1
         }
 283  
 
 284  
         public void runningStory(String path) {
 285  1
             getLog().info("Running story " + path);
 286  1
         }
 287  
 
 288  
         public void storiesSkipped(List<String> storyPaths) {
 289  1
             getLog().info("Skipped stories " + storyPaths);
 290  1
         }
 291  
 
 292  
         public void storyFailed(String path, Throwable cause) {
 293  1
             getLog().warn("Failed to run story " + path, cause);
 294  1
         }
 295  
 
 296  
         public void annotatedInstanceNotOfType(Object annotatedInstance, Class<?> type) {
 297  1
             getLog().warn("Annotated instance " + annotatedInstance + " not of type " + type);
 298  1
         }
 299  
 
 300  
         public void generatingStoriesView(File outputDirectory, List<String> formats, Properties viewProperties) {
 301  1
             getLog().info(
 302  
                     "Generating stories view in '" + outputDirectory + "' using formats '" + formats + "'"
 303  
                             + " and view properties '" + viewProperties + "'");
 304  1
         }
 305  
 
 306  
         public void storiesViewGenerationFailed(File outputDirectory, List<String> formats, Properties viewProperties,
 307  
                 Throwable cause) {
 308  1
             String message = "Failed to generate stories view in outputDirectory " + outputDirectory
 309  
                     + " using formats " + formats + " and view properties '" + viewProperties + "'";
 310  1
             getLog().warn(message, cause);
 311  1
         }
 312  
 
 313  
         public void storiesViewGenerated(int stories, int scenarios, int failedScenarios) {
 314  1
             getLog().info(
 315  
                     "Stories view generated with " + stories + " stories containing " + scenarios
 316  
                             + " scenarios (of which  " + failedScenarios + " failed)");
 317  1
         }
 318  
 
 319  
         public void storiesViewNotGenerated() {
 320  1
             getLog().info("Stories view not generated");
 321  1
         }
 322  
 
 323  
         public void mappingStory(String storyPath, List<String> metaFilters) {
 324  0
             getLog().info("Mapping story "+storyPath+" with meta filters "+metaFilters);
 325  0
         }
 326  
 
 327  
         @Override
 328  
         public String toString() {
 329  1
             return this.getClass().getSimpleName();
 330  
         }
 331  
 
 332  
     }
 333  
 }