rspec 0.6.4 → 0.7.0

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

@@ -0,0 +1,79 @@
+module Spec
+  module Expectations
+    module Should
+      class Have < Base
+
+        def initialize(target, relativity=:exactly, expected=nil, negate=false)
+          @target = target
+          @expected = expected == :no ? 0 : expected
+          @at_least = (relativity == :at_least)
+          @at_most = (relativity == :at_most)
+          @negate = negate
+        end
+    
+        def exactly(expected_number=nil)
+          @at_least = false
+          @at_most = false
+          @expected = expected_number == :no ? 0 : expected_number
+          self
+        end
+
+        def at_least(expected_number=nil)
+          @at_least = true
+          @at_most = false
+          @expected = expected_number == :no ? 0 : expected_number
+          self
+        end
+
+        def at_most(expected_number=nil)
+          @at_least = false
+          @at_most = true
+          @expected = expected_number == :no ? 0 : expected_number
+          self
+        end
+
+        def method_missing(sym, *args)
+          if @target.respond_to?(sym)
+            fail_with_message(build_message(sym, args)) unless as_specified?(sym, args)
+          elsif @target.respond_to?("has_#{sym}?")
+            if @negate
+              return unless @target.send("has_#{sym}?", *args)
+              fail_with_message msg(sym, args, "should not have")
+            else
+              return if @target.send("has_#{sym}?", *args)
+              fail_with_message msg(sym, args, "should have")
+            end
+          else
+            raise NoMethodError.new("#{@target.inspect} does not respond to `#{sym}' or `has_#{sym}?'")
+          end
+        end
+      
+        def msg(sym, args, text)
+          "#{@target.inspect_for_expectation_not_met_error} #{text} #{sym}: #{args.collect{|arg| arg.inspect_for_expectation_not_met_error}.join(', ')}"
+        end
+    
+        def actual_size(collection)
+          return collection.length if collection.respond_to? :length
+          return collection.size if collection.respond_to? :size
+        end
+    
+        def build_message(sym, args)
+          message = "#{@target.inspect_for_expectation_not_met_error} should have"
+          message += " at least" if @at_least
+          message += " at most" if @at_most
+          message += " #{@expected} #{sym} (has #{actual_size(collection(sym, args))})"
+        end
+    
+        def as_specified?(sym, args)
+          return actual_size(collection(sym, args)) >= @expected if @at_least
+          return actual_size(collection(sym, args)) <= @expected if @at_most
+          return actual_size(collection(sym, args)) == @expected
+        end
+
+        def collection(sym, args)
+          @target.send(sym, *args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Spec
+  module Expectations
+    module Should
+      class Not < Base
+    
+        def initialize(target)
+          @target = target
+          @be_seen = false
+        end
+
+        def have(expected_number=nil)
+          Have.new(@target, :exactly, expected_number, true)
+        end
+  
+        def satisfy
+          fail_with_message "Supplied expectation was satisfied, but should not have been" if (yield @target)
+        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 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
+    
+        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_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 raise(exception=Exception, message=nil)
+          begin
+            @target.call
+          rescue exception => e
+            return unless message.nil? || e.message == message || (message.is_a?(Regexp) && e.message =~ message)
+            fail_with_message("#{default_message("should not raise", exception)}") if e.instance_of? exception
+            fail_with_message("#{default_message("should not raise", exception)} but raised #{e.inspect}") unless e.instance_of? exception
+          rescue
+            true
+          end
+        end
+    
+        def throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
+          begin
+            catch symbol do
+              @target.call
+              return true
+            end
+            fail_with_message(default_message("should not throw", symbol.inspect))
+          rescue NameError
+            true
+          end
+        end
+
+        def __delegate_method_missing_to_target original_sym, actual_sym, *args
+          return unless @target.__send__(actual_sym, *args)
+          fail_with_message(default_message("should not#{@be_seen ? ' be' : ''} #{original_sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Spec
+  module Expectations
+    module Should
+      class Should < Base
+
+        def initialize(target)
+          @target = target
+          @be_seen = false
+        end
+      
+        def have(expected_number=nil)
+          Have.new(@target, :exactly, expected_number)
+        end
+
+        def not
+          Not.new(@target)
+        end
+      
+        def satisfy
+          return if yield(@target)
+          fail_with_message "Supplied expectation was not satisfied"
+        end
+      
+        def be(expected = :___no_arg)
+          @be_seen = true
+          return self if (expected == :___no_arg)
+          fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
+        end
+
+        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
+  
+        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_to(message)
+          fail_with_message(default_message("should respond to", message)) unless @target.respond_to? message
+        end
+  
+        def __delegate_method_missing_to_target(original_sym, actual_sym, *args)
+          return if @target.send(actual_sym, *args)
+          message = default_message("should#{@be_seen ? ' be' : ''} #{original_sym}", args[0])
+          fail_with_message(message)
+        end
+
+        def match(expected)
+           fail_with_message(default_message("should match", expected)) unless (@target =~ expected)
+        end
+
+        def raise(exception=Exception, message=nil)
+          begin
+            @target.call
+          rescue exception => e
+            unless message.nil?
+              if message.is_a?(Regexp)
+                e.message.should_match message
+              else
+                e.message.should_eql message
+              end
+            end
+            return
+          rescue => e
+            fail_with_message("#{default_message("should raise", exception)} but raised #{e.inspect}")
+          end
+          fail_with_message("#{default_message("should raise", exception)} but raised nothing")
+        end
+  
+        def throw(symbol)
+          begin
+            catch symbol do
+              @target.call
+              fail_with_message(default_message("should throw", symbol.inspect))
+            end
+          rescue NameError
+            fail_with_message(default_message("should throw", symbol.inspect))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spec/expectations/sugar.rb

@@ -2,42 +2,23 @@ module Spec
   module Expectations
     # This module adds syntactic sugar that allows usage of should_* instead of should.*
     module UnderscoreSugar
-      module SweetTooth; end
-
       def handle_underscores_for_rspec!
         original_method_missing = instance_method(:method_missing)
         class_eval do
-          include SweetTooth # 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
 
           define_method :_method_missing do |sym, args, block|
-            return original_method_missing.bind(self).call(sym, *args, &block) unless __sweetened?(sym)
-
-            object = self
-            calls = sym.to_s.split("_")
-            while calls.length > 1
-              remainder = calls.join("_")
-              break if (object.respond_to?(remainder))
-              call = calls.shift
-              object = object.__send__(call)
-              break if call == "be"
-            end
-            return object.__send__(calls.join("_"), *args, &block)
+            return original_method_missing.bind(self).call(sym, *args, &block) unless sym.to_s =~ /^should_/
+            return Spec::Expectations::Should::Should.new(self).__send__(__strip_should(sym), *args, &block)
           end
-
-          def __sweetened?(sym) #:nodoc:
-            return true if sym.to_s =~ /^should_/
+          
+          def __strip_should sym
+            sym.to_s[7..-1]
           end
         end
       end
     end
   end
-end
-
-class Module
-  include Spec::Expectations::UnderscoreSugar
-end
-
-Object.handle_underscores_for_rspec!
+end

data/lib/spec/mocks.rb

@@ -1,5 +1,9 @@
+require 'spec/mocks/mock_methods'
+require 'spec/mocks/mock_handler'
 require 'spec/mocks/mock'
 require 'spec/mocks/argument_expectation'
 require 'spec/mocks/message_expectation'
 require 'spec/mocks/order_group'
-require 'spec/mocks/exceptions'
+require 'spec/mocks/errors'
+require 'spec/mocks/error_generator'
+require 'spec/mocks/extensions/object'

data/lib/spec/mocks/argument_expectation.rb

@@ -11,6 +11,17 @@ module Spec
       end
     end
     
+    class RegexpArgConstraint
+      def initialize(regexp)
+        @regexp = regexp
+      end
+      
+      def matches?(value)
+        return value =~ @regexp unless value.is_a?(Regexp)
+        value == @regexp
+      end
+    end
+    
     class AnyArgConstraint
       def initialize(ignore)
       end
@@ -60,7 +71,7 @@ module Spec
     end
 
     class ArgumentExpectation
-    
+      attr_reader :args
       @@constraint_classes = Hash.new { |hash, key| LiteralArgConstraint}
       @@constraint_classes[:anything] = AnyArgConstraint
       @@constraint_classes[:numeric] = NumericArgConstraint
@@ -68,6 +79,7 @@ module Spec
       @@constraint_classes[:string] = StringArgConstraint
       
       def initialize(args)
+        @args = *args
         if [:any_args] == args then @expected_params = nil
         elsif [:no_args] == args then @expected_params = []
         else @expected_params = process_arg_constraints(args)
@@ -83,7 +95,9 @@ module Spec
       def convert_constraint(constraint)
         return @@constraint_classes[constraint].new(constraint) if constraint.is_a?(Symbol)
         return constraint if constraint.is_a?(DuckTypeArgConstraint)
+        return RegexpArgConstraint.new(constraint) if constraint.is_a?(Regexp)
         return LiteralArgConstraint.new(constraint)
+        
       end
       
       def check_args(args)

data/lib/spec/mocks/error_generator.rb

@@ -0,0 +1,72 @@
+module Spec
+  module Mocks
+    class ErrorGenerator
+      attr_writer :opts
+      
+      def initialize target, name
+        @target = target
+        @name = name
+      end
+      
+      def opts
+        @opts ||= {}
+      end
+
+      def raise_unexpected_message_error sym, *args
+        __raise "#{intro} received unexpected message :#{sym}#{arg_message(*args)}"
+      end
+      
+      def raise_expectation_error sym, expected_received_count, actual_received_count, *args
+        __raise "#{intro} expected :#{sym}#{arg_message(*args)} #{count_message(expected_received_count)}, but received it #{count_message(actual_received_count)}"
+      end
+      
+      def raise_out_of_order_error sym
+        __raise "#{intro} received :#{sym} out of order"
+      end
+      
+      def raise_block_failed_error sym, detail
+        __raise "#{intro} received :#{sym} but passed block failed with: #{detail}"
+      end
+      
+      def raise_missing_block_error args_to_yield
+        __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
+      end
+      
+      def raise_wrong_arity_error args_to_yield, arity
+        __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
+      end
+      
+      private
+      def intro
+        @name ? "Mock '#{@name}'" : @target.to_s
+      end
+      
+      def __raise message
+        message = opts[:message] unless opts[:message].nil?
+        Kernel::raise(Spec::Mocks::MockExpectationError, message)
+      end
+      
+      def arg_message *args
+        return "" if [:any_args] == args
+        return if args.empty?
+        " with [" + arg_list(*args) + "]"
+      end
+
+      def arg_list(*args)
+        args.collect{|arg| arg.inspect}.join(", ")
+      end
+      
+      def count_message(count)
+        return "at least #{pretty_print(count.abs)}" if count < 0
+        return pretty_print(count)
+      end
+
+      def pretty_print(count)
+        return "once" if count == 1
+        return "twice" if count == 2
+        return "#{count} times"
+      end
+
+    end
+  end
+end

data/lib/spec/mocks/extensions/object.rb

@@ -0,0 +1,3 @@
+class Object
+  include Spec::Mocks::MockMethods
+end

data/lib/spec/mocks/message_expectation.rb

@@ -1,11 +1,12 @@
 module Spec
   module Mocks
 
-    # Represents the expection of the reception of a message
-    class MessageExpectation
-    
-      def initialize(mock_name, expectation_ordering, expected_from, sym, method_block, expected_received_count=1)
-        @mock_name = mock_name
+    class BaseExpectation
+      attr_reader :sym
+      
+      def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={})
+        @error_generator = error_generator
+        @error_generator.opts = opts
         @expected_from = expected_from
         @sym = sym
         @method_block = method_block
@@ -16,61 +17,36 @@ module Spec
         @consecutive = false
         @exception_to_raise = nil
         @symbol_to_throw = nil
-        @ordering = expectation_ordering
-        @ordered = false
+        @order_group = expectation_ordering
         @at_least = nil
         @at_most = nil
         @args_to_yield = nil
       end
-  
-      def matches(sym, args)
-        @sym == sym and @args_expectation.check_args(args)
-      end
-       
-      def make_count_message(count)
-        return "at least #{pretty_print(count.abs)}" if count < 0
-        return pretty_print(count) if count > 0
-        return "never"
+
+      def and_return(*values, &return_block)
+        Kernel::raise AmbiguousReturnError unless @method_block.nil?
+        if values.size == 0
+          value = nil
+        elsif values.size == 1
+          value = values[0]
+        else
+          value = values
+          @consecutive = true
+          @expected_received_count = values.size if @expected_received_count < values.size
+        end
+        @return_block = block_given? ? return_block : lambda { value }
       end
       
-      def pretty_print(count)
-        return "once" if count == 1
-        return "twice" if count == 2
-        return "#{count} times"
+      def and_raise(exception=Exception)
+        @exception_to_raise = exception
       end
       
-      # This method is called at the end of a spec, after teardown.
-      def verify_messages_received
-        # TODO: this doesn't provide good enough error messages to fix the error.
-        # Error msg should tell exactly what went wrong. (AH).
-        
-        return if @expected_received_count == :any
-        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)
-
-        message = "Mock '#{@mock_name}' expected '#{@sym}' #{count_message}, but received it #{@received_count} times"
-        begin
-          Kernel::raise(Spec::Mocks::MockExpectationError, message)
-        rescue => error
-          error.backtrace.insert(0, @expected_from)
-          Kernel::raise error
-        end
-      end
-
-      def handle_order_constraint
-        return unless @ordered
-        return @ordering.consume(self) if @ordering.ready_for?(self)
-        message = "Mock '#{@mock_name}' received '#{@sym}' out of order"
-        Kernel::raise(Spec::Mocks::MockExpectationError, message) 
+      def matches(sym, args)
+        @sym == sym and @args_expectation.check_args(args)
       end
       
-      # This method is called when a method is invoked on a mock
       def invoke(args, block)
-        
-        handle_order_constraint
+        @order_group.handle_order_constraint self
 
         begin
           Kernel::raise @exception_to_raise.new unless @exception_to_raise.nil?
@@ -80,6 +56,8 @@ module Spec
             return invoke_method_block(args)
           elsif !@args_to_yield.nil?
             return invoke_with_yield(block)
+          elsif @consecutive
+            return invoke_consecutive_return_block(args, block)
           else
             return invoke_return_block(args, block)
           end
@@ -92,32 +70,57 @@ module Spec
         begin
           @method_block.call(*args)
         rescue Spec::Expectations::ExpectationNotMetError => detail
-          Kernel::raise Spec::Mocks::MockExpectationError, "Call expectation violated with: " + detail
+          @error_generator.raise_block_failed_error @sym, detail.message
         end
       end
       
       def invoke_with_yield(block)
         if block.nil?
-          Kernel::raise Spec::Mocks::MockExpectationError, "Expected block to be passed"
+          @error_generator.raise_missing_block_error @args_to_yield
         end
         if @args_to_yield.length != block.arity
-          Kernel::raise Spec::Mocks::MockExpectationError, "Wrong arity of passed block. Expected #{@args_to_yield.size}"
+          @error_generator.raise_wrong_arity_error @args_to_yield, block.arity
         end
         block.call(*@args_to_yield)
       end
-
+      
+      def invoke_consecutive_return_block(args, block)
+        args << block unless block.nil?
+        value = @return_block.call(*args)
+        
+        index = [@received_count, value.size-1].min
+        value[index]
+      end
+      
       def invoke_return_block(args, block)
         args << block unless block.nil?
         value = @return_block.call(*args)
     
-        if @consecutive
-          index = [@received_count, value.size-1].min
-          value[index]
-        else
-          value
+        value
+      end
+    end
+    
+    class MessageExpectation < BaseExpectation
+  
+      def matches_name_but_not_args(sym, args)
+        @sym == sym and not @args_expectation.check_args(args)
+      end
+       
+      def verify_messages_received        
+        return if @expected_received_count == :any
+        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
+    
+        begin
+          @error_generator.raise_expectation_error @sym, @expected_received_count, @received_count, @args_expectation.args
+        rescue => error
+          error.backtrace.insert(0, @expected_from)
+          Kernel::raise error
         end
       end
 
+
       def with(*args)
         @args_expectation = ArgumentExpectation.new(args)
         self
@@ -156,7 +159,6 @@ module Spec
         self
       end
   
-      #TODO - replace this w/ not syntax in mock
       def never
         @expected_received_count = 0
         self
@@ -172,16 +174,6 @@ module Spec
         self
       end
   
-      def and_return(value=nil, &return_block)
-        Kernel::raise AmbiguousReturnError unless @method_block.nil?
-        @consecutive = value.instance_of? Array
-        @return_block = block_given? ? return_block : lambda { value }
-      end
-      
-      def and_raise(exception=Exception)
-        @exception_to_raise = exception
-      end
-      
       def and_throw(symbol)
         @symbol_to_throw = symbol
       end
@@ -191,16 +183,31 @@ module Spec
       end
   
       def ordered
-        @ordering.register(self)
+        @order_group.register(self)
         @ordered = true
         self
       end
+      
+      def negative_expectation_for? sym
+        return false
+      end
     end
     
     class NegativeMessageExpectation < MessageExpectation
-      def initialize(mock_name, expectation_ordering, expected_from, sym, method_block)
-        super mock_name, expectation_ordering, expected_from, sym, method_block, 0
+      def initialize(message, expectation_ordering, expected_from, sym, method_block)
+        super message, expectation_ordering, expected_from, sym, method_block, 0
+      end
+      
+      def negative_expectation_for? sym
+        return @sym == sym
+      end
+    end
+    
+    class MethodStub < BaseExpectation
+      def initialize(message, expectation_ordering, expected_from, sym, method_block)
+        super message, expectation_ordering, expected_from, sym, method_block, 0
+        @expected_received_count = :any
       end
     end
   end
-end
+end