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