@Test public void shouldAllowToSkipScenariosAfterFailedScenario() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); Step failedStep = mock(Step.class); Step neverExecutedStep = mock(Step.class); StepResult failed = failed("When I fail", new UUIDExceptionWrapper(new IllegalStateException())); when(failedStep.perform(null)).thenReturn(failed); FailureStrategy failureStrategy = mock(FailureStrategy.class); StepCollector collector = mock(StepCollector.class); CandidateSteps mySteps = new Steps(); Scenario scenario1 = new Scenario(); when(collector.collectScenarioSteps(eq(asList(mySteps)), eq(scenario1), eq(parameters))) .thenReturn(asList(failedStep)); Scenario scenario2 = new Scenario(); when(collector.collectScenarioSteps(eq(asList(mySteps)), eq(scenario2), eq(parameters))) .thenReturn(asList(neverExecutedStep)); Story story = new Story(asList(scenario1, scenario2)); givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps); // When StoryRunner runner = new StoryRunner(); Configuration configuration = configurationWith(reporter, collector, failureStrategy); configuration.storyControls().doSkipScenariosAfterFailure(true); runner.run(configuration, asList(mySteps), story); // Then verify(failedStep).perform(null); verify(neverExecutedStep, never()).perform(null); }
@Test public void shouldNotRunScenariosNotAllowedByFilter() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); StepCollector collector = mock(StepCollector.class); FailureStrategy strategy = mock(FailureStrategy.class); CandidateSteps mySteps = new Steps(); when(collector.collectScenarioSteps( eq(asList(mySteps)), (Scenario) anyObject(), eq(parameters))) .thenReturn(Arrays.<Step>asList()); Meta meta = new Meta(asList("some property")); Story story = new Story( "", Description.EMPTY, Meta.EMPTY, Narrative.EMPTY, asList(new Scenario("", meta, GivenStories.EMPTY, ExamplesTable.EMPTY, asList("")))); boolean givenStory = false; givenStoryWithNoBeforeOrAfterSteps(story, givenStory, collector, mySteps); String filterAsString = "-some property"; MetaFilter filter = new MetaFilter(filterAsString); // When StoryRunner runner = new StoryRunner(); runner.run(configurationWith(reporter, collector, strategy), asList(mySteps), story, filter); // Then verify(reporter).beforeStory(story, givenStory); verify(reporter).beforeScenario(""); verify(reporter).scenarioNotAllowed(story.getScenarios().get(0), filterAsString); verify(reporter).afterScenario(); }
@Test public void shouldNotRunStoriesNotAllowedByFilterOnStoryElement() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); StepCollector collector = mock(StepCollector.class); FailureStrategy strategy = mock(FailureStrategy.class); CandidateSteps mySteps = new Steps(); when(collector.collectScenarioSteps( eq(asList(mySteps)), (Scenario) anyObject(), eq(parameters))) .thenReturn(Arrays.<Step>asList()); Story story = new Story( "excluded_path", Description.EMPTY, Meta.EMPTY, Narrative.EMPTY, asList(new Scenario())); boolean givenStory = false; givenStoryWithNoBeforeOrAfterSteps(story, givenStory, collector, mySteps); String filterAsString = "-story_path excluded_path"; MetaFilter filter = new MetaFilter(filterAsString); // When StoryRunner runner = new StoryRunner(); Configuration configuration = configurationWith(reporter, collector, strategy); configuration.storyControls().useStoryMetaPrefix("story_"); runner.run(configuration, asList(mySteps), story, filter); // Then verify(reporter).beforeStory(story, givenStory); verify(reporter).storyNotAllowed(story, filterAsString); verify(reporter).afterStory(givenStory); }
@Test public void shouldAllowToNotResetStateBeforeScenario() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); Step pendingStep = mock(Step.class); when(pendingStep.perform(null)).thenReturn(pending("pendingStep")); Step secondStep = mockSuccessfulStep("secondStep"); StepCollector collector = mock(StepCollector.class); CandidateSteps mySteps = new Steps(); Scenario scenario1 = new Scenario(); Scenario scenario2 = new Scenario(); when(collector.collectScenarioSteps(asList(mySteps), scenario1, parameters)) .thenReturn(asList(pendingStep)); when(collector.collectScenarioSteps(asList(mySteps), scenario2, parameters)) .thenReturn(asList(secondStep)); Story story = new Story(asList(scenario1, scenario2)); givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps); // When StoryRunner runner = new StoryRunner(); Configuration configuration = configurationWith(reporter, collector); configuration.storyControls().doResetStateBeforeScenario(false); runner.run(configuration, asList(mySteps), story); // Then verify(pendingStep).perform(Matchers.<UUIDExceptionWrapper>any()); verify(secondStep).doNotPerform(Matchers.<UUIDExceptionWrapper>any()); verify(secondStep, never()).perform(Matchers.<UUIDExceptionWrapper>any()); }
@Test public void shouldReportStoryCancellation() { // Given Configuration configuration = mock(Configuration.class, Mockito.RETURNS_DEEP_STUBS); when(configuration.storyControls().dryRun()).thenReturn(false); StoryReporter reporter = mock(ConcurrentStoryReporter.class); when(configuration.storyReporter(Matchers.anyString())).thenReturn(reporter); Story story = mock(Story.class); String storyPath = "story/path"; when(story.getPath()).thenReturn(storyPath); RuntimeException expected = new RuntimeException(); when(story.getMeta()).thenThrow(expected); InjectableStepsFactory stepsFactory = mock(InjectableStepsFactory.class); MetaFilter metaFilter = mock(MetaFilter.class); State state = mock(State.class); // When long durationInSecs = 2; long timeoutInSecs = 1; StoryDuration storyDuration = new StoryDuration(durationInSecs, timeoutInSecs); try { StoryRunner runner = new StoryRunner(); runner.cancelStory(story, storyDuration); runner.run(configuration, stepsFactory, story, metaFilter, state); fail("A exception should be thrown"); } catch (Throwable e) { // Then assertThat(e.equals(expected), is(true)); } verify(reporter).storyCancelled(story, storyDuration); }
@Test public void shouldAllowToNotResetStateBeforeStory() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); Step failedStep = mock(Step.class, "failedStep"); when(failedStep.perform(null)) .thenReturn( failed( "before stories", new UUIDExceptionWrapper(new RuntimeException("BeforeStories fail")))); Step pendingStep = mock(Step.class, "pendingStep"); when(pendingStep.perform(null)).thenReturn(pending("pendingStep")); StepCollector collector = mock(StepCollector.class); CandidateSteps mySteps = new Steps(); Scenario scenario1 = new Scenario(); List<CandidateSteps> candidateSteps = asList(mySteps); when(collector.collectBeforeOrAfterStoriesSteps(candidateSteps, Stage.BEFORE)) .thenReturn(asList(failedStep)); when(collector.collectScenarioSteps(candidateSteps, scenario1, parameters)) .thenReturn(asList(pendingStep)); Story story = new Story(asList(scenario1)); givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps); // When StoryRunner runner = new StoryRunner(); Configuration configuration = configurationWith(reporter, collector); configuration.storyControls().doResetStateBeforeStory(false).doResetStateBeforeScenario(false); runner.runBeforeOrAfterStories(configuration, candidateSteps, Stage.BEFORE); runner.run(configuration, candidateSteps, story); // Then verify(failedStep).perform(Matchers.<UUIDExceptionWrapper>any()); verify(pendingStep).perform(Matchers.<UUIDExceptionWrapper>any()); }
/** * Runs a Story with the given configuration and steps, applying the given meta filter. * * @param configuration the Configuration used to run story * @param candidateSteps the List of CandidateSteps containing the candidate steps methods * @param story the Story to run * @param filter the Filter to apply to the story Meta * @throws Throwable if failures occurred and FailureStrategy dictates it to be re-thrown. */ public void run( Configuration configuration, List<CandidateSteps> candidateSteps, Story story, MetaFilter filter) throws Throwable { run(configuration, candidateSteps, story, filter, null); }
@Test public void shouldRunStepsInDryRunMode() throws Throwable { // Given Scenario scenario1 = new Scenario("my title 1", asList("failingStep", "successfulStep")); Scenario scenario2 = new Scenario("my title 2", asList("successfulStep")); Scenario scenario3 = new Scenario("my title 3", asList("successfulStep", "pendingStep")); Story story = new Story( new Description("my blurb"), Narrative.EMPTY, asList(scenario1, scenario2, scenario3)); Step step = mock(Step.class); StepResult result = mock(StepResult.class, "result"); when(step.perform(null)).thenReturn(result); StoryReporter reporter = mock(ConcurrentStoryReporter.class); StepCollector collector = mock(StepCollector.class); FailureStrategy failureStrategy = mock(FailureStrategy.class); Configuration configuration = configurationWith(reporter, collector, failureStrategy); configuration.doDryRun(true); CandidateSteps mySteps = new Steps(configuration); UUIDExceptionWrapper failure = new UUIDExceptionWrapper(new IllegalArgumentException()); Step successfulStep = mockSuccessfulStep("successfulStep"); Step pendingStep = mock(Step.class, "pendingStep"); Step failingStep = mock(Step.class, "failingStep"); when(pendingStep.perform(Matchers.<UUIDExceptionWrapper>any())) .thenReturn(pending("pendingStep")); when(pendingStep.doNotPerform(failure)).thenReturn(pending("pendingStep")); when(failingStep.perform(Matchers.<UUIDExceptionWrapper>any())) .thenReturn(failed("failingStep", failure)); when(collector.collectScenarioSteps(asList(mySteps), scenario1, parameters)) .thenReturn(asList(failingStep, successfulStep)); when(collector.collectScenarioSteps(asList(mySteps), scenario2, parameters)) .thenReturn(asList(successfulStep)); when(collector.collectScenarioSteps(asList(mySteps), scenario3, parameters)) .thenReturn(asList(successfulStep, pendingStep)); boolean givenStory = false; givenStoryWithNoBeforeOrAfterSteps(story, givenStory, collector, mySteps); // When StoryRunner runner = new StoryRunner(); runner.run(configuration, asList(mySteps), story); // Then InOrder inOrder = inOrder(reporter, failureStrategy); inOrder.verify(reporter).beforeStory(story, givenStory); inOrder.verify(reporter).beforeScenario("my title 1"); inOrder.verify(reporter).failed("failingStep", failure); inOrder.verify(reporter).notPerformed("successfulStep"); inOrder.verify(reporter).afterScenario(); inOrder.verify(reporter).beforeScenario("my title 2"); inOrder.verify(reporter).successful("successfulStep"); inOrder.verify(reporter).afterScenario(); inOrder.verify(reporter).beforeScenario("my title 3"); inOrder.verify(reporter).successful("successfulStep"); inOrder.verify(reporter).pending("pendingStep"); inOrder.verify(reporter).afterScenario(); inOrder.verify(reporter).afterStory(givenStory); inOrder.verify(failureStrategy).handleFailure(failure); }
/** * Runs a Story with the given configuration and steps, applying the given meta filter, and * staring from given state. * * @param configuration the Configuration used to run story * @param candidateSteps the List of CandidateSteps containing the candidate steps methods * @param story the Story to run * @param filter the Filter to apply to the story Meta * @param beforeStories the State before running any of the stories, if not <code>null</code> * @throws Throwable if failures occurred and FailureStrategy dictates it to be re-thrown. */ public void run( Configuration configuration, List<CandidateSteps> candidateSteps, Story story, MetaFilter filter, State beforeStories) throws Throwable { run(configuration, new ProvidedStepsFactory(candidateSteps), story, filter, beforeStories); }
@Test public void shouldRunScenarioAndLifecycleStepsInCorrectOrderWithExamplesTable() throws Throwable { // Given ExamplesTable examplesTable = new ExamplesTable("|one|two|\n|1|2|\n"); Map<String, String> tableRow = examplesTable.getRow(0); Scenario scenario1 = new Scenario( "my title 1", Meta.EMPTY, GivenStories.EMPTY, examplesTable, asList("step <one>", "step <two>")); Story story = new Story(new Description("my blurb"), Narrative.EMPTY, asList(scenario1)); StoryReporter reporter = mock(ConcurrentStoryReporter.class); StepCollector collector = mock(StepCollector.class); FailureStrategy failureStrategy = mock(FailureStrategy.class); Configuration configuration = configurationWith(reporter, collector, failureStrategy); configuration.storyControls().doDryRun(true); CandidateSteps mySteps = new Steps(configuration); Step firstStep = mockSuccessfulStep("step <one>"); Step secondStep = mockSuccessfulStep("step <two>"); when(collector.collectScenarioSteps(asList(mySteps), scenario1, tableRow)) .thenReturn(asList(firstStep, secondStep)); boolean givenStory = false; givenStoryWithNoBeforeOrAfterSteps(story, givenStory, collector, mySteps); Step beforeExampleStep = mockSuccessfulStep("beforeExampleStep"); Step afterExampleStep = mockSuccessfulStep("afterExampleStep"); when(collector.collectBeforeOrAfterScenarioSteps( eq(asList(mySteps)), Matchers.<Meta>any(), eq(Stage.BEFORE), eq(ScenarioType.EXAMPLE))) .thenReturn(asList(beforeExampleStep)); when(collector.collectBeforeOrAfterScenarioSteps( eq(asList(mySteps)), Matchers.<Meta>any(), eq(Stage.AFTER), eq(ScenarioType.EXAMPLE))) .thenReturn(asList(afterExampleStep)); Step beforeStep = mockSuccessfulStep("lifecycleBeforeStep"); Step afterStep = mockSuccessfulStep("lifecycleAfterStep"); when(collector.collectLifecycleSteps( eq(asList(mySteps)), eq(Lifecycle.EMPTY), any(Meta.class), eq(Stage.BEFORE))) .thenReturn(asList(beforeStep)); when(collector.collectLifecycleSteps( eq(asList(mySteps)), eq(Lifecycle.EMPTY), any(Meta.class), eq(Stage.AFTER))) .thenReturn(asList(afterStep)); // When StoryRunner runner = new StoryRunner(); runner.run(configuration, asList(mySteps), story); // Then InOrder inOrder = inOrder(reporter, failureStrategy); inOrder.verify(reporter).successful("beforeExampleStep"); inOrder.verify(reporter).successful("lifecycleBeforeStep"); inOrder.verify(reporter).successful("step <one>"); inOrder.verify(reporter).successful("step <two>"); inOrder.verify(reporter).successful("lifecycleAfterStep"); inOrder.verify(reporter).successful("afterExampleStep"); }
/** * Runs a Story with the given steps factory, applying the given meta filter, and staring from * given state. * * @param configuration the Configuration used to run story * @param stepsFactory the InjectableStepsFactory used to created the candidate steps methods * @param story the Story to run * @param filter the Filter to apply to the story Meta * @param beforeStories the State before running any of the stories, if not <code>null</code> * @throws Throwable if failures occurred and FailureStrategy dictates it to be re-thrown. */ public void run( Configuration configuration, InjectableStepsFactory stepsFactory, Story story, MetaFilter filter, State beforeStories) throws Throwable { RunContext context = new RunContext(configuration, stepsFactory, story.getPath(), filter); if (beforeStories != null) { context.stateIs(beforeStories); } Map<String, String> storyParameters = new HashMap<String, String>(); run(context, story, storyParameters); }
@Test public void shouldNotPerformStepsAfterRestaringScenarioFailure() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); Step firstStepNormal = mockSuccessfulStep("Given I succeed"); final RestartingScenarioFailure hi = new RestartingScenarioFailure("hi"); Step restartStep = new AbstractStep() { private int count = 0; public StepResult perform(UUIDExceptionWrapper storyFailureIfItHappened) { if (count == 0) { count++; throw hi; } return new AbstractStepResult.Successful("When happened on second attempt"); } public StepResult doNotPerform(UUIDExceptionWrapper storyFailureIfItHappened) { return null; } @Override public String toString() { return "<fooStep>"; } }; Step lastStepNormal = mockSuccessfulStep("Then I succeeded"); StepCollector collector = mock(StepCollector.class); FailureStrategy strategy = mock(FailureStrategy.class); CandidateSteps mySteps = new Steps(); Scenario scenario = new Scenario(); when(collector.collectScenarioSteps(eq(asList(mySteps)), eq(scenario), eq(parameters))) .thenReturn(asList(firstStepNormal, restartStep, lastStepNormal)); Story story = new Story(asList(scenario)); givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps); // When StoryRunner runner = new StoryRunner(); runner.run(configurationWith(reporter, collector, strategy), asList(mySteps), story); verify(reporter, times(2)).successful("Given I succeed"); verify(reporter).restarted(eq("<fooStep>"), isA(RestartingScenarioFailure.class)); verify(reporter).successful("When happened on second attempt"); verify(reporter).successful("Then I succeeded"); }
private void runGivenStories( GivenStories givenStories, Map<String, String> parameters, RunContext context) throws Throwable { if (givenStories.getPaths().size() > 0) { reporter.get().givenStories(givenStories); for (GivenStory givenStory : givenStories.getStories()) { RunContext childContext = context.childContextFor(givenStory); // run given story, using any parameters provided Story story = storyOfPath(context.configuration(), childContext.path()); if (givenStory.hasAnchorParameters()) { story = storyWithMatchingScenarios(story, givenStory.getAnchorParameters()); } parameters.putAll(givenStory.getParameters()); run(childContext, story, parameters); } } }
@Test public void shouldRunScenarioWithExamplesTable() throws Throwable { // Given ExamplesTable examplesTable = new ExamplesTable("|one|two|\n|1|2|\n"); Map<String, String> tableRow = examplesTable.getRow(0); Scenario scenario1 = new Scenario( "my title 1", Meta.EMPTY, GivenStories.EMPTY, examplesTable, asList("step <one>", "step <two>")); Story story = new Story(new Description("my blurb"), Narrative.EMPTY, asList(scenario1)); Step step = mock(Step.class); StepResult result = mock(StepResult.class); when(step.perform(null)).thenReturn(result); StoryReporter reporter = mock(ConcurrentStoryReporter.class); StepCollector collector = mock(StepCollector.class); FailureStrategy failureStrategy = mock(FailureStrategy.class); Configuration configuration = configurationWith(reporter, collector, failureStrategy); configuration.storyControls().doDryRun(true); CandidateSteps mySteps = new Steps(configuration); Step firstStep = mockSuccessfulStep("step <one>"); Step secondStep = mockSuccessfulStep("step <two>"); when(collector.collectScenarioSteps(asList(mySteps), scenario1, tableRow)) .thenReturn(asList(firstStep, secondStep)); boolean givenStory = false; givenStoryWithNoBeforeOrAfterSteps(story, givenStory, collector, mySteps); // When StoryRunner runner = new StoryRunner(); runner.run(configuration, asList(mySteps), story); // Then InOrder inOrder = inOrder(reporter, failureStrategy); inOrder.verify(reporter).beforeStory(story, givenStory); inOrder.verify(reporter).beforeScenario("my title 1"); inOrder.verify(reporter).successful("step <one>"); inOrder.verify(reporter).successful("step <two>"); inOrder.verify(reporter).afterScenario(); inOrder.verify(reporter).afterStory(givenStory); }
@Test public void shouldReportAnyFailuresAndHandleThemAfterStory() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); Step firstStepExceptional = mock(Step.class); Step secondStepNotPerformed = mock(Step.class); StepResult failed = failed("When I fail", new UUIDExceptionWrapper(new IllegalStateException())); StepResult notPerformed = notPerformed("Then I should not be performed"); when(firstStepExceptional.perform(null)).thenReturn(failed); when(secondStepNotPerformed.doNotPerform(Matchers.<UUIDExceptionWrapper>any())) .thenReturn(notPerformed); FailureStrategy failureStrategy = mock(FailureStrategy.class); StepCollector collector = mock(StepCollector.class); CandidateSteps mySteps = new Steps(); Scenario scenario = new Scenario(); when(collector.collectScenarioSteps(eq(asList(mySteps)), eq(scenario), eq(parameters))) .thenReturn(asList(firstStepExceptional, secondStepNotPerformed)); Story story = new Story(asList(scenario)); boolean givenStory = false; givenStoryWithNoBeforeOrAfterSteps(story, givenStory, collector, mySteps); // When StoryRunner runner = new StoryRunner(); runner.run(configurationWith(reporter, collector, failureStrategy), asList(mySteps), story); // Then verify(firstStepExceptional).perform(null); verify(secondStepNotPerformed).doNotPerform(Matchers.<UUIDExceptionWrapper>any()); InOrder inOrder = inOrder(reporter, failureStrategy); inOrder.verify(reporter).beforeStory((Story) anyObject(), eq(givenStory)); inOrder.verify(reporter).beforeScenario((String) anyObject()); inOrder.verify(reporter).failed("When I fail", failed.getFailure()); inOrder.verify(reporter).notPerformed("Then I should not be performed"); inOrder.verify(reporter).afterScenario(); inOrder.verify(reporter).afterStory(givenStory); inOrder.verify(failureStrategy).handleFailure(failed.getFailure()); }
@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 }
@Test public void shouldNotPerformStepsAfterFailedOrPendingSteps() throws Throwable { // Given StoryReporter reporter = mock(ConcurrentStoryReporter.class); Step firstStepNormal = mockSuccessfulStep("Given I succeed"); Step secondStepPending = mock(Step.class, "secondStepPending"); Step thirdStepNormal = mock(Step.class, "thirdStepNormal"); Step fourthStepAlsoPending = mock(Step.class, "fourthStepAlsoPending"); StepCollector collector = mock(StepCollector.class); CandidateSteps mySteps = new Steps(); Scenario scenario = new Scenario(); when(collector.collectScenarioSteps(eq(asList(mySteps)), eq(scenario), eq(parameters))) .thenReturn( asList(firstStepNormal, secondStepPending, thirdStepNormal, fourthStepAlsoPending)); when(secondStepPending.perform(null)).thenReturn(pending("When I am pending")); when(thirdStepNormal.doNotPerform(Matchers.<UUIDExceptionWrapper>any())) .thenReturn(notPerformed("Then I should not be performed")); when(fourthStepAlsoPending.doNotPerform(Matchers.<UUIDExceptionWrapper>any())) .thenReturn(notPerformed("Then I should not be performed either")); Story story = new Story(asList(scenario)); givenStoryWithNoBeforeOrAfterSteps(story, false, collector, mySteps); // When StoryRunner runner = new StoryRunner(); runner.run(configurationWith(reporter, collector), asList(mySteps), story); // Then verify(firstStepNormal).perform(null); verify(secondStepPending).perform(null); verify(thirdStepNormal).doNotPerform(Matchers.<UUIDExceptionWrapper>any()); verify(fourthStepAlsoPending).doNotPerform(Matchers.<UUIDExceptionWrapper>any()); verify(reporter).successful("Given I succeed"); verify(reporter).pending("When I am pending"); verify(reporter).notPerformed("Then I should not be performed"); verify(reporter).notPerformed("Then I should not be performed either"); }
@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()); }
@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); }
@Test public void shouldRunGivenStoriesAtStoryAndScenarioLevel() throws Throwable { // Given GivenStories storyGivenStories = new GivenStories("/path/to/given/story1"); GivenStories scenarioGivenStories = new GivenStories("/path/to/given/story1"); Scenario scenario1 = new Scenario("scenario 1", asList("successfulStep")); Scenario scenario2 = new Scenario( "scenario 2", Meta.EMPTY, scenarioGivenStories, ExamplesTable.EMPTY, asList("anotherSuccessfulStep")); Story story1 = new Story(new Description("story 1"), Narrative.EMPTY, asList(scenario1)); Story story2 = new Story( "", new Description("story 2"), Meta.EMPTY, Narrative.EMPTY, storyGivenStories, asList(scenario2)); Step step = mock(Step.class); StepResult result = mock(StepResult.class); when(step.perform(null)).thenReturn(result); StoryParser storyParser = mock(StoryParser.class); StoryLoader storyLoader = mock(StoryLoader.class); StoryReporter reporter = mock(ConcurrentStoryReporter.class); StepCollector collector = mock(StepCollector.class); CandidateSteps mySteps = new Steps(); Step successfulStep = mockSuccessfulStep("successfulStep"); Step anotherSuccessfulStep = mockSuccessfulStep("anotherSuccessfulStep"); boolean givenStory = false; givenStoryWithNoBeforeOrAfterSteps(story1, givenStory, collector, mySteps); when(collector.collectScenarioSteps(asList(mySteps), scenario1, parameters)) .thenReturn(asList(successfulStep)); givenStoryWithNoBeforeOrAfterSteps(story2, givenStory, collector, mySteps); when(collector.collectScenarioSteps(asList(mySteps), scenario2, parameters)) .thenReturn(asList(anotherSuccessfulStep)); when(storyLoader.loadStoryAsText("/path/to/given/story1")).thenReturn("storyContent"); when(storyParser.parseStory("storyContent", "/path/to/given/story1")).thenReturn(story1); givenStoryWithNoBeforeOrAfterSteps(story1, givenStory, collector, mySteps); givenStoryWithNoBeforeOrAfterSteps(story2, givenStory, collector, mySteps); FailureStrategy failureStrategy = mock(FailureStrategy.class); // When StoryRunner runner = new StoryRunner(); Configuration configuration = configurationWith(storyParser, storyLoader, reporter, collector, failureStrategy); runner.run(configuration, asList(mySteps), story2); // Then InOrder inOrder = inOrder(reporter); inOrder.verify(reporter).beforeStory(story2, givenStory); inOrder.verify(reporter).givenStories(storyGivenStories); inOrder.verify(reporter).givenStories(scenarioGivenStories); inOrder.verify(reporter).successful("successfulStep"); inOrder.verify(reporter).successful("anotherSuccessfulStep"); inOrder.verify(reporter).afterStory(givenStory); verify(reporter, never()).beforeStory(story1, givenStory); }
@Test public void shouldAllowToSkipBeforeAndAfterScenarioStepsIfGivenStory() throws Throwable { // Given Scenario scenario1 = new Scenario("scenario 1", asList("successfulStep")); GivenStories givenStories = new GivenStories("/path/to/given/story1"); Scenario scenario2 = new Scenario( "scenario 2", Meta.EMPTY, givenStories, ExamplesTable.EMPTY, asList("anotherSuccessfulStep")); Story story1 = new Story(new Description("story 1"), Narrative.EMPTY, asList(scenario1)); Story story2 = new Story(new Description("story 2"), Narrative.EMPTY, asList(scenario2)); Step step = mock(Step.class); StepResult result = mock(StepResult.class); when(step.perform(null)).thenReturn(result); StoryParser storyParser = mock(StoryParser.class); StoryLoader storyLoader = mock(StoryLoader.class); StoryReporter reporter = mock(ConcurrentStoryReporter.class); StepCollector collector = mock(StepCollector.class); CandidateSteps mySteps = new Steps(); Step successfulStep = mockSuccessfulStep("successfulStep"); Step anotherSuccessfulStep = mockSuccessfulStep("anotherSuccessfulStep"); givenStoryWithNoBeforeOrAfterSteps(story1, false, collector, mySteps); when(collector.collectScenarioSteps(asList(mySteps), scenario1, parameters)) .thenReturn(asList(successfulStep)); givenStoryWithNoBeforeOrAfterSteps(story2, true, collector, mySteps); when(collector.collectScenarioSteps(asList(mySteps), scenario2, parameters)) .thenReturn(asList(anotherSuccessfulStep)); when(storyLoader.loadStoryAsText("/path/to/given/story1")).thenReturn("storyContent"); when(storyParser.parseStory("storyContent", "/path/to/given/story1")).thenReturn(story1); FailureStrategy failureStrategy = mock(FailureStrategy.class); Step beforeStep = mockSuccessfulStep("SuccessfulBeforeScenarioStep"); Step afterStep = mockSuccessfulStep("SuccessfulAfterScenarioStep"); when(collector.collectBeforeOrAfterScenarioSteps( eq(asList(mySteps)), Matchers.<Meta>any(), eq(Stage.BEFORE), eq(ScenarioType.NORMAL))) .thenReturn(asList(beforeStep)); when(collector.collectBeforeOrAfterScenarioSteps( eq(asList(mySteps)), Matchers.<Meta>any(), eq(Stage.AFTER), eq(ScenarioType.NORMAL))) .thenReturn(asList(afterStep)); // When StoryRunner runner = new StoryRunner(); Configuration configuration = configurationWith(storyParser, storyLoader, reporter, collector, failureStrategy); configuration.storyControls().doSkipBeforeAndAfterScenarioStepsIfGivenStory(true); runner.run(configuration, asList(mySteps), story2); // Then verify(collector).collectScenarioSteps(asList(mySteps), scenario1, parameters); verify(collector).collectScenarioSteps(asList(mySteps), scenario2, parameters); InOrder inOrder = inOrder(beforeStep, successfulStep, anotherSuccessfulStep, afterStep); inOrder.verify(beforeStep).perform(null); inOrder.verify(successfulStep).perform(null); inOrder.verify(anotherSuccessfulStep).perform(null); inOrder.verify(afterStep).perform(null); }
/** * Runs a Story with the given configuration and steps. * * @param configuration the Configuration used to run story * @param candidateSteps the List of CandidateSteps containing the candidate steps methods * @param story the Story to run * @throws Throwable if failures occurred and FailureStrategy dictates it to be re-thrown. */ public void run(Configuration configuration, List<CandidateSteps> candidateSteps, Story story) throws Throwable { run(configuration, candidateSteps, story, MetaFilter.EMPTY); }