rbehave 0.1.0

data/CHANGELOG.txt

@@ -0,0 +1,2 @@
+== Version 0.1.0
+* First running version

data/Manifest.txt

@@ -0,0 +1,31 @@
+lib/rbehave/reporter/plain_text_reporter.rb
+lib/rbehave/exceptions.rb
+lib/rbehave/documenter/plain_text_documenter.rb
+lib/rbehave/world.rb
+lib/rbehave/runner/story_runner.rb
+lib/rbehave/runner/scenario_collector.rb
+lib/rbehave/runner/scenario_runner.rb
+lib/rbehave/story.rb
+lib/rbehave/version.rb
+lib/rbehave/scenario.rb
+lib/rbehave.rb
+behaviour/everything.rb
+behaviour/examples/rbehave/reporter/plain_text_reporter_behaviour.rb
+behaviour/examples/rbehave/world_behaviour.rb
+behaviour/examples/rbehave/documenter/plain_text_documenter_behaviour.rb
+behaviour/examples/rbehave/story_behaviour.rb
+behaviour/examples/rbehave/runner/scenario_runner_behaviour.rb
+behaviour/examples/rbehave/runner/story_runner_behaviour.rb
+behaviour/examples/rbehave/runner/scenario_collector_behaviour.rb
+behaviour/examples/rbehave/exception_behaviour.rb
+behaviour/examples/rspec_adapter.rb
+behaviour/examples/everything.rb
+behaviour/examples/helper.rb
+
+CHANGELOG.txt
+History.txt
+Manifest.txt
+NOTES.txt
+Rakefile
+README.txt
+setup.rb

data/NOTES.txt

@@ -0,0 +1,11 @@
+StoryRunner
+* should collect all the stories
+* should count all the scenarios in the stories
+* should execute the scenarios
+
+ScenarioRunner
+- should run scenarios in a World
+
+Additions for rspec:
+	pending(msg)
+

data/README.txt

@@ -0,0 +1,4 @@
+== RBehave
+
+RBehave is a behaviour-driven development framework for Ruby.
+

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'rbehave', 'version')
+
+AUTHOR = "dan"  # can also be an array of Authors
+EMAIL = "dan@rbehave.org"
+DESCRIPTION = "RBehave"
+GEM_NAME = "rbehave" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "rbehave" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+
+
+NAME = "rbehave"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Rbehave::VERSION::STRING + (REV ? ".#{REV}" : ""))
+                          CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "rbehave documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["behaviour/everything.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  #p.extra_deps     - An array of rubygem dependencies.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end

data/behaviour/everything.rb

@@ -0,0 +1 @@
+require 'behaviour/examples/everything'

data/behaviour/examples/everything.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), 'rbehave/**/*_behaviour.rb')].each do |f|
+  require f
+end

data/behaviour/examples/helper.rb

@@ -0,0 +1,2 @@
+require 'behaviour/examples/rspec_adapter'
+require 'lib/rbehave'

data/behaviour/examples/rbehave/documenter/plain_text_documenter_behaviour.rb

@@ -0,0 +1,58 @@
+require 'behaviour/examples/helper'
+
+module RBehave
+  module Documenter
+    describe PlainTextDocumenter do
+      setup do
+        @out = String.new
+        @documenter = PlainTextDocumenter.new(@out)
+      end
+      
+      it 'should document a story title and narrative' do
+        # when
+        @documenter.story_started 'story', 'narrative'
+        
+        # then
+        @out.should contain("Story: story\nnarrative\n")
+      end
+      
+      it 'should document a scenario name' do
+        # when
+        @documenter.scenario_started 'story', 'scenario'
+        
+        # then
+        @out.should contain("\nScenario: scenario\n")
+      end
+      
+      it 'should document a step by sentence-casing its name' do
+        # when
+        @documenter.found_step :given, 'a context'
+        @documenter.found_step :when, 'an event'
+        @documenter.found_step :then, 'an outcome'
+        
+        # then
+        @out.should contain("  Given a context\n  When an event\n  Then an outcome\n")
+      end
+      
+      it 'should print some white space after each story' do
+        # when
+        @documenter.story_ended 'title', 'narrative'
+        
+        # then
+        @out.should contain("\n\n")
+      end
+      
+      it 'should ignore uninteresting calls' do
+        # when
+        @documenter.run_started(42)
+        @documenter.run_ended
+        @documenter.scenario_succeeded('story', 'scenario')
+        @documenter.scenario_failed('story', 'scenario', RuntimeError.new)
+        @documenter.scenario_pending('story', 'scenario', 'todo')
+        
+        # then
+        @out.should be_empty
+      end
+    end
+  end
+end

