rspec 0.6.4 → 0.7.0

data/examples/partial_mock_example.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../lib/spec'
+
+class MockableClass
+  def self.find id
+    return :original_return
+  end
+end
+
+context "A partial mock" do
+
+  specify "should work at the class level" do
+    MockableClass.should_receive(:find).with(1).and_return {:stub_return}
+    MockableClass.find(1).should_equal :stub_return
+  end
+
+  specify "should revert to the original after each spec" do
+    MockableClass.find(1).should_equal :original_return
+  end
+
+  specify "can be mocked w/ ordering" do
+    MockableClass.should_receive(:msg_1).ordered
+    MockableClass.should_receive(:msg_2).ordered
+    MockableClass.should_receive(:msg_3).ordered
+    MockableClass.msg_1
+    MockableClass.msg_2
+    MockableClass.msg_3
+  end
+end

data/examples/stack_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../lib/spec'
 require File.dirname(__FILE__) + "/stack"
 
-context "A stack (in general)" do
+context "A stack which is neither empty nor full" do
   setup do
     @stack = Stack.new
     ["a","b","c"].each { |x| @stack.push x }
@@ -9,25 +9,25 @@ context "A stack (in general)" do
   
   specify "should add to the top when sent 'push'" do
     @stack.push "d"
-    @stack.peek.should_equal "d"
+    @stack.peek.should == "d"
   end
   
   specify "should return the top item when sent 'peek'" do
-    @stack.peek.should_equal "c"
+    @stack.peek.should == "c"
   end
   
   specify "should NOT remove the top item when sent 'peek'" do
-    @stack.peek.should_equal "c"
-    @stack.peek.should_equal "c"
+    @stack.peek.should == "c"
+    @stack.peek.should == "c"
   end
   
   specify "should return the top item when sent 'pop'" do
-    @stack.pop.should_equal "c"
+    @stack.pop.should == "c"
   end
   
   specify "should remove the top item when sent 'pop'" do
-    @stack.pop.should_equal "c"
-    @stack.pop.should_equal "b"
+    @stack.pop.should == "c"
+    @stack.pop.should == "b"
   end
 end
 

data/examples/stubbing_example.rb

@@ -1,13 +1,11 @@
 require File.dirname(__FILE__) + '/../lib/spec'
 
 context "A consumer of a stub" do
-
-  specify "should be able to stub objects" do
+  specify "should be able to stub methods on any Object" do
     obj = Object.new
-    stub(obj).method(:foobar).with {:return_value}
+    obj.stub!(:foobar).and_return {:return_value}
     obj.foobar.should_equal :return_value
   end
-
 end
 
 class StubbableClass
@@ -16,13 +14,56 @@ class StubbableClass
   end
 end
 
-context "A stub" do
-  specify "should work at the class level" do
-    stub(StubbableClass).method(:find).with {:stub_return}
+context "A stubbed method on a class" do
+  specify "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 after each spec" do
+  specify "should revert to the original method after each spec" do
     StubbableClass.find(1).should_equal :original_return
   end
-end
+
+  specify "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)
+
+    StubbableClass.msg.should_equal :stub_value
+    StubbableClass.msg(:other_arg).should_equal :stub_value
+    StubbableClass.msg(:arg).should_equal :mock_value
+    StubbableClass.msg(:another_arg).should_equal :stub_value
+    StubbableClass.msg(:yet_another_arg).should_equal :stub_value
+    StubbableClass.msg.should_equal :stub_value
+  end
+end
+
+context "A mock" do
+  specify "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
+    mock = mock("stubbing mock")
+    mock.stub!(:stub_message).and_return(:stub_value)
+    mock.should_receive(:mock_message).once.and_return(:mock_value)
+    (1..10).each {mock.stub_message.should_equal :stub_value}
+    mock.mock_message.should_equal :mock_value
+    (1..10).each {mock.stub_message.should_equal :stub_value}
+  end
+  
+  specify "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)
+    mock.msg.should_equal :stub_value
+    mock.msg(:other_arg).should_equal :stub_value
+    mock.msg(:arg).should_equal :mock_value
+    mock.msg(:another_arg).should_equal :stub_value
+    mock.msg(:yet_another_arg).should_equal :stub_value
+    mock.msg.should_equal :stub_value
+  end
+end
+
+    

data/examples/test_case_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__)  + '/../lib/spec'
 require 'test/unit'
 
-class RspecIntegrationTest < Test::Unit::TestCase
+class RSpecIntegrationTest < Test::Unit::TestCase
   def self.fixtures(*args)
     @@fixtures = true
   end
@@ -32,8 +32,8 @@ module RandomHelperModule
   end
 end
 
-context "Rspec should integrate with Test::Unit::TestCase" do
-  inherit RspecIntegrationTest
+context "RSpec should integrate with Test::Unit::TestCase" do
+  inherit RSpecIntegrationTest
   include RandomHelperModule
 
   fixtures :some_table
