jferris-mocha 0.9.5.0.1240002286

data/lib/mocha/parameter_matchers/has_entries.rb

@@ -0,0 +1,45 @@
+require 'mocha/parameter_matchers/base'
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/parameter_matchers/has_entry'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_entries(entries) -> parameter_matcher
+    #
+    # Matches +Hash+ containing all +entries+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
+    #   object.method_1('key_1' => 1, 'key_2' => 2, 'key_3' => 3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
+    #   object.method_1('key_1' => 1, 'key_2' => 99)
+    #   # error raised, because method_1 was not called with Hash containing entries: 'key_1' => 1, 'key_2' => 2
+    def has_entries(entries)
+      HasEntries.new(entries)
+    end
+    
+    class HasEntries < Base # :nodoc:
+      
+      def initialize(entries)
+        @entries = entries
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        has_entry_matchers = @entries.map { |key, value| HasEntry.new(key, value) }
+        AllOf.new(*has_entry_matchers).matches?([parameter])
+      end
+      
+      def mocha_inspect
+        "has_entries(#{@entries.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -0,0 +1,57 @@
+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()
+    #   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' => 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
+    #
+    #   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 < Base # :nodoc:
+      
+      def initialize(key, value)
+        @key, @value = key, value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        return false unless parameter.respond_to?(:keys) && parameter.respond_to?(:[])
+        matching_keys = parameter.keys.select { |key| @key.to_matcher.matches?([key]) }
+        matching_keys.any? { |key| @value.to_matcher.matches?([parameter[key]]) }
+      end
+      
+      def mocha_inspect
+        "has_entry(#{@key.mocha_inspect} => #{@value.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/has_key.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_key(key) -> parameter_matcher
+    #
+    # Matches +Hash+ containing +key+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_key('key_1'))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_key('key_1'))
+    #   object.method_1('key_2' => 2)
+    #   # error raised, because method_1 was not called with Hash containing key: 'key_1'
+    def has_key(key)
+      HasKey.new(key)
+    end
+
+    class HasKey < Base # :nodoc:
+      
+      def initialize(key)
+        @key = key
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.keys.any? { |key| @key.to_matcher.matches?([key]) }
+      end
+      
+      def mocha_inspect
+        "has_key(#{@key.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/has_value.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_value(value) -> parameter_matcher
+    #
+    # Matches +Hash+ containing +value+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_value(1))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_value(1))
+    #   object.method_1('key_2' => 2)
+    #   # error raised, because method_1 was not called with Hash containing value: 1
+    def has_value(value)
+      HasValue.new(value)
+    end
+
+    class HasValue < Base # :nodoc:
+      
+      def initialize(value)
+        @value = value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.values.any? { |value| @value.to_matcher.matches?([value]) }
+      end
+      
+      def mocha_inspect
+        "has_value(#{@value.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/includes.rb

@@ -0,0 +1,40 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: includes(item) -> parameter_matcher
+    #
+    # Matches any object that responds true to include?(item)
+    #   object = mock()
+    #   object.expects(:method_1).with(includes('foo'))
+    #   object.method_1(['foo', 'bar'])
+    #   # no error raised
+    #
+    #   object.method_1(['baz'])
+    #   # error raised, because ['baz'] does not include 'foo'.
+    def includes(item)
+      Includes.new(item)
+    end
+
+    class Includes < Base # :nodoc:
+
+      def initialize(item)
+        @item = item
+      end
+
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        return parameter.include?(@item)
+      end
+
+      def mocha_inspect
+        "includes(#{@item.mocha_inspect})"
+      end
+
+    end
+
+  end
+  
+end

data/lib/mocha/parameter_matchers/instance_of.rb

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

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

data/lib/mocha/parameter_matchers/not.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: Not(parameter_matcher) -> parameter_matcher
+    #
+    # Matches if +parameter_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,15 @@
+require 'mocha/parameter_matchers/equals'
+
+module Mocha
+  
+  module ObjectMethods
+    def to_matcher # :nodoc:
+      Mocha::ParameterMatchers::Equals.new(self)
+    end
+  end
+  
+end
+
+class Object
+  include Mocha::ObjectMethods
+end

data/lib/mocha/parameter_matchers/optionally.rb

