rspec 1.1.12 → 1.2.0

data/spec/spec/story/step_mother_spec.rb

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

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

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

data/spec/spec/story/story_spec.rb

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

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