@@ -47,17 +47,17 @@ context "Rspec should integrate with Test::Unit::TestCase" do
     @rspec_setup_called.should_be true
   end
 
-  specify "Rspec should be able to access TestCase methods" do
+  specify "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
+  specify "RSpec should be able to accept included modules" do
     random_task
     @random_task_called.should_be true
   end
   
   teardown do
-    RspecIntegrationTest.verify_class_method
+    RSpecIntegrationTest.verify_class_method
   end
 end

data/lib/spec.rb

@@ -1,5 +1,4 @@
 require 'spec/version'
 require 'spec/expectations'
 require 'spec/mocks'
-require 'spec/runner'
-require 'spec/runner/kernel_ext'
+require 'spec/runner'

data/lib/spec/expectations.rb

@@ -1,7 +1,4 @@
-require 'spec/expectations/exceptions'
-require 'spec/expectations/expectations'
-require 'spec/expectations/should_base'
-require 'spec/expectations/have_helper'
-require 'spec/expectations/should_helper'
-require 'spec/expectations/should_negator'
 require 'spec/expectations/sugar'
+require 'spec/expectations/errors'
+require 'spec/expectations/extensions'
+require 'spec/expectations/should'

data/lib/spec/expectations/diff.rb

@@ -1,56 +1,32 @@
-begin
-  require 'rubygems'
-  require 'diff/lcs' #necessary to do loading bug on some machines - not sure why - DaC
-  require 'diff/lcs/hunk'
-rescue LoadError
-  raise "You must gem install diff-lcs to use diffing"
-end
-
 module Spec
   module Expectations
-    class ShouldBase
-      unless defined?(RSPEC_TESTING)
-        alias old_default_message default_message
-        def default_message(expectation, expected=:no_expectation_specified)
-          result = old_default_message(expectation, expected)
-          if expected.is_a?(String)
-            result << "\nDiff:" << diff_as_string(@target.to_s, expected)
-          end
-          result
+    module Should
+      class Base
+        unless defined? @@differ
+          @@differ = nil
+        end
+        def self.differ=(differ)
+          @@differ = differ
         end
-      end
 
-      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(data_old, data_new, format=:unified, context_lines=3)
-        data_old = data_old.split(/\n/).map! { |e| e.chomp }
-        data_new = data_new.split(/\n/).map! { |e| e.chomp }
-        output = ""
-        diffs = Diff::LCS.diff(data_old, data_new)
-        return output if diffs.empty?
-        oldhunk = hunk = nil  
-        file_length_difference = 0
-        diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
-                                       file_length_difference)
-            file_length_difference = hunk.file_length_difference      
-            next unless oldhunk      
-            # Hunks may overlap, which is why we need to be careful when our
-            # diff includes lines of context. Otherwise, we might print
-            # redundant lines.
-            if (context_lines > 0) and hunk.overlaps?(oldhunk)
-              hunk.unshift(oldhunk)
-            else
-              output << oldhunk.diff(format)
+        unless defined?(RSPEC_TESTING)
+          alias old_default_message default_message
+          def default_message(expectation, expected=:no_expectation_specified)
+            result = old_default_message(expectation, expected)
+
+            if expected != :no_expectation_specified
+              if expected.is_a?(String)
+                result << "\nDiff:" << @@differ.diff_as_string(@target.to_s, expected)
+              elsif ! @target.is_a? Proc
+                result << "\nDiff:" << @@differ.diff_as_object(@target,expected)
+              end
             end
-          ensure
-            oldhunk = hunk
-            output << "\n"
+
+            result
           end
-        end  
-        #Handle the last remaining hunk
-        output << oldhunk.diff(format) << "\n"
-      end  
+        end
+
+      end
     end
   end
 end

data/lib/spec/expectations/differs/default.rb

@@ -0,0 +1,62 @@
+begin
+  require 'rubygems'
+  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
+  require 'diff/lcs/hunk'
+rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
+
+require 'pp'
+
+module Spec
+  module Expectations
+    module Differs
+
+      # TODO add colour support
+      # TODO add some rdoc
+      class Default
+        def initialize(format=:unified,context_lines=nil,colour=nil)
+
+          context_lines ||= 3
+          colour        ||= false
+
+          @format,@context_lines,@colour = format,context_lines,colour
+        end
+
+        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+        def diff_as_string(data_old, data_new)
+          data_old = data_old.split(/\n/).map! { |e| e.chomp }
+          data_new = data_new.split(/\n/).map! { |e| e.chomp }
+          output = ""
+          diffs = Diff::LCS.diff(data_old, data_new)
+          return output if diffs.empty?
+          oldhunk = hunk = nil  
+          file_length_difference = 0
+          diffs.each do |piece|
+            begin
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @context_lines,
+                                         file_length_difference)
+              file_length_difference = hunk.file_length_difference      
+              next unless oldhunk      
+              # Hunks may overlap, which is why we need to be careful when our
+              # diff includes lines of context. Otherwise, we might print
+              # redundant lines.
+              if (@context_lines > 0) and hunk.overlaps?(oldhunk)
+                hunk.unshift(oldhunk)
+              else
+                output << oldhunk.diff(@format)
+              end
+            ensure
+              oldhunk = hunk
+              output << "\n"
+            end
+          end  
+          #Handle the last remaining hunk
+          output << oldhunk.diff(@format) << "\n"
+        end  
+
+        def diff_as_object(target,expected)
+          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
+        end
+      end
+    end
+  end
+end

