Java Embedder类代码示例

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Override
public Embedder configuredEmbedder() {
    StepEventBus.getEventBus().setUniqueSession(true);
    Embedder embedder = super.configuredEmbedder();
    embedder.useExecutorService(MoreExecutors.sameThreadExecutor());
    embedder.configuration().useStepCollector(stepCollector);
    embedder.useStepsFactory(new ScanningStepsFactory(embedder
            .configuration(), this.getClass(), pages));
    embedder.configuration()
            .useParameterControls(new ParameterControls()
                    .useDelimiterNamedParameters(true));
    embedder.configuration()
            .storyReporterBuilder()
            .withReporters(new SatisfyStoryReporter()
                    , new ConsoleOutput());
    embedder.useEmbedderMonitor(new NullEmbedderMonitor());
    embedder.useMetaFilters(getSatisfyProperties().getMetaFilters());
    return embedder;
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Override
public void runTests(TestPage pageToTest) {
    final ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
    testSummary = new TestSummary();

    testSystemListener.testStarted(pageToTest);

    try {
        Thread.currentThread().setContextClassLoader(classLoader);

        Embedder embedder = newEmbedder();

        resolveCandidateSteps(pageToTest, embedder);

        embedder.runStoriesAsPaths(Collections.singletonList(pageToTest.getContent()));
    } finally {
        Thread.currentThread().setContextClassLoader(originalClassLoader);
        testSystemListener.testComplete(pageToTest, testSummary);
    }
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
private void runStories(String... storyPaths) {
    StoryReporterBuilder storyReporterBuilder = new StoryReporterBuilder().withDefaultFormats()
            .withCodeLocation(CodeLocations.codeLocationFromClass(ReportTransformBehaviour.class))
            .withFormats(Format.XML);

    Configuration configuration = new MostUsefulConfiguration()
            .useStoryLoader(new LoadFromClasspath(this.getClass())).useStoryReporterBuilder(storyReporterBuilder)
            .useFailureStrategy(new SilentlyAbsorbingFailure())
            .useStepCollector(new MarkUnmatchedStepsAsPending(new StepFinder(new ByLevenshteinDistance())));

    Embedder embedder = new Embedder();
    embedder.useEmbedderControls(new EmbedderControls().doGenerateViewAfterStories(false));
    embedder.useConfiguration(configuration);
    embedder.useCandidateSteps(new InstanceStepsFactory(configuration, new MySteps()).createCandidateSteps());
    embedder.useMetaFilters(asList("-skip true"));

    try {
        embedder.runStoriesAsPaths(asList(storyPaths));
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldCreateNewEmbedderWithDefaultControls() {
    // Given
    AbstractEmbedderTask task = new AbstractEmbedderTask() {
    };
    // When
    Embedder embedder = task.newEmbedder();
    // Then
    EmbedderControls embedderControls = embedder.embedderControls();
    assertThat(embedderControls.batch(), is(false));
    assertThat(embedderControls.generateViewAfterStories(), is(true));
    assertThat(embedderControls.ignoreFailureInStories(), is(false));
    assertThat(embedderControls.ignoreFailureInView(), is(false));
    assertThat(embedderControls.skip(), is(false));
    assertThat(embedderControls.verboseFailures(), is(false));
    assertThat(embedderControls.verboseFiltering(), is(false));
    assertThat(embedderControls.storyTimeoutInSecs(), equalTo(300L));
    assertThat(embedderControls.threads(), equalTo(1));  
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldCreateNewEmbedderWithSystemProperties() throws IOException {
    // Given
    AbstractEmbedderTask task = new AbstractEmbedderTask() {
    };
    // When
    Properties systemProperties = new Properties();
    systemProperties.setProperty("one", "1");
    systemProperties.setProperty("two", "2");        
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    systemProperties.store(out, "");
    task.setSystemProperties(out.toString());
    Embedder embedder = task.newEmbedder();
    // Then
    assertThat(embedder.systemProperties(), equalTo(systemProperties));
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldGenerateStoriesView() {
    // Given
    GenerateStoriesView task = new GenerateStoriesView() {
        @Override
        protected Embedder newEmbedder() {
            return embedder;
        }

    };
    // When
    task.execute();

    // Then
    verify(embedder).generateReportsView();
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldReportStepdocs() {
    // Given
    ReportStepdocs task = new ReportStepdocs() {
        @Override
        protected Embedder newEmbedder() {
            return embedder;
        }

    };
    // When
    task.execute();

    // Then
    verify(embedder).reportStepdocs();
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldCreateNewEmbedderWithDefaultControls() {
    // Given
    AbstractEmbedderMojo mojo = new AbstractEmbedderMojo() {
        public void execute() throws MojoExecutionException, MojoFailureException {
        }
    };
    // When
    Embedder embedder = mojo.newEmbedder();
    // Then
    EmbedderControls embedderControls = embedder.embedderControls();
    assertThat(embedderControls.batch(), is(false));
    assertThat(embedderControls.generateViewAfterStories(), is(true));
    assertThat(embedderControls.ignoreFailureInStories(), is(false));
    assertThat(embedderControls.ignoreFailureInView(), is(false));
    assertThat(embedderControls.threads(), is(1));
    assertThat(embedderControls.skip(), is(false));
    assertThat(embedderControls.storyTimeoutInSecs(), equalTo(300L));
    assertThat(embedderControls.threads(), equalTo(1));
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldCreateNewEmbedderWithGivenControls() {
    // Given
    AbstractEmbedderMojo mojo = new AbstractEmbedderMojo() {
        public void execute() throws MojoExecutionException, MojoFailureException {
        }
    };
    // When
    mojo.batch = true;
    mojo.generateViewAfterStories = false;
    mojo.ignoreFailureInStories = true;
    mojo.ignoreFailureInView = true;
    mojo.storyTimeoutInSecs = 60;
    mojo.threads = 2;
    mojo.skip = true;
    Embedder embedder = mojo.newEmbedder();
    // Then
    EmbedderControls embedderControls = embedder.embedderControls();
    assertThat(embedderControls.batch(), is(true));
    assertThat(embedderControls.generateViewAfterStories(), is(false));
    assertThat(embedderControls.ignoreFailureInStories(), is(true));
    assertThat(embedderControls.ignoreFailureInView(), is(true));
    assertThat(embedderControls.storyTimeoutInSecs(), is(60L));
    assertThat(embedderControls.threads(), is(2));
    assertThat(embedderControls.skip(), is(true));
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldCreateNewEmbedderWithSystemProperties() {
    // Given
    AbstractEmbedderMojo mojo = new AbstractEmbedderMojo() {
        public void execute() throws MojoExecutionException, MojoFailureException {
        }
    };
    // When
    Properties systemProperties = new Properties();
    systemProperties.setProperty("one", "1");
    systemProperties.setProperty("two", "2");
    mojo.systemProperties = systemProperties;
    Embedder embedder = mojo.newEmbedder();
    // Then
    assertThat(embedder.systemProperties(), equalTo(systemProperties));
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldGenerateStoriesView() throws MojoExecutionException, MojoFailureException {
    // Given
    GenerateStoriesView mojo = new GenerateStoriesView() {
        @Override
        protected Embedder newEmbedder() {
            return embedder;
        }

    };
    // When
    mojo.execute();

    // Then
    verify(embedder).generateReportsView();
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldReportStepdocs() throws MojoExecutionException, MojoFailureException {
    // Given
    ReportStepdocs mojo = new ReportStepdocs() {
        @Override
        protected Embedder newEmbedder() {
            return embedder;
        }

    };
    // When
    mojo.execute();

    // Then
    verify(embedder).reportStepdocs();
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test(expected = MojoFailureException.class)
public void shouldReportFailuresWhenReportingStepdocs() throws MojoExecutionException, MojoFailureException {
    // Given
    ReportStepdocs mojo = new ReportStepdocs() {
        @Override
        protected Embedder newEmbedder() {
            return embedder;
        }

    };

    // When
    doThrow(new RuntimeException()).when(embedder).reportStepdocs();
    mojo.execute();

    // Then fail as expected
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
protected Object injectEmbedder(Embedder embedder, Class<?> annotatedClass) {
    try {
        Object instance = annotatedClass.newInstance();
        if (instance instanceof Embeddable) {
            Embeddable embeddable = (Embeddable) instance;
            embeddable.useEmbedder(embedder);
        }
        if (instance instanceof ConfigurableEmbedder) {
            ConfigurableEmbedder configurableEmbedder = (ConfigurableEmbedder) instance;
            configurableEmbedder.useConfiguration(embedder.configuration());
            configurableEmbedder.addSteps(embedder.candidateSteps());
            configurableEmbedder.useStepsFactory(embedder.stepsFactory());
        }
        return instance;
    } catch (Exception e) {
        annotationMonitor.elementCreationFailed(annotatedClass, e);
        throw new InstantiationFailed(annotatedClass, e);
    }
}
 

import org.jbehave.core.embedder.Embedder; //导入依赖的package包/类
@Test
public void shouldRunASingleStory() throws Throwable {
    // Given
    Embedder embedder = mock(Embedder.class);
    Configuration configuration = mock(Configuration.class);
    StoryPathResolver pathResolver = mock(StoryPathResolver.class);
    when(embedder.configuration()).thenReturn(configuration);
    when(configuration.storyPathResolver()).thenReturn(pathResolver);
    Class<MyStory> storyClass = MyStory.class;
    String storyPath = "/path/to/story";
    when(pathResolver.resolve(storyClass)).thenReturn(storyPath);
    CandidateSteps steps = mock(CandidateSteps.class);

    // When
    MyStory story = new MyStory(configuration, steps);
    story.useEmbedder(embedder);
    story.run();

    // Then
    verify(embedder).useConfiguration(configuration);
    verify(embedder).useCandidateSteps(eq(asList(steps)));
    verify(embedder).runStoriesAsPaths(asList(storyPath));
}