rspec 0.8.2 → 0.9.0

data/examples/stubbing_example.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "A consumer of a stub" do
-  specify "should be able to stub methods on any Object" do
+describe "A consumer of a stub" do
+  it "should be able to stub methods on any Object" do
     obj = Object.new
     obj.stub!(:foobar).and_return {:return_value}
     obj.foobar.should equal(:return_value)
@@ -14,17 +14,17 @@ class StubbableClass
   end
 end
 
-context "A stubbed method on a class" do
-  specify "should return the stubbed value" do
+describe "A stubbed method on a class" do
+  it "should return the stubbed value" do
     StubbableClass.stub!(:find).and_return(:stub_return)
     StubbableClass.find(1).should equal(:stub_return)
   end
   
-  specify "should revert to the original method after each spec" do
+  it "should revert to the original method after each spec" do
     StubbableClass.find(1).should equal(:original_return)
   end
 
-  specify "can stub! and mock the same message" do
+  it "can stub! and mock the same message" do
     StubbableClass.stub!(:msg).and_return(:stub_value)
     StubbableClass.should_receive(:msg).with(:arg).and_return(:mock_value)
 
@@ -37,14 +37,14 @@ context "A stubbed method on a class" do
   end
 end
 
-context "A mock" do
-  specify "can stub!" do
+describe "A mock" do
+  it "can stub!" do
     mock = mock("stubbing mock")
     mock.stub!(:msg).and_return(:value)
     (1..10).each {mock.msg.should equal(:value)}
   end
   
-  specify "can stub! and mock" do
+  it "can stub! and mock" do
     mock = mock("stubbing mock")
     mock.stub!(:stub_message).and_return(:stub_value)
     mock.should_receive(:mock_message).once.and_return(:mock_value)
@@ -53,7 +53,7 @@ context "A mock" do
     (1..10).each {mock.stub_message.should equal(:stub_value)}
   end
   
-  specify "can stub! and mock the same message" do
+  it "can stub! and mock the same message" do
     mock = mock("stubbing mock")
     mock.stub!(:msg).and_return(:stub_value)
     mock.should_receive(:msg).with(:arg).and_return(:mock_value)

data/examples/test_case_adapter_example.rb

@@ -0,0 +1,26 @@
+#This is an example of using RSpec's expectations in test/unit.
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'spec/test_case_adapter'
+
+class IntegratingRSpecExpectationsIntoTestCaseTest < Test::Unit::TestCase
+
+  def test_should_support_rspecs_equality_expectations
+    5.should == 5
+  end
+
+  def test_should_support_rspecs_comparison_expectations
+    5.should be > 4
+  end
+  
+  class Band
+    def players
+      ["John", "Paul", "George", "Ringo"]
+    end
+  end
+
+  def test_should_support_rspecs_collection_expectations
+    Band.new.should have(4).players
+  end
+end

data/examples/test_case_spec.rb

@@ -32,32 +32,32 @@ module RandomHelperModule
   end
 end
 
-context "RSpec should integrate with Test::Unit::TestCase" do
+describe "RSpec should integrate with Test::Unit::TestCase" do
   inherit RSpecIntegrationTest
   include RandomHelperModule
   
   fixtures :some_table
 
-  setup do
+  before(:each) do
     @rspec_setup_called = true
   end
 
-  specify "TestCase#setup should be called." do
+  it "TestCase#setup should be called." do
     @test_case_setup_called.should be_true
     @rspec_setup_called.should be_true
   end
 
-  specify "RSpec should be able to access TestCase methods" do
+  it "RSpec should be able to access TestCase methods" do
     helper_method
     @helper_method_called.should be_true
   end
 
-  specify "RSpec should be able to accept included modules" do
+  it "RSpec should be able to accept included modules" do
     random_task
     @random_task_called.should be_true
   end
   
-  teardown do
+  after(:each) do
     RSpecIntegrationTest.verify_class_method
   end
 end

data/lib/spec.rb

@@ -1,8 +1,13 @@
-require 'spec/deprecated'
+require 'spec/extensions'
 require 'spec/version'
