dchelimsky-rspec-stories 1.0.0

data/spec/spec/story/runner/story_parser_spec.rb

@@ -0,0 +1,401 @@
+require File.dirname(__FILE__) + '/../story_helper'
+
+module Spec
+	module Story
+		module Runner
+		  
+			describe StoryParser do
+			  before(:each) do
+			    @story_mediator = mock("story_mediator")
+		    	@parser = StoryParser.new(@story_mediator)
+			  end
+
+			  it "should parse no lines" do
+					@parser.parse([])
+			  end
+			  
+			  it "should ignore text before the first Story: begins" do
+			    @story_mediator.should_not_receive(:create_scenario)
+			    @story_mediator.should_not_receive(:create_given)
+			    @story_mediator.should_not_receive(:create_when)
+			    @story_mediator.should_not_receive(:create_then)
+			    @story_mediator.should_receive(:create_story).with("simple addition", "")
+					@parser.parse(["Here is a bunch of text", "about a calculator and all the things", "that it will do", "Story: simple addition"])
+		    end
+			  
+			  it "should create a story" do
+			    @story_mediator.should_receive(:create_story).with("simple addition", "")
+					@parser.parse(["Story: simple addition"])
+			  end
+			  
+			  it "should create a story when line has leading spaces" do
+			    @story_mediator.should_receive(:create_story).with("simple addition", "")
+					@parser.parse(["    Story: simple addition"])
+			  end
+			  
+			  it "should add a one line narrative to the story" do
+			    @story_mediator.should_receive(:create_story).with("simple addition","narrative")
+					@parser.parse(["Story: simple addition","narrative"])
+			  end
+			  
+			  it "should add a multi line narrative to the story" do
+			    @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2\nline 3")
+					@parser.parse(["Story: simple addition","narrative line 1", "line 2", "line 3"])
+			  end
+			  
+			  it "should exclude blank lines from the narrative" do
+			    @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2")
+					@parser.parse(["Story: simple addition","narrative line 1", "", "line 2"])
+			  end
+			  
+			  it "should exclude Scenario from the narrative" do
+			    @story_mediator.should_receive(:create_story).with("simple addition","narrative line 1\nline 2")
+			    @story_mediator.should_receive(:create_scenario)
+					@parser.parse(["Story: simple addition","narrative line 1", "line 2", "Scenario: add one plus one"])
+			  end
+			  
+			end
+
+			describe StoryParser, "in Story state" do
+			  before(:each) do
+			    @story_mediator = mock("story_mediator")
+		    	@parser = StoryParser.new(@story_mediator)
+			    @story_mediator.stub!(:create_story)
+			  end
+			  
+			  it "should create a second Story for Story" do
+          @story_mediator.should_receive(:create_story).with("number two","")
+					@parser.parse(["Story: s", "Story: number two"])
+			  end
+			  
+			  it "should include And in the narrative" do
+          @story_mediator.should_receive(:create_story).with("s","And foo")
+          @story_mediator.should_receive(:create_scenario).with("bar")
+					@parser.parse(["Story: s", "And foo", "Scenario: bar"])
+			  end
+			  
+			  it "should create a Scenario for Scenario" do
+          @story_mediator.should_receive(:create_scenario).with("number two")
+					@parser.parse(["Story: s", "Scenario: number two"])
+			  end
+
+			  it "should include Given in the narrative" do
+          @story_mediator.should_receive(:create_story).with("s","Given foo")
+          @story_mediator.should_receive(:create_scenario).with("bar")
+					@parser.parse(["Story: s", "Given foo", "Scenario: bar"])
+			  end
+			  
+			  it "should include Given: in the narrative" do
+          @story_mediator.should_receive(:create_story).with("s","Given: foo")
+          @story_mediator.should_receive(:create_scenario).with("bar")
+					@parser.parse(["Story: s", "Given: foo", "Scenario: bar"])
+			  end
+			  			  
+			  it "should include When in the narrative" do
+          @story_mediator.should_receive(:create_story).with("s","When foo")
+          @story_mediator.should_receive(:create_scenario).with("bar")
+					@parser.parse(["Story: s", "When foo", "Scenario: bar"])
+			  end
+			  			  
+			  it "should include Then in the narrative" do
+          @story_mediator.should_receive(:create_story).with("s","Then foo")
+          @story_mediator.should_receive(:create_scenario).with("bar")
+					@parser.parse(["Story: s", "Then foo", "Scenario: bar"])
+			  end
+			  			  
+			  it "should include other in the story" do
+          @story_mediator.should_receive(:create_story).with("s","narrative")
+					@parser.parse(["Story: s", "narrative"])
+			  end
+			end
+			
+			describe StoryParser, "in Scenario state" do
+			  before(:each) do
+			    @story_mediator = mock("story_mediator")
+		    	@parser = StoryParser.new(@story_mediator)
+			    @story_mediator.stub!(:create_story)
+			    @story_mediator.stub!(:create_scenario)
+			  end
+			  
+			  it "should create a Story for Story" do
+          @story_mediator.should_receive(:create_story).with("number two","")
+					@parser.parse(["Story: s", "Scenario: s", "Story: number two"])
+			  end
+			  
+			  it "should create a Scenario for Scenario" do
+          @story_mediator.should_receive(:create_scenario).with("number two")
+					@parser.parse(["Story: s", "Scenario: s", "Scenario: number two"])
+			  end
+
+			  it "should raise for And" do
+			    lambda {
+  					@parser.parse(["Story: s", "Scenario: s", "And second"])
+			    }.should raise_error(IllegalStepError, /^Illegal attempt to create a And after a Scenario/)
+			  end
+			  
+			  it "should create a Given for Given" do
+          @story_mediator.should_receive(:create_given).with("gift")
+					@parser.parse(["Story: s", "Scenario: s", "Given gift"])
+			  end
+			  
+			  it "should create a Given for Given:" do
+          @story_mediator.should_receive(:create_given).with("gift")
+					@parser.parse(["Story: s", "Scenario: s", "Given: gift"])
+			  end
+			  
+			  it "should create a GivenScenario for GivenScenario" do
+          @story_mediator.should_receive(:create_given_scenario).with("previous")
+					@parser.parse(["Story: s", "Scenario: s", "GivenScenario previous"])
+			  end
+			  
+			  it "should create a GivenScenario for GivenScenario:" do
+          @story_mediator.should_receive(:create_given_scenario).with("previous")
+					@parser.parse(["Story: s", "Scenario: s", "GivenScenario: previous"])
+			  end
+			  
+			  it "should transition to Given state after GivenScenario" do
+          @story_mediator.stub!(:create_given_scenario)
+					@parser.parse(["Story: s", "Scenario: s", "GivenScenario previous"])
+					@parser.instance_eval{@state}.should be_an_instance_of(StoryParser::GivenState)
+			  end
+			  
+			  it "should transition to Given state after GivenScenario:" do
+          @story_mediator.stub!(:create_given_scenario)
+					@parser.parse(["Story: s", "Scenario: s", "GivenScenario: previous"])
+					@parser.instance_eval{@state}.should be_an_instance_of(StoryParser::GivenState)
+			  end
+			  
+			  it "should create a When for When" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "When ever"])
+			  end
+			  
+			  it "should create a When for When:" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "When: ever"])
+			  end
+			  
+			  it "should create a Then for Then" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Then and there"])
+			  end
+			  
+			  it "should create a Then for Then:" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Then: and there"])
+			  end
+			  
+			  it "should ignore other" do
+					@parser.parse(["Story: s", "Scenario: s", "this is ignored"])
+			  end
+			end
+						
+			describe StoryParser, "in Given state" do
+			  before(:each) do
+			    @story_mediator = mock("story_mediator")
+		    	@parser = StoryParser.new(@story_mediator)
+			    @story_mediator.stub!(:create_story)
+			    @story_mediator.stub!(:create_scenario)
+			    @story_mediator.should_receive(:create_given).with("first")
+			  end
+			  
+			  it "should create a Story for Story" do
+          @story_mediator.should_receive(:create_story).with("number two","")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "Story: number two"])
+			  end
+			  
+			  it "should create a Scenario for Scenario" do
+          @story_mediator.should_receive(:create_scenario).with("number two")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "Scenario: number two"])
+			  end
+
+			  it "should create a second Given for Given" do
+          @story_mediator.should_receive(:create_given).with("second")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "Given second"])
+			  end
+			  
+			  it "should create a second Given for And" do
+          @story_mediator.should_receive(:create_given).with("second")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "And second"])
+			  end
+			  
+			  it "should create a second Given for And:" do
+          @story_mediator.should_receive(:create_given).with("second")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "And: second"])
+			  end
+			  
+			  it "should create a When for When" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When ever"])
+			  end
+			  
+			  it "should create a When for When:" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When: ever"])
+			  end
+			  
+			  it "should create a Then for Then" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "Then and there"])
+			  end
+			  
+			  it "should create a Then for Then:" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "Then: and there"])
+			  end
+			  
+			  it "should ignore lines beginning with '#'" do
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "#this is ignored"])
+			  end
+
+			  it "should not ignore lines beginning with non-keywords" do
+          @story_mediator.should_receive(:add_to_last).with("\nthis is not ignored")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "this is not ignored"])
+			  end
+			  
+			end
+
+			describe StoryParser, "in When state" do
+			  before(:each) do
+			    @story_mediator = mock("story_mediator")
+		    	@parser = StoryParser.new(@story_mediator)
+			    @story_mediator.stub!(:create_story)
+			    @story_mediator.stub!(:create_scenario)
+			    @story_mediator.should_receive(:create_given).with("first")
+			    @story_mediator.should_receive(:create_when).with("else")
+			  end
+			  
+			  it "should create a Story for Story" do
+          @story_mediator.should_receive(:create_story).with("number two","")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When: else", "Story: number two"])
+			  end
+			  
+			  it "should create a Scenario for Scenario" do
+          @story_mediator.should_receive(:create_scenario).with("number two")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Scenario: number two"])
+			  end
+
+			  it "should create Given for Given" do
+          @story_mediator.should_receive(:create_given).with("second")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given second"])
+			  end
+			  
+			  it "should create Given for Given:" do
+          @story_mediator.should_receive(:create_given).with("second")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Given: second"])
+			  end
+			  
+			  it "should create a second When for When" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "When ever"])
+			  end
+			  
+			  it "should create a second When for When:" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "When: ever"])
+			  end
+			  
+			  it "should create a second When for And" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "And ever"])
+			  end
+			  
+			  it "should create a second When for And:" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "And: ever"])
+			  end
+			  
+			  it "should create a Then for Then" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then and there"])
+			  end
+			  
+			  it "should create a Then for Then:" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: and there"])
+			  end
+			  
+			  it "should ignore lines beginning with '#'" do
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "#this is ignored"])
+			  end
+
+			  it "should not ignore lines beginning with non-keywords" do
+          @story_mediator.should_receive(:add_to_last).with("\nthis is not ignored")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When else", "this is not ignored"])
+			  end
+			end
+
+			describe StoryParser, "in Then state" do
+			  before(:each) do
+			    @story_mediator = mock("story_mediator")
+		    	@parser = StoryParser.new(@story_mediator)
+			    @story_mediator.stub!(:create_story)
+			    @story_mediator.stub!(:create_scenario)
+			    @story_mediator.should_receive(:create_given).with("first")
+			    @story_mediator.should_receive(:create_when).with("else")
+			    @story_mediator.should_receive(:create_then).with("what")
+			  end
+			  
+			  it "should create a Story for Story" do
+          @story_mediator.should_receive(:create_story).with("number two","")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Story: number two"])
+			  end
+			  
+			  it "should create a Scenario for Scenario" do
+          @story_mediator.should_receive(:create_scenario).with("number two")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Scenario: number two"])
+			  end
+
+			  it "should create Given for Given" do
+          @story_mediator.should_receive(:create_given).with("second")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Given second"])
+			  end
+			  
+			  it "should create Given for Given:" do
+          @story_mediator.should_receive(:create_given).with("second")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Given: second"])
+			  end
+			  
+			  it "should create When for When" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "When ever"])
+			  end
+			  
+			  it "should create When for When:" do
+          @story_mediator.should_receive(:create_when).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "When: ever"])
+			  end
+
+			  it "should create a Then for Then" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "Then and there"])
+			  end
+			  
+			  it "should create a Then for Then:" do
+          @story_mediator.should_receive(:create_then).with("and there")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "Then: and there"])
+			  end
+
+			  it "should create a second Then for And" do
+          @story_mediator.should_receive(:create_then).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "And ever"])
+			  end
+			  
+			  it "should create a second Then for And:" do
+          @story_mediator.should_receive(:create_then).with("ever")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When: else", "Then: what", "And: ever"])
+			  end
+
+			  
+			  it "should ignore lines beginning with '#'" do
+					@parser.parse(["Story: s", "Scenario: s", "Given first", "When else", "Then what", "#this is ignored"])
+			  end
+
+			  it "should not ignore lines beginning with non-keywords" do
+          @story_mediator.should_receive(:add_to_last).with("\nthis is not ignored")
+					@parser.parse(["Story: s", "Scenario: s", "Given: first", "When else", "Then what", "this is not ignored"])
+			  end
+			end
+		end
+	end
+end

