DelegatingStoryReporter.java

  1. package org.jbehave.core.reporters;

  2. import static java.util.Arrays.asList;

  3. import java.util.Collection;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.function.Consumer;

  7. import org.apache.commons.lang3.builder.ToStringBuilder;
  8. import org.apache.commons.lang3.builder.ToStringStyle;
  9. import org.jbehave.core.model.ExamplesTable;
  10. import org.jbehave.core.model.GivenStories;
  11. import org.jbehave.core.model.Lifecycle;
  12. import org.jbehave.core.model.Narrative;
  13. import org.jbehave.core.model.OutcomesTable;
  14. import org.jbehave.core.model.Scenario;
  15. import org.jbehave.core.model.Step;
  16. import org.jbehave.core.model.Story;
  17. import org.jbehave.core.model.StoryDuration;
  18. import org.jbehave.core.steps.StepCollector.Stage;
  19. import org.jbehave.core.steps.StepCreator.PendingStep;
  20. import org.jbehave.core.steps.Timing;

  21. /**
  22.  * Reporter which collects other {@link StoryReporter}s and delegates all
  23.  * invocations to the collected reporters.
  24.  *
  25.  * @author Mirko FriedenHagen
  26.  */
  27. public class DelegatingStoryReporter implements StoryReporter {

  28.     private final Collection<StoryReporter> delegates;

  29.     /**
  30.      * Creates DelegatingStoryReporter with a given collections of delegates
  31.      *
  32.      * @param delegates the ScenarioReporters to delegate to
  33.      */
  34.     public DelegatingStoryReporter(Collection<StoryReporter> delegates) {
  35.         this.delegates = delegates;
  36.     }

  37.     /**
  38.      * Creates DelegatingStoryReporter with a given varargs of delegates
  39.      *
  40.      * @param delegates the StoryReporters to delegate to
  41.      */
  42.     public DelegatingStoryReporter(StoryReporter... delegates) {
  43.         this(asList(delegates));
  44.     }

  45.     @Override
  46.     public void beforeStoriesSteps(Stage stage) {
  47.         delegate(reporter -> reporter.beforeStoriesSteps(stage));
  48.     }

  49.     @Override
  50.     public void afterStoriesSteps(Stage stage) {
  51.         delegate(reporter -> reporter.afterStoriesSteps(stage));
  52.     }

  53.     @Override
  54.     public void afterScenario(Timing timing) {
  55.         delegate(reporter -> reporter.afterScenario(timing));
  56.     }

  57.     @Override
  58.     public void afterScenarios() {
  59.         delegate(StoryReporter::afterScenarios);
  60.     }

  61.     @Override
  62.     public void afterStory(boolean givenStory) {
  63.         delegate(reporter -> reporter.afterStory(givenStory));
  64.     }

  65.     @Override
  66.     public void beforeScenarios() {
  67.         delegate(StoryReporter::beforeScenarios);
  68.     }

  69.     @Override
  70.     public void beforeScenario(Scenario scenario) {
  71.         delegate(reporter -> reporter.beforeScenario(scenario));
  72.     }

  73.     @Override
  74.     public void beforeStory(Story story, boolean givenStory) {
  75.         delegate(reporter -> reporter.beforeStory(story, givenStory));
  76.     }

  77.     @Override
  78.     public void narrative(final Narrative narrative) {
  79.         delegate(reporter -> reporter.narrative(narrative));
  80.     }

  81.     @Override
  82.     public void lifecycle(Lifecycle lifecycle) {
  83.         delegate(reporter -> reporter.lifecycle(lifecycle));
  84.     }

  85.     @Override
  86.     public void beforeScenarioSteps(Stage stage, Lifecycle.ExecutionType type) {
  87.         delegate(reporter -> reporter.beforeScenarioSteps(stage, type));
  88.     }

  89.     @Override
  90.     public void afterScenarioSteps(Stage stage, Lifecycle.ExecutionType type) {
  91.         delegate(reporter -> reporter.afterScenarioSteps(stage, type));
  92.     }

  93.     @Override
  94.     public void beforeComposedSteps() {
  95.         delegate(StoryReporter::beforeComposedSteps);
  96.     }

  97.     @Override
  98.     public void afterComposedSteps() {
  99.         delegate(StoryReporter::afterComposedSteps);
  100.     }

  101.     @Override
  102.     public void beforeStorySteps(Stage stage, Lifecycle.ExecutionType type) {
  103.         delegate(reporter -> reporter.beforeStorySteps(stage, type));
  104.     }

  105.     @Override
  106.     public void afterStorySteps(Stage stage, Lifecycle.ExecutionType type) {
  107.         delegate(reporter -> reporter.afterStorySteps(stage, type));
  108.     }

  109.     @Override
  110.     public void beforeExamples(List<String> steps, ExamplesTable table) {
  111.         delegate(reporter -> reporter.beforeExamples(steps, table));
  112.     }

  113.     @Override
  114.     public void example(Map<String, String> tableRow, int exampleIndex) {
  115.         delegate(reporter -> reporter.example(tableRow, exampleIndex));
  116.     }

  117.     @Override
  118.     public void afterExamples() {
  119.         delegate(StoryReporter::afterExamples);
  120.     }

  121.     @Override
  122.     public void failed(String step, Throwable cause) {
  123.         delegate(reporter -> reporter.failed(step, cause));
  124.     }

  125.     @Override
  126.     public void failedOutcomes(String step, OutcomesTable table) {
  127.         delegate(reporter -> reporter.failedOutcomes(step, table));
  128.     }

  129.     @Override
  130.     public void beforeGivenStories() {
  131.         delegate(StoryReporter::beforeGivenStories);
  132.     }

  133.     @Override
  134.     public void givenStories(GivenStories givenStories) {
  135.         delegate(reporter -> reporter.givenStories(givenStories));
  136.     }

  137.     @Override
  138.     public void givenStories(List<String> storyPaths) {
  139.         delegate(reporter -> reporter.givenStories(storyPaths));
  140.     }

  141.     @Override
  142.     public void afterGivenStories() {
  143.         delegate(StoryReporter::afterGivenStories);
  144.     }

  145.     @Override
  146.     public void beforeStep(Step step) {
  147.         delegate(reporter -> reporter.beforeStep(step));
  148.     }

  149.     @Override
  150.     public void ignorable(String step) {
  151.         delegate(reporter -> reporter.ignorable(step));
  152.     }

  153.     @Override
  154.     public void comment(String step) {
  155.         delegate(reporter -> reporter.comment(step));
  156.     }

  157.     @Override
  158.     public void notPerformed(String step) {
  159.         delegate(reporter -> reporter.notPerformed(step));
  160.     }

  161.     @Override
  162.     public void pending(PendingStep step) {
  163.         delegate(reporter -> reporter.pending(step));
  164.     }

  165.     @Override
  166.     public void pending(String step) {
  167.         delegate(reporter -> reporter.pending(step));
  168.     }

  169.     @Override
  170.     public void successful(String step) {
  171.         delegate(reporter -> reporter.successful(step));
  172.     }

  173.     @Override
  174.     public void scenarioExcluded(Scenario scenario, String filter) {
  175.         delegate(reporter -> reporter.scenarioExcluded(scenario, filter));
  176.     }

  177.     @Override
  178.     public void storyExcluded(Story story, String filter) {
  179.         delegate(reporter -> reporter.storyExcluded(story, filter));
  180.     }

  181.     @Override
  182.     public void dryRun() {
  183.         delegate(StoryReporter::dryRun);
  184.     }
  185.    
  186.     @Override
  187.     public void pendingMethods(List<String> methods) {
  188.         delegate(reporter -> reporter.pendingMethods(methods));
  189.     }

  190.     @Override
  191.     public void restarted(String step, Throwable cause) {
  192.         delegate(reporter -> reporter.restarted(step, cause));
  193.     }
  194.    
  195.     @Override
  196.     public void restartedStory(Story story, Throwable cause) {
  197.         delegate(reporter -> reporter.restartedStory(story, cause));
  198.     }

  199.     @Override
  200.     public void storyCancelled(Story story, StoryDuration storyDuration) {
  201.         delegate(reporter -> reporter.storyCancelled(story, storyDuration));
  202.     }

  203.     private void delegate(Consumer<StoryReporter> reporter) {
  204.         delegates.forEach(reporter);
  205.     }

  206.     public Collection<StoryReporter> getDelegates() {
  207.         return delegates;
  208.     }

  209.     @Override
  210.     public String toString() {
  211.         return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
  212.     }
  213. }