mocha 0.5.5 → 0.5.6

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -1,8 +1,11 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
 
     # :call-seq: has_entry(key, value) -> parameter_matcher
+    #            has_entry(key => value) -> parameter_matcher
     #
     # Matches +Hash+ containing entry with +key+ and +value+.
     #   object = mock()
@@ -11,20 +14,33 @@ module Mocha
     #   # no error raised
     #
     #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1' => 1))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
     #   object.expects(:method_1).with(has_entry('key_1', 1))
     #   object.method_1('key_1' => 2, 'key_2' => 1)
     #   # error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
-    def has_entry(key, value)
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1' => 1))
+    #   object.method_1('key_1' => 2, 'key_2' => 1)
+    #   # error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
+    def has_entry(*options)
+      key, value = options.shift, options.shift
+      key, value = key.to_a[0][0..1] if key.is_a?(Hash)
       HasEntry.new(key, value)
     end
-
-    class HasEntry # :nodoc:
+    
+    class HasEntry < Base # :nodoc:
       
       def initialize(key, value)
         @key, @value = key, value
       end
       
-      def ==(parameter)
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
         parameter[@key] == @value
       end
       

data/lib/mocha/parameter_matchers/has_key.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -18,13 +20,14 @@ module Mocha
       HasKey.new(key)
     end
 
-    class HasKey # :nodoc:
+    class HasKey < Base # :nodoc:
       
       def initialize(key)
         @key = key
       end
       
-      def ==(parameter)
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
         parameter.keys.include?(@key)
       end
       

data/lib/mocha/parameter_matchers/has_value.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -18,13 +20,14 @@ module Mocha
       HasValue.new(value)
     end
 
-    class HasValue # :nodoc:
+    class HasValue < Base # :nodoc:
       
       def initialize(value)
         @value = value
       end
       
-      def ==(parameter)
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
         parameter.values.include?(@value)
       end
       

data/lib/mocha/parameter_matchers/includes.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -16,13 +18,14 @@ module Mocha
       Includes.new(item)
     end
 
-    class Includes # :nodoc:
+    class Includes < Base # :nodoc:
 
       def initialize(item)
         @item = item
       end
 
-      def ==(parameter)
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
         return parameter.include?(@item)
       end
 

data/lib/mocha/parameter_matchers/instance_of.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -18,13 +20,14 @@ module Mocha
       InstanceOf.new(klass)
     end
     
-    class InstanceOf # :nodoc:
+    class InstanceOf < Base # :nodoc:
       
       def initialize(klass)
         @klass = klass
       end
     
-      def ==(parameter)
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
         parameter.instance_of?(@klass)
       end
       

data/lib/mocha/parameter_matchers/is_a.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: is_a(klass) -> parameter_matcher
+    #
+    # Matches any object that is a +klass+
+    #   object = mock()
+    #   object.expects(:method_1).with(is_a(Integer))
+    #   object.method_1(99)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(is_a(Integer))
+    #   object.method_1('string')
+    #   # error raised, because method_1 was not called with an Integer
+    def is_a(klass)
+      IsA.new(klass)
+    end
+    
+    class IsA < Base # :nodoc:
+      
+      def initialize(klass)
+        @klass = klass
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.is_a?(@klass)
+      end
+      
+      def mocha_inspect
+        "is_a(#{@klass.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/kind_of.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -18,13 +20,14 @@ module Mocha
       KindOf.new(klass)
     end
     
-    class KindOf # :nodoc:
+    class KindOf < Base # :nodoc:
       
       def initialize(klass)
         @klass = klass
       end
     
-      def ==(parameter)
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
         parameter.kind_of?(@klass)
       end
       

data/lib/mocha/parameter_matchers/not.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: Not(matcher) -> parameter_matcher
+    #
+    # Matches if +matcher+ does not match.
+    #   object = mock()
+    #   object.expects(:method_1).with(Not(includes(1)))
+    #   object.method_1([0, 2, 3])
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(Not(includes(1)))
+    #   object.method_1([0, 1, 2, 3])
+    #   # error raised, because method_1 was not called with object not including 1
+    def Not(matcher)
+      Not.new(matcher)
+    end
+    
+    class Not < Base # :nodoc:
+      
+      def initialize(matcher)
+        @matcher = matcher
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        !@matcher.matches?([parameter])
+      end
+      
+      def mocha_inspect
+        "Not(#{@matcher.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/object.rb

@@ -0,0 +1,9 @@
+require 'mocha/parameter_matchers/equals'
+
+class Object
+  
+  def to_matcher
+    Mocha::ParameterMatchers::Equals.new(self)
+  end
+  
+end

data/lib/mocha/parameter_matchers/optionally.rb

@@ -0,0 +1,33 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    def optionally(*matchers)
+      Optionally.new(*matchers)
+    end
+    
+    class Optionally < Base # :nodoc:
+      
+      def initialize(*parameters)
+        @matchers = parameters.map { |parameter| parameter.to_matcher }
+      end
+      
+      def matches?(available_parameters)
+        index = 0
+        while (available_parameters.length > 0) && (index < @matchers.length) do
+          matcher = @matchers[index]
+          return false unless matcher.matches?(available_parameters)
+          index += 1
+        end
+        return true
+      end
+      
+      def mocha_inspect
+        "optionally(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/regexp_matches.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -19,13 +21,14 @@ module Mocha
       RegexpMatches.new(regexp)
     end
 