@@ -0,0 +1,55 @@
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: optionally(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches optional parameters if available.
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2, 3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2, 3, 4)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(1, 2, optionally(3, 4))
+    #   object.method_1(1, 2, 3, 5)
+    #   # error raised, because optional parameters did not match
+    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

@@ -0,0 +1,43 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: regexp_matches(regular_expression) -> parameter_matcher
+    #
+    # Matches any object that matches +regular_expression+.
+    #   object = mock()
+    #   object.expects(:method_1).with(regexp_matches(/e/))
+    #   object.method_1('hello')
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(regexp_matches(/a/))
+    #   object.method_1('hello')
+    #   # error raised, because method_1 was not called with a parameter that matched the 
+    #   # regular expression
+    def regexp_matches(regexp)
+      RegexpMatches.new(regexp)
+    end
+
+    class RegexpMatches < Base # :nodoc:
+  
+      def initialize(regexp)
+        @regexp = regexp
+      end
+  
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter =~ @regexp
+      end
+  
+      def mocha_inspect
+        "regexp_matches(#{@regexp.mocha_inspect})"
+      end
+  
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/responds_with.rb

@@ -0,0 +1,43 @@
+require 'mocha/parameter_matchers/base'
+require 'yaml'
+
+module Mocha
+
+  module ParameterMatchers
+
+    # :call-seq: responds_with(message, result) -> parameter_matcher
+    #
+    # Matches any object that responds to +message+ with +result+. To put it another way, it tests the quack, not the duck.
+    #   object = mock()
+    #   object.expects(:method_1).with(responds_with(:upcase, "FOO"))
+    #   object.method_1("foo")
+    #   # no error raised, because "foo".upcase == "FOO"
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(responds_with(:upcase, "BAR"))
+    #   object.method_1("foo")
+    #   # error raised, because "foo".upcase != "BAR"
+    def responds_with(message, result)
+      RespondsWith.new(message, result)
+    end
+
+    class RespondsWith < Base # :nodoc:
+
+      def initialize(message, result)
+        @message, @result = message, result
+      end
+
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.__send__(@message) == @result
+      end
+
+      def mocha_inspect
+        "responds_with(#{@message.mocha_inspect}, #{@result.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/yaml_equivalent.rb

@@ -0,0 +1,43 @@
+require 'mocha/parameter_matchers/base'
+require 'yaml'
+
+module Mocha
+
+  module ParameterMatchers
+
+    # :call-seq: yaml_equivalent(object) -> parameter_matcher
+    #
+    # Matches any YAML that represents the specified +object+
+    #   object = mock()
+    #   object.expects(:method_1).with(yaml_equivalent(1, 2, 3))
+    #   object.method_1("--- \n- 1\n- 2\n- 3\n")
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(yaml_equivalent(1, 2, 3))
+    #   object.method_1("--- \n- 1\n- 2\n")
+    #   # error raised, because method_1 was not called with YAML representing the specified Array
+    def yaml_equivalent(object)
+      YamlEquivalent.new(object)
+    end
+
+    class YamlEquivalent < Base # :nodoc:
+
+      def initialize(object)
+        @object = object
+      end
+
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @object == YAML.load(parameter)
+      end
+
+      def mocha_inspect
+        "yaml_equivalent(#{@object.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers.rb

@@ -0,0 +1,27 @@
+module Mocha
+  
+  # Used as parameters for Expectation#with to restrict the parameter values which will match the expectation. Can be nested.
+  module ParameterMatchers; end
+  
+end
+
+require 'mocha/parameter_matchers/object'
+
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/parameter_matchers/any_of'
+require 'mocha/parameter_matchers/any_parameters'
+require 'mocha/parameter_matchers/anything'
+require 'mocha/parameter_matchers/equals'
+require 'mocha/parameter_matchers/has_entry'
+require 'mocha/parameter_matchers/has_entries'
+require 'mocha/parameter_matchers/has_key'
+require 'mocha/parameter_matchers/has_value'
+require 'mocha/parameter_matchers/includes'
+require 'mocha/parameter_matchers/instance_of'
+require 'mocha/parameter_matchers/is_a'
+require 'mocha/parameter_matchers/kind_of'
+require 'mocha/parameter_matchers/not'
+require 'mocha/parameter_matchers/optionally'
+require 'mocha/parameter_matchers/regexp_matches'
+require 'mocha/parameter_matchers/responds_with'
+require 'mocha/parameter_matchers/yaml_equivalent'

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