dchelimsky-rspec 1.1.10

data/spec/spec/story/step_mother_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe StepMother do
+      it 'should store a step by name and type' do
+        # given
+        step_mother = StepMother.new
+        step = Step.new("a given", &lambda {})
+        step_mother.store(:given, step)
+        
+        # when
+        found = step_mother.find(:given, "a given")
+        
+        # then
+        found.should == step
+      end
+      
+      it 'should NOT raise an error if a step is missing' do
+        # given
+        step_mother = StepMother.new
+        
+        # then
+        lambda do
+          # when
+          step_mother.find(:given, "doesn't exist")
+        end.should_not raise_error
+      end
+      
+      it "should create a default step which raises a pending error" do
+        # given
+        step_mother = StepMother.new
+        
+        # when
+        step = step_mother.find(:given, "doesn't exist")
+        
+        # then
+        step.should be_an_instance_of(Step)
+        
+        lambda do
+          step.perform(Object.new, "doesn't exist")
+        end.should raise_error(Spec::Example::ExamplePendingError, /Unimplemented/)
+      end
+      
+      it "should create a default step with it's name stripped" do
+        # given
+        step_mother = StepMother.new
+        
+        # when
+        step = step_mother.find(:given, "doesn't exist\n\n")
+        
+        # then
+        step.should be_an_instance_of(Step)
+        step.name.should == "doesn't exist"
+      end
+      
+      it 'should clear itself' do
+        # given
+        step_mother = StepMother.new
+        step = Step.new("a given") do end
+        step_mother.store(:given, step)
+
+        # when
+        step_mother.clear
+        
+        # then
+        step_mother.should be_empty
+      end
+      
+      it "should use assigned steps" do
+        step_mother = StepMother.new
+        
+        step = Step.new('step') {}
+        step_group = StepGroup.new
+        step_group.add(:given, step)
+        
+        step_mother.use(step_group)
+                
+        step_mother.find(:given, "step").should equal(step)
+      end
+
+    end
+  end
+end

data/spec/spec/story/step_spec.rb

