deckshuffler 0.0.2

data/vendor/plugins/rspec/spec/spec/story/runner_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe Runner do
+      def dev_null
+        io = StringIO.new
+        def io.write(str)
+          str.to_s.size
+        end
+        return io
+      end
+      
+      before :each do
+        Kernel.stub!(:at_exit)
+        @stdout, $stdout = $stdout, dev_null
+        @argv = Array.new(ARGV)
+        Runner.module_eval { @run_options = @story_runner = nil }
+      end
+      
+      after :each do
+        $stdout = @stdout
+        ARGV.replace @argv
+        Runner.module_eval { @run_options = @story_runner = nil }
+      end
+      
+      it 'should wire up a singleton StoryRunner' do
+        Runner.story_runner.should_not be_nil
+      end
+      
+      it 'should set its options based on ARGV' do
+        # given
+        ARGV << '--dry-run'
+        
+        # when
+        options = Runner.run_options
+        
+        # then
+        ensure_that options.dry_run, is(true)
+      end
+
+      it 'should add a documenter to the runner classes if one is specified' do
+        # given
+        ARGV << "--format" << "specdoc"
+        story_runner = mock('story runner')
+        scenario_runner = mock('scenario runner')
+        
+        story_runner.stub!(:add_listener).with(an_instance_of(Reporter::PlainTextReporter))
+        scenario_runner.stub!(:add_listener).with(an_instance_of(Reporter::PlainTextReporter))
+
+        Runner::StoryRunner.stub!(:new).and_return(story_runner)
+        Runner::ScenarioRunner.stub!(:new).and_return(scenario_runner)
+        
+        # expect
+        World.should_receive(:add_listener).with(an_instance_of(Documenter::PlainTextDocumenter))
+        story_runner.should_receive(:add_listener).with(an_instance_of(Documenter::PlainTextDocumenter))
+        scenario_runner.should_receive(:add_listener).with(an_instance_of(Documenter::PlainTextDocumenter))
+        
+        # when
+        Runner.story_runner
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/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/vendor/plugins/rspec/spec/spec/story/simple_step_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/story_helper'
+
+module Spec
+  module Story
+    describe SimpleStep do
+      it 'should perform itself on an object' do
+        # given
+        $instance = nil
+        step = SimpleStep.new 'step' do
+          $instance = self
+        end
+        instance = Object.new
+        
+        # when
+        step.perform(instance)
+        
+        # then
+        $instance.should == instance
+      end
+      
+      it 'should perform itself with parameters' do
+        # given
+        $result = nil
+        step = SimpleStep.new 'step' do |value|
+          $result = value
+        end
+        instance = Object.new
+        
+        # when
+        step.perform(instance, 3)
+        
+        # then
+        $result.should == 3
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/story/step_mother_spec.rb

@@ -0,0 +1,59 @@
+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 = SimpleStep.new("a given", &lambda {})
+        step_mother.store(:given, "a 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(SimpleStep)
+        
+        lambda do
+          step.perform(Object.new)
+        end.should raise_error(Spec::DSL::ExamplePendingError, /Unimplemented/)
+      end
+      
+      it 'should clear itself' do
+        # given
+        step_mother = StepMother.new
+        step = SimpleStep.new("a given") do end
+        step_mother.store(:given, "a given", step)
+
+        # when
+        step_mother.clear
+        
+        # then
+        step_mother.should be_empty
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/story/story_helper.rb

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

data/vendor/plugins/rspec/spec/spec/story/story_spec.rb

@@ -0,0 +1,45 @@
+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 do
+          Story.new 'title', 'narrative'
+        end
+        
+        # then
+        error.should be_nil
+      end
+      
+      it "should raise when error 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
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/story/world_spec.rb

@@ -0,0 +1,406 @@
+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
+        ensure_that $first, is('first')
+        ensure_that $second, is('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_propagates_error(expected_error, &block)
+        # given
+        world = World.create
+        $error = nil
+        
+        # when
+        error = exception_from do
+          world.instance_eval(&block)
+        end
+        
+        # then
+        error.should be_kind_of(expected_error)
+      end
+      
+      it 'should propagate a failure from a Given, When or Then step' do
+        ensure_world_propagates_error RuntimeError do
+          Given 'a given' do
+            raise RuntimeError, "oops"
+          end
+        end
+        
+        ensure_world_propagates_error RuntimeError do
+          When 'an event' do
+            raise RuntimeError, "oops"
+          end
+        end
+        
+        ensure_world_propagates_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(:found_step).with(:given, 'a context')
+        mock_listener1.should_receive(:found_step).with(:when, 'an event')
+        mock_listener1.should_receive(:found_step).with(:then, 'an outcome')
+        
+        mock_listener2.should_receive(:found_step).with(:given, 'a context')
+        mock_listener2.should_receive(:found_step).with(:when, 'an event')
+        mock_listener2.should_receive(:found_step).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
+        # TODO verify_all
+      end
+      
+      it 'should tell listeners but not execute the step in dry-run mode' do
+        # given
+        Runner.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(:found_step).with(:given, 'a context')
+        
+        # when
+        world.instance_eval do
+          Given 'a context' do
+            $step_invoked = true
+          end
+        end
+        
+        # then
+        # TODO verify_all
+        $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_step).with(:'given scenario', 'a scenario')
+        listener.should_receive(:found_step).never.with(:given, 'given')
+        listener.should_receive(:found_step).never.with(:when, 'event')
+        listener.should_receive(:found_step).never.with(:then, 'outcome')
+        
+        # when
+        world.GivenScenario 'a scenario'
+        
+        # then
+        # TODO verify_all
+        $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
+    end
+  end
+end