mocha 0.5.6 → 3.1.0

data/lib/mocha/parameter_matchers/anything.rb

@@ -1,33 +1,42 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
 
 module Mocha
-  
   module ParameterMatchers
-
-    # :call-seq: anything -> parameter_matcher
-    #
-    # Matches any object.
-    #   object = mock()
-    #   object.expects(:method_1).with(anything)
-    #   object.method_1('foo')
-    #   # no error raised
-    def anything
-      Anything.new
+    module Methods
+      # Matches any object.
+      #
+      # @return [Anything] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Any object will match.
+      #   object = mock()
+      #   object.expects(:method_1).with(anything)
+      #   object.method_1('foo')
+      #   object.method_1(789)
+      #   object.method_1(:bar)
+      #   # no error raised
+      def anything
+        Anything.new
+      end
     end
-    
-    class Anything < Base # :nodoc:
-    
+
+    # Parameter matcher which always matches a single parameter.
+    class Anything
+      include BaseMethods
+
+      # @private
       def matches?(available_parameters)
         available_parameters.shift
-        return true
+        true
       end
-      
+
+      # @private
       def mocha_inspect
-        "anything"
+        'anything'
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/base_methods.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'mocha/deprecation'
+
+module Mocha
+  module ParameterMatchers
+    # @abstract Include and implement +#matches?+ and +#mocha_inspect+ to define a custom matcher. Also add a suitably named instance method to {Methods} to build an instance of the new matcher c.f. {Methods#equals}.
+    module BaseMethods
+      # A shorthand way of combining two matchers when both must match.
+      #
+      # Returns a new {AllOf} parameter matcher combining two matchers using a logical AND.
+      #
+      # This shorthand will not work with an implicit equals match. Instead, an explicit {Equals} matcher should be used.
+      #
+      # @param [BaseMethods] other parameter matcher.
+      # @return [AllOf] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Alternative ways to combine matchers with a logical AND.
+      #   object = mock()
+      #   object.expects(:run).with(all_of(has_key(:foo), has_key(:bar)))
+      #   object.run(foo: 'foovalue', bar: 'barvalue')
+      #
+      #   # is exactly equivalent to
+      #
+      #   object.expects(:run).with(has_key(:foo) & has_key(:bar))
+      #   object.run(foo: 'foovalue', bar: 'barvalue)
+      def &(other)
+        AllOf.new(self, other)
+      end
+
+      # A shorthand way of combining two matchers when at least one must match.
+      #
+      # Returns a new +AnyOf+ parameter matcher combining two matchers using a logical OR.
+      #
+      # This shorthand will not work with an implicit equals match. Instead, an explicit {Equals} matcher should be used.
+      #
+      # @param [BaseMethods] other parameter matcher.
+      # @return [AnyOf] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Alternative ways to combine matchers with a logical OR.
+      #   object = mock()
+      #   object.expects(:run).with(any_of(has_key(:foo), has_key(:bar)))
+      #   object.run(foo: 'foovalue')
+      #
+      #   # is exactly equivalent to
+      #
+      #   object.expects(:run).with(has_key(:foo) | has_key(:bar))
+      #   object.run(foo: 'foovalue')
+      #
+      # @example Using an explicit {Equals} matcher in combination with {#|}.
+      #   object.expects(:run).with(equals(1) | equals(2))
+      #   object.run(1) # passes
+      #   object.run(2) # passes
+      #   object.run(3) # fails
+      def |(other)
+        AnyOf.new(self, other)
+      end
+    end
+  end
+end

data/lib/mocha/parameter_matchers/equals.rb

@@ -1,42 +1,53 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
 
 module Mocha
-  
   module ParameterMatchers
-
-    # :call-seq: equals(value) -> parameter_matcher
-    #
-    # Matches +Object+ equalling +value+.
-    #   object = mock()
-    #   object.expects(:method_1).with(equals(2))
-    #   object.method_1(2)
-    #   # no error raised
-    #
-    #   object = mock()
-    #   object.expects(:method_1).with(equals(2))
-    #   object.method_1(3)
-    #   # error raised, because method_1 was not called with Object equalling 3
-    def equals(value)
-      Equals.new(value)
+    module Methods
+      # Matches any +Object+ equalling +value+.
+      #
+      # @param [Object] value expected value.
+      # @return [Equals] parameter matcher.
+      #
+      # @see Expectation#with
+      # @see Object#==
+      #
+      # @example Actual parameter equals expected parameter.
+      #   object = mock()
+      #   object.expects(:method_1).with(equals(2))
+      #   object.method_1(2)
+      #   # no error raised
+      #
+      # @example Actual parameter does not equal expected parameter.
+      #   object = mock()
+      #   object.expects(:method_1).with(equals(2))
+      #   object.method_1(3)
+      #   # error raised, because method_1 was not called with an +Object+ that equals 2
+      def equals(value)
+        Equals.new(value)
+      end
     end
 