data/behaviour/examples/rbehave/exception_behaviour.rb

@@ -0,0 +1,27 @@
+require 'behaviour/examples/helper'
+
+describe Exception do
+  it 'should filter boring elements from its backtrace' do
+    # given
+    err = Exception.new 'oops'
+    err.set_backtrace [
+      '/an/interesting/line:1',
+      '/a/boring/line',
+      '/an/interesting/line:2',
+      '/another/dull/line',
+      '/an/interesting/line:3',
+    ]
+    Exception.add_backtrace_filter(/boring/)
+    Exception.add_backtrace_filter(/dull/)
+    
+    # when
+    backtrace = err.filtered_backtrace
+    
+    # then
+    backtrace.should == [
+      '/an/interesting/line:1',
+      '/an/interesting/line:2',
+      '/an/interesting/line:3',
+    ]
+  end
+end

data/behaviour/examples/rbehave/reporter/plain_text_reporter_behaviour.rb

@@ -0,0 +1,112 @@
+require 'behaviour/examples/helper'
+
+module RBehave
+  module Reporter
+    describe PlainTextReporter do
+      setup 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

data/behaviour/examples/rbehave/runner/scenario_collector_behaviour.rb

@@ -0,0 +1,25 @@
+require 'behaviour/examples/helper'
+
+module RBehave
+  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

data/behaviour/examples/rbehave/runner/scenario_runner_behaviour.rb

@@ -0,0 +1,143 @@
+require 'behaviour/examples/helper'
+
+module RBehave
+  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.expects(:scenario_started).with('story', 'scenario1')
+        mock_listener2.expects(:scenario_started).with('story', 'scenario1')
+        
+        # when
+        scenario_runner.run(scenario, world)
+        
+        # then
+        verify_mocks
+      end
+      
+      it 'should notify listeners when a scenario succeeds' 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.expects(:scenario_succeeded).with('story', 'scenario1')
+        mock_listener2.expects(:scenario_succeeded).with('story', 'scenario1')
+        
+        # when
+        scenario_runner.run(scenario, world)
+        
+        # then
+        verify_mocks
+      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.expects(:scenario_failed).with('title', 'scenario1', error)
+        
+        # when
+        scenario_runner.run scenario, world
+        
+        # then
+        verify_mocks
+      end
+      
+      
+      it 'should notify listeners when a scenario raises an error' do
+        # given
+        story = Story.new 'title', 'narrative' do end
+        scenario = Scenario.new story, 'scenario1' do
+          pending 'todo'
+        end
+        scenario_runner = ScenarioRunner.new
+        mock_listener = stub_everything('listener')
+        scenario_runner.add_listener(mock_listener)
+        world = World.create
+        
+        # expect
+        mock_listener.expects(:scenario_pending).with('title', 'scenario1', 'todo')
+        
+        # when
+        scenario_runner.run scenario, world
+        
+        # then
+        verify_mocks
+      end
+    end
+  end
+end

data/behaviour/examples/rbehave/runner/story_runner_behaviour.rb

@@ -0,0 +1,169 @@
+require 'behaviour/examples/helper'
+
+module RBehave
+  module Runner
+    describe StoryRunner do
+      it 'should collect all the stories' do
+        # given
+        story_runner = StoryRunner.new(stub)
+        
+        # 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)
+        
+        # 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 ScenarioRunnerThatStoresWorlds
+        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 = ScenarioRunnerThatStoresWorlds.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.expects(:create).times(2)
+        
+        # when
+        story_runner.run_stories
+        
+        # then
+        verify_mocks
+      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.expects(:run_started).with(3)
+        mock_listener2.expects(:run_started).with(3)
+        
+        # when
+        story_runner.run_stories
+        
+        # then
+        verify_mocks
+      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.expects(:story_started).with('story1', 'narrative1')
+        mock_listener1.expects(:story_ended).with('story1', 'narrative1')
+        mock_listener2.expects(:story_started).with('story2', 'narrative2')
+        mock_listener2.expects(:story_ended).with('story2', 'narrative2')
+        
+        # when
+        story_runner.run_stories
+        
+        # then
+        verify_mocks
+      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.expects(:run_ended)
+        mock_listener2.expects(:run_ended)
+        
+        # when
+        story_runner.run_stories
+        
+        # then
+        verify_mocks
+      end
+    end
+  end
+end

data/behaviour/examples/rbehave/story_behaviour.rb

@@ -0,0 +1,20 @@
+require 'behaviour/examples/helper'
+
+module RBehave
+  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
+  end
+end