deckshuffler 0.0.2

data/vendor/plugins/rspec/spec/spec/story/reporter/plain_text_reporter_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/../story_helper'
+
+module Spec
+  module Story
+    module Reporter
+      describe PlainTextReporter do
+        before :each do
+          # given
+          @out = String.new
+          @reporter = PlainTextReporter.new(@out)
+        end
+        
+        it 'should write a dot when a scenario succeeds' do
+          # when
+          @reporter.scenario_succeeded('story', 'scenario')
+          
+          # then
+          @out.should == '.'
+        end
+        
+        it 'should write a F when a scenario fails' do
+          # when
+          @reporter.scenario_failed('story', 'scenario', RuntimeError.new('oops'))
+          
+          # then
+          @out.should == 'F'
+        end
+        
+        it 'should write a P when a scenario is pending' do
+          # when
+          @reporter.scenario_pending('story', 'scenario', 'todo')
+          
+          # then
+          @out.should == 'P'
+        end
+        
+        it 'should summarize the number of scenarios when the run ends' do
+          # when
+          @reporter.run_started(3)
+          @reporter.scenario_succeeded('story', 'scenario1')
+          @reporter.scenario_succeeded('story', 'scenario2')
+          @reporter.scenario_succeeded('story', 'scenario3')
+          @reporter.run_ended
+          
+          # then
+          @out.should contain('3 scenarios')
+        end
+        
+        it 'should summarize the number of failed scenarios when the run ends' do
+          # when
+          @reporter.run_started(3)
+          @reporter.scenario_succeeded('story', 'scenario1')
+          @reporter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops' })
+          @reporter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops' })
+          @reporter.run_ended
+          
+          # then
+          @out.should contain("3 scenarios: 1 succeeded, 2 failed")
+        end
+        
+        it 'should produce details of each failed scenario when the run ends' do
+          # when
+          @reporter.run_started(3)
+          @reporter.scenario_succeeded('story', 'scenario1')
+          @reporter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops2' })
+          @reporter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops3' })
+          @reporter.run_ended
+          
+          # then
+          @out.should contain("FAILURES:\n")
+          @out.should contain("1) story (scenario2) FAILED")
+          @out.should contain("RuntimeError: oops2")
+          @out.should contain("2) story (scenario3) FAILED")
+          @out.should contain("RuntimeError: oops3")
+        end
+        
+        it 'should summarize the number of pending scenarios when the run ends' do
+          # when
+          @reporter.run_started(3)
+          @reporter.scenario_succeeded('story', 'scenario1')
+          @reporter.scenario_pending('story', 'scenario2', 'todo')
+          @reporter.scenario_pending('story', 'scenario3', 'todo')
+          @reporter.run_ended
+          
+          # then
+          @out.should contain("3 scenarios: 1 succeeded, 0 failed, 2 pending")
+        end
+        
+        it 'should produce details of each pending scenario when the run ends' do
+          # when
+          @reporter.run_started(3)
+          @reporter.scenario_succeeded('story', 'scenario1')
+          @reporter.scenario_pending('story', 'scenario2', 'todo2')
+          @reporter.scenario_pending('story', 'scenario3', 'todo3')
+          @reporter.run_ended
+          
+          # then
+          @out.should contain("Pending:\n")
+          @out.should contain("1) story (scenario2): todo2")
+          @out.should contain("2) story (scenario3): todo3")
+        end
+        
+        it 'should ignore uninteresting callbacks' do
+          # when
+          @reporter.story_started 'story', 'narrative'
+          @reporter.scenario_started 'story', 'scenario'
+          
+          # then
+          @out.should be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# add ensure_that(..)
+module Spec::Expectations::ObjectExpectations
+  def ensure_that(obj, expr)
+    obj.should expr
+  end
+end
+
+def exception_from(&block)
+  exception = nil
+  begin
+    yield
+  rescue StandardError => e
+    exception = e
+  end
+  exception
+end
+
+# simplify matchers
+
+
+# custom matchers
+
+def contain(string)
+  return simple_matcher(%[string containing "#{string}"]) do |actual|
+    actual.include? string
+  end
+end
+
+alias :contains :contain
+
+def is(expected)
+  return simple_matcher("equal to #{expected}") do |actual| actual == expected end
+end
+
+alias :are :is
+
+def is_a(type)
+  return simple_matcher("object of type #{type}") do |actual|
+    actual.is_a? type
+  end
+end
+
+alias :is_an :is_a
+
+def matches(pattern)
+  return simple_matcher("string matching #{pattern}") do |actual|
+    actual =~ pattern
+  end
+end