@@ -0,0 +1,272 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe Step, "#matching" do
+      it "should match a text string" do
+        step = Step.new("this text") {}
+        step.matches?("this text").should be_true
+      end
+      
+      it "should match a text string that has additional line returns" do
+        step = Step.new("this text") {}
+        step.matches?("this text\n\n").should be_true
+      end
+      
+      it "should not match a text string that does not start the same" do
+        step = Step.new("this text") {}
+        step.matches?("Xthis text").should be_false
+      end
+      
+      it "should not match a text string that does not end the same" do
+        step = Step.new("this text") {}
+        step.matches?("this textX").should be_false
+      end
+      
+      it "should match a text string with a param" do
+        step = Step.new("this $param text") {}
+        step.matches?("this anything text").should be_true
+      end
+      
+      it "should not be greedy" do
+        step = Step.new("enter $value for $key") {}
+        step.parse_args("enter 3 for keys for a piano").should == ['3','keys for a piano']
+      end
+      
+      it "should match a text string with 3 params" do
+        step = Step.new("1 $one 2 $two 3 $three 4") {}
+        step.matches?("1 a 2 b 3 c 4").should be_true
+      end
+
+      it "should match a text string with two params sharing a prefix" do
+        step = Step.new("I am cool $n times out of $n_total")
+        step.matches?("I am cool 3 times out of 7").should be_true
+      end
+      
+      it "should match a text string with a param at the beginning" do
+        step = Step.new("$one 2 3") {}
+        step.matches?("a 2 3").should be_true
+      end
+      
+      it "should match a text string with a param at the end" do
+        step = Step.new("1 2 $three") {}
+        step.matches?("1 2 c").should be_true
+      end
+
+      it "should match a text string with a dollar sign ($)" do
+        step = Step.new("show me the $$money") {}
+        step.matches?("show me the $kwan").should be_true
+      end
+
+      it "should match a string with an escaped dollar sign" do
+        step = Step.new("show me the \$money") {}
+        step.matches?("show me the $kwan").should be_true
+      end
+      
+      it "should not match a different string" do
+        step = Step.new("this text") {}
+        step.matches?("other text").should be_false
+      end
+
+      it "should match a regexp" do
+        step = Step.new(/this text/) {}
+        step.matches?("this text").should be_true
+      end
+      
+      it "should match a regexp with a match group" do
+        step = Step.new(/this (.*) text/) {}
+        step.matches?("this anything text").should be_true
+      end
+      
+      it "should match a regexp with a named variable" do
+        step = Step.new(/this $variable text/) {}
+        step.matches?("this anything text").should be_true
+      end
+      
+      it "should not match a non matching regexp" do
+        step = Step.new(/this (.*) text/) {}
+        step.matches?("other anything text").should be_false
+      end
+      
+      it "should not match a non matching regexp with a named variable" do
+        step = Step.new(/this $variable text/) {}
+        step.matches?("other anything text").should be_false
+      end
+      
+      it "should not get bogged down by parens in strings" do
+        step = Step.new("before () after") {}
+        step.matches?("before () after").should be_true
+      end
+      
+      it "should not get bogged down by regular expression special characters in strings" do
+        step = Step.new("These characters should work ? ( ) [ ] { } ^ !") {}
+        step.matches?("These characters should work ? ( ) [ ] { } ^ !").should be_true
+      end
+      
+      it "should match any option of an alteration" do
+        step = Step.new(/(he|she) is cool/) {}
+        step.matches?("he is cool").should be_true
+        step.matches?("she is cool").should be_true
+      end
+      
+      it "should match alteration as well as a variable" do
+        step = Step.new(/(he|she) is (.*)/) {}
+        step.matches?("he is cool").should be_true
+        step.parse_args("he is cool").should == ['he', 'cool']
+      end
+      
+      it "should match alteration as well as a named variable" do
+        step = Step.new(/(he|she) is $adjective/) {}
+        step.matches?("he is cool").should be_true
+        step.parse_args("he is cool").should == ['he', 'cool']
+      end
+      
+      it "should match alteration as well as a anonymous and named variable" do
+        step = Step.new(/(he|she) is (.*?) $adjective/) {}
+        step.matches?("he is very cool").should be_true
+        step.parse_args("he is very cool").should == ['he', 'very', 'cool']
+      end
+
+      it "should match a regex with a dollar sign ($)" do
+        step = Step.new(/show me the \$\d+/) {}
+        step.matches?("show me the $123").should be_true
+      end
+
+      it "should match a regex with a dollar sign and named variable" do
+        step = Step.new(/show me the \$$money/) {}
+        step.matches?("show me the $123").should be_true
+      end
+      
+      it "should match a multiline regex" do
+        step = Step.new(/.*should have text.$text/) {}
+        step.matches?(<<TEXT).should be_true
+          should have text
+          this is the text
+          and so is this
+TEXT
+      end
+      
+      it "should match the beginning of the string, not the line" do
+        step = Step.new(/should have text/) {}
+        step.matches?(<<TEXT).should be_false
+whatever
+should have text
+TEXT
+      end
+
+      it "should match the end of the string, not the line" do
+        step = Step.new(/should have text/) {}
+        step.matches?(<<TEXT).should be_false
+should have text
+whatever
+TEXT
+      end
+    end
+    
+    describe Step, "#parse_args" do
+      it "should return an empty array for a text string with no parameters" do
+        step = Step.new("this text") {}
+        step.parse_args("this text").should == []
+      end
+      
+      it "should return an empty array for a text string with additional line returns and no parameters" do
+        step = Step.new("this text") {}
+        step.parse_args("this text\n\n").should == []
+      end
+    end
+    
+    describe Step do
+      it "should be pending with no block" do
+        step = Step.new("foo")
+        lambda {
+          step.perform(Object.new)
+        }.should raise_error(Spec::Example::ExamplePendingError, "Not Yet Implemented")
+      end
+      
+      it "should perform itself on an object" do
+        # given
+        $instance = nil
+        step = Step.new 'step' do
+          $instance = self
+        end
+        instance = Object.new
+        
+        # when
+        step.perform(instance, "step")
+        
+        # then
+        $instance.should == instance
+      end
+      
+      it "should perform itself with one parameter with match expression" do
+        # given
+        $result = nil
+        step = Step.new 'an account with $count dollars' do |count|
+          $result = count
+        end
+        instance = Object.new
+        
+        # when
+        args = step.parse_args("an account with 3 dollars")
+        step.perform(instance, *args)
+        
+        # then
+        $result.should == "3"
+      end
+      
+      it "should perform itself with one parameter without a match expression" do
+        # given
+        $result = nil
+        step = Step.new 'an account with a balance of' do |amount|
+          $result = amount
+        end
+        instance = Object.new
+        
+        # when
+        step.perform(instance, 20)
+        
+        # then
+        $result.should == 20
+      end
+      
+      it "should perform itself with 2 parameters" do
+        # given
+        $account_type = nil
+        $amount = nil
+        step = Step.new 'a $account_type account with $amount dollars' do |account_type, amount|
+          $account_type = account_type
+          $amount = amount
+        end
+        instance = Object.new
+        
+        # when
+        args = step.parse_args("a savings account with 3 dollars")
+        step.perform(instance, *args)
+        
+        # then
+        $account_type.should == "savings"
+        $amount.should == "3"
+      end
+
+      it "should perform itself when defined with a regexp with 2 parameters" do
+        # given
+        $pronoun = nil
+        $adjective = nil
+        step = Step.new /(he|she) is (.*)/ do |pronoun, adjective|
+          $pronoun = pronoun
+          $adjective = adjective
+        end
+        instance = Object.new
+        
+        # when
+        args = step.parse_args("he is cool")
+        step.perform(instance, *args)
+        
+        # then
+        $pronoun.should == "he"
+        $adjective.should == "cool"
+      end
+
+    end
+  end
+end

