flexmock 1.3.3 → 2.0.0.rc1

data/flexmock.gemspec

@@ -0,0 +1,33 @@
+require './lib/flexmock/version.rb'
+spec = Gem::Specification.new do |s|
+  #### Basic information.
+  s.name = 'flexmock'
+  s.version = FlexMock::VERSION
+  s.summary = "Simple and Flexible Mock Objects for Testing"
+  s.description = %{
+    FlexMock is a extremely simple mock object class compatible
+    with the Minitest framework.  Although the FlexMock's
+    interface is simple, it is very flexible.
+  }
+
+  s.required_ruby_version = ">= 2.0"
+
+  s.license = 'MIT'
+
+  #### Dependencies and requirements.
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rake'
+
+  #### Which files are to be included in this gem?  Everything!  (Except CVS directories.)
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.require_paths = ['lib']                         # Use these for libraries.]
+
+  #### Author and project details.
+
+  s.authors = ["Jim Weirich", "Sylvain Joyeux"]
+  s.email = "sylvain.joyeux@m4x.org"
+  s.homepage = "https://github.com/doudou/flexmock"
+end
+

data/lib/flexmock.rb

@@ -10,4 +10,3 @@
 #+++
 
 require 'flexmock/base'
-require 'flexmock/test_unit_integration'

data/lib/flexmock/composite_expectation.rb

@@ -40,7 +40,7 @@ class FlexMock
     # applied to the new expectation.
     def should_receive(*args, &block)
       @expectations.first.mock.
-        flexmock_define_expectation(caller.first, *args, &block)
+        flexmock_define_expectation(caller, *args, &block)
     end
 
     # Return a string representations

data/lib/flexmock/core.rb

@@ -191,8 +191,7 @@ class FlexMock
   # See Expectation for a list of declarators that can be used.
   #
   def should_receive(*args)
-    location = caller.first
-    flexmock_define_expectation(location, *args)
+    flexmock_define_expectation(caller, *args)
   end
 
   # Using +location+, define the expectations specified by +args+.
@@ -230,13 +229,10 @@ class FlexMock
   # that the mock name is added to the error message .
   def flexmock_wrap(&block)
     yield
-  rescue FlexMock.framework_adapter.assertion_failed_error => ex
-    raise FlexMock.framework_adapter.assertion_failed_error,
-    "in mock '#{@flexmock_name}': #{ex.message}",
-    ex.backtrace
+  rescue FlexMock.framework_adapter.assertion_failed_error, FlexMock.framework_adapter.check_failed_error => ex
+    raise ex, "in mock '#{@flexmock_name}': #{ex.message}", ex.backtrace
   end
 
-
   # Override the existing definition of method +method_name+ in the
   # mock. Most methods depend on the method_missing trick to be
   # invoked. However, if the method already exists, it will not call

data/lib/flexmock/core_class_methods.rb

@@ -67,7 +67,11 @@ class FlexMock
     # Check will assert the block returns true.  If it doesn't, an
     # assertion failure is triggered with the given message.
     def check(msg, &block)  # :nodoc:
-      FlexMock.framework_adapter.make_assertion(msg, &block)
+      if FlexMock.framework_adapter.respond_to?(:check)
+        FlexMock.framework_adapter.check(msg, &block)
+      else
+        FlexMock.framework_adapter.make_assertion(msg, &block)
+      end
     end
 
   end

data/lib/flexmock/default_framework_adapter.rb

@@ -20,8 +20,8 @@ class FlexMock
       end
     end
 
-    def assert_equal(a, b, msg=nil)
-      make_assertion(msg || "Expected equal") { a == b }
+    def check(msg, &block)
+      make_assertion(msg, &block)
     end
 
     class AssertionFailedError < StandardError; end

data/lib/flexmock/expectation.rb

@@ -68,10 +68,22 @@ class FlexMock
       result
     end
 
+    # Validate that this expectation is eligible for an extra call
+    def validate_eligible
+      @count_validators.each do |v|
+        if !v.eligible?(@actual_count)
+          v.validate(@actual_count + 1)
+        end
+      end
+    rescue CountValidator::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)
       validate_order
+      validate_eligible
       @actual_count += 1
       perform_yielding(args)
       return_value(args)
@@ -140,6 +152,8 @@ class FlexMock
       @count_validators.each do |v|
         v.validate(@actual_count)
       end
+    rescue CountValidator::ValidationFailed => e
+      FlexMock.framework_adapter.make_assertion(e.message, @location) { false }
     end
 
     # Does the argument list match this expectation's argument