data/lib/spec/expectations/extensions.rb

@@ -0,0 +1,4 @@
+require 'spec/expectations/extensions/object'
+require 'spec/expectations/extensions/numeric'
+require 'spec/expectations/extensions/symbol'
+require 'spec/expectations/extensions/inspect_for_expectation_not_met_error'

data/lib/spec/expectations/extensions/inspect_for_expectation_not_met_error.rb

@@ -0,0 +1,14 @@
+class Object
+  def inspect_for_expectation_not_met_error
+    return "#{inspect}" if inspect.include? "<"
+    return "<#{inspect}>" unless inspect.include? "<"
+  end
+end
+class TrueClass; def inspect_for_expectation_not_met_error; "true" end end
+class FalseClass; def inspect_for_expectation_not_met_error; "false" end end
+class NilClass; def inspect_for_expectation_not_met_error; "nil" end end
+class Class; def inspect_for_expectation_not_met_error; "<#{name}>" end end
+class Proc; def inspect_for_expectation_not_met_error; "<Proc>" end end
+class Array; def inspect_for_expectation_not_met_error; inspect end end
+class String; def inspect_for_expectation_not_met_error; inspect end end
+class Numeric; def inspect_for_expectation_not_met_error; inspect end end

data/lib/spec/expectations/extensions/numeric.rb

@@ -0,0 +1,5 @@
+class Numeric
+  def close?(other, precision)
+    (self - other).abs < precision
+  end
+end

data/lib/spec/expectations/{expectations.rb → extensions/object.rb}

@@ -2,7 +2,7 @@ module Spec
   module Expectations
     module ObjectExpectations
       def should
-        ShouldHelper.new self
+        Should::Should.new self
       end
     end
   end
@@ -10,10 +10,7 @@ end
 
 class Object
   include Spec::Expectations::ObjectExpectations
+  include Spec::Expectations::UnderscoreSugar
 end
 
-class Numeric
-  def close?(other, precision)
-    (self - other).abs < precision
-  end
-end
+Object.handle_underscores_for_rspec!

data/lib/spec/expectations/extensions/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def supported_by_rspec?
+    return ["<","<=",">=",">","==","=~"].include?(to_s)
+  end
+end

data/lib/spec/expectations/should.rb

@@ -0,0 +1,4 @@
+require 'spec/expectations/should/base'
+require 'spec/expectations/should/have'
+require 'spec/expectations/should/not'
+require 'spec/expectations/should/should'

data/lib/spec/expectations/should/base.rb

@@ -0,0 +1,42 @@
+module Spec
+  module Expectations
+    module Should
+      class Base
+
+        instance_methods.each { |m| undef_method m unless m =~ /^(__|\w)/ }
+
+        def default_message(expectation, expected=:no_expectation_specified)
+          message = "#{@target.inspect_for_expectation_not_met_error} #{expectation}"
+          if (expected != :no_expectation_specified)
+            message << " " << expected.inspect_for_expectation_not_met_error
+          end
+          message
+         end
+
+        def fail_with_message(message)
+          Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+        end
+    
+        def find_supported_sym(original_sym)
+          ["#{original_sym}?", "#{original_sym}s?"].each do |alternate_sym|
+            return alternate_sym.to_s if @target.respond_to?(alternate_sym.to_s)
+          end
+          return original_sym.supported_by_rspec? ? original_sym : "#{original_sym}?"
+        end
+
+        def method_missing(original_sym, *args, &block)
+          if original_sym.to_s =~ /^not_/
+            return Not.new(@target).__send__(original_sym.to_s[4..-1].to_sym, *args, &block)
+          end
+          if original_sym.to_s =~ /^be_/
+            return __send__(original_sym.to_s[3..-1].to_sym, *args, &block)
+          end
+          if original_sym.to_s =~ /^have_/
+            return have.__send__(original_sym.to_s[5..-1].to_sym, *args, &block)
+          end
+          __delegate_method_missing_to_target original_sym, find_supported_sym(original_sym), *args
+        end
+      end
+    end
+  end
+end