org.jbehave.core.steps.InjectableStepsFactory Java Examples

private void mockStepsAndCandidates(String resourceLocation, List<String> steps, List<StepCandidate> stepCandidates)
        throws Exception
{
    PowerMockito.whenNew(BddStepsCounter.class).withNoArguments().thenReturn(bddStepsCounter);
    PowerMockito.doNothing().when(Vividus.class, "init");
    when(BeanFactory.getBean(StoryLoader.class)).thenReturn(storyLoader);
    when(BeanFactory.getBean(IPathFinder.class)).thenReturn(pathFinder);
    when(BeanFactory.getBean(ExtendedConfiguration.class)).thenReturn(configuration);
    when(configuration.keywords()).thenReturn(keywords);
    when(keywords.and()).thenReturn(AND);
    when(keywords.ignorable()).thenReturn(COMMENT);
    when(configuration.storyParser()).thenReturn(storyParser);
    String path = "";
    when(pathFinder.findPaths(argThat(arg -> resourceLocation.equals(arg.getResourceLocation())))).thenReturn(
            List.of(path));
    String storyText = "";
    when(storyLoader.loadResourceAsText(path)).thenReturn(storyText);
    when(storyParser.parseStory(any(String.class))).thenReturn(story);
    when(story.getScenarios()).thenReturn(List.of(scenario));
    when(scenario.getSteps()).thenReturn(steps);
    when(BeanFactory.getBean(InjectableStepsFactory.class)).thenReturn(stepFactory);
    when(stepFactory.createCandidateSteps()).thenReturn(List.of(candidateSteps));
    when(candidateSteps.listCandidates()).thenReturn(stepCandidates);
}
 

@SuppressWarnings("PMD.SignatureDeclareThrowsException")
private List<String> mockStepCandidates() throws Exception
{
    mockStatic(Vividus.class);
    PowerMockito.doNothing().when(Vividus.class, "init");
    mockStatic(BeanFactory.class);
    InjectableStepsFactory stepsFactory = mock(InjectableStepsFactory.class);
    when(BeanFactory.getBean(InjectableStepsFactory.class)).thenReturn(stepsFactory);
    CandidateSteps candidateSteps = mock(CandidateSteps.class);
    when(stepsFactory.createCandidateSteps()).thenReturn(List.of(candidateSteps));
    StepCandidate stepCandidate1 = mockStepCandidate("Given", "initial state is '$status'", "simpleMethod");
    StepCandidate stepCandidate2 = mockStepCandidate("When", "I do '$action'", "deprecatedMethod");
    StepCandidate stepCandidate3 = mockStepCandidate("Then", "I perform '$verification'", (Method) null);
    when(candidateSteps.listCandidates()).thenReturn(List.of(stepCandidate1, stepCandidate2, stepCandidate3));
    return List.of("                         Given initial state is '$status'",
            " DEPRECATED              When I do '$action'",
            " COMPOSITE IN STEPS FILE Then I perform '$verification'");
}
 

@Override
public InjectableStepsFactory stepsFactory() {
  return new InstanceStepsFactory(configuration(),
    new LogSearchDockerSteps(),
    new SolrSteps(),
    new LogSearchApiSteps(),
    new LogSearchConfigApiSteps());
}
 

private AllureResults runStories(final String... storyResources) {
    final AllureResultsWriterStub writer = new AllureResultsWriterStub();
    final AllureLifecycle lifecycle = new AllureLifecycle(writer);

    final Embedder embedder = new Embedder();
    embedder.useEmbedderMonitor(new NullEmbedderMonitor());
    embedder.useEmbedderControls(new EmbedderControls()
            .doGenerateViewAfterStories(false)
            .doFailOnStoryTimeout(false)
            .doBatch(false)
            .doIgnoreFailureInStories(true)
            .doIgnoreFailureInView(true)
            .doVerboseFailures(false)
            .doVerboseFiltering(false)
    );
    final AllureJbehave allureJbehave = new AllureJbehave(lifecycle);
    embedder.useConfiguration(new MostUsefulConfiguration()
            .useStoryLoader(new LoadFromClasspath(this.getClass()))
            .useStoryReporterBuilder(new ReportlessStoryReporterBuilder(temp.toFile())
                    .withReporters(allureJbehave)
            )
            .useDefaultStoryReporter(new NullStoryReporter())
    );
    final InjectableStepsFactory stepsFactory = new InstanceStepsFactory(
            embedder.configuration(),
            new SimpleStorySteps(),
            new BrokenStorySteps()
    );
    embedder.useCandidateSteps(stepsFactory.createCandidateSteps());
    final AllureLifecycle cached = Allure.getLifecycle();
    try {
        Allure.setLifecycle(lifecycle);
        embedder.runStoriesAsPaths(Arrays.asList(storyResources));
    } finally {
        Allure.setLifecycle(cached);
    }
    return writer;
}
 