@@ -278,7 +292,15 @@ class FlexMock
     def pass_thru(&block)
       block ||= lambda { |value| value }
       and_return { |*args|
-        block.call(@mock.flexmock_invoke_original(@sym, args))
+        begin
+          block.call(@mock.flexmock_invoke_original(@sym, args))
+        rescue NoMethodError => e
+          if e.name == @sym
+            raise e, "#{e.message} while performing #pass_thru in expectation object #{self}"
+          else
+            raise
+          end
+        end 
       }
     end
 
@@ -417,8 +439,12 @@ class FlexMock
     def flexmock_location_filter
       yield
     rescue Exception => ex
-      ex.backtrace.insert(0, @location)
-      raise ex
+      bt = @location.dup
+      flexmock_dir = File.expand_path(File.dirname(__FILE__))
+      while bt.first.start_with?(flexmock_dir)
+          bt.shift
+      end
+      raise ex, ex.message, bt
     end
 
   end

data/lib/flexmock/expectation_director.rb

@@ -40,7 +40,7 @@ class FlexMock
       call_record.expectation = exp if call_record
       FlexMock.check(
         "no matching handler found for " +
-        FlexMock.format_call(@sym, args)) { ! exp.nil? }
+        FlexMock.format_call(@sym, args)) { !exp.nil? }
       returned_value = exp.verify_call(*args)
       returned_value
     end

data/lib/flexmock/minitest.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#+++
+
+require 'flexmock/minitest_integration'
+require 'flexmock/minitest_extensions'

data/lib/flexmock/minitest_extensions.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#+++
+
+begin
+  # Minitest 5.0+
+  require 'minitest/test'
+  class Minitest::Test
+    include FlexMock::Minitest
+  end
+
+rescue LoadError
+  # Minitest < 5.0, as shipped with ruby at least up to 2.1
+  require 'minitest/unit'
+  class MiniTest::Unit::TestCase
+    include FlexMock::Minitest
+  end
+end
+

data/lib/flexmock/minitest_integration.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#+++
+
+begin
+  require 'minitest/assertions'
+rescue LoadError
+  require 'minitest/unit'
+end
+
+require 'flexmock/base'
+require 'flexmock/test_unit_assert_spy_called'
+
+class FlexMock
+
+  # Minitest::Test Integration.
+  #
+  # Include this module in any Test subclass (in test-style minitest) or or
+  # describe block (in spec-style minitest) to get integration with FlexMock.
+  # When this module is included, the mock container methods (e.g. flexmock(),
+  # flexstub()) will be available.
+  #
+  module Minitest
+    include ArgumentTypes
+    include MockContainer
+    include TestUnitAssertions
+
+    # Teardown the test case, verifying any mocks that might have been
+    # defined in this test case.
+    def before_teardown
+      super
+      @flexmock_teardown_failure = nil
+      if respond_to?(:capture_exceptions)
+        capture_exceptions do
+          flexmock_teardown
+        end
+      else
+        begin
+          flexmock_teardown
+        rescue Exception => e
+          @flexmock_teardown_failure = e
+        end
+      end
+    end
+
+    def after_teardown
+      if @flexmock_teardown_failure
+        raise @flexmock_teardown_failure
+      end
+    end
+  end
+
+  class CheckFailedError < RuntimeError; end
+
+  # Adapter for adapting FlexMock to the Test::Unit framework.
+  #
+  class MinitestFrameworkAdapter
+    if defined?(Minitest::Test)
+      include Minitest::Assertions
+    else
+      include MiniTest::Assertions
+    end
+
+    attr_accessor :assertions
+
+    def initialize
+      @assertions = 0
+    end
+
+    def filtered_backtrace
+      bt = caller
+      flexmock_dir = File.expand_path(File.dirname(__FILE__))
+      while bt.first.start_with?(flexmock_dir)
+          bt.shift
+      end
+      bt
+    end
+
+    def make_assertion(msg, backtrace = caller, &block)
+      assert(yield, msg)
+    rescue Exception => e
+      e.set_backtrace backtrace
+      raise e
+    end
+
+    def check(msg, &block)
+      unless yield
+        msg = msg.call if msg.is_a?(Proc)
+        raise CheckFailedError, msg, filtered_backtrace
+      end
+    end
+
+    def assertion_failed_error
+      MiniTest::Assertion
+    end
+
+    def check_failed_error
+      CheckFailedError
+    end
+  end
+
+  @framework_adapter = MinitestFrameworkAdapter.new
+end
+

data/lib/flexmock/mock_container.rb

@@ -118,9 +118,8 @@ class FlexMock
     #   the mock object.
     #
     def flexmock(*args, &block)
-      location = caller.first
       @flexmock_worker ||= MockBuilder.new(self)
-      @flexmock_worker.define_a_mock(location, *args, &block)
+      @flexmock_worker.define_a_mock(caller, *args, &block)
     end
     alias flexstub flexmock
 

