flexmock 1.3.2 → 1.3.3

data/lib/flexmock/mock_container.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003-2012 by Jim Weirich (jim.weirich@gmail.com).
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -12,10 +12,11 @@
 require 'flexmock/noop'
 require 'flexmock/argument_types'
 require 'flexmock/ordering'
+require 'flexmock/mock_builder'
 
 class FlexMock
 
-  # ######################################################################
+
   # Mock container methods
   #
   # Include this module in to get integration with FlexMock.  When this module
@@ -116,60 +117,10 @@ class FlexMock
     #   for a partial mock, flexmock will return the domain object rather than
     #   the mock object.
     #
-    def flexmock(*args)
+    def flexmock(*args, &block)
       location = caller.first
-      name = nil
-      quick_defs = {}
-      domain_obj = nil
-      safe_mode = false
-      model_class = nil
-      base_class = nil
-      mock = nil
-      while ! args.empty?
-        case args.first
-        when :base, :safe
-          safe_mode = (args.shift == :safe)
-          domain_obj = args.shift
-        when :model
-          args.shift
-          model_class = args.shift
-        when :on
-          args.shift
-          base_class = args.shift
-          name ||= "#{base_class} Mock"
-        when String, Symbol
-          name = args.shift.to_s
-        when Hash
-          quick_defs = args.shift
-        when FlexMock
-          mock = args.shift
-        else
-          domain_obj = args.shift
-        end
-      end
-      raise UsageError, "a block is required in safe mode" if safe_mode && ! block_given?
-
-      if domain_obj
-        mock = ContainerHelper.make_partial_proxy(self, domain_obj, name, safe_mode)
-        result = domain_obj
-      elsif model_class
-        id = ContainerHelper.next_id
-        mock ||= FlexMock.new("#{model_class}_#{id}", self)
-        result = mock
-      else
-        mock ||= FlexMock.new(name || "unknown", self)
-        result = mock
-      end
-      if base_class
-        mock.flexmock_based_on(base_class)
-      elsif domain_obj && FlexMock.partials_are_based
-        mock.flexmock_based_on(domain_obj.class)
-      end
-      mock.flexmock_define_expectation(location, quick_defs)
-      yield(mock) if block_given?
-      flexmock_remember(mock)
-      ContainerHelper.add_model_methods(mock, model_class, id, location) if model_class
-      result
+      @flexmock_worker ||= MockBuilder.new(self)
+      @flexmock_worker.define_a_mock(location, *args, &block)
     end
     alias flexstub flexmock
 
@@ -187,171 +138,19 @@ class FlexMock
     # indicate the test isn't over yet.  From our point of view we are
     # only interested if the test has actually failed, so we wrap the
     # raw call to passed? and handle accordingly.
-    def flexmock_test_has_failed?
+    def flexmock_test_has_failed? # :nodoc:
       passed? == false
     end
   end
 
