flexmock 2.4.5 → 3.0.0

data/lib/flexmock/expectation.rb

@@ -37,11 +37,11 @@ class FlexMock
       @sym = sym
       @location = location
       @expected_args = nil
-      @expected_kw_args = nil
-      @expected_block = nil
+      @expected_kw = nil
       @count_validators = []
       @signature_validator = SignatureValidator.new(self)
       @count_validator_class = ExactCountValidator
+      @with_block = nil
       @actual_count = 0
       @return_value = nil
       @return_queue = []
@@ -52,7 +52,7 @@ class FlexMock
     end
 
     def to_s
-      FlexMock.format_call(@sym, @expected_args)
+      FlexMock.format_call(@sym, @expected_args, @expected_kw)
     end
 
     # Return a description of the matching features of the
@@ -64,8 +64,9 @@ class FlexMock
     #
     def description
       result = ["should_receive(#{@sym.inspect})"]
-      result << ".with(#{FlexMock.format_args(@expected_args)})" if @expected_args
-      result << ".with_kw_args(#{FlexMock.format_kw_args(@expected_kw_args)})" if @expected_kw_args
+      if @expected_args || @expected_kw
+        result << ".with(#{FlexMock.format_args(@expected_args, @expected_kw)})"
+      end
       @count_validators.each do |validator|
         result << validator.describe
       end
@@ -86,63 +87,49 @@ class FlexMock
       FlexMock.framework_adapter.check(e.message) { false }
     end
 
-    def validate_signature(args)
-      @signature_validator.validate(args)
+    def validate_signature(args, kw, block)
+      @signature_validator.validate(args, kw, block)
     rescue SignatureValidator::ValidationFailed => e
       FlexMock.framework_adapter.check(e.message) { false }
     end
 
     # Verify the current call with the given arguments matches the
     # expectations recorded in this object.
-    def verify_call(*args, &block)
+    def verify_call(args, kw, block)
       validate_eligible
       validate_order
-      enhanced_args =
-        if block
-          args + [block]
-        else
-          args
-        end
-
-      validate_signature(enhanced_args)
+      validate_signature(args, kw, block)
       @actual_count += 1
-      perform_yielding(args, block)
-      return_value(args, block)
+      perform_yielding(block)
+      return_value(args, kw, block)
     end
 
     # Public return value (odd name to avoid accidental use as a
     # constraint).
-    def _return_value(args, block) # :nodoc:
-      return_value(args, block)
+    def _return_value(args, kw, block) # :nodoc:
+      return_value(args, kw, block)
     end
 
     # Find the return value for this expectation. (private version)
-    def return_value(args, block)
+    def return_value(args, kw, block)
       case @return_queue.size
       when 0
-        ret_block = lambda { |*a| @return_value }
+        ret_block = lambda { |*, **| @return_value }
       when 1
         ret_block = @return_queue.first
       else
         ret_block = @return_queue.shift
       end
-
-      if @expected_block
-        ret_block.call(*args, &block)
-      elsif block && @expected_block.nil?
-        ret_block.call(*args, block)
-      else
-        ret_block.call(*args)
-      end
+      ret_block.call(*args, **kw, &block)
     end
     private :return_value
 
     # Yield stored values to any blocks given.
-    def perform_yielding(args, block)
+    def perform_yielding(block)
       @return_value = nil
       unless @yield_queue.empty?
         values = (@yield_queue.size == 1) ? @yield_queue.first : @yield_queue.shift
-        if block
+        if block && block.respond_to?(:call)
           values.each do |v|
             @return_value = block.call(*v)
           end
@@ -186,44 +173,14 @@ class FlexMock
 
     # Does the argument list match this expectation's argument
     # specification.
