mocha 1.1.0 → 2.0.2

data/lib/mocha/object_methods.rb

@@ -4,18 +4,20 @@ require 'mocha/argument_iterator'
 require 'mocha/expectation_error_factory'
 
 module Mocha
-
   # Methods added to all objects to allow mocking and stubbing on real (i.e. non-mock) objects.
   #
   # Both {#expects} and {#stubs} return an {Expectation} which can be further modified by methods on {Expectation}.
   module ObjectMethods
-
     # @private
     alias_method :_method, :method
 
     # @private
-    def mocha
-      @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+    def mocha(instantiate = true)
+      if instantiate
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+      else
+        defined?(@mocha) ? @mocha : nil
+      end
     end
 
     # @private
@@ -33,17 +35,22 @@ module Mocha
       self
     end
 
+    # @private
+    def stubba_class
+      singleton_class
+    end
+
     # Adds an expectation that the specified method must be called exactly once with any parameters.
     #
     # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
     #
-    # @param [Symbol,String] method_name name of expected method
-    # @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {#expects} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
     #
     # @overload def expects(method_name)
+    #   @param [Symbol,String] method_name name of expected method
     # @overload def expects(expected_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
-    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {#expects} were called multiple times.
     #
     # @example Setting up an expectation on a non-mock object.
     #   product = Product.new
@@ -71,14 +78,14 @@ module Mocha
       expectation = nil
       mockery = Mocha::Mockery.instance
       iterator = ArgumentIterator.new(expected_methods_vs_return_values)
-      iterator.each { |*args|
+      iterator.each do |*args|
         method_name = args.shift
         mockery.on_stubbing(self, method_name)
         method = stubba_method.new(stubba_object, method_name)
         mockery.stubba.stub(method)
         expectation = mocha.expects(method_name, caller)
-        expectation.returns(args.shift) if args.length > 0
-      }
+        expectation.returns(args.shift) unless args.empty?
+      end
       expectation
     end
 
@@ -86,13 +93,13 @@ module Mocha
     #
     # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
     #
-    # @param [Symbol,String] method_name name of stubbed method
-    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {#stubs} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
     #
     # @overload def stubs(method_name)
+    #   @param [Symbol,String] method_name name of stubbed method
     # @overload def stubs(stubbed_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
-    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {#stubs} were called multiple times.
     #
     # @example Setting up a stubbed methods on a non-mock object.
     #   product = Product.new
@@ -117,14 +124,14 @@ module Mocha
       expectation = nil
       mockery = Mocha::Mockery.instance
       iterator = ArgumentIterator.new(stubbed_methods_vs_return_values)
-      iterator.each { |*args|
+      iterator.each do |*args|
         method_name = args.shift
         mockery.on_stubbing(self, method_name)
         method = stubba_method.new(stubba_object, method_name)
         mockery.stubba.stub(method)
         expectation = mocha.stubs(method_name, caller)
-        expectation.returns(args.shift) if args.length > 0
-      }
+        expectation.returns(args.shift) unless args.empty?
+      end
       expectation
     end
 
@@ -158,18 +165,5 @@ module Mocha
         mockery.stubba.unstub(method)
       end
     end
-
-    # @private
-    def method_exists?(method, include_public_methods = true)
-      if include_public_methods
-        return true if public_methods(include_superclass_methods = true).include?(method)
-        return true if respond_to?(method.to_sym)
-      end
-      return true if protected_methods(include_superclass_methods = true).include?(method)
-      return true if private_methods(include_superclass_methods = true).include?(method)
-      return false
-    end
-
   end
-
 end

data/lib/mocha/parameter_matchers/all_of.rb

@@ -1,12 +1,10 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches if all +matchers+ match.
     #
-    # @param [*Array<Base>] parameter_matchers parameter matchers.
+    # @param [*Array<Base>] matchers parameter matchers.
     # @return [AllOf] parameter matcher.
     #
     # @see Expectation#with
@@ -28,7 +26,6 @@ module Mocha
 
     # Parameter matcher which combines a number of other matchers using a logical AND.
     class AllOf < Base
-
       # @private
       def initialize(*matchers)
         @matchers = matchers
@@ -42,11 +39,8 @@ module Mocha
 
       # @private
       def mocha_inspect
-        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+        "all_of(#{@matchers.map(&:mocha_inspect).join(', ')})"
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/any_of.rb

@@ -1,12 +1,10 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches if any +matchers+ match.
     #
-    # @param [*Array<Base>] parameter_matchers parameter matchers.
+    # @param [*Array<Base>] matchers parameter matchers.
     # @return [AnyOf] parameter matcher.
     #
     # @see Expectation#with
@@ -34,7 +32,6 @@ module Mocha
 
     # Parameter matcher which combines a number of other matchers using a logical OR.
     class AnyOf < Base
-
       # @private
       def initialize(*matchers)
         @matchers = matchers
@@ -48,11 +45,8 @@ module Mocha
 
       # @private
       def mocha_inspect
-        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+        "any_of(#{@matchers.map(&:mocha_inspect).join(', ')})"
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/any_parameters.rb

@@ -1,9 +1,7 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches any parameters. This is used as the default for a newly built expectation.
     #
     # @return [AnyParameters] parameter matcher.
@@ -26,22 +24,18 @@ module Mocha
 
     # Parameter matcher which always matches whatever the parameters.
     class AnyParameters < Base
-
       # @private
       def matches?(available_parameters)
-        while available_parameters.length > 0 do
+        until available_parameters.empty?
           available_parameters.shift
         end
-        return true
+        true
       end
 
       # @private
       def mocha_inspect
-        "any_parameters"
+        'any_parameters'
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/anything.rb

@@ -1,9 +1,7 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches any object.
     #
     # @return [Anything] parameter matcher.
@@ -23,20 +21,16 @@ module Mocha
 
     # Parameter matcher which always matches a single parameter.
     class Anything < Base
-
       # @private
       def matches?(available_parameters)
         available_parameters.shift
-        return true
+        true
       end
 
       # @private
       def mocha_inspect
-        "anything"
+        'anything'
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/base.rb

@@ -1,12 +1,9 @@
 module Mocha
-
   module ParameterMatchers
-
     # @abstract Subclass and implement +#matches?+ and +#mocha_inspect+ to define a custom matcher. Also add a suitably named instance method to {ParameterMatchers} to build an instance of the new matcher c.f. {#equals}.
     class Base
-
       # @private
-      def to_matcher
+      def to_matcher(_expectation = nil)
         self
       end
 
@@ -16,7 +13,7 @@ module Mocha
       #
       # This shorthand will not work with an implicit equals match. Instead, an explicit {Equals} matcher should be used.
       #
-      # @param [Base] matcher parameter matcher.
+      # @param [Base] other parameter matcher.
       # @return [AllOf] parameter matcher.
       #
       # @see Expectation#with
@@ -30,8 +27,8 @@ module Mocha
       #
       #   object.expects(:run).with(has_key(:foo) & has_key(:bar))
       #   object.run(:foo => 'foovalue', :bar => 'barvalue)
-      def &(matcher)
-        AllOf.new(self, matcher)
+      def &(other)
+        AllOf.new(self, other)
       end
 
       # A shorthand way of combining two matchers when at least one must match.
@@ -40,7 +37,7 @@ module Mocha
       #
       # This shorthand will not work with an implicit equals match. Instead, an explicit {Equals} matcher should be used.
       #
-      # @param [Base] matcher parameter matcher.
+      # @param [Base] other parameter matcher.
       # @return [AnyOf] parameter matcher.
       #
       # @see Expectation#with
@@ -60,12 +57,9 @@ module Mocha
       #   object.run(1) # passes
       #   object.run(2) # passes
       #   object.run(3) # fails
-      def |(matcher)
-        AnyOf.new(self, matcher)
+      def |(other)
+        AnyOf.new(self, other)
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/equals.rb

@@ -1,9 +1,7 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches any +Object+ equalling +value+.
     #
     # @param [Object] value expected value.
@@ -22,14 +20,13 @@ module Mocha
     #   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 3
+    #   # error raised, because method_1 was not called with an +Object+ that equals 2
     def equals(value)
       Equals.new(value)
     end
 
     # Parameter matcher which matches when actual parameter equals expected value.
     class Equals < Base
-
       # @private
       def initialize(value)
         @value = value
@@ -45,9 +42,6 @@ module Mocha
       def mocha_inspect
         @value.mocha_inspect
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/{query_string.rb → equivalent_uri.rb}

@@ -1,34 +1,33 @@
 require 'mocha/parameter_matchers/base'
 require 'uri'
+require 'cgi'
 
 module Mocha
   module ParameterMatchers
-
     # Matches a URI without regard to the ordering of parameters in the query string.
     #
     # @param [String] uri URI to match.
-    # @return [QueryStringMatches] parameter matcher.
+    # @return [EquivalentUri] parameter matcher.
     #
     # @see Expectation#with
     #
-    # @example Actual URI has equivalent query string.
+    # @example Actual URI is equivalent.
     #   object = mock()
-    #   object.expects(:method_1).with(has_equivalent_query_string('http://example.com/foo?a=1&b=2))
+    #   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 does not have equivalent query string.
+    # @example Actual URI is not equivalent.
     #   object = mock()
-    #   object.expects(:method_1).with(has_equivalent_query_string('http://example.com/foo?a=1&b=2))
+    #   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 has_equivalent_query_string(uri)
-      QueryStringMatches.new(uri)
+    def equivalent_uri(uri)
+      EquivalentUri.new(uri)
     end
 
     # Parameter matcher which matches URIs with equivalent query strings.
-    class QueryStringMatches < Base
-
+    class EquivalentUri < Base
       # @private
       def initialize(uri)
         @uri = URI.parse(uri)
@@ -43,16 +42,16 @@ module Mocha
 
       # @private
       def mocha_inspect
-        "has_equivalent_query_string(#{@uri.mocha_inspect})"
+        "equivalent_uri(#{@uri.mocha_inspect})"
       end
 
-    private
+      private
+
       # @private
       def explode(uri)
-        query_hash = (uri.query || '').split('&').inject({}){ |h, kv| h.merge(Hash[*kv.split('=')]) }
-        URI::Generic::COMPONENT.inject({}){ |h, k| h.merge(k => uri.__send__(k)) }.merge(:query => query_hash)
+        query_hash = CGI.parse(uri.query || '')
+        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

@@ -3,9 +3,7 @@ require 'mocha/parameter_matchers/all_of'
 require 'mocha/parameter_matchers/has_entry'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches +Hash+ containing all +entries+.
     #
     # @param [Hash] entries expected +Hash+ entries.
@@ -24,13 +22,13 @@ module Mocha
     #   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)
+    #
+    def has_entries(entries) # rubocop:disable Naming/PredicateName
       HasEntries.new(entries)
     end
 
     # Parameter matcher which matches when actual parameter contains all expected +Hash+ entries.
     class HasEntries < Base
-
       # @private
       def initialize(entries)
         @entries = entries
@@ -47,9 +45,6 @@ module Mocha
       def mocha_inspect
         "has_entries(#{@entries.mocha_inspect})"
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -1,9 +1,7 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches +Hash+ containing entry with +key+ and +value+.
     #
     # @overload def has_entry(key, value)
@@ -41,36 +39,27 @@ module Mocha
     #   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)
+    #
+    def has_entry(*options) # rubocop:disable Naming/PredicateName
       case options.length
+      when 0
+        raise ArgumentError, 'No arguments. Expecting at least one.'
       when 1
-        case options[0]
-        when Hash
-          case options[0].length
-          when 0
-            raise ArgumentError.new("Argument has no entries.")
-          when 1
-            key, value = options[0].first
-          else
-            raise ArgumentError.new("Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.")
-          end
-        else
-          raise ArgumentError.new("Argument is not a Hash.")
-        end
+        key, value = parse_option(options[0])
       when 2
         key, value = options
       else
-        raise ArgumentError.new("Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).")
+        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
 
     # Parameter matcher which matches when actual parameter contains expected +Hash+ entry.
     class HasEntry < Base
-
       # @private
       def initialize(key, value)
-        @key, @value = key, value
+        @key = key
+        @value = value
       end
 
       # @private
@@ -85,9 +74,25 @@ module Mocha
       def mocha_inspect
         "has_entry(#{@key.mocha_inspect} => #{@value.mocha_inspect})"
       end
-
     end
 
-  end
+    private
 
+    # @private
+    def 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

data/lib/mocha/parameter_matchers/has_key.rb

@@ -1,9 +1,7 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches +Hash+ containing +key+.
     #
     # @param [Object] key expected key.
@@ -22,13 +20,13 @@ module Mocha
     #   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)
+    #
+    def has_key(key) # rubocop:disable Naming/PredicateName
       HasKey.new(key)
     end
 
     # Parameter matcher which matches when actual parameter contains +Hash+ entry with expected key.
     class HasKey < Base
-
       # @private
       def initialize(key)
         @key = key
@@ -45,9 +43,6 @@ module Mocha
       def mocha_inspect
         "has_key(#{@key.mocha_inspect})"
       end
-
     end
-
   end
-
 end

data/lib/mocha/parameter_matchers/has_keys.rb

@@ -0,0 +1,53 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  module ParameterMatchers
+    # 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/PredicateName
+      HasKeys.new(*keys)
+    end
+
+    # Parameter matcher which matches when actual parameter contains +Hash+ with all expected keys.
+    class HasKeys < Base
+      # @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(false)})"
+      end
+    end
+  end
+end

data/lib/mocha/parameter_matchers/has_value.rb

@@ -1,9 +1,7 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches +Hash+ containing +value+.
     #
     # @param [Object] value expected value.
@@ -22,13 +20,13 @@ module Mocha
     #   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)
+    #
+    def has_value(value) # rubocop:disable Naming/PredicateName
       HasValue.new(value)
     end
 
     # Parameter matcher which matches when actual parameter contains +Hash+ entry with expected value.
     class HasValue < Base
-
       # @private
       def initialize(value)
         @value = value
@@ -45,9 +43,6 @@ module Mocha
       def mocha_inspect
         "has_value(#{@value.mocha_inspect})"
       end
-
     end
-
   end
-
 end