-  # #################################################################
-  # Helper methods for mock containers.  MockContainer is a module
-  # that is designed to be mixed into other classes, particularly
-  # testing framework test cases.  Since we don't want to pollute the
-  # method namespace of the class that mixes in MockContainer, a
-  # number of MockContainer methods were moved into ContainerHelper to
-  # to isoloate the names.
-  #
-  class MockContainerHelper
-    include FlexMock::ArgumentTypes
-
-    # Return the next id for mocked models.
-    def next_id
-      @id_counter ||= 10000
-      @id_counter += 1
-    end
-
-    # :call-seq:
-    #   parse_should_args(args) { |symbol| ... }
-    #
-    # This method provides common handling for the various should_receive
-    # argument lists. It sorts out the differences between symbols, arrays and
-    # 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:
-      result = CompositeExpectation.new
-      args.each do |arg|
-        case arg
-        when Hash
-          arg.each do |k,v|
-            exp = build_demeter_chain(mock, k, &block).and_return(v)
-            result.add(exp)
-          end
-        when Symbol, String
-          result.add(build_demeter_chain(mock, arg, &block))
-        end
-      end
-      result
-    end
-
-    # Automatically add mocks for some common methods in ActiveRecord
-    # models.
-    def add_model_methods(mock, model_class, id, location)
-      container = mock.flexmock_container
-
-      mock_errors = container.flexmock("errors")
-      mock_errors.flexmock_define_expectation(location, :count).and_return(0).by_default
-      mock_errors.flexmock_define_expectation(location, :full_messages).and_return([]).by_default
-
-      mock.flexmock_define_expectation(location, :id).and_return(id).by_default
-      mock.flexmock_define_expectation(location, :to_params).and_return(id.to_s).by_default
-      mock.flexmock_define_expectation(location, :new_record?).and_return(false).by_default
-      mock.flexmock_define_expectation(location, :class).and_return(model_class).by_default
-      mock.flexmock_define_expectation(location, :errors).and_return(mock_errors).by_default
-
-      # HACK: Ruby 1.9 needs the following lambda so that model_class
-      # is correctly bound below.
-      lambda { }
-      mock.flexmock_define_expectation(location, :is_a?).with(any).and_return { |other|
-        other == model_class
-      }.by_default
-      mock.flexmock_define_expectation(location, :instance_of?).with(any).and_return { |other|
-        other == model_class
-      }.by_default
-      mock.flexmock_define_expectation(location, :kind_of?).with(any).and_return { |other|
-        model_class.ancestors.include?(other)
-      }.by_default
-    end
-
-    # Create a PartialMockProxy for the given object.  Use +name+ as
-    # the name of the mock object.
-    def make_partial_proxy(container, obj, name, safe_mode)
-      name ||= "flexmock(#{obj.class.to_s})"
-      if !obj.instance_variable_defined?("@flexmock_proxy") || obj.instance_variable_get("@flexmock_proxy").nil?
-        mock = FlexMock.new(name, container)
-        proxy = PartialMockProxy.new(obj, mock, safe_mode)
-        obj.instance_variable_set("@flexmock_proxy", proxy)
-      end
-      obj.instance_variable_get("@flexmock_proxy")
+  class ExtensionRegistry
+    def add_extension(extension)
+      extensions << extension
     end