data/spec/spec/story/story_helper.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/builders'

data/spec/spec/story/story_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe Story do
+      it 'should run itself in a given object' do
+        # given
+        $instance = nil
+        story = Story.new 'title', 'narrative' do
+          $instance = self
+        end
+        object = Object.new
+        
+        # when
+        story.run_in(object)
+        
+        # then
+        $instance.should be(object)
+      end
+      
+      it 'should not raise an error if no block is supplied' do
+        # when
+        error = exception_from { Story.new 'title', 'narrative' }
+        
+        # then
+        error.should be_nil
+      end
+      
+      it "should raise an error when an error is raised running in another object" do
+        #given
+        story = Story.new 'title', 'narrative' do
+          raise "this is raised in the story"
+        end
+        object = Object.new
+        
+        # when/then
+        lambda do
+          story.run_in(object)
+        end.should raise_error
+      end
+      
+      it "should use the steps it is told to using a StepGroup" do
+        story = Story.new("title", "narrative", :steps_for => steps = StepGroup.new) do end
+        assignee = mock("assignee")
+        assignee.should_receive(:use).with(steps)
+        story.assign_steps_to(assignee)
+      end
+
+      it "should use the steps it is told to using a key" do
+        begin
+          orig_rspec_story_steps = $rspec_story_steps
+          $rspec_story_steps = StepGroupHash.new
+          $rspec_story_steps[:foo] = steps = Object.new
+        
+          story = Story.new("title", "narrative", :steps_for => :foo) do end
+          assignee = mock("assignee")
+        
+          assignee.should_receive(:use).with(steps)
+          story.assign_steps_to(assignee)
+        ensure
+          $rspec_story_steps = orig_rspec_story_steps
+        end
+      end
+      
+      it "should use the steps it is told to using multiple keys" do
+        begin
+          orig_rspec_story_steps = $rspec_story_steps
+          $rspec_story_steps = StepGroupHash.new
+          $rspec_story_steps[:foo] = foo_steps = Object.new
+          $rspec_story_steps[:bar] = bar_steps = Object.new
+        
+          story = Story.new("title", "narrative", :steps_for => [:foo, :bar]) do end
+          assignee = mock("assignee")
+        
+          assignee.should_receive(:use).with(foo_steps)
+          assignee.should_receive(:use).with(bar_steps)
+          story.assign_steps_to(assignee)
+        ensure
+          $rspec_story_steps = orig_rspec_story_steps
+        end
+      end
+    end
+  end
+end

data/spec/spec/story/world_spec.rb

