RubyGems - typo - Versions diffs - 5.2 → 5.2.98 - Mend

typo 5.2 → 5.2.98

Files changed (862) hide show

data/vendor/plugins/rspec/spec/spec/story/runner/scenario_collector_spec.rb DELETED Viewed

@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + '/../story_helper'
-module Spec
-  module Story
-    module Runner
-      describe ScenarioCollector do
-        it 'should construct scenarios with the supplied story' do
-          # given
-          story = stub_everything('story')
-          scenario_collector = ScenarioCollector.new(story)
-          # when
-          scenario_collector.Scenario 'scenario1' do end
-          scenario_collector.Scenario 'scenario2' do end
-          scenarios = scenario_collector.scenarios
-          # then
-          scenario_collector.should have(2).scenarios
-          scenarios.first.name.should == 'scenario1'
-          scenarios.first.story.should equal(story)
-          scenarios.last.name.should == 'scenario2'
-          scenarios.last.story.should equal(story)
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/spec/spec/story/runner/scenario_runner_spec.rb DELETED Viewed

@@ -1,214 +0,0 @@
-require File.dirname(__FILE__) + '/../story_helper'
-module Spec
-  module Story
-    module Runner
-      describe ScenarioRunner do
-        it 'should run a scenario in its story' do
-          # given
-          world = stub_everything
-          scenario_runner = ScenarioRunner.new
-          $answer = nil
-          story = Story.new 'story', 'narrative' do
-            @answer = 42 # this should be available to the scenario
-          end
-          scenario = Scenario.new story, 'scenario' do
-            $answer = @answer
-          end
-          # when
-          scenario_runner.run(scenario, world)
-          # then
-          $answer.should == 42
-        end
-        it 'should allow scenarios to share methods' do
-          # given
-          world = stub_everything
-          $shared_invoked = 0
-          story = Story.new 'story', 'narrative' do
-            def shared
-              $shared_invoked += 1
-            end
-          end
-          scenario1 = Scenario.new story, 'scenario1' do
-            shared()
-          end
-          scenario2 = Scenario.new story, 'scenario2' do
-            shared()
-          end
-          scenario_runner = ScenarioRunner.new
-          # when
-          scenario_runner.run(scenario1, world)
-          scenario_runner.run(scenario2, world)
-          # then
-          $shared_invoked.should == 2
-        end
-        it 'should notify listeners when a scenario starts' do
-          # given
-          world = stub_everything
-          story = Story.new 'story', 'narrative' do end
-          scenario = Scenario.new story, 'scenario1' do
-            # succeeds
-          end
-          scenario_runner = ScenarioRunner.new
-          mock_listener1 = stub_everything('listener1')
-          mock_listener2 = stub_everything('listener2')
-          scenario_runner.add_listener(mock_listener1)
-          scenario_runner.add_listener(mock_listener2)
-          # expect
-          mock_listener1.should_receive(:scenario_started).with('story', 'scenario1')
-          mock_listener2.should_receive(:scenario_started).with('story', 'scenario1')
-          # when
-          scenario_runner.run(scenario, world)
-          # then
-        end
-        describe "when a scenario succeeds" do
-          before(:each) do
-            # given
-            @world = stub_everything('world')
-            @story = Story.new 'story', 'narrative' do end
-            @scenario = Scenario.new @story, 'scenario1' do
-              # succeeds
-            end
-            @scenario_runner = ScenarioRunner.new
-          end
-          it 'should notify listeners' do
-            #given
-            mock_listener1 = stub_everything('listener1')
-            mock_listener2 = stub_everything('listener2')
-            @scenario_runner.add_listener(mock_listener1)
-            @scenario_runner.add_listener(mock_listener2)
-            # expect
-            mock_listener1.should_receive(:scenario_succeeded).with('story', 'scenario1')
-            mock_listener2.should_receive(:scenario_succeeded).with('story', 'scenario1')
-            # when
-            @scenario_runner.run(@scenario, @world)
-            # then
-          end
-          it "should return true" do
-            #when
-            success = @scenario_runner.run(@scenario, @world)
-            #then
-            success.should == true
-          end
-        end
-        describe "when a scenario raises an error (other than a pending error)" do
-          before(:each) do
-            # given
-            @error = RuntimeError.new('oops')
-            @story = Story.new 'title', 'narrative' do end
-            @scenario = Scenario.new @story, 'scenario1' do
-            end
-            @scenario_runner = ScenarioRunner.new
-            @world = stub_everything
-            # expect
-            @world.should_receive(:errors).twice.and_return([@error, @error])
-          end
-          it 'should notify listeners ONCE' do
-            #given
-            mock_listener = stub_everything('listener')
-            @scenario_runner.add_listener(mock_listener)
-            #expect
-            mock_listener.should_receive(:scenario_failed).with('title', 'scenario1', @error).once
-            # when
-            @scenario_runner.run @scenario, @world
-            # then
-          end
-          it "should return false" do
-            # when
-            success = @scenario_runner.run @scenario, @world
-            # then
-            success.should == false
-          end
-        end
-        describe "when a scenario is pending" do
-          before(:each) do
-            # given
-            @pending_error = Spec::Example::ExamplePendingError.new('todo')
-            @story = Story.new 'title', 'narrative' do end
-            @scenario = Scenario.new @story, 'scenario1' do
-            end
-            @scenario_runner = ScenarioRunner.new
-            @world = stub_everything
-            # expect
-            @world.should_receive(:errors).twice.and_return([@pending_error, @pending_error])
-          end
-          it 'should notify listeners' do
-            #given
-            mock_listener = mock('listener')
-            @scenario_runner.add_listener(mock_listener)
-            # expect
-            mock_listener.should_receive(:scenario_started).with('title', 'scenario1')
-            mock_listener.should_receive(:scenario_pending).with('title', 'scenario1', 'todo').once
-            # when
-            @scenario_runner.run @scenario, @world
-            # then
-          end
-          it "should return true" do
-            # when
-            success = @scenario_runner.run @scenario, @world
-            # then
-            success.should == true
-          end
-        end
-        describe "when a scenario has an empty body" do
-          before(:each) do
-            @story = Story.new 'title', 'narrative' do end
-            @scenario = Scenario.new @story, 'scenario'
-            @scenario_runner = ScenarioRunner.new
-            @world = stub_everything
-          end
-          it "should mark the scenario as pending" do
-            mock_listener = stub('listener', :scenario_started => true)
-            @scenario_runner.add_listener mock_listener
-            mock_listener.should_receive(:scenario_pending).with('title', 'scenario', '')
-            @scenario_runner.run @scenario, @world
-          end
-          it "should return true" do
-            # when
-            success = @scenario_runner.run @scenario, @world
-            # then
-            success.should == true
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/spec/spec/story/runner/story_mediator_spec.rb DELETED Viewed

