EmbedderMonitorBehaviour.java

package org.jbehave.core.embedder;

import java.io.File;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;

import org.apache.commons.io.output.ByteArrayOutputStream;
import org.jbehave.core.failures.BatchFailures;
import org.jbehave.core.model.Meta;
import org.jbehave.core.model.Story;
import org.jbehave.core.model.StoryDuration;
import org.jbehave.core.model.StoryMaps;
import org.jbehave.core.reporters.PrintStreamOutput.Format;
import org.jbehave.core.reporters.ReportsCount;
import org.junit.Test;

import static java.util.Arrays.asList;

import static org.hamcrest.MatcherAssert.assertThat;

import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

public class EmbedderMonitorBehaviour {

    @Test
    public void shouldNotPrintWithSilentMonitor() throws Throwable {
        OutputStream out = new ByteArrayOutputStream();
        SilentEmbedderMonitor monitor = new SilentEmbedderMonitor(new PrintStream(out));
        monitor.print("a message");
        monitor.printStackTrace(new RuntimeException());
        assertThat(out.toString(), is(""));
    }

    @Test
    public void shouldOnlyPrintFailuresWithReportingFailuresMonitor() throws Throwable {
        OutputStream out = new ByteArrayOutputStream();
        ReportingFailuresEmbedderMonitor monitor = new ReportingFailuresEmbedderMonitor(new PrintStream(out));
        monitor.runningEmbeddable("embeddable");
        monitor.runningStory("/path");
        monitor.generatingReportsView(new File("target"), Arrays.asList(Format.HTML.name()), new Properties());
        monitor.reportsViewGenerated(new ReportsCount(1, 0, 1, 2, 1, 0, 1, 1));
        assertThat(out.toString(), is(""));
        monitor.batchFailed(new BatchFailures());
        monitor.storyFailed("/path", new RuntimeException());
        assertThat(out.toString(), is(not("")));
   }

    @Test
    public void shouldDelegateOutput() throws Throwable {
        EmbedderMonitor monitor = new ReportingFailuresEmbedderMonitor();
        assertThat(monitor.toString(), containsString(ReportingFailuresEmbedderMonitor.class.getSimpleName()+"[output="));
   }


    @Test
    public void shouldAllowDecorationOfDelegate() throws Throwable {
        // Given
        EmbedderMonitor delegate = mock(EmbedderMonitor.class);
        EmbedderMonitor monitor = new EmbedderMonitorDecorator(delegate);
        
        // When
        Object annotatedInstance = new Object();
        monitor.annotatedInstanceNotOfType(annotatedInstance, annotatedInstance.getClass());
        BatchFailures failures = new BatchFailures();
        monitor.batchFailed(failures);
        monitor.beforeOrAfterStoriesFailed();
        String name = "name";
        Throwable cause = new Throwable();
        monitor.embeddableFailed(name, cause);
        monitor.embeddableNotConfigurable(name);
        List<String> names = asList("name1");
        monitor.embeddablesSkipped(names);
        File outputDirectory = new File("target");
        StoryMaps storyMaps = mock(StoryMaps.class);
        Properties viewProperties = mock(Properties.class);
        monitor.generatingMapsView(outputDirectory, storyMaps, viewProperties);
        Properties viewResources = mock(Properties.class);
        monitor.generatingNavigatorView(outputDirectory, viewResources);
        List<String> formats = asList("TXT");
        monitor.generatingReportsView(outputDirectory, formats, viewProperties);
        String storyPath = "path";
        List<String> metaFilters = asList("- skip");
        monitor.mappingStory(storyPath, metaFilters);
        monitor.mapsViewGenerationFailed(outputDirectory, storyMaps, viewProperties, cause);
        Meta meta = mock(Meta.class);
        MetaFilter filter = mock(MetaFilter.class);
        monitor.metaNotAllowed(meta, filter);
        monitor.navigatorViewGenerationFailed(outputDirectory, viewResources, cause);
        monitor.navigatorViewNotGenerated();
        Properties properties = mock(Properties.class);
        monitor.processingSystemProperties(properties);
        ReportsCount count = mock(ReportsCount.class);
        monitor.reportsViewGenerated(count);
        monitor.reportsViewGenerationFailed(outputDirectory, formats, viewProperties, cause);
        monitor.reportsViewNotGenerated();
        monitor.runningEmbeddable(name);
        monitor.runningStory(storyPath);
        monitor.runningWithAnnotatedEmbedderRunner(name);
        List<String> storyPaths = asList("path1");
        monitor.storiesSkipped(storyPaths);
        monitor.storyFailed(storyPath, cause);
        Story story = mock(Story.class);
        long durationInSecs = 1L;
        long timeoutInSecs = 2L;
        StoryDuration storyDuration = new StoryDuration(timeoutInSecs);
        monitor.storyTimeout(story, storyDuration);
        String value = "value";
        monitor.systemPropertySet(name, value);
        int threads = 2;
        monitor.usingThreads(threads);
        
        // Then        
        verify(delegate).annotatedInstanceNotOfType(annotatedInstance, annotatedInstance.getClass());
        verify(delegate).batchFailed(failures);
        verify(delegate).beforeOrAfterStoriesFailed();
        verify(delegate).embeddableFailed(name, cause);
        verify(delegate).embeddableNotConfigurable(name);
        verify(delegate).embeddablesSkipped(names);
        verify(delegate).generatingMapsView(outputDirectory, storyMaps, viewProperties);
        verify(delegate).generatingNavigatorView(outputDirectory, viewResources);
        verify(delegate).generatingReportsView(outputDirectory, formats, viewProperties);
        verify(delegate).mappingStory(storyPath, metaFilters);
        verify(delegate).mapsViewGenerationFailed(outputDirectory, storyMaps, viewProperties, cause);
        verify(delegate).metaNotAllowed(meta, filter);
        verify(delegate).navigatorViewGenerationFailed(outputDirectory, viewResources, cause);
        verify(delegate).navigatorViewNotGenerated();
        verify(delegate).processingSystemProperties(properties);
        verify(delegate).reportsViewGenerated(count);
        verify(delegate).reportsViewGenerationFailed(outputDirectory, formats, viewProperties, cause);
        verify(delegate).reportsViewNotGenerated();
        verify(delegate).storiesSkipped(storyPaths);
        verify(delegate).storyFailed(storyPath, cause);
        verify(delegate).storyTimeout(story, storyDuration);
        verify(delegate).systemPropertySet(name, value);
        verify(delegate).usingThreads(threads);
   }

}