data/spec/spec/story/runner/story_runner_spec.rb

@@ -0,0 +1,294 @@
+require File.dirname(__FILE__) + '/../story_helper'
+
+module Spec
+  module Story
+    module Runner
+      describe StoryRunner do
+        it 'should collect all the stories' do
+          # given
+          story_runner = StoryRunner.new(stub('scenario_runner'))
+          
+          # when
+          story_runner.Story 'title1', 'narrative1' do end
+          story_runner.Story 'title2', 'narrative2' do end
+          stories = story_runner.stories
+          
+          # then
+          story_runner.should have(2).stories
+          stories.first.title.should == 'title1'
+          stories.first.narrative.should == 'narrative1'
+          stories.last.title.should == 'title2'
+          stories.last.narrative.should == 'narrative2'
+        end
+        
+        it 'should gather all the scenarios in the stories' do
+          # given
+          story_runner = StoryRunner.new(stub('scenario_runner'))
+          
+          # when
+          story_runner.Story "story1", "narrative1" do
+            Scenario "scenario1" do end
+            Scenario "scenario2" do end
+          end
+          story_runner.Story "story2", "narrative2" do
+            Scenario "scenario3" do end
+          end
+          scenarios = story_runner.scenarios
+          
+          # then
+          story_runner.should have(3).scenarios
+          scenarios[0].name.should == 'scenario1'
+          scenarios[1].name.should == 'scenario2'
+          scenarios[2].name.should == 'scenario3'
+        end
+        
+        # captures worlds passed into a ScenarioRunner
+        class ScenarioWorldCatcher
+          attr_accessor :worlds
+          def run(scenario, world)
+           (@worlds ||= [])  << world
+          end
+        end
+        
+        it 'should run each scenario in a separate object' do
+          # given
+          scenario_world_catcher = ScenarioWorldCatcher.new
+          story_runner = StoryRunner.new(scenario_world_catcher)
+          story_runner.Story 'story', 'narrative' do
+            Scenario 'scenario1' do end
+            Scenario 'scenario2' do end
+          end
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+          worlds = scenario_world_catcher.worlds
+          scenario_world_catcher.should have(2).worlds
+          worlds[0].should_not == worlds[1]
+        end
+        
+        it "should return false if the scenario runner returns false ever" do
+          #given
+          stub_scenario_runner = stub_everything
+          story_runner = StoryRunner.new(stub_scenario_runner)
+          story_runner.Story 'story', 'narrative' do
+            Scenario 'scenario1' do end
+            Scenario 'scenario2' do end
+          end
+          
+          # expect
+          stub_scenario_runner.should_receive(:run).once.and_return(false,true)
+          
+          # when
+          success = story_runner.run_stories
+          
+          #then
+          success.should == false
+        end
+        
+        it "should return true if the scenario runner returns true for all scenarios" do
+          #given
+          stub_scenario_runner = stub_everything
+          story_runner = StoryRunner.new(stub_scenario_runner)
+          story_runner.Story 'story', 'narrative' do
+            Scenario 'scenario1' do end
+            Scenario 'scenario2' do end
+          end
+          
+          # expect
+          stub_scenario_runner.should_receive(:run).once.and_return(true,true)
+          
+          # when
+          success = story_runner.run_stories
+          
+          #then
+          success.should == true
+        end
+        
+        it 'should use the provided world creator to create worlds' do
+          # given
+          stub_scenario_runner = stub_everything
+          mock_world_creator = mock('world creator')
+          story_runner = StoryRunner.new(stub_scenario_runner, mock_world_creator)
+          story_runner.Story 'story', 'narrative' do
+            Scenario 'scenario1' do end
+            Scenario 'scenario2' do end
+          end
+          
+          # expect
+          mock_world_creator.should_receive(:create).twice
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+        end
+        
+        it 'should notify listeners of the scenario count when the run starts' do
+          # given
+          story_runner = StoryRunner.new(stub_everything)
+          mock_listener1 = stub_everything('listener1')
+          mock_listener2 = stub_everything('listener2')
+          story_runner.add_listener(mock_listener1)
+          story_runner.add_listener(mock_listener2)
+          
+          story_runner.Story 'story1', 'narrative1' do
+            Scenario 'scenario1' do end
+          end
+          story_runner.Story 'story2', 'narrative2' do
+            Scenario 'scenario2' do end
+            Scenario 'scenario3' do end
+          end
+          
+          # expect
+          mock_listener1.should_receive(:run_started).with(3)
+          mock_listener2.should_receive(:run_started).with(3)
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+        end
+        
+        it 'should notify listeners when a story starts' do
+          # given
+          story_runner = StoryRunner.new(stub_everything)
+          mock_listener1 = stub_everything('listener1')
+          mock_listener2 = stub_everything('listener2')
+          story_runner.add_listener(mock_listener1)
+          story_runner.add_listener(mock_listener2)
+          
+          story_runner.Story 'story1', 'narrative1' do
+            Scenario 'scenario1' do end
+          end
+          story_runner.Story 'story2', 'narrative2' do
+            Scenario 'scenario2' do end
+            Scenario 'scenario3' do end
+          end
+          
+          # expect
+          mock_listener1.should_receive(:story_started).with('story1', 'narrative1')
+          mock_listener1.should_receive(:story_ended).with('story1', 'narrative1')
+          mock_listener2.should_receive(:story_started).with('story2', 'narrative2')
+          mock_listener2.should_receive(:story_ended).with('story2', 'narrative2')
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+        end
+        
+        it 'should notify listeners when the run ends' do
+          # given
+          story_runner = StoryRunner.new(stub_everything)
+          mock_listener1 = stub_everything('listener1')
+          mock_listener2 = stub_everything('listener2')
+          story_runner.add_listener mock_listener1
+          story_runner.add_listener mock_listener2
+          story_runner.Story 'story1', 'narrative1' do
+            Scenario 'scenario1' do end
+          end
+          
+          # expect
+          mock_listener1.should_receive(:run_ended)
+          mock_listener2.should_receive(:run_ended)
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+        end
+        
+        it 'should run a story in an instance of a specified class' do
+          # given
+          scenario_world_catcher = ScenarioWorldCatcher.new
+          story_runner = StoryRunner.new(scenario_world_catcher)
+          story_runner.Story 'title', 'narrative', :type => String do
+            Scenario 'scenario' do end
+          end
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+          scenario_world_catcher.worlds[0].should be_kind_of(String)
+          scenario_world_catcher.worlds[0].should be_kind_of(World)
+        end
+        
+        it 'should pass initialization params through to the constructed instance' do
+          # given
+          scenario_world_catcher = ScenarioWorldCatcher.new
+          story_runner = StoryRunner.new(scenario_world_catcher)
+          story_runner.Story 'title', 'narrative', :type => Array, :args => [3]  do
+            Scenario 'scenario' do end
+          end
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+          scenario_world_catcher.worlds[0].should be_kind_of(Array)
+          scenario_world_catcher.worlds[0].size.should == 3
+        end
+        
+        it 'should find a scenario in the current story by name' do
+          # given
+          story_runner = StoryRunner.new(ScenarioRunner.new)
+          scenario = nil
+          
+          story_runner.Story 'title', 'narrative' do
+            Scenario 'first scenario' do
+            end
+            Scenario 'second scenario' do
+              scenario = StoryRunner.scenario_from_current_story 'first scenario'
+            end
+          end
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+          scenario.name.should == 'first scenario'
+        end
+        
+        it "should clean the steps between stories" do
+          #given
+          story_runner = StoryRunner.new(ScenarioRunner.new)
+          result = mock 'result'
+          
+          step1 = Step.new('step') do
+            result.one
+          end
+          steps1 = StepGroup.new
+          steps1.add :when, step1
+          
+          story_runner.Story 'title', 'narrative', :steps_for => steps1 do
+            Scenario 'first scenario' do
+              When 'step'
+            end
+          end
+          
+          step2 = Step.new('step') do
+            result.two
+          end
+          steps2 = StepGroup.new
+          steps2.add :when, step2
+          
+          story_runner.Story 'title2', 'narrative', :steps_for => steps2 do
+            Scenario 'second scenario' do
+              When 'step'
+            end
+          end
+          
+          #then
+          result.should_receive(:one)
+          result.should_receive(:two)
+          
+          #when
+          story_runner.run_stories
+        end
+      end
+    end
+  end
+end