rspec 0.0.10

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

data/spec/spec/story/runner_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/story_helper'
+require 'spec/runner/formatter/story/plain_text_formatter'
+require 'spec/runner/formatter/story/html_formatter'
+
+module Spec
+  module Story
+    describe Runner, "module" do
+      before(:each) do
+        @world_creator = World.dup
+        @runner_module = Runner.dup
+        @runner_module.instance_eval {@story_runner = nil}
+        @runner_module.stub!(:register_exit_hook)
+      end
+      
+      def create_options(args=[])
+        Spec::Runner::OptionParser.parse(args, StringIO.new, StringIO.new)
+      end
+      
+      it 'should wire up a singleton StoryRunner' do
+        @runner_module.story_runner.should_not be_nil
+      end
+      
+      it 'should set its options based on ARGV' do
+        # given
+        @runner_module.should_receive(:run_options).and_return(
+          create_options(['--dry-run'])
+        )
+
+        # when
+        options = @runner_module.run_options
+        
+        # then
+        options.dry_run.should be_true
+      end
+      
+      describe "initialization" do
+        
+        before(:each) do
+          # given
+          @story_runner = mock('story runner', :null_object => true)
+          @scenario_runner = mock('scenario runner', :null_object => true)
+          @world_creator = mock('world', :null_object => true)
+        
+          @runner_module.stub!(:world_creator).and_return(@world_creator)
+          @runner_module.stub!(:create_story_runner).and_return(@story_runner)
+          @runner_module.stub!(:scenario_runner).and_return(@scenario_runner)
+        end
+
+        it 'should add a reporter to the runner classes' do
+          @runner_module.should_receive(:run_options).and_return(
+            create_options
+          )
+        
+          # expect
+          @world_creator.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
+          @story_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
+          @scenario_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::PlainTextFormatter))
+        
+          # when
+          @runner_module.story_runner
+        end
+      
+        it 'should add a documenter to the runner classes if one is specified' do
+        
+          @runner_module.should_receive(:run_options).and_return(
+            create_options(["--format","html"])
+          )
+
+          # expect
+          @world_creator.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
+          @story_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
+          @scenario_runner.should_receive(:add_listener).with(an_instance_of(Spec::Runner::Formatter::Story::HtmlFormatter))
+        
+          # when
+          @runner_module.story_runner
+        end
+      
+        it 'should add any registered listener to the runner classes' do
+          # given
+          listener = Object.new
+        
+          # expect
+          @world_creator.should_receive(:add_listener).with(listener)
+          @story_runner.should_receive(:add_listener).with(listener)
+          @scenario_runner.should_receive(:add_listener).with(listener)
+        
+          # when
+          @runner_module.register_listener listener
+        end
+      end
+      end
+  end
+end

data/spec/spec/story/scenario_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe Scenario do
+      it 'should not raise an error if no body is supplied' do
+        # given
+        story = StoryBuilder.new.to_story
+        
+        # when
+        error = exception_from do
+          Scenario.new story, 'name'
+        end
+        
+        # then
+        error.should be_nil
+      end
+    end
+  end
+end