-    class Equals < Base # :nodoc:
-      
+    # Parameter matcher which matches when actual parameter equals expected value.
+    class Equals
+      include BaseMethods
+
+      # @private
       def initialize(value)
         @value = value
       end
-      
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
         parameter == @value
       end
-      
+
+      # @private
       def mocha_inspect
         @value.mocha_inspect
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/equivalent_uri.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
+require 'uri'
+
+module Mocha
+  module ParameterMatchers
+    module Methods
+      # Matches a URI without regard to the ordering of parameters in the query string.
+      #
+      # @param [String] uri URI to match.
+      # @return [EquivalentUri] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Actual URI is equivalent.
+      #   object = mock()
+      #   object.expects(:method_1).with(equivalent_uri('http://example.com/foo?a=1&b=2'))
+      #   object.method_1('http://example.com/foo?b=2&a=1')
+      #   # no error raised
+      #
+      # @example Actual URI is not equivalent.
+      #   object = mock()
+      #   object.expects(:method_1).with(equivalent_uri('http://example.com/foo?a=1&b=2'))
+      #   object.method_1('http://example.com/foo?a=1&b=3')
+      #   # error raised, because the query parameters were different
+      def equivalent_uri(uri)
+        EquivalentUri.new(uri)
+      end
+    end
+
+    # Parameter matcher which matches URIs with equivalent query strings.
+    class EquivalentUri
+      include BaseMethods
+
+      # @private
+      def initialize(uri)
+        @uri = URI.parse(uri)
+      end
+
+      # @private
+      def matches?(available_parameters)
+        actual = explode(URI.parse(available_parameters.shift))
+        expected = explode(@uri)
+        actual == expected
+      end
+
+      # @private
+      def mocha_inspect
+        "equivalent_uri(#{@uri.mocha_inspect})"
+      end
+
+      private
+
+      # @private
+      def explode(uri)
+        query_hash = Hash.new { |hash, key| hash[key] = [] }
+        URI.decode_www_form(uri.query || '').each do |key, value|
+          query_hash[key] << value
+        end
+        URI::Generic::COMPONENT.inject({}) { |h, k| h.merge(k => uri.__send__(k)) }.merge(query: query_hash)
+      end
+    end
+  end
+end

data/lib/mocha/parameter_matchers/has_entries.rb

@@ -1,42 +1,61 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
+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)
+    module Methods
+      # Matches +Hash+ containing all +entries+.
+      #
+      # @param [Hash] entries expected +Hash+ entries.
+      # @return [HasEntries] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Actual parameter contains all expected 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
+      #
+      # @example Actual parameter does not contain all expected entries.
+      #   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) # rubocop:disable Naming/PredicatePrefix
+        HasEntries.new(entries)
+      end
     end
-    
-    class HasEntries < Base # :nodoc:
-      
-      def initialize(entries)
+
+    # Parameter matcher which matches when actual parameter contains all expected +Hash+ entries.
+    class HasEntries
+      include BaseMethods
+
+      # @private
+      def initialize(entries, exact: false)
         @entries = entries
+        @exact = exact
       end
-      
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        @entries.all? { |key, value| parameter[key] == value }
+        return false unless parameter
+        return false unless parameter.respond_to?(:keys)
+        return false if @exact && @entries.length != parameter.keys.length
+
+        has_entry_matchers = @entries.map { |key, value| HasEntry.new(key, value) }
+        AllOf.new(*has_entry_matchers).matches?([parameter])
       end
-      
+
+      # @private
       def mocha_inspect
-        "has_entries(#{@entries.mocha_inspect})"
+        @exact ? @entries.mocha_inspect : "has_entries(#{@entries.mocha_inspect})"
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -1,55 +1,103 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
 
 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)
+    module Methods
+      # Matches +Hash+ containing entry with +key+ and +value+.
+      #
+      # @overload def has_entry(key, value)
+      #   @param [Object] key key for entry.
+      #   @param [Object] value value for entry.
+      # @overload def has_entry(single_entry_hash)
+      #   @param [Hash] single_entry_hash +Hash+ with single entry.
+      #   @raise [ArgumentError] if +single_entry_hash+ does not contain exactly one entry.
+      #
+      # @return [HasEntry] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Actual parameter contains expected entry supplied as 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
+      #
+      # @example Actual parameter contains expected entry supplied as +Hash+ entry.
+      #   object = mock()
+      #   object.expects(:method_1).with(has_entry('key_1' => 1))
+      #   object.method_1('key_1' => 1, 'key_2' => 2)
+      #   # no error raised
+      #
+      # @example Actual parameter does not contain expected entry supplied as key and 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
+      #
+      # @example Actual parameter does not contain expected entry supplied as +Hash+ entry.
+      #
+      #   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) # rubocop:disable Naming/PredicatePrefix
+        case options.length
+        when 0
+          raise ArgumentError, 'No arguments. Expecting at least one.'
+        when 1
+          key, value = HasEntry.parse_option(options[0])
+        when 2
+          key, value = options
+        else
+          raise ArgumentError, 'Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).'
+        end
+        HasEntry.new(key, value)
+      end
     end