-require 'spec/callback'
 require 'spec/matchers'
 require 'spec/expectations'
-require 'spec/mocks'
-require 'spec/runner'
 require 'spec/translator'
+require 'spec/dsl'
+require 'spec/runner'
+
+class Object
+  def metaclass
+    class << self; self; end
+  end
+end

data/lib/spec/dsl.rb

@@ -0,0 +1,10 @@
+require 'spec/dsl/description'
+require 'spec/dsl/configuration'
+require 'spec/dsl/behaviour_callbacks'
+require 'spec/dsl/behaviour'
+require 'spec/dsl/behaviour_eval'
+require 'spec/dsl/composite_proc_builder'
+require 'spec/dsl/example'
+require 'spec/dsl/example_matcher'
+require 'spec/dsl/example_should_raise_handler'
+require 'spec/dsl/behaviour_factory'

data/lib/spec/dsl/behaviour.rb

@@ -0,0 +1,189 @@
+module Spec
+  module DSL
+    class EvalModule < Module; end
+    class Behaviour
+      extend BehaviourCallbacks
+
+      class << self
+        def add_shared_behaviour(behaviour)
+          raise ArgumentError.new("Shared Behaviour '#{behaviour.description}' already exists") if find_shared_behaviour(behaviour.description)
+          shared_behaviours << behaviour
+        end
+
+        def find_shared_behaviour(behaviour_description)
+          shared_behaviours.find { |b| b.description == behaviour_description }
+        end
+
+        def shared_behaviours
+          # TODO - this needs to be global, or at least accessible from
+          # from subclasses of Behaviour in a centralized place. I'm not loving
+          # this as a solution, but it works for now.
+          $shared_behaviours ||= []
+        end
+      end
+
+      def initialize(*args, &behaviour_block)
+        init_description(*args)
+        init_eval_module
+        before_eval
+        eval_behaviour(&behaviour_block)
+      end
+      
+    private
+
+      def init_description(*args)
+        @description = Description.new(*args)
+      end
+      
+      def init_eval_module
+        @eval_module = EvalModule.new
+        @eval_module.extend BehaviourEval::ModuleMethods
+        @eval_module.include BehaviourEval::InstanceMethods
+        @eval_module.behaviour = self
+        @eval_module.description = @description
+      end
+
+      def eval_behaviour(&behaviour_block)
+        @eval_module.class_eval(&behaviour_block)
+      end
+      
+    protected
+    
+      def before_eval
+      end
+      
+    public
+
+      def run(reporter, dry_run=false, reverse=false, timeout=nil)
+        return if shared?
+        reporter.add_behaviour(description)
+        prepare_execution_context_class
+        errors = run_before_all(reporter, dry_run)
+
+        specs = reverse ? examples.reverse : examples
+        example_execution_context = nil
+         
+        if errors.empty?
+          specs.each do |example|
+            example_execution_context = execution_context(example)
+            example_execution_context.copy_instance_variables_from(@before_and_after_all_context_instance) unless before_all_proc.nil?
+            example.run(reporter, before_each_proc, after_each_proc, dry_run, example_execution_context, timeout)
+          end
+        end
+        
+        @before_and_after_all_context_instance.copy_instance_variables_from(example_execution_context) unless after_all_proc.nil?
+        run_after_all(reporter, dry_run)
+      end
+
+      def number_of_examples
+        examples.length
+      end
+
+      def matches?(specified_examples)
+        matcher ||= ExampleMatcher.new(description)
+
+        examples.each do |example|
+          return true if example.matches?(matcher, specified_examples)
+        end
+        return false
+      end
+
+      def shared?
+        @description[:shared]
+      end
+
+      def retain_examples_matching!(specified_examples)
+        return if specified_examples.index(description)
+        matcher = ExampleMatcher.new(description)
+        examples.reject! do |example|
+          !example.matches?(matcher, specified_examples)
+        end
+      end
+
+      def methods
+        my_methods = super
+        my_methods |= @eval_module.methods
+        my_methods
+      end
+
+    protected
+
+      # Messages that this class does not understand
+      # are passed directly to the @eval_module.
+      def method_missing(sym, *args, &block)
+        @eval_module.send(sym, *args, &block)
+      end
+
+      def prepare_execution_context_class
+        plugin_mock_framework
+        weave_in_included_modules
+        define_predicate_matchers #this is in behaviour_eval
+        execution_context_class
+      end
+
+      def weave_in_included_modules
+        mods = included_modules
+        eval_module = @eval_module
+        execution_context_class.class_eval do
+          include eval_module
+          Spec::Runner.configuration.included_modules.each do |mod|
+            include mod
+          end
+          mods.each do |mod|
+            include mod
+          end
+        end
+      end
+
+      def execution_context(example)
+        execution_context_class.new(example)
+      end
+
+      def run_before_all(reporter, dry_run)
+        errors = []
+        unless dry_run
+          begin
+            @before_and_after_all_context_instance = execution_context(nil)
+            @before_and_after_all_context_instance.instance_eval(&before_all_proc)
+          rescue => e
+            errors << e
+            location = "before(:all)"
+            reporter.example_finished(location, e, location) if reporter
+          end
+        end
+        errors
+      end
+      
+      def run_after_all(reporter, dry_run)
+        unless dry_run
+          begin 
+            @before_and_after_all_context_instance ||= execution_context(nil) 
+            @before_and_after_all_context_instance.instance_eval(&after_all_proc) 
+          rescue => e
+            location = "after(:all)"
+            reporter.example_finished(location, e, location) if reporter
+          end
+        end
+      end
+      
+      def plugin_mock_framework
+        case mock_framework = Spec::Runner.configuration.mock_framework
+        when Module
+          include mock_framework
+        else
+          require Spec::Runner.configuration.mock_framework
+          include Spec::Plugins::MockFramework
+        end
+      end
+      
+      def description
+        @description.to_s
+      end
+      
+      def described_type
+        @description.described_type
+      end
+
+    end
+  end
+end