@@ -0,0 +1,423 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+require 'spec/story'
+
+module Spec
+  module Story
+    describe World do
+      before :each do
+        World.listeners.clear
+      end
+
+      after :each do
+        World.listeners.clear
+        World.step_mother.clear
+      end
+
+      it 'should create an object that mixes in a World' do
+        # when
+        obj = World::create
+
+        # then
+        obj.should be_kind_of(World)
+      end
+
+      it 'should create a World from any object type' do
+        # when
+        obj = World::create String
+
+        # then
+        obj.should be_kind_of(String)
+        obj.should be_kind_of(World)
+      end
+
+      it 'should pass arguments to #new when creating an object of a specified type that mixes in a world' do
+        # given
+        Thing = Struct.new(:name, :age)
+
+        # when
+        obj = World::create Thing, "David", "I'm not telling"
+
+        # then
+        obj.should be_an_instance_of(Thing)
+        obj.name.should == "David"
+        obj.age.should == "I'm not telling"
+        obj.should be_kind_of(World)
+      end
+
+      def ensure_world_executes_step(&block)
+        # given
+        obj = World::create
+        $step_ran = false
+
+        # when
+        obj.instance_eval(&block)
+
+        # then
+        $step_ran.should be_true
+      end
+
+      it 'should execute a Given, When or Then step' do
+        ensure_world_executes_step do
+          Given 'a given' do
+            $step_ran = true
+          end
+        end
+
+        ensure_world_executes_step do
+          When 'an event' do
+            $step_ran = true
+          end
+        end
+
+        ensure_world_executes_step do
+          Then 'an outcome' do
+            $step_ran = true
+          end
+        end
+      end
+
+      it 'should interpret Given... And... as multiple givens' do
+        # given
+        world = World.create
+        $steps = []
+
+        # when
+        world.instance_eval do
+          Given 'step 1' do
+            $steps << 1
+          end
+          And 'step 2' do
+            $steps << 2
+          end
+        end
+
+        # then
+        $steps.should == [1,2]
+        World.step_mother.find(:given, 'step 1').should_not be_nil
+        World.step_mother.find(:given, 'step 2').should_not be_nil
+      end
+
+      it 'should interpret When... And... as multiple events' do
+        # given
+        world = World.create
+        $steps = []
+
+        # when
+        world.instance_eval do
+          When 'step 1' do
+            $steps << 1
+          end
+          And 'step 2' do
+            $steps << 2
+          end
+        end
+
+        # then
+        $steps.should == [1,2]
+        World.step_mother.find(:when, 'step 1').should_not be_nil
+        World.step_mother.find(:when, 'step 2').should_not be_nil
+      end
+
+      it 'should interpret Then... And... as multiple outcomes' do
+        # given
+        world = World.create
+        $steps = []
+
+        # when
+        world.instance_eval do
+          Then 'step 1' do
+            $steps << 1
+          end
+          And 'step 2' do
+            $steps << 2
+          end
+        end
+
+        # then
+        $steps.should == [1,2]
+        World.step_mother.find(:then, 'step 1').should_not be_nil
+        World.step_mother.find(:then, 'step 2').should_not be_nil
+      end
+
+      it 'should reuse a given across scenarios' do
+        # given
+        $num_invoked = 0
+        a_world = World::create
+        a_world.instance_eval do
+          Given 'a given' do
+            $num_invoked += 1
+          end
+        end
+        another_world = World::create
+
+        # when
+        another_world.instance_eval do
+          Given 'a given' # without a body
+        end
+
+        # then
+        $num_invoked.should == 2
+      end
+
+      it 'should reuse an event across scenarios' do
+        # given
+        $num_invoked = 0
+        a_world = World::create
+        a_world.instance_eval do
+          When 'an event' do
+            $num_invoked += 1
+          end
+        end
+
+        another_world = World::create
+
+        # when
+        another_world.instance_eval do
+          When 'an event' # without a body
+        end
+
+        # then
+        $num_invoked.should == 2
+      end
+
+      it 'should reuse an outcome across scenarios' do
+        # given
+        $num_invoked = 0
+        a_world = World::create
+        a_world.instance_eval do
+          Then 'an outcome' do
+            $num_invoked += 1
+          end
+        end
+
+        another_world = World::create
+
+        # when
+        another_world.instance_eval do
+          Then 'an outcome' # without a body
+        end
+
+        # then
+        $num_invoked.should == 2
+      end
+
+      it 'should preserve instance variables between steps within a scenario' do
+        # given
+        world = World::create
+        $first = nil
+        $second = nil
+
+        # when
+        world.instance_eval do
+          Given 'given' do
+            @first = 'first'
+          end
+          When 'event' do
+            @second = @first # from given
+          end
+          Then 'outcome' do
+            $first = @first # from given
+            $second = @second # from event
+          end
+        end
+
+        # then
+        $first.should == 'first'
+        $second.should == 'first'
+      end
+
+      it 'should invoke a reused step in the new object instance' do
+        # given
+        $instances = []
+        $debug = true
+        world1 = World.create
+        world1.instance_eval do
+          Given 'a given' do
+            $instances << self.__id__
+          end
+        end
+        world2 = World.create
+
+        # when
+        world2.instance_eval do
+          Given 'a given' # reused
+          Then 'an outcome' do
+            $instances << __id__
+          end
+        end
+        $debug = false
+        # then
+        $instances.should == [ world1.__id__, world2.__id__, world2.__id__ ]
+      end
+
+      def ensure_world_collects_error(expected_error, &block)
+        # given
+        world = World.create
+        # $error = nil
+
+        # when
+        world.start_collecting_errors
+        world.instance_eval(&block)
+
+        # then
+        world.should have(1).errors
+        world.errors[0].should be_kind_of(expected_error)
+      end
+
+      it 'should collect a failure from a Given step' do
+        ensure_world_collects_error RuntimeError do
+          Given 'a given' do
+            raise RuntimeError, "oops"
+          end
+        end
+      end
+
+      it 'should collect a failure from a When step' do
+        ensure_world_collects_error RuntimeError do
+          When 'an event' do
+            raise RuntimeError, "oops"
+          end
+        end
+      end
+
+      it 'should collect a failure from a Then step' do
+        ensure_world_collects_error RuntimeError do
+          Then 'an outcome' do
+            raise RuntimeError, "oops"
+          end
+        end
+      end
+
+      it 'should inform listeners when it runs a Given, When or Then step' do
+        # given
+        world = World.create
+        mock_listener1 = mock('listener1')
+        mock_listener2 = mock('listener2')
+        World.add_listener(mock_listener1)
+        World.add_listener(mock_listener2)
+
+        # expect
+        mock_listener1.should_receive(:step_upcoming).with(:given, 'a context')
+        mock_listener1.should_receive(:step_succeeded).with(:given, 'a context')
+        mock_listener1.should_receive(:step_upcoming).with(:when, 'an event')
+        mock_listener1.should_receive(:step_succeeded).with(:when, 'an event')
+        mock_listener1.should_receive(:step_upcoming).with(:then, 'an outcome')
+        mock_listener1.should_receive(:step_succeeded).with(:then, 'an outcome')
+
+        mock_listener2.should_receive(:step_upcoming).with(:given, 'a context')
+        mock_listener2.should_receive(:step_succeeded).with(:given, 'a context')
+        mock_listener2.should_receive(:step_upcoming).with(:when, 'an event')
+        mock_listener2.should_receive(:step_succeeded).with(:when, 'an event')
+        mock_listener2.should_receive(:step_upcoming).with(:then, 'an outcome')
+        mock_listener2.should_receive(:step_succeeded).with(:then, 'an outcome')
+
+        # when
+        world.instance_eval do
+          Given 'a context' do end
+          When 'an event' do end
+          Then 'an outcome' do end
+        end
+
+        # then
+      end
+
+      it 'should tell listeners but not execute the step in dry-run mode' do
+        # given
+        World.stub!(:dry_run).and_return(true)
+        mock_listener = mock('listener')
+        World.add_listener(mock_listener)
+        $step_invoked = false
+        world = World.create
+
+        # expect
+        mock_listener.should_receive(:step_upcoming).with(:given, 'a context')
+        mock_listener.should_receive(:step_succeeded).with(:given, 'a context')
+
+        # when
+        world.instance_eval do
+          Given 'a context' do
+            $step_invoked = true
+          end
+        end
+
+        # then
+        $step_invoked.should be(false)
+      end
+
+      it 'should suppress listeners while it runs a GivenScenario' do
+        # given
+        scenario_ran = false
+
+        scenario = ScenarioBuilder.new.name('a scenario').to_scenario do
+          scenario_ran = true
+          Given 'given' do end
+          When 'event' do end
+          Then 'outcome' do end
+        end
+
+        given_scenario = GivenScenario.new('a scenario')
+        Runner::StoryRunner.should_receive(:scenario_from_current_story).
+          with('a scenario').and_return(scenario)
+
+        world = World.create
+        listener = mock('listener')
+        World.add_listener(listener)
+
+        # expect
+        listener.should_receive(:found_scenario).with(:'given scenario', 'a scenario')
+        listener.should_receive(:step_succeeded).never.with(:given, 'given')
+        listener.should_receive(:step_succeeded).never.with(:when, 'event')
+        listener.should_receive(:step_succeeded).never.with(:then, 'outcome')
+
+        # when
+        world.GivenScenario 'a scenario'
+
+        # then
+        scenario_ran.should be_true
+      end
+
+      it 'should interpret GivenScenario... And... as multiple givens' do
+        # given
+        world = World.create
+        steps = []
+
+        scenario = ScenarioBuilder.new.name('a scenario').to_scenario do
+          steps << 1
+        end
+        Runner::StoryRunner.should_receive(:scenario_from_current_story).
+          with('a scenario').and_return(scenario)
+
+        # when
+        world.instance_eval do
+          GivenScenario 'a scenario'
+          And 'step 2' do
+            steps << 2
+          end
+        end
+
+        # then
+        steps.should == [1,2]
+        World.step_mother.find(:given, 'step 2').should_not be_nil
+      end
+
+      it 'should provide rspec matchers' do
+        # given
+        world = World.create
+
+        # then
+        world.instance_eval do
+          'hello'.should match(/^hello$/)
+        end
+      end
+
+      it "should use assigned matchers" do
+        world = World.create
+
+        World.should_receive(:use).with(steps = Object.new)
+
+        World.use(steps)
+      end
+    end
+  end
+end