-    
-    class HasEntry < Base # :nodoc:
-      
+
+    # Parameter matcher which matches when actual parameter contains expected +Hash+ entry.
+    class HasEntry
+      include BaseMethods
+
+      # @private
       def initialize(key, value)
-        @key, @value = key, value
+        @key = key
+        @value = value
       end
-      
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        parameter[@key] == @value
+        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
-      
+
+      # @private
       def mocha_inspect
-        "has_entry(#{@key.mocha_inspect}, #{@value.mocha_inspect})"
+        "has_entry(#{@key.mocha_inspect} => #{@value.mocha_inspect})"
+      end
+
+      # @private
+      def self.parse_option(option)
+        case option
+        when Hash
+          case option.length
+          when 0
+            raise ArgumentError, 'Argument has no entries.'
+          when 1
+            option.first
+          else
+            raise ArgumentError, 'Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.'
+          end
+        else
+          raise ArgumentError, 'Argument is not a Hash.'
+        end
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/has_key.rb

@@ -1,42 +1,55 @@
-require 'mocha/parameter_matchers/base'
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
 
 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)
+    module Methods
+      # Matches +Hash+ containing +key+.
+      #
+      # @param [Object] key expected key.
+      # @return [HasKey] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Actual parameter contains entry with expected key.
+      #   object = mock()
+      #   object.expects(:method_1).with(has_key('key_1'))
+      #   object.method_1('key_1' => 1, 'key_2' => 2)
+      #   # no error raised
+      #
+      # @example Actual parameter does not contain entry with expected key.
+      #   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) # rubocop:disable Naming/PredicatePrefix
+        HasKey.new(key)
+      end
     end
 
-    class HasKey < Base # :nodoc:
-      
+    # Parameter matcher which matches when actual parameter contains +Hash+ entry with expected key.
+    class HasKey
+      include BaseMethods
+
+      # @private
       def initialize(key)
         @key = key
       end
-      
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        parameter.keys.include?(@key)
+        return false unless parameter.respond_to?(:keys)
+
+        parameter.keys.any? { |key| @key.to_matcher.matches?([key]) }
       end
-      
+
+      # @private
       def mocha_inspect
         "has_key(#{@key.mocha_inspect})"
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/has_keys.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'mocha/parameter_matchers/base_methods'
+
+module Mocha
+  module ParameterMatchers
+    module Methods
+      # Matches +Hash+ containing +keys+.
+      #
+      # @param [*Array<Object>] keys expected keys.
+      # @return [HasKeys] parameter matcher.
+      #
+      # @see Expectation#with
+      #
+      # @example Actual parameter contains entry with expected keys.
+      #   object = mock()
+      #   object.expects(:method_1).with(has_keys(:key_1, :key_2))
+      #   object.method_1(:key_1 => 1, :key_2 => 2, :key_3 => 3)
+      #   # no error raised
+      #
+      # @example Actual parameter does not contain all expected keys.
+      #   object = mock()
+      #   object.expects(:method_1).with(has_keys(:key_1, :key_2))
+      #   object.method_1(:key_2 => 2)
+      #   # error raised, because method_1 was not called with Hash containing key: :key_1
+      #
+      def has_keys(*keys) # rubocop:disable Naming/PredicatePrefix
+        HasKeys.new(*keys)
+      end
+    end
+
+    # Parameter matcher which matches when actual parameter contains +Hash+ with all expected keys.
+    class HasKeys
+      include BaseMethods
+
+      # @private
+      def initialize(*keys)
+        raise ArgumentError, 'No arguments. Expecting at least one.' if keys.empty?
+
+        @keys = keys
+      end
+
+      # @private
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        return false unless parameter.respond_to?(:keys)
+
+        @keys.map(&:to_matcher).all? do |matcher|
+          parameter.keys.any? { |key| matcher.matches?([key]) }
+        end
+      end
+
+      # @private
+      def mocha_inspect
+        "has_keys(#{@keys.mocha_inspect(wrapped: false)})"
+      end
+    end
+  end
+end