data/spec/spec/story/step_group_spec.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe StepGroup do
+      before(:each) do
+        @step_group = StepGroup.new
+      end
+      
+      it "should not find a matcher if empty" do
+        @step_group.find(:given, "this and that").should be_nil
+      end
+      
+      it "should create a given_scenario matcher" do
+        step = @step_group.given_scenario("this and that") {}
+        @step_group.find(:given_scenario, "this and that").should_not be_nil
+        @step_group.find(:given_scenario, "this and that").should equal(step)
+      end
+      
+      it "should create a given matcher" do
+        step = @step_group.given("this and that") {}
+        @step_group.find(:given, "this and that").should equal(step)
+      end
+      
+      it "should create a when matcher" do
+        step = @step_group.when("this and that") {}
+        @step_group.find(:when, "this and that").should equal(step)
+      end
+      
+      it "should create a them matcher" do
+        step = @step_group.then("this and that") {}
+        @step_group.find(:then, "this and that").should equal(step)
+      end
+      
+      it "should add a matcher object" do
+        step = Step.new("this and that") {}
+        @step_group.add(:given, step)
+        @step_group.find(:given, "this and that").should equal(step)
+      end
+      
+      it "should add it matchers to another StepGroup (with one given)" do
+        source = StepGroup.new
+        target = StepGroup.new
+        step = source.given("this and that") {}
+        source.add_to target
+        target.find(:given, "this and that").should equal(step)
+      end
+      
+      it "should add it matchers to another StepGroup (with some of each type)" do
+        source = StepGroup.new
+        target = StepGroup.new
+        given_scenario = source.given_scenario("1") {}
+        given = source.given("1") {}
+        when1 = source.when("1") {}
+        when2 = source.when("2") {}
+        then1 = source.then("1") {}
+        then2 = source.then("2") {}
+        then3 = source.then("3") {}
+        source.add_to target
+        target.find(:given_scenario, "1").should equal(given_scenario)
+        target.find(:given, "1").should equal(given)
+        target.find(:when, "1").should equal(when1)
+        target.find(:when, "2").should equal(when2)
+        target.find(:then, "1").should equal(then1)
+        target.find(:then, "2").should equal(then2)
+        target.find(:then, "3").should equal(then3)
+      end
+      
+      it "should append another collection" do
+        matchers_to_append = StepGroup.new
+        step = matchers_to_append.given("this and that") {}
+        @step_group << matchers_to_append
+        @step_group.find(:given, "this and that").should equal(step)
+      end
+      
+      it "should append several other collections" do
+        matchers_to_append = StepGroup.new
+        more_matchers_to_append = StepGroup.new
+        first_matcher = matchers_to_append.given("this and that") {}
+        second_matcher = more_matchers_to_append.given("and the other") {}
+        @step_group << matchers_to_append
+        @step_group << more_matchers_to_append
+        @step_group.find(:given, "this and that").should equal(first_matcher)
+        @step_group.find(:given, "and the other").should equal(second_matcher)
+      end
+      
+      it "should yield itself on initialization" do
+        begin
+          $step_group_spec_step = nil
+          matchers = StepGroup.new do |matchers|
+            $step_group_spec_step = matchers.given("foo") {}
+          end
+          $step_group_spec_step.matches?("foo").should be_true
+        ensure
+          $step_group_spec_step = nil
+        end
+      end
+      
+      it "should support defaults" do
+        class StepGroupSubclass < StepGroup
+          steps do |add|
+            add.given("foo") {}
+          end
+        end
+        StepGroupSubclass.new.find(:given, "foo").should_not be_nil
+      end
+      
+      it "should create a Given" do
+        sub = Class.new(StepGroup).new
+        step = sub.Given("foo") {}
+        sub.find(:given, "foo").should == step
+      end
+      
+      it "should create a When" do
+        sub = Class.new(StepGroup).new
+        step = sub.When("foo") {}
+        sub.find(:when, "foo").should == step
+      end
+      
+      it "should create a Then" do
+        sub = Class.new(StepGroup).new
+        step = sub.Then("foo") {}
+        sub.find(:then, "foo").should == step
+      end
+      
+      it "should create steps in a block" do
+        sub = Class.new(StepGroup).new do
+          Given("a given") {}
+          When("a when") {}
+          Then("a then") {}
+        end
+        sub.find(:given, "a given").should_not be_nil
+        sub.find(:when, "a when").should_not be_nil
+        sub.find(:then, "a then").should_not be_nil
+      end
+      
+      it "should clear itself" do
+        step = @step_group.given("this and that") {}
+        @step_group.clear
+        @step_group.find(:given, "this and that").should be_nil
+      end
+      
+      it "should tell you when it is empty" do
+        @step_group.should be_empty
+      end
+      
+      it "should tell you when it is not empty" do
+        @step_group.given("this and that") {}
+        @step_group.should_not be_empty
+      end
+      
+      it "should handle << nil" do
+        @step_group << nil
+      end
+    end
+  end
+end