-    class RegexpMatches # :nodoc:
+    class RegexpMatches < Base # :nodoc:
   
       def initialize(regexp)
         @regexp = regexp
       end
   
-      def ==(parameter)
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
         parameter =~ @regexp
       end
   

data/lib/mocha/parameters_matcher.rb

@@ -0,0 +1,37 @@
+require 'mocha/inspect'
+require 'mocha/parameter_matchers'
+
+module Mocha
+  
+  class ParametersMatcher
+    
+    def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], &matching_block)
+      @expected_parameters, @matching_block = expected_parameters, matching_block
+    end
+    
+    def match?(actual_parameters = [])
+      if @matching_block
+        return @matching_block.call(*actual_parameters)
+      else
+        return parameters_match?(actual_parameters)
+      end
+    end
+    
+    def parameters_match?(actual_parameters)
+      matchers.all? { |matcher| matcher.matches?(actual_parameters) } && (actual_parameters.length == 0)
+    end
+    
+    def mocha_inspect
+      signature = matchers.mocha_inspect
+      signature = signature.gsub(/^\[|\]$/, '')
+      signature = signature.gsub(/^\{|\}$/, '') if matchers.length == 1
+      "(#{signature})"
+    end
+    
+    def matchers
+      @expected_parameters.map { |parameter| parameter.to_matcher }
+    end
+    
+  end
+
+end

data/lib/mocha/pretty_parameters.rb

@@ -20,7 +20,7 @@ module Mocha
     end
   
     def remove_outer_hash_braces!
-      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.size == 1
+      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.length == 1
     end
   
   end

data/lib/mocha/return_values.rb

@@ -15,10 +15,13 @@ module Mocha # :nodoc:
     end
     
     def next
-      case @values.size
-      when 0: nil
-      when 1: @values.first.evaluate
-      else @values.shift.evaluate
+      case @values.length
+        when 0
+          nil
+        when 1
+          @values.first.evaluate
+        else
+          @values.shift.evaluate
       end
     end
     

data/lib/mocha/sequence.rb

@@ -0,0 +1,42 @@
+module Mocha # :nodoc:
+  
+  class Sequence
+    
+    class InSequenceOrderingConstraint
+      
+      def initialize(sequence, index)
+        @sequence, @index = sequence, index
+      end
+      
+      def allows_invocation_now?
+        @sequence.satisfied_to_index?(@index)
+      end
+      
+      def mocha_inspect
+        "in sequence #{@sequence.mocha_inspect}"
+      end
+      
+    end
+    
+    def initialize(name)
+      @name = name
+      @expectations = []
+    end
+    
+    def constrain_as_next_in_sequence(expectation)
+      index = @expectations.length
+      @expectations << expectation
+      expectation.add_ordering_constraint(InSequenceOrderingConstraint.new(self, index))
+    end
+    
+    def satisfied_to_index?(index)
+      @expectations[0...index].all? { |expectation| expectation.satisfied? }
+    end
+    
+    def mocha_inspect
+      "#{@name.mocha_inspect}"
+    end
+    
+  end
+  
+end

data/lib/mocha/yield_parameters.rb

@@ -11,9 +11,9 @@ module Mocha # :nodoc:
     end
     
     def next_invocation
-      case @parameter_groups.size
-      when 0: NoYields.new
-      when 1: @parameter_groups.first
+      case @parameter_groups.length
+      when 0; NoYields.new
+      when 1; @parameter_groups.first
       else @parameter_groups.shift
       end
     end

data/test/acceptance/expected_invocation_count_acceptance_test.rb

@@ -23,7 +23,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method - expected calls: 0, actual calls: 1'], failure_messages
+    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 0, actual calls: 1'], failure_messages
   end
   
   def test_should_pass_if_method_is_expected_twice_and_is_called_twice
@@ -43,7 +43,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method - expected calls: 2, actual calls: 1'], failure_messages
+    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2, actual calls: 1'], failure_messages
   end
   
   def test_should_fail_if_method_is_expected_twice_but_is_called_three_times
@@ -54,7 +54,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method - expected calls: 2, actual calls: 3'], failure_messages
+    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2, actual calls: 3'], failure_messages
   end
   
   def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_twice
@@ -92,7 +92,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method - expected calls: 2..4, actual calls: 1'], failure_messages
+    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2..4, actual calls: 1'], failure_messages
   end
 
   def test_should_fail_if_method_is_expected_between_two_and_four_times_and_is_called_five_times
@@ -103,7 +103,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method - expected calls: 2..4, actual calls: 5'], failure_messages
+    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2..4, actual calls: 5'], failure_messages
   end
   
   def test_should_pass_if_method_is_expected_at_least_once_and_is_called_once
@@ -132,7 +132,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method - expected calls: at least 1, actual calls: 0'], failure_messages
+    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: at least 1, actual calls: 0'], failure_messages
   end
   
   def test_should_pass_if_method_is_expected_at_most_once_and_is_never_called
@@ -161,7 +161,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method - expected calls: at most 1, actual calls: 2'], failure_messages
+    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: at most 1, actual calls: 2'], failure_messages
   end
   
   def test_should_pass_if_method_is_never_expected_and_is_never_called_even_if_everything_is_stubbed
@@ -181,7 +181,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
     end
     assert_failed(test_result)
     failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:stub>.method - expected calls: 0, actual calls: 1'], failure_messages
+    assert_equal ['#<Mock:stub>.method(any_parameters) - expected calls: 0, actual calls: 1'], failure_messages
   end
   
 end