private static Set<Step> getSteps()
{
    InjectableStepsFactory stepFactory = BeanFactory.getBean(InjectableStepsFactory.class);
    return stepFactory.createCandidateSteps()
            .stream()
            .map(CandidateSteps::listCandidates)
            .flatMap(List::stream)
            .map(BddStepPrinter::createStepFrom)
            .collect(Collectors.toCollection(TreeSet::new));
}
 

private void fillStepCandidates()
{
    InjectableStepsFactory stepFactory = BeanFactory.getBean(InjectableStepsFactory.class);
    for (CandidateSteps candidateSteps : stepFactory.createCandidateSteps())
    {
        stepCandidates.addAll(candidateSteps.listCandidates());
    }
}
 

@Test
void testStoryManager()
{
    ExtendedConfiguration mockedConfiguration = mock(ExtendedConfiguration.class);
    ExtendedStoryReporterBuilder mockedExtendedStoryReporterBuilder = mock(ExtendedStoryReporterBuilder.class);
    when(mockedConfiguration.storyReporterBuilder()).thenReturn(mockedExtendedStoryReporterBuilder);
    BatchedEmbedder embedder = new BatchedEmbedder(bddRunContext, bddVariableContext, batchStorage);
    embedder.setEmbedderMonitor(embedderMonitor);
    BatchedEmbedder spy = spy(embedder);
    spy.useConfiguration(mockedConfiguration);
    InjectableStepsFactory mockedInjectableStepsFactory = mock(InjectableStepsFactory.class);
    spy.useStepsFactory(mockedInjectableStepsFactory);
    EmbedderControls mockedEmbedderControls = mockEmbedderControls(spy);
    when(mockedEmbedderControls.threads()).thenReturn(THREADS);
    ExecutorService mockedExecutorService = mock(ExecutorService.class);
    spy.useExecutorService(mockedExecutorService);
    PerformableTree mockedPerformableTree = mock(BatchedPerformableTree.class);
    PerformableTree.PerformableRoot mockedPerformableRoot = mock(PerformableTree.PerformableRoot.class);
    when(mockedPerformableTree.getRoot()).thenReturn(mockedPerformableRoot);
    spy.usePerformableTree(mockedPerformableTree);
    TimeoutParser mockedTimeoutParser = mock(TimeoutParser.class);
    TimeoutParser[] timeoutParsers = { mockedTimeoutParser };
    spy.useTimeoutParsers(timeoutParsers);
    StoryManager expected = new StoryManager(mockedConfiguration, mockedInjectableStepsFactory,
            mockedEmbedderControls, embedderMonitor, mockedExecutorService, mockedPerformableTree, timeoutParsers);
    StoryManager actual = spy.storyManager();
    assertEquals(expected.performableRoot(), actual.performableRoot());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
    return new InstanceStepsFactory(configuration(),
            new CommonSteps(),
            new PeopleSteps()
    );
}
 

@Override
public InjectableStepsFactory stepsFactory() {
	return new InstanceStepsFactory(configuration(), new UserRegistrationSteps());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
	return new InstanceStepsFactory(configuration(),
			new UserRegistrationSteps());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
    return new InstanceStepsFactory(configuration(), new IncreaseSteps());
}
 

@Override
public InjectableStepsFactory stepsFactory()
{
    return embedder.stepsFactory();
}
 

@Override
public InjectableStepsFactory stepsFactory() {
    return new InstanceStepsFactory(configuration(), stepInstance());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
    return new InstanceStepsFactory(configuration(), new MetricsReportingSteps());
}
 

@Override
public InjectableStepsFactory stepsFactory() {        
    // varargs, can have more that one steps classes
    return new InstanceStepsFactory(configuration(),new AdderSteps());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
    return new InstanceStepsFactory(configuration(), getSteps());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
    return new InstanceStepsFactory(configuration(), new WebSteps());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
    return new InstanceStepsFactory(configuration(), new Steps());
}
 

@Override
public InjectableStepsFactory stepsFactory() {
  Configuration configuration = configuration();
  return new InstanceStepsFactory(configuration, new LogSearchDockerSteps(), new LogSearchUISteps(driverProvider),
    new WebDriverScreenshotOnFailure(driverProvider, configuration.storyReporterBuilder()));
}
 

public void setStepFactory(InjectableStepsFactory stepsFactory)
{
    useStepsFactory(stepsFactory);
}
 

public StepExamplesTableParser(ExtendedConfiguration configuration, InjectableStepsFactory stepsFactory)
{
    this.configuration = configuration;
    this.stepsFactory = stepsFactory;
}