path: root/activesupport/lib/active_support/vendor/flexmock.rb

#!/usr/bin/env ruby

#---
# Copyright 2003, 2004, 2005, 2006 by Jim Weirich (jim@weirichhouse.org).
# 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 'test/unit'

######################################################################
# FlexMock is a flexible mock object suitable for using with Ruby's
# Test::Unit unit test framework.  FlexMock has a simple interface
# that's easy to remember, and leaves the hard stuff to all those
# other mock object implementations.
#
# Basic Usage:
#
#   m = FlexMock.new("name")
#   m.mock_handle(:meth) { |args| assert_stuff }
#
# Simplified Usage:
#
#   m = FlexMock.new("name")
#   m.should_receive(:upcase).with("stuff").
#     returns("STUFF")
#   m.should_receive(:downcase).with(String).
#     returns { |s| s.downcase }.once
#
# With Test::Unit Integration:
#
#   class TestSomething < Test::Unit::TestCase
#     include FlexMock::TestCase
#
#     def test_something
#       m = flexmock("name")
#       m.should_receive(:hi).and_return("Hello")
#       m.hi
#     end
#   end
#
# Note: When using Test::Unit integeration, don't forget to include
# FlexMock::TestCase.  Also, if you override +teardown+, make sure you
# call +super+.
#
class FlexMock
  include Test::Unit::Assertions

  class BadInterceptionError < RuntimeError; end

  attr_reader :mock_name, :mock_groups
  attr_accessor :mock_current_order

  # Create a FlexMock object with the given name.  The name is used in
  # error messages.
  def initialize(name="unknown")
    @mock_name = name
    @expectations = Hash.new
    @allocated_order = 0
    @mock_current_order = 0
    @mock_groups = {}
    @ignore_missing = false
    @verified = false
  end
  
  # Handle all messages denoted by +sym+ by calling the given block
  # and passing any parameters to the block.  If we know exactly how
  # many calls are to be made to a particular method, we may check
  # that by passing in the number of expected calls as a second
  # paramter.
  def mock_handle(sym, expected_count=nil, &block)
    self.should_receive(sym).times(expected_count).returns(&block)
  end

  # Verify that each method that had an explicit expected count was
  # actually called that many times.
  def mock_verify
    return if @verified
    @verified = true
    mock_wrap do
      @expectations.each do |sym, handler|
        handler.mock_verify
      end
    end
  end

  # Teardown and infrastructure setup for this mock.
  def mock_teardown
  end

  # Allocation a new order number from the mock.
  def mock_allocate_order
    @auto_allocate = true
    @allocated_order += 1
  end

  # Ignore all undefined (missing) method calls.
  def should_ignore_missing
    @ignore_missing = true
  end
  alias mock_ignore_missing should_ignore_missing

  # Handle missing methods by attempting to look up a handler.
  def method_missing(sym, *args, &block)
    mock_wrap do
      if handler = @expectations[sym]
        args << block  if block_given?
        handler.call(*args)
      else
        super(sym, *args, &block)  unless @ignore_missing
      end
    end
  end

  # Save the original definition of respond_to? for use a bit later.
  alias mock_respond_to? respond_to?

  # Override the built-in respond_to? to include the mocked methods.
  def respond_to?(sym)
    super || (@expectations[sym] ? true : @ignore_missing)
  end

  # Override the built-in +method+ to include the mocked methods.
  def method(sym)
    @expectations[sym] || super
  rescue NameError => ex
    if @ignore_missing
      proc { }
    else
      raise ex
    end
  end

  # Declare that the mock object should receive a message with the
  # given name.  An expectation object for the method name is returned
  # as the result of this method.  Further expectation constraints can
  # be added by chaining to the result.
  #
  # See Expectation for a list of declarators that can be used.
  def should_receive(sym)
    @expectations[sym] ||= ExpectationDirector.new(sym)
    result = Expectation.new(self, sym)
    @expectations[sym] << result
    override_existing_method(sym) if mock_respond_to?(sym)
    result
  end

  # Override the existing definition of method +sym+ in the mock.
  # Most methods depend on the method_missing trick to be invoked.
  # However, if the method already exists, it will not call
  # method_missing.  This method defines a singleton method on the
  # mock to explicitly invoke the method_missing logic.
  def override_existing_method(sym)
    sclass.class_eval "def #{sym}(*args, &block) method_missing(:#{sym}, *args, &block) end"
  end
  private :override_existing_method
  
  # Return the singleton class of the mock object.
  def sclass
    class << self; self; end
  end
  private :sclass

  # Declare that the mock object should expect methods by providing a
  # recorder for the methods and having the user invoke the expected
  # methods in a block.  Further expectations may be applied the
  # result of the recording call.
  #
  # Example Usage:
  #
  #   mock.should_expect do |record|
  #     record.add(Integer, 4) { |a, b|
  #       a + b
  #     }.at_least.once
  #
  def should_expect
    yield Recorder.new(self)
  end

  # Return a factory object that returns this mock.  This is useful in
  # Class Interception.
  def mock_factory
    Factory.new(self)
  end

  class << self
    include Test::Unit::Assertions

    # Class method to make sure that verify is called at the end of a
    # test.  One mock object will be created for each name given to
    # the use method.  The mocks will be passed to the block as
    # arguments.  If no names are given, then a single anonymous mock
    # object will be created.
    #
    # At the end of the use block, each mock object will be verified
    # to make sure the proper number of calls have been made.
    #
    # Usage:
    #
    #   FlexMock.use("name") do |mock|    # Creates a mock named "name"
    #     mock.should_receive(:meth).
    #       returns(0).once
    #   end                               # mock is verified here
    #
    # NOTE: If you include FlexMock::TestCase into your test case
    # file, you can create mocks that will be automatically verified in
    # the test teardown by using the +flexmock+ method. 
    #
    def use(*names)
      names = ["unknown"] if names.empty?
      got_excecption = false
      mocks = names.collect { |n| new(n) }
      yield(*mocks)
    rescue Exception => ex
      got_exception = true
      raise
    ensure
      mocks.each do |mock|
        mock.mock_verify     unless got_exception
      end
    end
    
    # Class method to format a method name and argument list as a nice
    # looking string.
    def format_args(sym, args)
      if args
        "#{sym}(#{args.collect { |a| a.inspect }.join(', ')})"
      else
        "#{sym}(*args)"
      end
    end
    
    # Check will assert the block returns true.  If it doesn't, an
    # assertion failure is triggered with the given message.
    def check(msg, &block)
      assert_block(msg, &block)
    end
  end

  private

  # Wrap a block of code so the any assertion errors are wrapped so
  # that the mock name is added to the error message .
  def mock_wrap(&block)
    yield
  rescue Test::Unit::AssertionFailedError => ex
    raise Test::Unit::AssertionFailedError, 
      "in mock '#{@mock_name}': #{ex.message}",
      ex.backtrace
  end

  ####################################################################
  # A Factory object is returned from a mock_factory method call.  The
  # factory merely returns the manufactured object it is initialized
  # with.  The factory is handy to use with class interception,
  # allowing the intercepted class to return the mock object.
  #
  # If the user needs more control over the mock factory, they are
  # free to create their own.
  #
  # Typical Usage:
  #    intercept(Bar).in(Foo).with(a_mock.mack_factory)
  #
  class Factory
    def initialize(manufactured_object)
      @obj = manufactured_object
    end
    def new(*args, &block)
      @obj
    end
  end

  ####################################################################
  # The expectation director is responsible for routing calls to the
  # correct expectations for a given argument list.
  #
  class ExpectationDirector

    # Create an ExpectationDirector for a mock object.
    def initialize(sym)
      @sym = sym
      @expectations = []
      @expected_order = nil
    end

    # Invoke the expectations for a given set of arguments.
    #
    # First, look for an expectation that matches the arguements and
    # is eligible to be called.  Failing that, look for a expectation
    # that matches the arguments (at this point it will be ineligible,
    # 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)
      exp = @expectations.find { |e| e.match_args(args) && e.eligible? } ||
        @expectations.find { |e| e.match_args(args) } ||
        @expectations.find { |e| e.expected_args.nil? }
      FlexMock.check("no matching handler found for " +
        FlexMock.format_args(@sym, args)) { ! exp.nil? }
      exp.verify_call(*args)
    end

    # Same as call.
    def [](*args)
      call(*args)
    end

    # Append an expectation to this director.
    def <<(expectation)
      @expectations << expectation
    end

    # Do the post test verification for this directory.  Check all the
    # expectations.
    def mock_verify
      @expectations.each do |exp|
        exp.mock_verify
      end
    end
  end

  ####################################################################
  # Match any object
  class AnyMatcher
    def ===(target)
      true
    end
    def inspect
      "ANY"
    end
  end
  
  ####################################################################
  # Match only things that are equal.
  class EqualMatcher
    def initialize(obj)
      @obj = obj
    end
    def ===(target)
      @obj == target
    end
    def inspect
      "==(#{@obj.inspect})"
    end
  end
  
  ANY = AnyMatcher.new

  ####################################################################
  # Match only things where the block evaluates to true.
  class ProcMatcher
    def initialize(&block)
      @block = block
    end
    def ===(target)
      @block.call(target)
    end
    def inspect
      "on{...}"
    end
  end

  ####################################################################
  # Include this module in your test class if you wish to use the +eq+
  # and +any+ argument matching methods without a prefix.  (Otherwise
  # use <tt>FlexMock.any</tt> and <tt>FlexMock.eq(obj)</tt>.
  #
  module ArgumentTypes
    # Return an argument matcher that matches any argument.
    def any
      ANY
    end

    # Return an argument matcher that only matches things equal to
    # (==) the given object.
    def eq(obj)
      EqualMatcher.new(obj)
    end

    # Return an argument matcher that matches any object, that when
    # passed to the supplied block, will cause the block to return
    # true.
    def on(&block)
      ProcMatcher.new(&block)
    end
  end
  extend ArgumentTypes

  ####################################################################
  # Base class for all the count validators.
  #
  class CountValidator
    include Test::Unit::Assertions
    def initialize(expectation, limit)
      @exp = expectation
      @limit = limit
    end

    # If the expectation has been called +n+ times, is it still
    # eligible to be called again?  The default answer compares n to
    # the established limit.
    def eligible?(n)
      n < @limit
    end
  end

  ####################################################################
  # Validator for exact call counts.
  #
  class ExactCountValidator < CountValidator
    # Validate that the method expectation was called exactly +n+
    # times.
    def validate(n)
      assert_equal @limit, n, 
        "method '#{@exp}' called incorrect number of times"
    end
  end

  ####################################################################
  # Validator for call counts greater than or equal to a limit.
  #
  class AtLeastCountValidator < CountValidator
    # Validate the method expectation was called no more than +n+
    # times.
    def validate(n)
      assert n >= @limit,
        "Method '#{@exp}' should be called at least #{@limit} times,\n" +
        "only called #{n} times"
    end

    # If the expectation has been called +n+ times, is it still
    # eligible to be called again?  Since this validator only
    # establishes a lower limit, not an upper limit, then the answer
    # is always true.
    def eligible?(n)
      true
    end
  end

  ####################################################################
  # Validator for call counts less than or equal to a limit.
  #
  class AtMostCountValidator < CountValidator
    # Validate the method expectation was called at least +n+ times.
    def validate(n)
      assert n <= @limit,
        "Method '#{@exp}' should be called at most #{@limit} times,\n" +
        "only called #{n} times"
    end
  end

  ####################################################################
  # An Expectation is returned from each +should_receive+ message sent
  # to mock object.  Each expectation records how a message matching
  # the message name (argument to +should_receive+) and the argument
  # list (given by +with+) should behave.  Mock expectations can be
  # recorded by chaining the declaration methods defined in this
  # class.
  #
  # For example:
  #
  #   mock.should_receive(:meth).with(args).and_returns(result)
  #
  class Expectation
    include Test::Unit::Assertions

    attr_reader :expected_args, :mock, :order_number

    # Create an expectation for a method named +sym+.
    def initialize(mock, sym)
      @mock = mock
      @sym = sym
      @expected_args = nil
      @count_validators = []
      @count_validator_class = ExactCountValidator
      @actual_count = 0
      @return_value = nil
      @return_block = lambda { @return_value }
      @order_number = nil
    end

    def to_s
      FlexMock.format_args(@sym, @expected_args)
    end

    # Verify the current call with the given arguments matches the
    # expectations recorded in this object.
    def verify_call(*args)
      validate_order
      @actual_count += 1
      @return_block.call(*args)
    end

    # Is this expectation eligible to be called again?  It is eligible
    # only if all of its count validators agree that it is eligible.
    def eligible?
      @count_validators.all? { |v| v.eligible?(@actual_count) }
    end

    # Validate that the order 
    def validate_order
      return if @order_number.nil?
      FlexMock.check("method #{to_s} called out of order " +
        "(expected order #{@order_number}, was #{@mock.mock_current_order})") {
        @order_number >= @mock.mock_current_order
      }
      @mock.mock_current_order = @order_number
    end
    private :validate_order

    # Validate the correct number of calls have been made.  Called by
    # the teardown process.
    def mock_verify
      @count_validators.each do |v|
        v.validate(@actual_count)
      end
    end

    # Does the argument list match this expectation's argument
    # specification.
    def match_args(args)
      return false if @expected_args.nil?
      return false if args.size != @expected_args.size
      (0...args.size).all? { |i| match_arg(@expected_args[i], args[i]) }
    end

    # Does the expected argument match the corresponding actual value.
    def match_arg(expected, actual)
      expected === actual ||
        expected == actual ||
        ( Regexp === expected && expected === actual.to_s )
    end

    # Declare that the method should expect the given argument list.
    def with(*args)
      @expected_args = args
      self
    end

    # Declare that the method should be called with no arguments.
    def with_no_args
      with
    end

    # Declare that the method can be called with any number of
    # arguments of any type.
    def with_any_args
      @expected_args = nil
      self
    end

    # Declare that the method returns a particular value (when the
    # argument list is matched).
    #
    # * If a single value is given, it will be returned for all matching
    #   calls.
    # * If multiple values are given, each value will be returned in turn for 
    #   each successive call.  If the number of matching calls is greater
    #   than the number of values, the last value will be returned for 
    #   the extra matching calls.
    # * If a block is given, it is evaluated on each call and its 
    #   value is returned.  
    # 
    # For example:
    # 
    #  mock.should_receive(:f).returns(12)   # returns 12
    #
    #  mock.should_receive(:f).with(String). # returns an
    #    returns { |str| str.upcase }        # upcased string
    #
    # +and_return+ is an alias for +returns+.
    #
    def returns(*args, &block)
      @return_block = block_given? ? 
        block : 
        lambda { args.size == 1 ? args.first : args.shift }
      self
    end
    alias :and_return :returns  # :nodoc:

    # Declare that the method may be called any number of times.
    def zero_or_more_times
      at_least.never
    end

    # Declare that the method is called +limit+ times with the
    # declared argument list.  This may be modified by the +at_least+
    # and +at_most+ declarators.
    def times(limit)
      @count_validators << @count_validator_class.new(self, limit) unless limit.nil?
      @count_validator_class = ExactCountValidator
      self
    end

    # Declare that the method is never expected to be called with the
    # given argument list.  This may be modified by the +at_least+ and
    # +at_most+ declarators.
    def never
      times(0)
    end

    # Declare that the method is expected to be called exactly once
    # with the given argument list.  This may be modified by the
    # +at_least+ and +at_most+ declarators.
    def once
      times(1)
    end

    # Declare that the method is expected to be called exactly twice
    # with the given argument list.  This may be modified by the
    # +at_least+ and +at_most+ declarators.
    def twice
      times(2)
    end

    # Modifies the next call count declarator (+times+, +never+,
    # +once+ or +twice+) so that the declarator means the method is
    # called at least that many times.
    #
    # E.g. method f must be called at least twice:
    #
    #   mock.should_receive(:f).at_least.twice
    #
    def at_least
      @count_validator_class = AtLeastCountValidator
      self
    end

    # Modifies the next call count declarator (+times+, +never+,
    # +once+ or +twice+) so that the declarator means the method is
    # called at most that many times.
    #
    # E.g. method f must be called no more than twice
    #
    #   mock.should_receive(:f).at_most.twice
    #
    def at_most
      @count_validator_class = AtMostCountValidator
      self
    end

    # Declare that the given method must be called in order.  All
    # ordered method calls must be received in the order specified by
    # the ordering of the +should_receive+ messages.  Receiving a
    # methods out of the specified order will cause a test failure.
    #
    # If the user needs more fine control over ordering
    # (e.g. specifying that a group of messages may be received in any
    # order as long as they all come after another group of messages),
    # a _group_ _name_ may be specified in the +ordered+ calls.  All
    # messages within the same group may be received in any order.
    #
    # For example, in the following, messages +flip+ and +flop+ may be
    # received in any order (because they are in the same group), but
    # must occur strictly after +start+ but before +end+.  The message
    # +any_time+ may be received at any time because it is not
    # ordered.
    #
    #    m = FlexMock.new
    #    m.should_receive(:any_time)
    #    m.should_receive(:start).ordered
    #    m.should_receive(:flip).ordered(:flip_flop_group)
    #    m.should_receive(:flop).ordered(:flip_flop_group)
    #    m.should_receive(:end).ordered
    #
    def ordered(group_name=nil)
      if group_name.nil?
        @order_number = @mock.mock_allocate_order
      elsif (num = @mock.mock_groups[group_name])
        @order_number = num
      else
        @order_number = @mock.mock_allocate_order
        @mock.mock_groups[group_name] = @order_number
      end
      self
    end
  end

  ####################################################################
  # Translate arbitrary method calls into expectations on the given
  # mock object.
  #
  class Recorder
    include FlexMock::ArgumentTypes

    # Create a method recorder for the mock +mock+.
    def initialize(mock)
      @mock = mock
      @strict = false
    end

    # Place the record in strict mode.  While recording expectations
    # in strict mode, the following will be true.
    #
    # * All expectations will be expected in the order they were
    #   recorded.
    # * All expectations will be expected once.
    # * All arguments will be placed in exact match mode,
    #   including regular expressions and class objects.
    #
    # Strict mode is usually used when giving the recorder to a known
    # good algorithm.  Strict mode captures the exact sequence of
    # calls and validate that the code under test performs the exact
    # same sequence of calls.
    #
    # The recorder may exit strict mode via a
    # <tt>should_be_strict(false)</tt> call.  Non-strict expectations
    # may be recorded at that point, or even explicit expectations
    # (using +should_receieve+) can be specified.
    #
    def should_be_strict(is_strict=true)
      @strict = is_strict
    end

    # Is the recorder in strict mode?
    def strict?
      @strict
    end

    # Record an expectation for receiving the method +sym+ with the
    # given arguments.
    def method_missing(sym, *args, &block)
      expectation = @mock.should_receive(sym).and_return(&block)
      if @strict
        args = args.collect { |arg| eq(arg) }
        expectation.with(*args).ordered.once
      else
        expectation.with(*args)
      end
      expectation
    end
  end
  
  ####################################################################
  # Test::Unit::TestCase Integration.
  #
  # Include this module in any TestCase class in a Test::Unit test
  # suite to get integration with FlexMock.  When this module is
  # included, mocks may be created with a simple call to the
  # +flexmock+ method.  Mocks created with via the method call will
  # automatically be verified in the teardown of the test case.
  #
  # <b>Note:</b> If you define a +teardown+ method in the test case,
  # <em>dont' forget to invoke the +super+ method!</em> Failure to
  # invoke super will cause all mocks to not be verified.
  #
  module TestCase
    include ArgumentTypes

    # Teardown the test case, verifying any mocks that might have been
    # defined in this test case.
    def teardown
      super
      flexmock_teardown
    end
    
    # Do the flexmock specific teardown stuff.
    def flexmock_teardown
      @flexmock_created_mocks ||= []
      if passed?
        @flexmock_created_mocks.each do |m|
          m.mock_verify
        end
      end
    ensure
      @flexmock_created_mocks.each do |m|
        m.mock_teardown
      end
      @flexmock_interceptors ||= []
      @flexmock_interceptors.each do |i|
        i.restore
      end
    end

    # Create a FlexMock object with the given name.  Mocks created
    # with this method will be automatically verify during teardown
    # (assuming the the flexmock teardown isn't overridden).
    #
    # If a block is given, then the mock object is passed to the block and
    # may be configured in the block.
    def flexmock(name="unknown")
      mock = FlexMock.new(name)
      yield(mock) if block_given?
      flexmock_remember(mock)
      mock
    end
    
    # Stub the given object by overriding the behavior of individual methods.
    # The stub object returned will respond to the +should_receive+ 
    # method, just like normal stubs.  Singleton methods cannot be 
    # stubbed.
    #
    # Example:  Stub out DBI to return a fake db connection.
    #
    #   flexstub(DBI).should_receive(:connect).and_return {
    #     fake_db = flexmock("db connection")
    #     fake_db.should_receive(:select_all).and_return(...)
    #     fake_db
    #   }
    #
    def flexstub(obj, name=nil)
      name ||= "flexstub(#{obj.class.to_s})"
      obj.instance_eval {
        @flexmock_proxy ||= StubProxy.new(obj, FlexMock.new(name))
      }
      flexmock_remember(obj.instance_variable_get("@flexmock_proxy"))
    end
    
    # Intercept the named class in the target class for the duration
    # of the test.  Class interception is very simple-minded and has a
    # number of restrictions.  First, the intercepted class must be
    # reference in the tested class via a simple constant name
    # (e.g. no scoped names using "::") that is not directly defined
    # in the class itself.  After the test, a proxy class constant
    # will be left behind that will forward all calls to the original
    # class.
    #
    # Usage:
    #   intercept(SomeClass).in(ClassBeingTested).with(MockClass)
    #   intercept(SomeClass).with(MockClass).in(ClassBeingTested)
    #
    def intercept(intercepted_class)
      result = Interception.new(intercepted_class)
      @flexmock_interceptors ||= []
      @flexmock_interceptors << result
      result
    end
    
    private
    
    def flexmock_remember(mocking_object)
      @flexmock_created_mocks ||= []
      @flexmock_created_mocks << mocking_object
      mocking_object
    end
  end

  ####################################################################
  # A Class Interception defines a constant in the target class to be
  # a proxy that points to a replacement class for the duration of a
  # test.  When an interception is restored, the proxy will point to
  # the original intercepted class.
  #
  class Interception
    # Create an interception object with the class to intercepted.
    def initialize(intercepted_class)
      @intercepted = nil
      @target  = nil
      @replacement = nil
      @proxy = nil
      intercept(intercepted_class)
      update
    end

    # Intercept this class in the class to be tested.
    def intercept(intercepted_class)
      @intercepted = intercepted_class
      update
      self
    end
    
    # Define the class number test that will receive the
    # interceptioned definition.
    def in(target_class)
      @target = target_class
      update
      self
    end

    # Define the replacement class.  This is normally a proxy or a
    # stub.
    def with(replacement_class)
      @replacement = replacement_class
      update
      self
    end

    # Restore the original class.  The proxy remains in place however.
    def restore
      @proxy.proxied_class = @restore_class if @proxy
    end
    
    private
    
    # Update the interception if the definition is complete.
    def update
      if complete?
        do_interception
      end
    end
      
    # Is the interception definition complete.  In other words, are
    # all three actors defined?
    def complete?
      @intercepted && @target && @replacement
    end

    # Implement interception on the classes defined.
    def do_interception
      @target_class = coerce_class(@target, "target")
      @replacement_class = coerce_class(@replacement, "replacement")
      case @intercepted
      when String, Symbol
        @intercepted_name = @intercepted.to_s
      when Class
        @intercepted_name = @intercepted.name
      end
      @intercepted_class = coerce_class(@intercepted, "intercepted")
      current_class = @target_class.const_get(@intercepted_name)
      if ClassProxy === current_class
        @proxy = current_class
        @restore_class = @proxy.proxied_class
        @proxy.proxied_class = @replacement_class
      else
        @proxy = ClassProxy.new(@replacement_class)
        @restore_class = current_class
        @target_class.const_set(@intercepted_name, @proxy)
      end
    end

    # Coerce a class object, string to symbol to be the class object.
    def coerce_class(klass, where)
      case klass
      when String, Symbol
        lookup_const(klass.to_s, where)
      else
        klass
      end
    end

    def lookup_const(name, where, target=Object)
      begin
        target.const_get(name)
      rescue NameError
        raise BadInterceptionError, "in #{where} class #{name}"
      end
    end
  end

  ####################################################################
  # Class Proxy for class interception.  Forward all method calls to
  # whatever is the proxied_class.
  #
  class ClassProxy
    attr_accessor :proxied_class
    def initialize(default_class)
      @proxied_class = default_class
    end
    def method_missing(sym, *args, &block)
      @proxied_class.__send__(sym, *args, &block)
    end
  end
  
  ####################################################################
  # StubProxy 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_mock</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, StubProxy
  # will erase the mocking infrastructure from the object being 
  # stubbed (e.g. remove instance variables and mock singleton 
  # methods).
  #
  class StubProxy
    attr_reader :mock
    
    def initialize(obj, mock)
      @obj = obj
      @mock = mock
      @method_definitions = {}
      @methods_proxied = []
    end
    
    # Stub out the given method in the existing object and then let the 
    # mock object handle should_receive.
    def should_receive(method_name)
      method_name = method_name.to_sym
      unless @methods_proxied.include?(method_name)
        hide_existing_method(method_name)
        @methods_proxied << method_name
      end
      @mock.should_receive(method_name)
    end
    
    # Verify that the mock has been properly called.  After verification, 
    # detach the mocking infrastructure from the existing object.
    def mock_verify
      @mock.mock_verify
    end

    # Remove all traces of the mocking framework from the existing object.
    def mock_teardown
      if ! detached?
        @methods_proxied.each do |method_name|
          remove_current_method(method_name)
          restore_original_definition(method_name)
        end
        @obj.instance_variable_set("@flexmock_proxy", nil)
        @obj = nil
      end
    end

    private

    # The singleton class of the object.
    def sclass
      class << @obj; self; end
    end

    # Is the current method a singleton method in the object we are
    # mocking?
    def singleton?(method_name)
      @obj.methods(false).include?(method_name.to_s)
    end

    # Hide the existing method definition with a singleton defintion
    # that proxies to our mock object.  If the current definition is a
    # singleton, we need to record the definition and remove it before
    # creating our own singleton method.  If the current definition is
    # not a singleton, all we need to do is override it with our own
    # singleton.
    def hide_existing_method(method_name)
      if singleton?(method_name)
        @method_definitions[method_name] = @obj.method(method_name)
        remove_current_method(method_name)
      end
      define_proxy_method(method_name)
    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)
      sclass.class_eval %{
        def #{method_name}(*args, &block)
          @flexmock_proxy.mock.#{method_name}(*args, &block)
        end  
      }
    end

    # Restore the original singleton defintion for method_name that
    # was saved earlier.
    def restore_original_definition(method_name)
      method_def = @method_definitions[method_name]
      if method_def
        sclass.class_eval {
          define_method(method_name, &method_def)
        }
      end
    end

    # 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) }
    end

    # Have we been detached from the existing object?
    def detached?
      @obj.nil?
    end
    
  end
end