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