data/lib/spec/dsl/behaviour_callbacks.rb

@@ -0,0 +1,43 @@
+module Spec
+  module DSL
+    module BehaviourCallbacks
+      def before(scope=:each, &block)
+        case scope
+        when :each; before_each_parts << block
+        when :all;  before_all_parts << block
+        end
+      end
+
+      def after(scope=:each, &block)
+        case scope
+        when :each; after_each_parts.unshift(block)
+        when :all;  after_all_parts.unshift(block)
+        end
+      end
+
+      def setup(&block)
+        before(:each, &block)
+      end
+
+      def teardown(&block)
+        after(:each, &block)
+      end
+
+      def before_all_parts
+        @before_all_parts ||= []
+      end
+
+      def after_all_parts
+        @after_all_parts ||= []
+      end
+
+      def before_each_parts
+        @before_each_parts ||= []
+      end
+
+      def after_each_parts
+        @after_each_parts ||= []
+      end
+    end
+  end
+end

data/lib/spec/dsl/behaviour_eval.rb

@@ -0,0 +1,170 @@
+module Spec
+  module DSL
+    module BehaviourEval
+      module ModuleMethods
+        include BehaviourCallbacks
+
+        attr_writer :behaviour
+        attr_accessor :description
+
+        def inherit(klass)
+          raise ArgumentError.new("Shared behaviours cannot inherit from classes") if @behaviour.shared?
+          @behaviour_superclass = klass
+          derive_execution_context_class_from_behaviour_superclass
+        end
+
+        def include(mod)
+          included_modules << mod
+          mod.send :included, self
+        end
+
+        def it_should_behave_like(behaviour_description)
+          behaviour = @behaviour.class.find_shared_behaviour(behaviour_description)
+          if behaviour.nil?
+            raise RuntimeError.new("Shared Behaviour '#{behaviour_description}' can not be found")
+          end
+          behaviour.copy_to(self)
+        end
+
+        def copy_to(eval_module)
+          examples.each          { |e| eval_module.examples << e; }
+          before_each_parts.each { |p| eval_module.before_each_parts << p }
+          after_each_parts.each  { |p| eval_module.after_each_parts << p }
+          before_all_parts.each  { |p| eval_module.before_all_parts << p }
+          after_all_parts.each   { |p| eval_module.after_all_parts << p }
+          included_modules.each  { |m| eval_module.included_modules << m }
+        end
+        
+        # :call-seq:
+        #   predicate_matchers[method_on_object] = matcher_name
+        #
+        # Dynamically generates a custom matcher that will match
+        # a predicate on your class.
+        #
+        # == Example
+        #
+        #   class Fish
+        #     def can_swim?
+        #       true
+        #     end
+        #   end
+        #
+        #   describe Fish do
+        #     predicate_matchers[:can_swim?] = :swim
+        #     it "should swim" do
+        #       Fish.new.should swim
+        #     end
+        #   end
+        def predicate_matchers
+          @predicate_matchers ||= {:exist? => :exist}
+        end
+        
+        def define_predicate_matchers(hash=nil) # :nodoc:
+          if hash.nil?
+            define_predicate_matchers(predicate_matchers)
+            define_predicate_matchers(Spec::Runner.configuration.predicate_matchers)
+          else
+            hash.each_pair do |method_on_object, matcher_method|
+              define_method matcher_method do |*args|
+                eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
+              end
+            end
+          end
+        end
+        
+        def it(description=:__generate_description, opts={}, &block)
+          examples << Example.new(description, opts, &block)
+        end
+        
+        def specify(description, opts={}, &block)
+          it(description, opts, &block)
+        end
+
+        def methods
+          my_methods = super
+          my_methods |= behaviour_superclass.methods
+          my_methods
+        end
+
+      protected
+
+        def method_missing(method_name, *args)
+          if behaviour_superclass.respond_to?(method_name)
+            return execution_context_class.send(method_name, *args)
+          end
+          super
+        end
+
+        def before_all_proc(&error_handler)
+          parts = []
+          parts.push(*Behaviour.before_all_parts)
+          parts.push(*before_all_parts)
+          CompositeProcBuilder.new(parts).proc(&error_handler)
+        end
+
+        def after_all_proc(&error_handler)
+          parts = []
+          parts.push(*after_all_parts)
+          parts.push(*Behaviour.after_all_parts)
+          CompositeProcBuilder.new(parts).proc(&error_handler)
+        end
+
+        def before_each_proc(&error_handler)
+          parts = []
+          add_superclass_method(parts, 'setup')
+          parts.push(*Behaviour.before_each_parts)
+          parts.push(*before_each_parts)
+          CompositeProcBuilder.new(parts).proc(&error_handler)
+        end
+
+        def after_each_proc(&error_handler)
+          parts = []
+          parts.push(*after_each_parts)
+          add_superclass_method(parts, 'teardown')
+          parts.push(*Behaviour.after_each_parts)
+          CompositeProcBuilder.new(parts).proc(&error_handler)
+        end
+
+        def add_superclass_method(parts, method_name)
+          parts << behaviour_superclass.instance_method(method_name) if behaviour_superclass.instance_methods.include?(method_name)
+        end
+
+      private
+
+        def execution_context_class
+          @execution_context_class ||= derive_execution_context_class_from_behaviour_superclass
+        end
+
+        def derive_execution_context_class_from_behaviour_superclass
+          @execution_context_class = Class.new(behaviour_superclass)
+        end
+
+        def behaviour_superclass
+          @behaviour_superclass ||= Object
+        end
+
+        protected
+        def included_modules
+          @included_modules ||= [::Spec::Matchers]
+        end
+
+        def examples
+          @examples ||= []
+        end
+      end
+
+      module InstanceMethods
+        def initialize(*args, &block) #:nodoc:
+          # TODO - inheriting from TestUnit::TestCase fails without this
+          # - let's figure out why and move this somewhere else
+        end
+
+        def violated(message="")
+          raise Spec::Expectations::ExpectationNotMetError.new(message)
+        end
+
+      end
+
+    end
+  end
+end