-    def match_args(args)
-      expected_args =
-        if @expected_kw_args
-          if proc_matcher?(@expected_args&.last) && @expected_block.nil?
-            @expected_args[0..-2] + [@expected_kw_args, @expected_args[-1]]
-          else
-            (@expected_args || []) + [@expected_kw_args]
-          end
-        else
-          @expected_args
-        end
-
-      if @expected_block
-        expected_args = (expected_args || []) + [@expected_block]
-      end
-
-      ArgumentMatching.all_match?(expected_args, args)
-    end
-
-    def proc_matcher?(obj)
-      obj == Proc || obj == OPTIONAL_PROC_MATCHER
-    end
-
-    def with_optional_block
-      @expected_block = OPTIONAL_PROC_MATCHER
-    end
-
-    def with_block
-      @expected_block = Proc
-    end
-
-    def with_no_block
-      @expected_block = false
+    def match_args(args, kw, block)
+      ArgumentMatching.all_match?(@expected_args, @expected_kw, @expected_block, args, kw, block)
     end
 
     # Declare that the method should expect the given argument list.
-    def with(*args)
+    def with(*args, **kw)
       @expected_args = args
+      @expected_kw = kw
       self
     end
 
@@ -236,47 +193,71 @@ class FlexMock
     # arguments of any type.
     def with_any_args
       @expected_args = nil
+      @expected_kw = nil
       self
     end
 
     # Declare that the method can be called with any number of
     # arguments of any type.
-    def with_kw_args(matcher)
-      @expected_kw_args =
-        if matcher.kind_of?(Hash)
-          KwArgsMatcher.new(matcher)
-        else
-          matcher
-        end
+    def with_any_kw_args
+      @expected_kw = nil
       self
     end
 
     # Declare that the method can be called with any number of
     # arguments of any type.
-    def with_any_kw_args
-      @expected_kw_args = FlexMock.any
+    def with_any_positional_args
+      @expected_args = nil
+      self
+    end
+
+    # Declare that the method should be called with the given
+    # keyword arguments
+    def with_kw_args(kw)
+      @expected_kw = kw
+      self
+    end
+
+    # Declare that the call should have a block
+    def with_block
+      @expected_block = true
+      self
+    end
+
+    # Declare that the call should have a block
+    def with_no_block
+      @expected_block = false
+      self
+    end
+
+    def with_optional_block
+      @expected_block = nil
       self
     end
 
     # Validate general parameters on the call signature
     def with_signature(
-        required_arguments: 0, optional_arguments: 0, splat: false,
-        required_keyword_arguments: [], optional_keyword_arguments: [], keyword_splat: false)
+      required_arguments: 0, optional_arguments: 0, splat: false,
+      required_keyword_arguments: [], optional_keyword_arguments: [],
+      keyword_splat: false
+    )
       @signature_validator = SignatureValidator.new(
-          self,
-          required_arguments: required_arguments,
-          optional_arguments: optional_arguments,
-          splat: splat,
-          required_keyword_arguments: required_keyword_arguments,
-          optional_keyword_arguments: optional_keyword_arguments,
-          keyword_splat: keyword_splat)
+        self,
+        required_arguments: required_arguments,
+        optional_arguments: optional_arguments,
+        splat: splat,
+        required_keyword_arguments: required_keyword_arguments,
+        optional_keyword_arguments: optional_keyword_arguments,
+        keyword_splat: keyword_splat
+      )
       self
     end
 
     # Validate that the passed arguments match the method signature from the
     # given instance method
     def with_signature_matching(instance_method)
-      @signature_validator = SignatureValidator.from_instance_method(self, instance_method)
+      @signature_validator =
+        SignatureValidator.from_instance_method(self, instance_method)
       self
     end
 
@@ -411,15 +392,9 @@ class FlexMock
 
     def pass_thru(&block)
       block ||= lambda { |value| value }