data/lib/flexmock/partial_mock.rb

@@ -28,21 +28,27 @@ class FlexMock
 
     attr_reader :mock
 
+    ProxyBox = Struct.new :proxy
+
     # Make a partial mock proxy and install it on the target +obj+.
     def self.make_proxy_for(obj, container, name, safe_mode)
       name ||= "flexmock(#{obj.class.to_s})"
       if ! proxy_defined_on?(obj)
         mock = FlexMock.new(name, container)
         proxy = PartialMockProxy.new(obj, mock, safe_mode)
-        obj.instance_variable_set("@flexmock_proxy", proxy)
+        if obj.instance_variable_defined?("@flexmock_proxy")
+          obj.instance_variable_get("@flexmock_proxy").proxy = proxy
+        else
+          obj.instance_variable_set("@flexmock_proxy", ProxyBox.new(proxy))
+        end
       end
-      obj.instance_variable_get("@flexmock_proxy")
+      obj.instance_variable_get("@flexmock_proxy").proxy
     end
 
     # Is there a mock proxy defined on the domain object?
     def self.proxy_defined_on?(obj)
       obj.instance_variable_defined?("@flexmock_proxy") &&
-        obj.instance_variable_get("@flexmock_proxy")
+        obj.instance_variable_get("@flexmock_proxy").proxy
     end
 
     # The following methods are added to partial mocks so that they
@@ -61,6 +67,7 @@ class FlexMock
       @mock = mock
       @method_definitions = {}
       @methods_proxied = []
+      @proxy_definition_module = nil
       unless safe_mode
         add_mock_method(:should_receive)
         MOCK_METHODS.each do |sym|
@@ -97,8 +104,7 @@ class FlexMock
     #
     # See Expectation for a list of declarators that can be used.
     def should_receive(*args)
-      location = caller.first
-      flexmock_define_expectation(location, *args)
+      flexmock_define_expectation(caller, *args)
     end
 
     def flexmock_define_expectation(location, *args)
@@ -118,9 +124,9 @@ class FlexMock
 
     def add_mock_method(method_name)
       stow_existing_definition(method_name)
