rbehave 0.1.0

data/behaviour/examples/rbehave/world_behaviour.rb

@@ -0,0 +1,259 @@
+require 'behaviour/examples/helper'
+
+module RBehave
+  describe World do
+    setup do
+      World.listeners.clear
+      RBehave::Runner.dry_run = false
+    end
+    
+    teardown do
+      World.listeners.clear
+      RBehave::Runner.dry_run = false
+    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 an object of a specified type that mixes in a world' do
+      # when
+      obj = World::create String
+      
+      # then
+      obj.should be_kind_of(String)
+      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 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 the reused step in the new object instance' do
+      # given
+      $instances = []
+      world1 = World.create
+      world1.instance_eval do
+        Given 'a given' do
+          $instances << self
+        end
+      end
+      world2 = World.create
+      
+      # when
+      world2.instance_eval do
+        Given 'a given' # reused
+        Then 'an outcome' do
+          $instances << self
+        end
+      end
+      
+      # then
+      $instances.should == [ world1, world2, world2 ]
+    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.expects(:found_step).with(:given, 'a context')
+      mock_listener1.expects(:found_step).with(:when, 'an event')
+      mock_listener1.expects(:found_step).with(:then, 'an outcome')
+      
+      mock_listener2.expects(:found_step).with(:given, 'a context')
+      mock_listener2.expects(:found_step).with(:when, 'an event')
+      mock_listener2.expects(: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
+      verify_mocks
+    end
+    
+    it 'should tell listeners but not execute the step if it is in dry-run mode' do
+      # given
+      RBehave::Runner.dry_run = true
+      mock_listener = mock('listener')
+      World.add_listener(mock_listener)
+      $step_invoked = false
+      world = World.create
+      
+      # expect
+      mock_listener.expects(:found_step).with(:given, 'a context')
+      
+      # when
+      world.instance_eval do
+        Given 'a context' do
+          $step_invoked = true
+        end
+      end
+      
+      # then
+      verify_mocks
+      $step_invoked.should be(false)
+    end
+  end
+end

data/behaviour/examples/rspec_adapter.rb

@@ -0,0 +1,81 @@
+require 'rubygems'
+require 'spec'
+require 'mocha'
+
+# replace rspec's mocks with mocha
+Spec::Runner::configuration.mock_with :mocha
+
+# add ensure_that(..), verify(..)
+module Spec::Expectations::ObjectExpectations
+    def ensure_that(obj, expr)
+      obj.should expr
+    end
+end
+
+# helper methods
+def pending(message = "todo")
+  where = caller[0]
+  at_exit { puts "#{where}: #{message}" }
+end
+
+def exception_from(&block)
+  begin
+    yield
+  rescue StandardError => e
+    e
+  end
+end
+
+# simplify matchers
+
+class Matcher
+  def initialize(description, &match_block)
+    @description = description
+    @match_block = match_block
+  end
+  
+  def matches?(actual)
+    @actual = actual
+    return @match_block.call(actual)
+  end
+  
+  def failure_message()
+    return %[Expected #@description but got #@actual]
+  end
+  
+  def negative_failure_message()
+    return %[Expected not to get #@description, but got #@actual]
+  end
+  
+  def to_s
+    failure_message
+  end
+end
+
+# custom matchers
+
+def contain(string)
+  return Matcher.new(%[string containing "#{string}"]) do |actual|
+    actual.include? string
+  end
+end
+
+alias :contains :contain
+
+def is(expected)
+  return Matcher.new("equal to #{expected}") do |actual| actual == expected end
+end
+
+alias :are :is
+
+def is_a(type)
+  return Matcher.new("object of type #{type}") do |actual|
+    actual.is_a? type
+  end
+end
+
+def matches(pattern)
+  return Matcher.new("string matching #{pattern}") do |actual|
+    actual =~ pattern
+  end
+end

data/lib/rbehave/documenter/plain_text_documenter.rb

@@ -0,0 +1,29 @@
+module RBehave
+  module Documenter
+    class PlainTextDocumenter
+      def initialize(out)
+        @out = out
+      end
+      
+      def story_started(title, narrative)
+        @out << "Story: #{title}\n#{narrative}\n"
+      end
+      
+      def story_ended(title, narrative)
+        @out << "\n\n"
+      end
+      
+      def scenario_started(story_title, scenario_name)
+        @out << "\nScenario: #{scenario_name}\n"
+      end
+      
+      def found_step(name, description)
+        @out << "  #{name.to_s.capitalize} #{description}\n"
+      end
+      
+      def method_missing(meth, *args, &block)
+        # ignore any other calls
+      end
+    end
+  end
+end

data/lib/rbehave/exceptions.rb

@@ -0,0 +1,24 @@
+module RBehave
+  class PendingException < StandardError
+  end
+end
+
+class Exception
+  class << self
+    def backtrace_filters
+      @backtrace_filters ||= []
+    end
+    def add_backtrace_filter(filter)
+      backtrace_filters << filter
+    end
+  end
+  
+  def filtered_backtrace
+    trace = backtrace || []
+    trace.reject do |line|
+      Exception.backtrace_filters.inject(false) do |already_matched, filter|
+        already_matched || line =~ filter
+      end
+    end
+  end
+end

data/lib/rbehave/reporter/plain_text_reporter.rb

@@ -0,0 +1,58 @@
+module RBehave
+  module Reporter
+    class PlainTextReporter
+      def initialize(out)
+        @out = out
+        @succeeded = 0
+        @failed = []
+        @pending = []
+      end
+      
+      def scenario_succeeded(story_title, scenario_name)
+        @out << '.'
+        @succeeded += 1
+      end
+      
+      def scenario_failed(story_title, scenario_name, err)
+        @out << 'F'
+        @failed << [story_title, scenario_name, err]
+      end
+      
+      def scenario_pending(story_title, scenario_name, msg)
+        @pending << [story_title, scenario_name, msg]
+        @out << 'P'
+      end
+      
+      def run_started(count)
+        @count = count
+        @out << "Running #@count scenarios:\n"
+      end
+      
+      def run_ended
+        @out << "\n\n#@count scenarios: #@succeeded succeeded, #{@failed.size} failed, #{@pending.size} pending\n"
+        unless @pending.empty?
+          @out << "\nPending:\n"
+          @pending.each_with_index do |pending, i|
+            title, scenario_name, msg = pending
+            @out << "#{i+1}) #{title} (#{scenario_name}): #{msg}\n"
+          end
+        end
+        unless @failed.empty?
+          @out << "\nFAILURES:"
+          @failed.each_with_index do |failure, i|
+            title, scenario_name, err = failure
+            @out << %[
+#{i+1}) #{title} (#{scenario_name}) FAILED
+#{err.class}: #{err.message}
+#{err.filtered_backtrace.join("\n")}
+]
+          end
+        end
+      end
+      
+      def method_missing(meth, *args, &block)
+        # ignore unexpected callbacks
+      end
+    end
+  end
+end

data/lib/rbehave/runner/scenario_collector.rb

@@ -0,0 +1,16 @@
+module RBehave
+  module Runner
+    class ScenarioCollector
+      attr_accessor :scenarios
+      
+      def initialize(story)
+        @story = story
+        @scenarios = []
+      end
+      
+      def Scenario(name, &body)
+        @scenarios << Scenario.new(@story, name, &body)
+      end
+    end
+  end
+end

data/lib/rbehave/runner/scenario_runner.rb

@@ -0,0 +1,40 @@
+module RBehave
+  module Runner
+    class ScenarioRunner
+      def initialize
+        @listeners = []
+      end
+      
+      def run(scenario, world)
+        begin
+          @listeners.each { |l| l.scenario_started(scenario.story.title, scenario.name) }
+          run_story_ignoring_scenarios(scenario.story, world)
+          world.instance_eval(&scenario.body)
+          @listeners.each { |l| l.scenario_succeeded(scenario.story.title, scenario.name) }
+        rescue PendingException => e
+          @listeners.each { |l| l.scenario_pending(scenario.story.title, scenario.name, e.message) }
+        rescue StandardError => e
+          @listeners.each { |l| l.scenario_failed(scenario.story.title, scenario.name, e) }
+        end
+      end
+      
+      def add_listener(listener)
+        @listeners << listener
+      end
+      
+      private
+      
+      def run_story_ignoring_scenarios(story, world)
+        class << world
+          def Scenario(name, &block)
+            # do nothing
+          end
+        end
+        story.run_in(world)
+        class << world
+          remove_method(:Scenario)
+        end
+      end
+    end
+  end
+end

data/lib/rbehave/runner/story_runner.rb

@@ -0,0 +1,44 @@
+module RBehave
+  module Runner
+    class StoryRunner
+      attr_accessor :stories, :scenarios
+      
+      def initialize(scenario_runner, world_creator = World)
+        @scenario_runner = scenario_runner
+        @world_creator = world_creator
+        @stories = []
+        @scenarios_by_story = {}
+        @scenarios = []
+        @listeners = []
+      end
+      
+      def Story(title, narrative, &body)
+        story = Story.new(title, narrative, &body)
+        @stories << story
+        
+        # collect scenarios
+        collector = ScenarioCollector.new(story)
+        story.run_in(collector)
+        @scenarios += collector.scenarios
+        @scenarios_by_story[story.title] = collector.scenarios
+      end
+      
+      def run_stories
+        @listeners.each { |l| l.run_started(scenarios.size) }
+        @stories.each do |story|
+          @listeners.each { |l| l.story_started(story.title, story.narrative) }
+          scenarios = @scenarios_by_story[story.title]
+          scenarios.each do |scenario|
+            @scenario_runner.run(scenario, @world_creator.create)
+          end
+          @listeners.each { |l| l.story_ended(story.title, story.narrative) }
+        end
+        @listeners.each { |l| l.run_ended }
+      end
+      
+      def add_listener(listener)
+        @listeners << listener
+      end
+    end
+  end
+end

data/lib/rbehave/scenario.rb

@@ -0,0 +1,11 @@
+module RBehave
+  class Scenario
+    attr_accessor :name, :body, :story
+    
+    def initialize(story, name, &body)
+      @story = story
+      @name = name
+      @body = body
+    end
+  end
+end

data/lib/rbehave/story.rb

@@ -0,0 +1,15 @@
+module RBehave
+  class Story
+    attr_reader :title, :narrative
+    
+    def initialize(title, narrative, &body)
+      @body = body
+      @title = title
+      @narrative = narrative
+    end
+    
+    def run_in(container)
+      container.instance_eval(&@body)
+    end
+  end
+end

data/lib/rbehave/version.rb

@@ -0,0 +1,9 @@
+module Rbehave #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/rbehave/world.rb

@@ -0,0 +1,55 @@
+module RBehave
+=begin
+  A World represents the actual instance a scenario will run in.
+  
+  RBehave ensures any instance variables and methods defined anywhere
+  in a story block are available to all the scenarios. This includes
+  variables that are created or referenced inside Given, When and Then
+  blocks.
+=end
+  module World
+    # store steps and listeners in the singleton metaclass.
+    # This serves both to keep them out of the way and to
+    # make them available to all instances.
+    class << self
+      def create(cls = Object)
+        cls.new.extend(World)
+      end
+      
+      def store_and_call(instance, type, name, &block)
+        @step_mother ||= Hash.new {|hsh,key| hsh[key] = Hash.new }
+        if block_given?
+          @step_mother[type][name] = block
+        else
+          block = @step_mother[type][name]
+        end
+        listeners.each { |l| l.found_step(type, name) }
+        instance.instance_eval(&block) unless RBehave::Runner.dry_run?
+      end
+      
+      def listeners
+        @listeners ||= []
+      end
+      
+      def add_listener(listener)
+        listeners << listener
+      end
+    end
+    
+    def Given(name, &block)
+      World.store_and_call self, :given, name, &block
+    end
+    
+    def When(name, &block)
+      World.store_and_call self, :when, name, &block
+    end
+    
+    def Then(name, &block)
+      World.store_and_call self, :then, name, &block
+    end
+    
+    def pending(message = 'todo')
+      raise PendingException, message
+    end
+  end
+end