Java Story类代码示例

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Override
public void beforeScenario(final String title) {
    final Story story = stories.get();
    final String uuid = scenarios.get();
    final String fullName = String.format("%s: %s", story.getName(), title);
    final TestResult result = new TestResult()
            .withUuid(uuid)
            .withName(title)
            .withFullName(fullName)
            .withStage(Stage.SCHEDULED)
            .withLabels(createStoryLabel(story.getName()), createHostLabel(), createThreadLabel())
            .withDescription(story.getDescription().asString())
            .withHistoryId(md5(fullName));
    getLifecycle().scheduleTestCase(result);
    getLifecycle().startTestCase(result.getUuid());
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Override
public void beforeStory(Story story, boolean givenStory)
{
  // name includes full path so try to extract just the last component (i.e.
  // the story filename)
  // and put that into the MDC
  String name = story.getName();
  String shortName = name;

  int idx = name.lastIndexOf('/') + 1;
  if (idx > 0) {
    shortName = name.substring(idx);
  }

  MDC.put("story", shortName);
  LOG.info("LoggingStoryReporter.beforeStory() - (path: {})", story.getPath());
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldParseStoryWithNarrativeUsingGherkin() throws IOException{
	String storyAsText = "Feature: Hello Car\n"
			    + "Narrative:\n"
			    + "In order to feel safer\n"
			    + "As a car driver\n"
			    + "I want to drive cars on 4 wheels\n"
				+ "Scenario: Car can drive\n"
				+ "Given I have a car with 4 wheels\n"
				+ "Then I can drive it.\n";
	Story story = storyParser.parseStory(storyAsText);
	assertThat(story.getDescription().asString(), equalTo("Hello Car"));		
	Narrative narrative = story.getNarrative();
	assertThat(narrative.inOrderTo(), equalTo("feel safer"));
	assertThat(narrative.asA(), equalTo("car driver"));
	assertThat(narrative.iWantTo(), equalTo("drive cars on 4 wheels"));
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test(expected = PendingStepFound.class)
public void shouldFailWithFailingUpongPendingStepsStrategy() throws Throwable {
    // Given
    StoryReporter reporter = mock(ConcurrentStoryReporter.class);
    Step pendingStep = mock(Step.class);
    StepResult pendingResult = pending("My step isn't defined!");
    when(pendingStep.perform(null)).thenReturn(pendingResult);
    PendingStepStrategy strategy = new FailingUponPendingStep();
    StepCollector collector = mock(StepCollector.class);
    CandidateSteps mySteps = new Steps();
    when(collector.collectScenarioSteps(eq(asList(mySteps)), (Scenario) anyObject(), eq(parameters))).thenReturn(
            asList(pendingStep));
    Story story = new Story(asList(new Scenario()));
    givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps);

    // When
    StoryRunner runner = new StoryRunner();
    runner.run(configurationWithPendingStrategy(collector, reporter,
            strategy), asList(mySteps), story);

    // Then ... fail as expected
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldRunBeforeAndAfterStorySteps() throws Throwable {
    // Given
    StoryReporter reporter = mock(ConcurrentStoryReporter.class);
    Step beforeStep = mockSuccessfulStep("beforeStep");
    Step afterStep = mockSuccessfulStep("secondStep");
    StepCollector collector = mock(StepCollector.class);
    FailureStrategy strategy = mock(FailureStrategy.class);
    CandidateSteps mySteps = new Steps();
    Story story = new Story();
    boolean givenStory = false;
    when(collector.collectBeforeOrAfterStorySteps(asList(mySteps), story, Stage.BEFORE, givenStory)).thenReturn(asList(beforeStep));
    when(collector.collectBeforeOrAfterStorySteps(asList(mySteps), story, Stage.AFTER, givenStory)).thenReturn(asList(afterStep));

    // When
    StoryRunner runner = new StoryRunner();
    runner.run(configurationWith(reporter, collector, strategy),asList(mySteps), story);

    // Then
    verify(beforeStep).perform(null);
    verify(afterStep).perform(null);
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
/**
 * Maps a story if it is allowed by the meta filter
 * 
 * @param story
 *            the Story
 * @param metaFilter
 *            the meta filter
 */
public void map(Story story, MetaFilter metaFilter) {
    if (metaFilter.allow(story.getMeta())) {
        boolean allowed = false;
        for (Scenario scenario : story.getScenarios()) {
            // scenario also inherits meta from story
            Meta inherited = scenario.getMeta().inheritFrom(story.getMeta());
            if (metaFilter.allow(inherited)) {
                allowed = true;
                break;
            }
        }
        if (allowed) {
            add(metaFilter.asString(), story);
        }
    }
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldHandlePendingStepsAccordingToStrategy() throws Throwable {
    // Given
    StoryReporter reporter = mock(ConcurrentStoryReporter.class);
    Step pendingStep = mock(Step.class);
    StepResult pendingResult = pending("My step isn't defined!");
    when(pendingStep.perform(null)).thenReturn(pendingResult);
    PendingStepStrategy strategy = mock(PendingStepStrategy.class);
    StepCollector collector = mock(StepCollector.class);
    CandidateSteps mySteps = new Steps();
    when(collector.collectScenarioSteps(eq(asList(mySteps)), (Scenario) anyObject(), eq(parameters))).thenReturn(
            asList(pendingStep));
    Story story = new Story(asList(new Scenario()));
    givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps);

    // When
    StoryRunner runner = new StoryRunner();
    runner.run(configurationWithPendingStrategy(collector, reporter,
            strategy), asList(mySteps), story);

    // Then
    verify(strategy).handleFailure(pendingResult.getFailure());
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldParseStoryWithMeta() {
    String wholeStory = "Meta: @skip @theme parsing" + NL + 
    		"GivenStories: path1,path2 " + NL +
            "Scenario: A scenario" + NL +
            "Meta: @author Mauro" + NL +
            "Given a step " + NL +
            "Scenario: Another scenario" + NL +
            "Meta: @author Paul" + NL +
            "Given another step ";
    Story story = parser.parseStory(
            wholeStory, storyPath);
    assertThat(story.getPath(), equalTo(storyPath));
    Meta storyMeta = story.getMeta();
    assertThat(storyMeta.getProperty("theme"), equalTo("parsing"));
    assertThat(storyMeta.getProperty("skip"), equalTo(""));
    assertThat(storyMeta.getProperty("unknown"), equalTo(""));        
    assertThat(story.getGivenStories().getPaths(), equalTo(asList("path1", "path2")));
    List<Scenario> scenarios = story.getScenarios();
    assertThat(scenarios.get(0).getTitle(), equalTo("A scenario"));
    assertThat(scenarios.get(0).getMeta().getProperty("author"), equalTo("Mauro"));
    assertThat(scenarios.get(1).getTitle(), equalTo("Another scenario"));
    assertThat(scenarios.get(1).getMeta().getProperty("author"), equalTo("Paul"));
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldAllowSpacesInMetaProperties() {
    String wholeStory = "Meta: @ theme parsing @ skip" + NL +
            "Scenario: " + NL +
            "Meta: @authors Mauro Paul" + NL +
            "Given a scenario " + NL +
            "When I parse it" + NL +
            "Then I should get steps";
    Story story = parser.parseStory(
            wholeStory, storyPath);
    assertThat(story.getPath(), equalTo(storyPath));
    Meta storyMeta = story.getMeta();
    assertThat(storyMeta.getProperty("theme"), equalTo("parsing"));
    assertThat(storyMeta.getProperty("skip"), equalTo(""));
    assertThat(story.getScenarios().get(0).getMeta().getProperty("authors"), equalTo("Mauro Paul"));
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
public void runStories(List<String> storyPaths, MetaFilter filter, BatchFailures failures) {
    // configure cross reference with meta filter
    if ( configuration.storyReporterBuilder().hasCrossReference() ){
        configuration.storyReporterBuilder().crossReference().withMetaFilter(filter.asString());
    }
    
    // run before stories
    State beforeStories = runBeforeOrAfterStories(failures, Stage.BEFORE);

    // run stories as paths
    runningStoriesAsPaths(storyPaths, filter, beforeStories);
    waitUntilAllDoneOrFailed(failures);
    List<Story> notAllowed = notAllowedBy(filter);
    if (!notAllowed.isEmpty()) {
        embedderMonitor.storiesNotAllowed(notAllowed, filter, embedderControls.verboseFiltering());
    }

    // run after stories
   runBeforeOrAfterStories(failures, Stage.AFTER);
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
public void mapStoriesAsPaths(List<String> storyPaths) {
    EmbedderControls embedderControls = embedderControls();
    embedderMonitor.usingControls(embedderControls);

    if (embedderControls.skip()) {
        embedderMonitor.storiesSkipped(storyPaths);
        return;
    }

    processSystemProperties();

    StoryManager storyManager = storyManager();
    for (String storyPath : storyPaths) {
        Story story = storyManager.storyOfPath(storyPath);
        embedderMonitor.mappingStory(storyPath, metaFilters);
        storyMapper.map(story, new MetaFilter(""));
        for (String filter : metaFilters) {
            storyMapper.map(story, new MetaFilter(filter));
        }
    }

    generateMapsView(storyMapper.getStoryMaps());

}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldNotPassSilentlyOutputNotAllowedByMetaFilter() {
    // Given
    StoryReporter delegate = mock(StoryReporter.class);
    SilentSuccessFilter filter = new SilentSuccessFilter(delegate);
    Story story = new Story();
    Scenario scenario = new Scenario();

    String metaFilter = "";
    // When
    filter.storyNotAllowed(story, metaFilter);
    filter.scenarioNotAllowed(scenario, metaFilter);

    // Then
    InOrder inOrder = inOrder(delegate);

    inOrder.verify(delegate).storyNotAllowed(story, metaFilter);
    inOrder.verify(delegate).scenarioNotAllowed(scenario, metaFilter);

}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
public void stepMatchesPattern(String step, boolean matches, StepPattern pattern, Method method,
        Object stepsInstance) {
    Story story = currentStory.get();
    if (story == null) {
        throw new NullPointerException("story not setup for CrossReference");
    }

    if (matches) {
        String key = pattern.type() + pattern.annotated();
        StepMatch stepMatch = stepMatches.get(key);
        if (stepMatch == null) {
            stepMatch = new StepMatch(pattern.type(), pattern.annotated(), pattern.resolved());
            stepMatches.put(key, stepMatch);
        }
        // find canonical ref for same stepMatch
        stepMatch.usages.add(new StepUsage(story.getPath(), currentScenarioTitle.get(), step));
    }
    super.stepMatchesPattern(step, matches, pattern, method, stepsInstance);
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldIgnoreCommentsInMetaProperties() {
    String wholeStory = "Meta: !-- this is the theme @theme parsing !-- skip me @skip" + NL +
            "Scenario: " + NL +
            "Meta: !-- these are the authors @authors Mauro Paul" + NL +
            "Given a scenario " + NL +
            "When I parse it" + NL +
            "Then I should get steps";
    Story story = parser.parseStory(
            wholeStory, storyPath);
    assertThat(story.getPath(), equalTo(storyPath));
    Meta storyMeta = story.getMeta();
    assertThat(storyMeta.getProperty("theme"), equalTo("parsing"));
    assertThat(storyMeta.getProperty("skip"), equalTo(""));
    assertThat(story.getScenarios().get(0).getMeta().getProperty("authors"), equalTo("Mauro Paul"));
}
 

import org.jbehave.core.model.Story; //导入依赖的package包/类
@Test
public void shouldParseStoryWithDescriptionAndNarrative() {
    String wholeStory = "Story: This is free-text description"+ NL +
            "Narrative: This bit of text is ignored" + NL +
            "In order to renovate my house" + NL +
            "As a customer" + NL +
            "I want to get a loan" + NL +
            "Scenario:  A first scenario";
    Story story = parser.parseStory(
            wholeStory, storyPath);
    Description description = story.getDescription();
    assertThat(description.asString(), equalTo("Story: This is free-text description"));
    Narrative narrative = story.getNarrative();
    assertThat(narrative.isEmpty(), not(true));
    assertThat(narrative.inOrderTo().toString(), equalTo("renovate my house"));
    assertThat(narrative.asA().toString(), equalTo("customer"));
    assertThat(narrative.iWantTo().toString(), equalTo("get a loan"));
}