##### Coverage Report - org.jbehave.core.junit.AnnotatedPathRunner

Classes in this File | Line Coverage | Branch Coverage | Complexity
AnnotatedPathRunner |
0% | 0/22
0% | 0/2
| 1.2727272727272727;1.273
AnnotatedPathRunner$1 |
N/A | N/A
N/A | N/A
| 1.2727272727272727;1.273
AnnotatedPathRunner$NotifierEmbedderMonitor |
0% | 0/19
0% | 0/2
| 1.2727272727272727;1.273

1 |  |
     package org.jbehave.core.junit;
2 |  |
3 |  |
     import java.util.List;
4 |  |
5 |  |
     import org.jbehave.core.annotations.UsingPaths;
6 |  |
     import org.jbehave.core.configuration.AnnotationBuilder;
7 |  |
     import org.jbehave.core.embedder.Embedder;
8 |  |
     import org.jbehave.core.embedder.EmbedderMonitor;
9 |  |
     import org.jbehave.core.embedder.EmbedderMonitorDecorator;
10 |  |
     import org.jbehave.core.io.StoryNameResolver;
11 |  |
     import org.jbehave.core.io.UnderscoredToCapitalized;
12 |  |
     import org.junit.runner.Description;
13 |  |
     import org.junit.runner.Runner;
14 |  |
     import org.junit.runner.notification.Failure;
15 |  |
     import org.junit.runner.notification.RunNotifier;
16 |  |
     import org.junit.runners.model.InitializationError;
17 |  |
18 |  |
     /**
19 |  |
      * A JUnit {@link Runner} that uses a {@link UsingPaths} annotation to specify
20 |  |
      * which story paths to run and uses the {@link RunNotifier} to provide a
21 |  |
      * {@link Description} for each. The story description uses a
22 |  |
      * {@link StoryNameResolver} (overridable via the {@link #storyNameResolver()}
23 |  |
      * method) to resolve the story path to a name.
24 |  |
      */
25 | 0 |
     public class AnnotatedPathRunner extends AnnotatedEmbedderRunner {
26 |  |
27 |  |
         private final AnnotationBuilder annotationBuilder;
28 |  |
         private final StoryNameResolver nameResolver;
29 |  |
         private final List<String> paths;
30 |  |
31 |  |
         /**
32 |  |
          * Class constructor.
33 |  |
          *
34 |  |
          * @param annotatedClass the annotated {@link Class}.
35 |  |
          * @throws InitializationError if an error occurs.
36 |  |
          */
37 |  |
         public AnnotatedPathRunner(Class<?> annotatedClass) throws InitializationError {
38 | 0 |
             super(annotatedClass);
39 | 0 |
             this.annotationBuilder = annotationBuilder();
40 | 0 |
             this.nameResolver = storyNameResolver();
41 | 0 |
             this.paths = annotationBuilder.findPaths();
42 | 0 |
         }
43 |  |
44 |  |
         protected StoryNameResolver storyNameResolver() {
45 | 0 |
             return new UnderscoredToCapitalized();
46 |  |
         }
47 |  |
48 |  |
         @Override
49 |  |
         public Description getDescription() {
50 | 0 |
             Description description = Description.createSuiteDescription(testClass());
51 | 0 |
             for (String path : paths)
52 | 0 |
                 description.addChild(createDescriptionForPath(path));
53 |  |
54 | 0 |
             return description;
55 |  |
         }
56 |  |
57 |  |
         private Description createDescriptionForPath(String path) {
58 | 0 |
             String name = nameResolver.resolveName(path);
59 | 0 |
             return Description.createTestDescription(testClass(), name);
60 |  |
         }
61 |  |
62 |  |
         @Override
63 |  |
         protected void collectInitializationErrors(List<Throwable> errors) {
64 |  |
             // overridden to avoid JUnit-specific errors
65 | 0 |
         }
66 |  |
67 |  |
         @Override
68 |  |
         protected void validateInstanceMethods(List<Throwable> errors) {
69 |  |
             // overridden to avoid JUnit-specific errors
70 | 0 |
         }
71 |  |
72 |  |
         @Override
73 |  |
         public void run(RunNotifier notifier) {
74 | 0 |
             Embedder embedder = annotationBuilder.buildEmbedder();
75 | 0 |
             NotifierEmbedderMonitor notifierEmbedderMonitor = new NotifierEmbedderMonitor(embedder.embedderMonitor(),
76 |  |
                     notifier);
77 | 0 |
             embedder.useEmbedderMonitor(notifierEmbedderMonitor);
78 |  |
79 |  |
             try {
80 | 0 |
                 embedder.runStoriesAsPaths(paths);
81 |  |
             } finally {
82 | 0 |
                 notifierEmbedderMonitor.storyFinished();
83 | 0 |
             }
84 | 0 |
         }
85 |  |
86 |  |
         /**
87 |  |
          * {@link EmbedderMonitor} that reports story updates to a
88 |  |
          * {@link RunNotifier}.
89 |  |
          */
90 | 0 |
         private final class NotifierEmbedderMonitor extends EmbedderMonitorDecorator {
91 |  |
             private final RunNotifier notifier;
92 |  |
             private Description currentStory;
93 |  |
94 |  |
             /**
95 |  |
              * Creates a NotifierEmbedderMonitor
96 |  |
              *
97 |  |
              * @param delegate the EmbedderMonitor delegate
98 |  |
              * @param notifier the RunNotifier
99 |  |
              */
100 | 0 |
             private NotifierEmbedderMonitor(EmbedderMonitor delegate, RunNotifier notifier) {
101 | 0 |
                 super(delegate);
102 | 0 |
                 this.notifier = notifier;
103 | 0 |
             }
104 |  |
105 |  |
             @Override
106 |  |
             public void runningStory(String path) {
107 | 0 |
                 super.runningStory(path);
108 | 0 |
                 storyFinished();
109 | 0 |
                 currentStory = createDescriptionForPath(path);
110 | 0 |
                 notifier.fireTestStarted(currentStory);
111 | 0 |
             }
112 |  |
113 |  |
             @Override
114 |  |
             public void storyFailed(String path, Throwable cause) {
115 | 0 |
                 super.storyFailed(path, cause);
116 | 0 |
                 notifier.fireTestFailure(new Failure(currentStory, cause));
117 | 0 |
                 notifier.fireTestFinished(currentStory);
118 | 0 |
                 currentStory = null;
119 | 0 |
             }
120 |  |
121 |  |
             /**
122 |  |
              * Finishes the last story.
123 |  |
              */
124 |  |
             private void storyFinished() {
125 | 0 |
                 if (currentStory == null) {
126 | 0 |
                     return;
127 |  |
                 }
128 | 0 |
                 notifier.fireTestFinished(currentStory);
129 | 0 |
             }
130 |  |
         }
131 |  |
     }