-      and_return { |*args, &orig_block|
+      and_return { |*args, **kw|
         begin
-          if @expected_block.nil? && !orig_block
-            if Proc === args.last
-              orig_block = args.last
-              args = args[0..-2]
-            end
-          end
-          block.call(@mock.flexmock_invoke_original(@sym, args, orig_block))
+          block.call(@mock.flexmock_invoke_original(@sym, args, kw))
         rescue NoMethodError => e
           if e.name == @sym
             raise e, "#{e.message} while performing #pass_thru in expectation object #{self}"

data/lib/flexmock/expectation_builder.rb

@@ -22,12 +22,12 @@ class FlexMock
     # hashes, and identifies the method names specified by each.  As each
     # method name is identified, create a mock expectation for it using the
     # supplied block.
-    def parse_should_args(mock, args, &block)  # :nodoc:
+    def parse_should_args(mock, args, kw, &block)  # :nodoc:
       result = CompositeExpectation.new
       args.each do |arg|
         case arg
         when Hash
-          arg.each do |k,v|
+          arg.each do |k, v|
             exp = create_expectation(mock, k, &block).and_return(v)
             result.add(exp)
           end
@@ -35,6 +35,12 @@ class FlexMock
           result.add(create_expectation(mock, arg, &block))
         end
       end
+
+      kw.each do |k, v|
+        exp = create_expectation(mock, k, &block).and_return(v)
+        result.add(exp)
+      end
+
       result
     end
 
@@ -86,7 +92,7 @@ class FlexMock
       names.each do |name|
         exp = mock.flexmock_find_expectation(name)
         if exp
-          next_mock = exp._return_value([], nil)
+          next_mock = exp._return_value([], {}, nil)
           check_proper_mock(next_mock, name)
         else
           next_mock = container.flexmock("demeter_#{name}")

data/lib/flexmock/expectation_director.rb

@@ -35,18 +35,16 @@ class FlexMock
     # but at least we will get a good failure message).  Finally,
     # check for expectations that don't have any argument matching
     # criteria.
-    def call(args, block = nil, call_record=nil)
-      find_args = args.dup
-      find_args << block if block
-      exp = find_expectation(*find_args)
+    def call(args, kw, block, call_record=nil)
+      exp = find_expectation(args, kw, block)
       call_record.expectation = exp if call_record
       FlexMock.check(
         proc { "no matching handler found for " +
-               FlexMock.format_call(@sym, args) +
+               FlexMock.format_call(@sym, args, kw) +
                "\nDefined expectations:\n  " +
                @expectations.map(&:description).join("\n  ") }
       ) { !exp.nil? }
-      returned_value = exp.verify_call(*args, &block)
+      returned_value = exp.verify_call(args, kw, block)
       returned_value
     end
 
@@ -56,11 +54,11 @@ class FlexMock
     end
 
     # Find an expectation matching the given arguments.
-    def find_expectation(*args) # :nodoc:
+    def find_expectation(args, kw, block) # :nodoc:
       if @expectations.empty?
-        find_expectation_in(@defaults, *args)
+        find_expectation_in(@defaults, args, kw, block)
       else
-        find_expectation_in(@expectations, *args)
+        find_expectation_in(@expectations, args, kw, block)
       end
     end
 
@@ -86,9 +84,9 @@ class FlexMock
 
     private
 
-    def find_expectation_in(expectations, *args)
-      expectations.find { |e| e.match_args(args) && e.eligible? } ||
-        expectations.find { |e| e.match_args(args) }
+    def find_expectation_in(expectations, args, kw, block)
+      expectations.find { |e| e.match_args(args, kw, block) && e.eligible? } ||
+        expectations.find { |e| e.match_args(args, kw, block) }
     end
   end
 

data/lib/flexmock/expectation_recorder.rb

@@ -23,8 +23,8 @@ class FlexMock
     end
 
     # Save any incoming messages to be played back later.
-    def method_missing(sym, *args, &block)
-      @expectations << [sym, args, block]
+    def method_missing(sym, *args, **kw, &block)
+      @expectations << [sym, args, kw, block]
       self
     end
 
@@ -33,8 +33,8 @@ class FlexMock
     # call).
     def apply(mock)
       obj = mock
-      @expectations.each do |sym, args, block|
-        obj = obj.__send__(sym, *args, &block)
+      @expectations.each do |sym, args, kw, block|
+        obj = obj.send(sym, *args, **kw, &block)
       end
     end
   end

data/lib/flexmock/explicit_needed.rb

@@ -31,9 +31,9 @@ class FlexMock
 
     WHITELIST = [:with_signature_matching]
 
-    def method_missing(sym, *args, &block)
+    def method_missing(sym, *args, **kw, &block)
       if explicit? || WHITELIST.include?(sym)
-        @expectation.send(sym, *args, &block)
+        @expectation.send(sym, *args, **kw, &block)
       else
         fail NoMethodError, "Cannot stub methods not defined by the base class\n" +
           "   Method:     #{@method_name}\n" +

data/lib/flexmock/partial_mock.rb

@@ -150,8 +150,8 @@ class FlexMock
     # to the result.
     #
     # See Expectation for a list of declarators that can be used.
-    def should_receive(*args)
-      flexmock_define_expectation(caller, *args)
+    def should_receive(*args, **kw)
+      flexmock_define_expectation(caller, *args, **kw)
     end
 
     def should_expect(*args)
@@ -161,13 +161,22 @@ class FlexMock
     # Invoke the original of a mocked method
     #
     # Usually called in a #and_return statement
-    def invoke_original(m, *args, &block)
-      flexmock_invoke_original(m, args, block)
+    def invoke_original(m, *args, **kw, &block)
+      if block
+        args << block
+      end
+      flexmock_invoke_original(m, args, kw)
     end
 
     # Whether the given method's original definition has been stored
     def find_original_method(m)
-      it = @obj.method(m)
+      it =
+        if m.respond_to?(:to_str) || m.respond_to?(:to_sym)
+          @obj.method(m)
+        else
+          m
+        end
+
       while it && (it.owner != @proxy_definition_module)
         it = it.super_method
       end
@@ -200,15 +209,24 @@ class FlexMock
           @proxy_definition_module.method_defined?(m)
     end
 
-    def flexmock_define_expectation(location, *args)
-      EXP_BUILDER.parse_should_args(self, args) do |method_name|
+    def flexmock_plain_new_method?(m)
+      m.name == :new && m.owner == Class
+    end
+
+    def flexmock_define_expectation(location, *args, **kw)
+      EXP_BUILDER.parse_should_args(self, args, kw) do |method_name|
         if !has_proxied_method?(method_name)
           define_proxy_method(method_name)
         end
         ex = @mock.flexmock_define_expectation(location, method_name)
         if FlexMock.partials_verify_signatures
           if (existing_method = find_original_method(method_name))
-            ex.with_signature_matching(existing_method)
+            if flexmock_plain_new_method?(existing_method)
+              # Look for the signature of `initialize` instead
+              ex.with_signature_matching(@obj.instance_method(:initialize))
+            else
+              ex.with_signature_matching(existing_method)
+            end
           end
         end
         ex.mock = self
@@ -216,17 +234,17 @@ class FlexMock
       end
     end
 
-    def flexmock_find_expectation(*args)
-      @mock.flexmock_find_expectation(*args)
+    def flexmock_find_expectation(*args, **kw, &block)
+      @mock.flexmock_find_expectation(*args, **kw, &block)
     end
 
     def add_mock_method(method_name)
       proxy_module_eval do
-        define_method(method_name) { |*args, &block|
+        define_method(method_name) { |*args, **kw, &block|
           proxy = __flexmock_proxy or
             fail "Missing FlexMock proxy " +
                  "(for method_name=#{method_name.inspect}, self=\#{self})"
-          proxy.send(method_name, *args, &block)
+          proxy.send(method_name, *args, **kw, &block)
         }
       end
     end
@@ -262,9 +280,9 @@ class FlexMock
       end
 
       allocators.each do |allocate_method|
-        flexmock_define_expectation(location, allocate_method).and_return { |*args|
+        flexmock_define_expectation(location, allocate_method).and_return { |*args, **kw|
           create_new_mocked_object(
-            allocate_method, args, expectation_recorder, block)
+            allocate_method, args, kw, expectation_recorder, block)
         }
       end
       expectation_recorder
@@ -276,7 +294,7 @@ class FlexMock
         expectation_blocks    = @initialize_expectation_blocks = Array.new
         expectation_recorders = @initialize_expectation_recorders = Array.new
         @initialize_override = Module.new do
-          define_method :initialize do |*args, &block|
+          define_method :initialize do |*args, **kw, &block|
             if self.class.respond_to?(:__flexmock_proxy) && (mock = self.class.__flexmock_proxy)
               container = mock.flexmock_container
               mock = container.flexmock(self)
@@ -287,8 +305,7 @@ class FlexMock
                 r.apply(mock)
               end
             end
-            # Workaround kw arg support for ruby < 2.7
-            super(*args, &block)
+            super(*args, **kw, &block)
           end
         end
         override = @initialize_override
@@ -318,8 +335,8 @@ class FlexMock
     # (2) Pass to the block for custom configuration.
     # (3) Apply any recorded expecations
     #
-    def create_new_mocked_object(allocate_method, args, recorder, block)
-      new_obj = flexmock_invoke_original(allocate_method, args, nil)
+    def create_new_mocked_object(allocate_method, args, kw, recorder, block)
+      new_obj = flexmock_invoke_original(allocate_method, args, kw)
       mock = flexmock_container.flexmock(new_obj)
       block.call(mock) unless block.nil?
       recorder.apply(mock)
@@ -329,11 +346,15 @@ class FlexMock
 
     # Invoke the original definition of method on the object supported by
     # the stub.
-    def flexmock_invoke_original(method, args, block)
+    def flexmock_invoke_original(method, args, kw)
       if (original_method = find_original_method(method))
-        original_method.call(*args, &block)
+        if Proc === args.last
+          block = args.last
+          args = args[0..-2]
+        end
+        original_method.call(*args, **kw, &block)
       else
-        @obj.__send__(:method_missing, method, *args, &block)
+        @obj.__send__(:method_missing, method, *args, **kw, &block)
       end
     end
 
@@ -367,8 +388,8 @@ class FlexMock
     end
 
     # Forward to the mock
-    def flexmock_received?(*args)
-      @mock.flexmock_received?(*args)
+    def flexmock_received?(*args, **kw)
+      @mock.flexmock_received?(*args, **kw)
     end
 
     # Forward to the mock
@@ -400,15 +421,15 @@ class FlexMock
 
     # Evaluate a block (or string) in the context of the singleton
     # class of the target partial object.
-    def target_class_eval(*args, &block)
-      target_singleton_class.class_eval(*args, &block)
+    def target_class_eval(*args, **kw, &block)
+      target_singleton_class.class_eval(*args, **kw, &block)
     end
 
     class ProxyDefinitionModule < Module
     end
 
     # Evaluate a block into the module we use to define the proxy methods
-    def proxy_module_eval(*args, &block)
+    def proxy_module_eval(*args, **kw, &block)
       if !@proxy_definition_module
         obj = @obj
         @proxy_definition_module = m = ProxyDefinitionModule.new do
@@ -420,7 +441,7 @@ class FlexMock
         end
         target_class_eval { prepend m }
       end
-      @proxy_definition_module.class_eval(*args, &block)
+      @proxy_definition_module.class_eval(*args, **kw, &block)
     end
 
     # Hide the existing method definition with a singleton defintion
@@ -439,15 +460,15 @@ class FlexMock
     def define_proxy_method(method_name)
       if method_name =~ /=$/
         proxy_module_eval do
-          define_method(method_name) do |*args, &block|
-            __flexmock_proxy.mock.__send__(method_name, *args, &block)
+          define_method(method_name) do |*args, **kw, &block|
+            __flexmock_proxy.mock.__send__(method_name, *args, **kw, &block)
           end
         end
       else
         proxy_module_eval <<-EOD
-          def #{method_name}(*args, &block)
+          def #{method_name}(*args, **kw, &block)
             FlexMock.verify_mocking_allowed!
-            __flexmock_proxy.mock.#{method_name}(*args, &block)
+            __flexmock_proxy.mock.#{method_name}(*args, **kw, &block)
           end
         EOD
       end

data/lib/flexmock/spy_describers.rb

@@ -1,25 +1,25 @@
 class FlexMock
 
     module SpyDescribers
-      def spy_description(spy, sym, args, options)
+      def spy_description(spy, sym, args, kw, options)
         result = "have received "
-        result << FlexMock.format_call(sym, args)
+        result << FlexMock.format_call(sym, args, kw)
         result << times_description(options[:times])
         result << block_description(options[:with_block])
         result
       end
 
-      def describe_spy_expectation(spy, sym, args, options={})
-        describe_spy(spy, sym, args, options)
+      def describe_spy_expectation(spy, sym, args, kw, options={})
+        describe_spy(spy, sym, args, kw, options)
       end
 
-      def describe_spy_negative_expectation(spy, sym, args, options={})
-        describe_spy(spy, sym, args, options, " NOT")
+      def describe_spy_negative_expectation(spy, sym, args, kw, options={})
+        describe_spy(spy, sym, args, kw, options, " NOT")
       end
 
-      def describe_spy(spy, sym, args, options, not_clause="")
+      def describe_spy(spy, sym, args, kw, options, not_clause="")
         result = "expected "
-        result << FlexMock.format_call(sym, args)
+        result << FlexMock.format_call(sym, args, kw)
         result << " to#{not_clause} be received by " << spy.inspect
         result << times_description(options[:times])
         result << block_description(options[:with_block])
@@ -44,7 +44,7 @@ class FlexMock
       def append_call_record(result, call_record)
         result <<
           "    " <<
-          FlexMock.format_call(call_record.method_name, call_record.args)
+          FlexMock.format_call(call_record.method_name, call_record.args, call_record.kw)
         if call_record.expectation
           result <<
             " matched by " <<

data/lib/flexmock/test_unit_assert_spy_called.rb

@@ -4,29 +4,36 @@ class FlexMock
   module TestUnitAssertions
     include FlexMock::SpyDescribers
 
-    def assert_spy_called(spy, method_name, *args)
-      _assert_spy_called(false, spy, method_name, *args)
+    def assert_spy_called(spy, method_name, *args, **kw)
+      _assert_spy_called(false, spy, method_name, *args, **kw)
     end
 
-    def assert_spy_not_called(spy, method_name, *args)
-      _assert_spy_called(true, spy, method_name, *args)
+    def assert_spy_not_called(spy, method_name, *args, **kw)
+      _assert_spy_called(true, spy, method_name, *args, **kw)
     end
 
     private
 
-    def _assert_spy_called(negative, spy, method_name, *args)
+    def _assert_spy_called(negative, spy, method_name, *args, **kw)
       options = {}
       if method_name.is_a?(Hash)
         options = method_name
         method_name = args.shift
       end
+
+      # Prior to ruby3, kw args would be matched in *args
+      # thus, expecting any args (:_) implied also expecting
+      # any kw args.
+      kw = :_ if args == [:_]
+
       args = nil if args == [:_]
-      bool = spy.flexmock_received?(method_name, args, options)
+      kw = nil if kw == :_
+      bool = spy.flexmock_received?(method_name, args, kw, options)
       if negative
         bool = !bool
-        message = describe_spy_negative_expectation(spy, method_name, args, options)
+        message = describe_spy_negative_expectation(spy, method_name, args, kw, options)
       else
-        message = describe_spy_expectation(spy, method_name, args, options)
+        message = describe_spy_expectation(spy, method_name, args, kw, options)
       end
       assert bool, message
     end