rspec 0.5.16 → 0.6.0

data/CHANGES

@@ -1,5 +1,17 @@
 = RSpec Changelog
 
+== Version 0.6.0
+This release makes an official commitment to underscore_syntax (with no more support for dot.syntax)
+
+* Fixed bug (5292) that caused mock argument matching to fail on classes that overrided ==
+* Converted ALL tests to use underscore syntax
+* Fixed all remaining problems with underscores revealed by converting all the tests to underscores
+* Enhanced sugar to support combinations of methods (i.e. once.and_return) 
+* Simplified helper structure taking advantage of dot/underscore combos (i.e. should.be.an_instance_of, which can be expressed as should_be_an_instance_of)
+* Added support for at_most in mocks
+* Added support for should_not_receive(:msg) (will be removing should_receive(:msg).never some time soon)
+* Added support for should_have_exactly(5).items_in_collection
+
 == Version 0.5.16
 This release improves Rails support and test2spec translation.
 

data/EXAMPLES.rd

@@ -14,8 +14,8 @@
 # An IoProcessor
 # * should raise nothing when the file is exactly 32 bytes
 # * should raise an exception when the file length is less than 32 bytes
-# Mocker
-# * should be able to call mock()
+# A consumer of a mock
+# * should be able to send messages to the mock
 # An empty stack
 # * should accept an item when sent push
 # * should complain when sent top

data/examples/custom_method_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__)  + '/../lib/spec'
 context "Rspec allow you to define custom methods" do
   specify "Rspec should allow you to define methods" do
     a_method
-    @a_method_called.should.be true
+    @a_method_called.should_be true
   end
 
   def a_method
@@ -15,7 +15,7 @@ require File.dirname(__FILE__)  + '/../lib/spec'
 context "Rspec allow you to define custom methods" do
   specify "Rspec should allow you to define methods" do
     a_method
-    @a_method_called.should.be true
+    @a_method_called.should_be true
   end
 
   def a_method

data/examples/mocking_spec.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/../lib/spec'
 
-context "Mocker" do
+context "A consumer of a mock" do
 
-  specify "should be able to call mock()" do
+  specify "should be able to send messages to the mock" do
     mock = mock("poke me")
     mock.should_receive(:poke)
     mock.poke

data/lib/spec/api/helper.rb

@@ -1,10 +1,4 @@
 require 'spec/api/helper/should_base'
 require 'spec/api/helper/have_helper'
-require 'spec/api/helper/instance_helper'
-require 'spec/api/helper/instance_negator'
-require 'spec/api/helper/kind_helper'
-require 'spec/api/helper/kind_negator'
-require 'spec/api/helper/respond_helper'
-require 'spec/api/helper/respond_negator'
 require 'spec/api/helper/should_helper'
 require 'spec/api/helper/should_negator'

data/lib/spec/api/helper/diff.rb

@@ -1,5 +1,6 @@
 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 this feature"

data/lib/spec/api/helper/have_helper.rb

@@ -2,11 +2,11 @@ module Spec
 
   class HaveHelper < ShouldBase
 
-    def initialize(target, expected=nil)
+    def initialize(target, relativity=:exactly, expected=nil)
       @target = target
       @expected = expected == :no ? 0 : expected
-      @min = false
-      @max = false
+      @at_least = (relativity == :at_least)
+      @at_most = (relativity == :at_most)
     end
     
     def method_missing(sym, *args)
@@ -24,33 +24,17 @@ module Spec
     
     def build_message(sym)
       message = "<#{@target.class.to_s}> should have"
-      message += " at least" if @min
-      message += " at most" if @max
+      message += " at least" if @at_least
+      message += " at most" if @at_most
       message += " #{@expected} #{sym} (has #{actual_size(collection(sym))})"
     end
     
     def as_specified?(sym)
-      return actual_size(collection(sym)) >= @expected if @min
-      return actual_size(collection(sym)) <= @expected if @max
+      return actual_size(collection(sym)) >= @expected if @at_least
+      return actual_size(collection(sym)) <= @expected if @at_most
       return actual_size(collection(sym)) == @expected
     end
 
-    def at
-      self
-    end
-    
-    def least(min)
-      @expected = min
-      @min = true
-      self
-    end
-    
-    def most(max)
-      @expected = max
-      @max = true
-      self
-    end
-
   end
 
 end

data/lib/spec/api/helper/should_helper.rb

@@ -11,7 +11,19 @@ module Spec
     end
     
     def have(expected_number=nil)
-      HaveHelper.new(@target, expected_number)
+      HaveHelper.new(@target, :exactly, expected_number)
+    end
+  
+    def have_exactly(expected_number=nil)
+      HaveHelper.new(@target, :exactly, expected_number)
+    end
+  
+    def have_at_least(expected_number=nil)
+      HaveHelper.new(@target, :at_least, expected_number)
+    end
+  
+    def have_at_most(expected_number=nil)
+      HaveHelper.new(@target, :at_most, expected_number)
     end
   
     def satisfy(&block)
