dchelimsky-rspec-stories 1.0.0

data/spec/spec/story/extensions_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+require 'spec/story'
+
+describe Kernel, "#Story" do
+  before(:each) do
+    Kernel.stub!(:at_exit)
+  end
+
+  it "should delegate to ::Spec::Story::Runner.story_runner" do
+    ::Spec::Story::Runner.story_runner.should_receive(:Story)
+    story = Story("title","narrative"){}
+  end
+end

data/spec/spec/story/given_scenario_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe GivenScenario do
+      it 'should execute a scenario from the current story in its world' do
+        # given
+        class MyWorld
+          attr :scenario_ran
+        end
+        instance = World.create(MyWorld)
+        scenario = ScenarioBuilder.new.to_scenario do
+          @scenario_ran = true
+        end
+        Runner::StoryRunner.should_receive(:scenario_from_current_story).with('scenario name').and_return(scenario)
+        
+        step = GivenScenario.new 'scenario name'
+        
+        # when
+        step.perform(instance, nil)
+        
+        # then
+        instance.scenario_ran.should be_true
+      end
+    end
+  end
+end

data/spec/spec/story/runner/plain_text_story_runner_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../story_helper'
+
+module Spec
+  module Story
+    module Runner
+      describe PlainTextStoryRunner do
+        before(:each) do
+          StoryParser.stub!(:new).and_return(@parser = mock("parser"))
+          @parser.stub!(:parse).and_return([])
+          File.stub!(:read).with("path").and_return("this\nand that")
+        end
+
+        it "should provide access to steps" do
+          runner = PlainTextStoryRunner.new("path")
+          
+          runner.steps do |add|
+            add.given("baz") {}
+          end
+          
+          runner.steps.find(:given, "baz").should_not be_nil
+        end
+        
+        it "should parse a story file" do
+          runner = PlainTextStoryRunner.new("path")
+          @parser.should_receive(:parse).with(["this", "and that"])
+          runner.run(mock('runner'))
+        end
+        
+        it "should build up a mediator with its own steps and the singleton story_runner" do
+          @story_runner = mock('story runner', :null_object => true)
+
+          runner = PlainTextStoryRunner.new("path")
+          
+          Spec::Story::Runner::StoryMediator.should_receive(:new).with(
+            runner.steps, @story_runner, {}
+          ).and_return(mediator = stub("mediator", :run_stories => nil))
+          runner.run(@story_runner)
+        end
+        
+        it "should build up a parser with the mediator" do
+          runner = PlainTextStoryRunner.new("path")
+          Spec::Story::Runner::StoryMediator.should_receive(:new).and_return(mediator = stub("mediator", :run_stories => nil))
+          Spec::Story::Runner::StoryParser.should_receive(:new).with(mediator).and_return(@parser)
+          runner.run(stub("story_runner"))
+        end
+        
+        it "should tell the mediator to run the stories" do
+          runner = PlainTextStoryRunner.new("path")
+          mediator = mock("mediator")
+          Spec::Story::Runner::StoryMediator.should_receive(:new).and_return(mediator)
+          mediator.should_receive(:run_stories)
+          runner.run(mock('runner'))
+        end
+        
+        it "should accept a block instead of a path" do
+          runner = PlainTextStoryRunner.new do |runner|
+            runner.load("path/to/story")
+          end
+          File.should_receive(:read).with("path/to/story").and_return("this\nand that")
+          runner.run(mock('runner'))
+        end
+        
+        it "should tell you if you try to run with no path set" do
+          runner = PlainTextStoryRunner.new
+          lambda {
+            runner.run(mock('runner'))
+          }.should raise_error(RuntimeError, "You must set a path to the file with the story. See the RDoc.")
+        end
+        
+        it "should pass options to the mediator" do
+          runner = PlainTextStoryRunner.new("path", :foo => :bar)
+          Spec::Story::Runner::StoryMediator.should_receive(:new).
+            with(anything, anything, :foo => :bar).
+            and_return(mediator = stub("mediator", :run_stories => nil))
+          runner.run(mock('runner'))
+        end
+        
+        it "should provide access to its options" do
+          runner = PlainTextStoryRunner.new("path")
+          runner[:foo] = :bar
+          Spec::Story::Runner::StoryMediator.should_receive(:new).
+            with(anything, anything, :foo => :bar).
+            and_return(mediator = stub("mediator", :run_stories => nil))
+          runner.run mock('runner')
+        end
+        
+      end
+    end
+  end
+end

data/spec/spec/story/runner/scenario_collector_spec.rb

@@ -0,0 +1,27 @@
+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/spec/spec/story/runner/scenario_runner_spec.rb

@@ -0,0 +1,214 @@
+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/spec/spec/story/runner/story_mediator_spec.rb

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