-      target_class_eval do
+      proxy_module_eval do
         define_method(method_name) { |*args, &block|
-          proxy = instance_variable_get("@flexmock_proxy") or
+          proxy = __flexmock_proxy or
             fail "Missing FlexMock proxy " +
                  "(for method_name=#{method_name.inspect}, self=\#{self})"
           proxy.send(method_name, *args, &block)
@@ -149,11 +155,10 @@ class FlexMock
     def new_instances(*allocators, &block)
       fail ArgumentError, "new_instances requires a Class to stub" unless
         Class === @obj
-      location = caller.first
+      location = caller
       allocators = [:new] if allocators.empty?
       expectation_recorder = ExpectationRecorder.new
       allocators.each do |allocate_method|
-        check_allocate_method(allocate_method)
         flexmock_define_expectation(location, allocate_method).and_return { |*args|
           create_new_mocked_object(
             allocate_method, args, expectation_recorder, block)
@@ -181,8 +186,15 @@ class FlexMock
     # Invoke the original definition of method on the object supported by
     # the stub.
     def flexmock_invoke_original(method, args)
-      method_proc = @method_definitions[method]
-      method_proc.call(*args)
+      if original_method = @method_definitions[method]
+        if Proc === args.last
+          block = args.last
+          args = args[0..-2]
+        end
+        original_method.bind(@obj).call(*args, &block)
+      else
+        @obj.__send__(:method_missing, method, *args, &block)
+      end
     end
 
     # Verify that the mock has been properly called.  After verification,
@@ -194,11 +206,16 @@ class FlexMock
     # Remove all traces of the mocking framework from the existing object.
     def flexmock_teardown
       if ! detached?
-        @methods_proxied.each do |method_name|
-          remove_current_method(method_name)
-          restore_original_definition(method_name)
+        proxy_module_eval do
+          methods = instance_methods(false).to_a
+          methods.each do |m|
+            remove_method m
+          end
+        end
+        if @obj.instance_variable_defined?(:@flexmock_proxy) &&
+            (box = @obj.instance_variable_get(:@flexmock_proxy))
+          box.proxy = nil
         end
-        @obj.instance_variable_set("@flexmock_proxy", nil)
         @obj = nil
       end
     end
@@ -235,16 +252,9 @@ class FlexMock
 
     private
 
-    def check_allocate_method(allocate_method)
-      if allocate_method == :allocate && RUBY_VERSION >= "1.9"
-        fail UsageError,
-          "Cannot mock the allocation method using new_instances in Ruby 1.9"
-      end
-    end
-
     # The singleton class of the object.
     def target_singleton_class
-      class << @obj; self; end
+      @obj.singleton_class
     end
 
     # Evaluate a block (or string) in the context of the singleton
@@ -253,8 +263,20 @@ class FlexMock
       target_singleton_class.class_eval(*args, &block)
     end
 
-    def singleton?(method_name)
-      @obj.flexmock_singleton_defined?(method_name)
+    # Evaluate a block into the module we use to define the proxy methods
+    def proxy_module_eval(*args, &block)
+      if !@proxy_definition_module
+        obj = @obj
+        @proxy_definition_module = m = Module.new do
+          define_method(:__flexmock_proxy) do
+            if box = obj.instance_variable_get(:@flexmock_proxy)
+              box.proxy
+            end
+          end
+        end
+        target_class_eval { prepend m }
+      end
+      @proxy_definition_module.class_eval(*args, &block)
     end
 
     # Hide the existing method definition with a singleton defintion
@@ -271,109 +293,44 @@ class FlexMock
     # Stow the existing method definition so that it can be recovered
     # later.
     def stow_existing_definition(method_name)
-      @methods_proxied << method_name
-      new_alias = create_alias_for_existing_method(method_name)
-      if new_alias
-        @method_definitions[method_name] = create_aliased_definition(@obj, new_alias)
-      end
-      remove_current_method(method_name) if singleton?(method_name)
-    end
-
-    # Create a method definition that invokes the original behavior
-    # via the alias.
-    def create_aliased_definition(my_object, new_alias)
-      Proc.new { |*args|
-        block = nil
-        if Proc === args.last
-          block = args.last
-          args = args[0...-1]
-        end
-        my_object.send(new_alias, *args, &block)
-      }
-    end
-    private :create_aliased_definition
-
-    # Create an alias for the existing +method_name+.  Returns the new
-    # alias name.  If the aliasing process fails (because the method
-    # doesn't really exist, then return nil.
-    def create_alias_for_existing_method(method_name)
-      new_alias = new_name(method_name)
-      unless @obj.respond_to?(new_alias)
-        safe_alias_method(new_alias, method_name)
-      end
-      new_alias
-    end
-
-    # Create an alias for the existing method named +method_name+. It
-    # is possible that +method_name+ is implemented via a
-    # meta-programming, so we provide for the case that the
-    # method_name does not exist.
-    def safe_alias_method(new_alias, method_name)
-      target_class_eval do
-        begin
-          alias_method(new_alias, method_name)
-        rescue NameError
-          nil
-        end
+      if !@methods_proxied.include?(method_name)
+        @method_definitions[method_name] = target_class_eval { instance_method(method_name) }
+        @methods_proxied << method_name
       end
+    rescue NameError
     end
 
     # Define a proxy method that forwards to our mock object.  The
     # proxy method is defined as a singleton method on the object
     # being mocked.
     def define_proxy_method(method_name)
-      if method_name.to_s =~ /=$/
-        eval_line = __LINE__ + 1
-        target_class_eval %{
-          def #{method_name}(*args, &block)
-            instance_variable_get('@flexmock_proxy').
-              mock.__send__(:#{method_name}, *args, &block)
+      if method_name =~ /=$/
+        proxy_module_eval do
+          define_method(method_name) do |*args, &block|
+            __flexmock_proxy.mock.__send__(method_name, *args, &block)
           end
-        }, __FILE__, eval_line
+        end
       else
-        eval_line = __LINE__ + 1
-        target_class_eval %{
+        proxy_module_eval <<-EOD
           def #{method_name}(*args, &block)
-            instance_variable_get('@flexmock_proxy').
-              mock.#{method_name}(*args, &block)
+            __flexmock_proxy.mock.#{method_name}(*args, &block)
           end
-        }, __FILE__, eval_line
-        _ = true       # make rcov recognize the above eval is covered
+        EOD
       end
     end
 
     # Restore the original singleton defintion for method_name that
     # was saved earlier.
     def restore_original_definition(method_name)
-      begin
-        method_def = @method_definitions[method_name]
-        if method_def
-          the_alias = new_name(method_name)
-          target_class_eval do
-            alias_method(method_name, the_alias)
-          end
-        end
-      rescue NameError => _
-        # Alias attempt failed
-        nil
+      proxy_module_eval do
+        remove_method method_name
       end
     end
 
-    # Remove the current method if it is a singleton method of the
-    # object being mocked.
-    def remove_current_method(method_name)
-      target_class_eval { remove_method(method_name) }
-    end
-
     # Have we been detached from the existing object?
     def detached?
       @obj.nil?
     end
 
-    # Generate a name to be used to alias the original behavior.
-    def new_name(old_name)
-      "flexmock_original_behavior_for_#{old_name}"
-    end
-
   end
 end