@@ -24,48 +36,40 @@ module Spec
     end
 
     def be(expected = :___no_arg)
+      @be_seen = true
       return self if (expected == :___no_arg)
       return if (expected == false and @target.nil?)
       return if (expected == true and (!@target.nil?) and (@target != false))
       fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
     end
 
-    def a
-      self
+    def an_instance_of expected_class
+      fail_with_message(default_message("should be an instance of", expected_class)) unless @target.instance_of? expected_class
     end
     
-    alias an a
-    
-    def instance
-      InstanceHelper.new(@target)
-    end
-    
-    def kind
-      KindHelper.new(@target)
+    def a_kind_of expected_class
+      fail_with_message(default_message("should be a kind of", expected_class)) unless @target.kind_of? expected_class
     end
     
-    def respond
-      RespondHelper.new(@target)
+    def respond_to message
+      fail_with_message(default_message("should respond to", message)) unless @target.respond_to? message
     end
     
     def method_missing(sym, *args)
       return if @target.send("#{sym}?", *args)
-      fail_with_message(default_message("should be #{sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
+      fail_with_message(default_message("should be #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) if @be_seen
+      fail_with_message(default_message("should #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) unless @be_seen
     end
 
     def match(expected)
        fail_with_message(default_message("should match", expected)) unless (@target =~ expected)
     end
 
-    def include(sub)
-      fail_with_message(default_message("should include", sub)) unless (@target.include? sub)
-    end
-    
     def raise(exception=Exception, message=nil)
       begin
         @target.call
       rescue exception => e
-        e.message.should.equal message unless message.nil?
+        e.message.should_equal message unless message.nil?
         return
       rescue => e
         fail_with_message("#{default_message("should raise", exception)} but raised #{e.inspect}")

data/lib/spec/api/helper/should_negator.rb

@@ -15,36 +15,27 @@ module Spec
     end
     
     def be(expected = :no_arg)
+      @be_seen = true
       return self if (expected == :no_arg)
       fail_with_message(default_message("should not be", expected)) if (@target.equal?(expected))
     end
 
-    def a
-      self
+    def an_instance_of expected_class
+      fail_with_message(default_message("should not be an instance of", expected_class)) if @target.instance_of? expected_class
     end
     
-    alias an a
-    
-    def instance
-      InstanceNegator.new(@target)
-    end
-    
-    def kind
-      KindNegator.new(@target)
+    def a_kind_of expected_class
+      fail_with_message(default_message("should not be a kind of", expected_class)) if @target.kind_of? expected_class
     end
 
-      def respond
-        RespondNegator.new(@target)
-      end
+    def respond_to message
+      fail_with_message(default_message("should not respond to", message)) if @target.respond_to? message
+    end
     
     def match(expected)
         fail_with_message(default_message("should not match", expected)) if (@target =~ expected)
     end
     
-    def include(sub)
-        fail_with_message(default_message("should not include", sub)) if (@target.include? sub)
-    end
-   
     def raise(exception=Exception, message=nil)
       begin
         @target.call
@@ -71,7 +62,8 @@ module Spec
 
     def method_missing(sym, *args)
       return unless @target.send("#{sym}?", *args)
-      fail_with_message(default_message("should not be #{sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
+      fail_with_message(default_message("should not #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) unless @be_seen
+      fail_with_message(default_message("should not be #{sym}" + (args.empty? ? '' : (' ' + args.join(', '))))) if @be_seen
     end
 
   end

data/lib/spec/api/mocks/argument_expectation.rb

@@ -68,8 +68,8 @@ module Spec
       @@constraint_classes[:string] = StringArgConstraint
       
       def initialize(args)
-        if args == [:any_args] then @expected_params = nil
-        elsif args == [:no_args] then @expected_params = []
+        if [:any_args] == args then @expected_params = nil
+        elsif [:no_args] == args then @expected_params = []
         else @expected_params = process_arg_constraints(args)
         end
       end

data/lib/spec/api/mocks/message_expectation.rb

@@ -16,9 +16,6 @@ module Spec
         @consecutive = false
         @exception_to_raise = nil
         @symbol_to_throw = nil
-        @any_seen = false
-        @at_seen = false
-        @and_seen = false
         @ordering = expectation_ordering
         @ordered = false
       end
@@ -45,7 +42,8 @@ module Spec
         # Error msg should tell exactly what went wrong. (AH).
         
         return if @expected_received_count == :any
-        return if (@expected_received_count < 0) && (@received_count >= @expected_received_count.abs)
+        return if (@at_least) && (@received_count >= @expected_received_count)
+        return if (@at_most) && (@received_count <= @expected_received_count)
         return if @expected_received_count == @received_count
     
         count_message = make_count_message(@expected_received_count)
@@ -122,49 +120,40 @@ module Spec
         self
       end
       
-      def at
-        @at_seen = true
-        self
-      end
-      
       def exactly(n)
-        @expected_received_count = n
+        set_expected_received_count :exactly, n
         self
       end
       
-      def least(arg)
-        if @at_seen
-          @expected_received_count = -1 if arg == :once
-          @expected_received_count = -2 if arg == :twice
-          @expected_received_count = -arg if arg.kind_of? Numeric
-        end
-        @at_seen = false
-        self
-      end
-
-      def any
-        @any_seen = true
+      def at_least(n)
+        set_expected_received_count :at_least, n
         self
       end
       
-      def number
-        @number_seen = @any_seen
-        @any_seen = false
+      def at_most(n)
+        set_expected_received_count :at_most, n
         self
       end
       
-      def of
-        @of_seen = @number_seen
-        @number_seen = false
-        self
+      def set_expected_received_count relativity, n
+        @at_least = (relativity == :at_least)
+        @at_most = (relativity == :at_most)
+        @expected_received_count = 1 if n == :once
+        @expected_received_count = 2 if n == :twice
+        @expected_received_count = n if n.kind_of? Numeric
       end
-      
+
       def times
-        @expected_received_count = :any if @of_seen
-        @of_seen = false
+        #pure sugar
         self
       end
   
+      def any_number_of_times
+        @expected_received_count = :any
+        self
+      end
+  
+      #TODO - replace this w/ not syntax in mock
       def never
         @expected_received_count = 0
         self
@@ -180,43 +169,29 @@ module Spec
         self
       end
   
-      def and
-        @and_seen = true
-        self
-      end
-
-      def return(value=nil, &return_block)
+      def and_return(value=nil, &return_block)
         Kernel::raise AmbiguousReturnError unless @method_block.nil?
-        return self unless @and_seen
-        @and_seen = false
         @consecutive = value.instance_of? Array
         @return_block = block_given? ? return_block : lambda { value }
       end
       
-      def raise(exception=Exception)
-        return self unless @and_seen
-        @and_seen = false
+      def and_raise(exception=Exception)
         @exception_to_raise = exception
       end
       
-      def throw(symbol)
-        return self unless @and_seen
-        @and_seen = false
+      def and_throw(symbol)
         @symbol_to_throw = symbol
       end
       
+      def and_yield(*args)
+        @args_to_yield = args
+      end
+  
       def ordered
         @ordering.register(self)
         @ordered = true
         self
       end
-      
-      def yield(*args)
-        return self unless @and_seen
-        @and_seen = false
-        @args_to_yield = args
-      end
-  
     end
   end
 end

data/lib/spec/api/mocks/mock.rb

@@ -16,16 +16,15 @@ module Spec
         @expectation_ordering = OrderGroup.new
       end
       
-      def should
-        self
-      end
-
-      def receive(sym, &block)
+      def should_receive(sym, &block)
         expected_from = caller(1)[0]
         expectation = MessageExpectation.new(@name, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
         @expectations << expectation
         expectation
       end
+      
+      def should_not_receive(sym, &block)
+      end
 
       def __verify #:nodoc:
         @expectations.each do |expectation|

data/lib/spec/api/sugar.rb

@@ -1,13 +1,13 @@
 module Spec
   module Api
     # This module adds syntactic sugar that allows usage of should_* instead of should.*
-    module Sugar
+    module UnderscoreSugar
       module SugarizeForRspec; end
 
       def sugarize_for_rspec!
         original_method_missing = instance_method(:method_missing)
         class_eval do
-          include SugarizeForRspec # This is meant to add a signiture to the object that sugarization occurred.
+          include SugarizeForRspec # This is meant to add a signature to the object that sugarization occurred.
           def method_missing(sym, *args, &block)
             _method_missing(sym, args, block)
           end
@@ -18,9 +18,10 @@ module Spec
             object = self
             calls = sym.to_s.split("_")
             while calls.length > 1
+              break if (object.respond_to?calls.join("_"))
               call = calls.shift
               object = object.__send__(call)
-              break if call == "be" unless ["an","a"].include? calls[0]
+              break if call == "be"
             end
             return object.__send__(calls.join("_"), *args, &block)
           end
@@ -31,29 +32,11 @@ module Spec
         end
       end
     end
-    
-    module MessageExpectationSugar
-      def __is_sweetened?(sym) #:nodoc:
-        return true if sym.to_s =~ /^and_|^at_|^any_|^once_/
-      end
-    end
   end
 end
 
 class Module
-  include Spec::Api::Sugar
-end
-
-Object.sugarize_for_rspec!
-
-class Spec::Api::Mock #:nodoc:
-  # NOTE: this resolves a bug caused by a conflict between Sugar#method_missing and Mock#method_missing, specifically
-  # when the mock is set null_object=>true. It would be nice to get rid of this.
-  def should_receive(sym, &block)
-    return receive(sym, &block)
-  end
+  include Spec::Api::UnderscoreSugar
 end
 
-class Spec::Api::MessageExpectation #:nodoc:
-  include Spec::Api::MessageExpectationSugar
-end
+Object.sugarize_for_rspec!