@@ -1,143 +0,0 @@
-require File.dirname(__FILE__) + '/../story_helper'
-module Spec
-  module Story
-    module Runner
-      describe StoryMediator do
-        before(:each) do
-          $story_mediator_spec_value = nil
-          @step_group = StepGroup.new
-          @step_group.create_matcher(:given, "given") { $story_mediator_spec_value = "given matched" }
-          @step_group.create_matcher(:when, "when") { $story_mediator_spec_value = "when matched" }
-          @step_group.create_matcher(:then, "then") { $story_mediator_spec_value = "then matched" }
-          @scenario_runner = ScenarioRunner.new
-          @runner = StoryRunner.new @scenario_runner
-          @mediator = StoryMediator.new @step_group, @runner
-        end
-        def run_stories
-          @mediator.run_stories
-          @runner.run_stories
-        end
-        it "should have no stories" do
-          @mediator.stories.should be_empty
-        end
-        it "should create two stories" do
-          @mediator.create_story "story title", "story narrative"
-          @mediator.create_story "story title 2", "story narrative 2"
-          run_stories
-          @runner.should have(2).stories
-          @runner.stories.first.title.should == "story title"
-          @runner.stories.first.narrative.should == "story narrative"
-          @runner.stories.last.title.should == "story title 2"
-          @runner.stories.last.narrative.should == "story narrative 2"
-        end
-        it "should create a scenario" do
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario name"
-          run_stories
-          @runner.should have(1).scenarios
-          @runner.scenarios.first.name.should == "scenario name"
-          @runner.scenarios.first.story.should == @runner.stories.first
-        end
-        it "should create a given scenario step if one matches" do
-          pending("need to untangle the dark mysteries of the story runner - something needs to get stubbed here") do
-            story = @mediator.create_story "title", "narrative"
-            @mediator.create_scenario "previous scenario"
-            @mediator.create_scenario "current scenario"
-            @mediator.create_given_scenario "previous scenario"
-            run_stories
-            $story_mediator_spec_value.should == "previous scenario matched"
-          end
-        end
-        it "should create a given step if one matches" do
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario"
-          @mediator.create_given "given"
-          run_stories
-          $story_mediator_spec_value.should == "given matched"
-        end
-        it "should create a pending step if no given step matches" do
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario"
-          @mediator.create_given "no match"
-          mock_listener = stub_everything("listener")
-          mock_listener.should_receive(:scenario_pending).with("title", "scenario", "Unimplemented step: no match")
-          @scenario_runner.add_listener mock_listener
-          run_stories
-        end
-        it "should create a when step if one matches" do
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario"
-          @mediator.create_when "when"
-          run_stories
-          $story_mediator_spec_value.should == "when matched"
-        end
-        it "should create a pending step if no when step matches" do
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario"
-          @mediator.create_when "no match"
-          mock_listener = stub_everything("listener")
-          mock_listener.should_receive(:scenario_pending).with("title", "scenario", "Unimplemented step: no match")
-          @scenario_runner.add_listener mock_listener
-          run_stories
-        end
-        it "should create a then step if one matches" do
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario"
-          @mediator.create_then "then"
-          run_stories
-          $story_mediator_spec_value.should == "then matched"
-        end
-        it "should create a pending step if no 'then' step matches" do
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario"
-          @mediator.create_then "no match"
-          mock_listener = stub_everything("listener")
-          mock_listener.should_receive(:scenario_pending).with("title", "scenario", "Unimplemented step: no match")
-          @scenario_runner.add_listener mock_listener
-          run_stories
-        end
-        it "should pass options to the stories it creates" do
-          @mediator = StoryMediator.new @step_group, @runner, :foo => :bar
-          @mediator.create_story "story title", "story narrative"
-          run_stories
-          @runner.stories.first[:foo].should == :bar
-        end
-        it "should description" do
-          @mediator = StoryMediator.new @step_group, @runner, :foo => :bar
-          @mediator.create_story "title", "narrative"
-          @mediator.create_scenario "scenario"
-          @mediator.create_given "something"
-          given = @mediator.last_step
-          @mediator.add_to_last " else"
-          given.name.should == "something else"
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/spec/spec/story/runner/story_parser_spec.rb DELETED Viewed

@@ -1,401 +0,0 @@
-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