data/vendor/plugins/rspec/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
+          ensure_that scenarios.size, is(2)
+          ensure_that scenarios[0].name, is('scenario1')
+          ensure_that scenarios[0].story, is(story)
+          ensure_that scenarios[1].name, is('scenario2')
+          ensure_that scenarios[1].story, is(story)
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/story/runner/scenario_runner_spec.rb

@@ -0,0 +1,145 @@
+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
+          ensure_that $answer, is(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
+          # TODO verify_all
+        end
+        
+        it 'should notify listeners when a scenario succeeds' 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
+          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
+          # TODO verify_all
+        end
+        
+        it 'should notify listeners when a scenario raises an error' do
+          # given
+          error = RuntimeError.new('oops')
+          story = Story.new 'title', 'narrative' do end
+          scenario = Scenario.new story, 'scenario1' do
+            raise error
+          end
+          scenario_runner = ScenarioRunner.new
+          mock_listener = stub_everything('listener')
+          scenario_runner.add_listener(mock_listener)
+          world = stub_everything
+          
+          # expect
+          mock_listener.should_receive(:scenario_failed).with('title', 'scenario1', error)
+          
+          # when
+          scenario_runner.run scenario, world
+          
+          # then
+          # TODO verify_all
+        end
+        
+        it 'should notify listeners when a scenario is pending' do
+          # given
+          story = Story.new 'title', 'narrative' do end
+          scenario = Scenario.new story, 'scenario1' do
+            pending 'todo'
+          end
+          scenario_runner = ScenarioRunner.new
+          mock_listener = mock('listener')
+          scenario_runner.add_listener(mock_listener)
+          world = World.create
+          
+          # expect
+          mock_listener.should_receive(:scenario_started).with('title', 'scenario1')
+          mock_listener.should_receive(:scenario_pending).with('title', 'scenario1', 'todo')
+          
+          # when
+          scenario_runner.run scenario, world
+          
+          # then
+          # TODO verify_all
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/spec/spec/story/runner/story_runner_spec.rb

@@ -0,0 +1,247 @@
+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
+          ensure_that stories.size, is(2)
+          ensure_that stories[0].title, is('title1')
+          ensure_that stories[0].narrative, is('narrative1')
+          ensure_that stories[1].title, is('title2')
+          ensure_that stories[1].narrative, is('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
+          ensure_that scenarios.size, is(3)
+          ensure_that scenarios[0].name, is('scenario1')
+          ensure_that scenarios[1].name, is('scenario2')
+          ensure_that scenarios[2].name, is('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
+          ensure_that worlds.size, is(2)
+          worlds[0].should_not == worlds[1]
+        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
+          # TODO verify_all
+        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
+          # TODO verify_all
+        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
+          # TODO verify_all
+        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
+          # TODO verify_all
+        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 store the current running story in the world' do
+          # given
+          $stories = []
+          story_runner = StoryRunner.new(ScenarioRunner.new)
+          story_runner.Story 'title1', 'narrative1' do
+            Scenario 'scenario1' do
+              $stories << @current_story
+            end
+          end
+          story_runner.Story 'title2', 'narrative2' do
+            Scenario 'scenario2' do
+              $stories << @current_story
+            end
+          end
+          
+          # when
+          story_runner.run_stories
+          
+          # then
+          $stories.size.should == 2
+          ensure_that $stories[0].title, is('title1')
+          ensure_that $stories[1].title, is('title2')
+        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
+      end
+    end
+  end
+end