-
-    private
-
-    # Build the chain of mocks for demeter style mocking.
-    #
-    # Warning: Nasty code ahead.
-    #
-    # This method builds a chain of mocks to support demeter style
-    # mocking.  Given a mock chain of "first.second.third.last", we
-    # must build a chain of mock methods that return the next mock in
-    # the chain.  The expectation for the last method of the chain is
-    # returned as the result of the method.
-    #
-    # Things to consider:
-    #
-    # (1) The expectation for the "first" method must be created by
-    # the proper mechanism, which is supplied by the block parameter
-    # "block".  In other words, first expectation is created by
-    # calling the block.  (This allows us to create expectations on
-    # both pure mocks and partial mocks, with the block handling the
-    # details).
-    #
-    # (2) Although the first mock is arbitrary, the remaining mocks in
-    # the chain will always be pure mocks created specifically for
-    # this purpose.
-    #
-    # (3) The expectations for all methods but the last in the chain
-    # will be setup to expect no parameters and to return the next
-    # mock in the chain.
-    #
-    # (4) It could very well be the case that several demeter chains
-    # will be defined on a single mock object, and those chains could
-    # share some of the same methods (e.g. "mock.one.two.read" and
-    # "mock.one.two.write" both share the methods "one" and "two").
-    # It is important that the shared methods return the same mocks in
-    # both chains.
-    #
-    def build_demeter_chain(mock, arg, &block)
-      container = mock.flexmock_container
-      names = arg.to_s.split('.')
-      check_method_names(names)
-      exp = nil
-      next_exp = lambda { |n| block.call(n) }
-      loop do
-        method_name = names.shift.to_sym
-        exp = mock.flexmock_find_expectation(method_name)
-        need_new_exp = exp.nil? || names.empty?
-        exp = next_exp.call(method_name) if need_new_exp
-        break if names.empty?
-        if need_new_exp
-          mock = container.flexmock("demeter_#{method_name}")
-          exp.with_no_args.and_return(mock)
-        else
-          mock = exp._return_value([])
-        end
-        check_proper_mock(mock, method_name)
-        next_exp = lambda { |n| mock.should_receive(n) }
-      end
-      exp
-    end
-
-    # Check that the given mock is a real FlexMock mock.
-    def check_proper_mock(mock, method_name)
-      unless mock.kind_of?(FlexMock)
-        fail FlexMock::UsageError,
-          "Conflicting mock declaration for '#{method_name}' in demeter style mock"
-      end
-    end
-
-    METHOD_NAME_RE = /^([A-Za-z_][A-Za-z0-9_]*[=!?]?|\[\]=?||\*\*|<<|>>|<=>|[<>=!]=|[=!]~|===|[-+]@|[-+\*\/%&^|<>~`!])$/
-
-    # Check that all the names in the list are valid method names.
-    def check_method_names(names)
-      names.each do |name|
-        fail FlexMock::UsageError, "Ill-formed method name '#{name}'" if
-          name !~ METHOD_NAME_RE
-      end
+    def extensions
+      @extensions ||= []
     end
   end
 
-  ContainerHelper = MockContainerHelper.new
+  CONTAINER_HELPER = ExtensionRegistry.new
 end

data/lib/flexmock/noop.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003-2012 by Jim Weirich (jim.weirich@gmail.com).
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,

data/lib/flexmock/ordering.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003-2012 by Jim Weirich (jim.weirich@gmail.com).
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -11,7 +11,6 @@
 
 class FlexMock
 
-  # #################################################################
   # The ordering module contains the methods and data structures used
   # to determine proper orderring of mocked calls.  By providing the
   # functionality in a module, a individual mock object can order its

data/lib/flexmock/partial_mock.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003-2012 by Jim Weirich (jim.weirich@gmail.com).
+# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -10,24 +10,41 @@
 #+++
 
 require 'flexmock/noop'
+require 'flexmock/expectation_builder'
 
 class FlexMock
 
-  # #########################################################################
   # PartialMockProxy is used to mate the mock framework to an existing
-  # object.  The object is "enhanced" with a reference to a mock
-  # object (stored in <tt>@flexmock_proxy</tt>).  When the
-  # +should_receive+ method is sent to the proxy, it overrides the
-  # existing object's method by creating singleton method that
-  # forwards to the mock.  When testing is complete, PartialMockProxy
-  # will erase the mocking infrastructure from the object being mocked
-  # (e.g.  remove instance variables and mock singleton methods).
+  # object. The object is "enhanced" with a reference to a mock object
+  # (stored in <tt>@flexmock_proxy</tt>). When the +should_receive+
+  # method is sent to the proxy, it overrides the existing object's
+  # method by creating singleton method that forwards to the mock.
+  # When testing is complete, PartialMockProxy will erase the mocking
+  # infrastructure from the object being mocked (e.g. remove instance
+  # variables and mock singleton methods).
   #
   class PartialMockProxy
     include Ordering
 
     attr_reader :mock
 
+    # 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)
+      end
+      obj.instance_variable_get("@flexmock_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")
+    end
+
     # The following methods are added to partial mocks so that they
     # can act like a mock.
 
@@ -35,7 +52,7 @@ class FlexMock
       :should_receive, :new_instances,
       :should_receive_with_location,
       :flexmock_get,   :flexmock_teardown, :flexmock_verify,
-      :flexmock_received?, :flexmock_calls,
+      :flexmock_received?, :flexmock_calls, :flexmock_find_expectation
     ]
 
     # Initialize a PartialMockProxy object.
@@ -85,25 +102,27 @@ class FlexMock
     end
 
     def flexmock_define_expectation(location, *args)
-      ContainerHelper.parse_should_args(@mock, args) do |sym|
-        unless @methods_proxied.include?(sym)
-          hide_existing_method(sym)
+      EXP_BUILDER.parse_should_args(self, args) do |method_name|
+        unless @methods_proxied.include?(method_name)
+          hide_existing_method(method_name)
         end
-        ex = @mock.flexmock_define_expectation(location, sym)
+        ex = @mock.flexmock_define_expectation(location, method_name)
         ex.mock = self
         ex
       end
     end
 
+    def flexmock_find_expectation(*args)
+      @mock.flexmock_find_expectation(*args)
+    end
+
     def add_mock_method(method_name)
       stow_existing_definition(method_name)
-      sclass.module_eval do
+      target_class_eval do
         define_method(method_name) { |*args, &block|
-          proxy = instance_variable_get("@flexmock_proxy")
-          if proxy.nil?
+          proxy = instance_variable_get("@flexmock_proxy") or
             fail "Missing FlexMock proxy " +
-              "(for method_name=#{method_name.inspect}, self=\#{self})"
-          end
+                 "(for method_name=#{method_name.inspect}, self=\#{self})"
           proxy.send(method_name, *args, &block)
         }
       end
@@ -128,39 +147,43 @@ class FlexMock
     #    flexmock(ClassName).new_instances(:make).should_receive(...)
     #
     def new_instances(*allocators, &block)
-      fail ArgumentError, "new_instances requires a Class to stub" unless Class === @obj
+      fail ArgumentError, "new_instances requires a Class to stub" unless
+        Class === @obj
       location = caller.first
       allocators = [:new] if allocators.empty?
-      result = ExpectationRecorder.new
+      expectation_recorder = ExpectationRecorder.new
       allocators.each do |allocate_method|
         check_allocate_method(allocate_method)
-        # HACK: Without the following lambda, Some versions of Ruby 1.9
-        #       would not bind the allocate_method parameter
-        #       correctly. I don't think it is necessary for recent
-        #       versions.
-        lambda { }
-        self.flexmock_define_expectation(location, allocate_method).and_return { |*args|
-          new_obj = invoke_original(allocate_method, args)
-          mock = flexmock_container.flexmock(new_obj)
-          block.call(mock) if block_given?
-          result.apply(mock)
-          new_obj
+        flexmock_define_expectation(location, allocate_method).and_return { |*args|
+          create_new_mocked_object(
+            allocate_method, args, expectation_recorder, block)
         }
       end
-      result
+      expectation_recorder
+    end
+
+    # Create a new mocked object.
+    #
+    # The mocked object is created using the following steps:
+    # (1) Allocate with the original allocation method (and args)
+    # (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)
+      mock = flexmock_container.flexmock(new_obj)
+      block.call(mock) unless block.nil?
+      recorder.apply(mock)
+      new_obj
     end
+    private :create_new_mocked_object
 
     # Invoke the original definition of method on the object supported by
     # the stub.
-    def invoke_original(method, args)
+    def flexmock_invoke_original(method, args)
       method_proc = @method_definitions[method]
       method_proc.call(*args)
     end
-    private :invoke_original
-
-    def flexmock_invoke_original(method, args)
-      invoke_original(method, args)
-    end
 
     # Verify that the mock has been properly called.  After verification,
     # detach the mocking infrastructure from the existing object.
@@ -214,15 +237,22 @@ class FlexMock
 
     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"
+        fail UsageError,
+          "Cannot mock the allocation method using new_instances in Ruby 1.9"
       end
     end
 
     # The singleton class of the object.
-    def sclass
+    def target_singleton_class
       class << @obj; self; end
     end
 
+    # 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)
+    end
+
     def singleton?(method_name)
       @obj.flexmock_singleton_defined?(method_name)
     end
@@ -244,19 +274,25 @@ class FlexMock
       @methods_proxied << method_name
       new_alias = create_alias_for_existing_method(method_name)
       if new_alias
-        my_object = @obj
-        @method_definitions[method_name] = Proc.new { |*args|
-          block = nil
-          if Proc === args.last
-            block = args.last
-            args = args[0...-1]
-          end
-          my_object.send(new_alias, *args, &block)
-        }
+        @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.
@@ -273,7 +309,7 @@ class FlexMock
     # meta-programming, so we provide for the case that the
     # method_name does not exist.
     def safe_alias_method(new_alias, method_name)
-      sclass.class_eval do
+      target_class_eval do
         begin
           alias_method(new_alias, method_name)
         rescue NameError
@@ -288,16 +324,18 @@ class FlexMock
     def define_proxy_method(method_name)
       if method_name.to_s =~ /=$/
         eval_line = __LINE__ + 1
-        sclass.class_eval %{
+        target_class_eval %{
           def #{method_name}(*args, &block)
-            instance_variable_get('@flexmock_proxy').mock.__send__(:#{method_name}, *args, &block)
+            instance_variable_get('@flexmock_proxy').
+              mock.__send__(:#{method_name}, *args, &block)
           end
         }, __FILE__, eval_line
       else
         eval_line = __LINE__ + 1
-        sclass.class_eval %{
+        target_class_eval %{
           def #{method_name}(*args, &block)
-            instance_variable_get('@flexmock_proxy').mock.#{method_name}(*args, &block)
+            instance_variable_get('@flexmock_proxy').
+              mock.#{method_name}(*args, &block)
           end
         }, __FILE__, eval_line
         _ = true       # make rcov recognize the above eval is covered
@@ -311,7 +349,7 @@ class FlexMock
         method_def = @method_definitions[method_name]
         if method_def
           the_alias = new_name(method_name)
-          sclass.class_eval do
+          target_class_eval do
             alias_method(method_name, the_alias)
           end
         end
@@ -324,7 +362,7 @@ class FlexMock
     # Remove the current method if it is a singleton method of the
     # object being mocked.
     def remove_current_method(method_name)
-      sclass.class_eval { remove_method(method_name) }
+      target_class_eval { remove_method(method_name) }
     end
 
     # Have we been detached from the existing object?