flexmock 0.5.1 → 0.6.0

data/lib/flexmock.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003, 2004, 2005, 2006 by Jim Weirich (jim@weirichhouse.org).
+# Copyright 2003, 2004, 2005, 2006, 2007 by Jim Weirich (jim@weirichhouse.org).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -9,1162 +9,5 @@
 # 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").
-#     and_return("STUFF")
-#   m.should_receive(:downcase).with(String).
-#     and_return { |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, :mock_container
-
-  # 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_container = nil
-    @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 <<-EOS
-      def #{sym}(*args, &block)
-        method_missing(:#{sym}, *args, &block)
-      end
-    EOS
-  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) }
-      FlexMock.check("no matching handler found for " +
-        FlexMock.format_args(@sym, args)) { ! exp.nil? }
-      exp.verify_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)
-      # TODO: Rethink this:
-      # return false if @expected_args.nil?
-      return true 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 = 
-        if block_given? 
-           block
-        else
-          lambda { args.size == 1 ? args.first : args.shift }
-        end
-      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_created_mocks = []
-      @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 within 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.
-    #
-    # If a block is given, then the stub object is passed to the block
-    # and may be configured within the block.
-    #
-    # Example:  Stub out DBI to return a fake db connection.
-    #
-    #   flexstub(DBI) do |s|
-    #     s.should_receive(:connect).and_return {
-    #       flexmock("db connection") do |m|
-    #          m.should_receive(:select_all).and_return(...)
-    #       end
-    #     }
-    #   end
-    #
-    def flexstub(obj, name=nil)
-      name ||= "flexstub(#{obj.class.to_s})"
-      obj.instance_eval {
-        @flexmock_proxy ||= StubProxy.new(obj, FlexMock.new(name))
-      }
-      proxy = obj.instance_variable_get("@flexmock_proxy")
-      yield(proxy) if block_given?
-      flexmock_remember(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.
-    #
-    # <b>Warning:</b> <em>Class Interception is deprecated.  Use
-    # flexstub instead.</em>
-    #
-    # 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.mock_container = self
-      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)
-      self.class.show_intercept_warning
-      @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
-
-    @shown_warning = false
-    
-    class << self
-      def show_intercept_warning
-        unless @shown_warning
-          @shown_warning = true
-          $stderr.puts "FlexMock Class Interception is deprecated and will be removed in future versions."
-        end
-      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
-
-    # Initialize a StubProxy object.
-    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
-
-    # new_instances is a short cut method for overriding the behavior of any
-    # new instances created via a stubbed class object.
-    #
-    # By default, new_instances will stub the behaviour of the :new and
-    # :allocate methods.  If you wish to stub a different set of class
-    # methods, just pass a list of symbols to as arguments.
-    #
-    # For example, to stub only objects created by :make (and not :new
-    # or :allocate), use:
-    #
-    #    flexstub(ClassName).new_instances(:make) do |obj|
-    #      obj.should_receive(...)
-    #    end
-    #
-    def new_instances(*allocators, &block)
-      fail ArgumentError, "new_instances requires a Class to stub" unless Class === @obj
-      fail ArgumentError, "new_instances requires a block" unless block_given?
-      allocators = [:new, :allocate] if allocators.empty?
-      allocators.each do |m|
-        self.should_receive(m).and_return { |*args|
-          new_obj = invoke_original(m, args)
-          mock = mock_container.flexstub(new_obj)
-          block.call(mock)
-          new_obj
-        }
-      end
-      nil
-    end
-
-    # any_instance is present for backwards compatibility with version 0.5.0.
-    # @deprecated
-    def any_instance(&block)
-      $stderr.puts "any_instance is deprecated, use new_instances instead."
-      new_instances(&block)
-    end
-
-    # Invoke the original definition of method on the object supported by
-    # the stub.
-    def invoke_original(method, args)
-      method_proc = @method_definitions[method]
-      method_proc.call(*args)
-    end
-    private :invoke_original
-
-    # 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
-
-    # Return the container for this mocking object.  Returns nil if the
-    # mock is not in a container.  Mock containers make sure that mock objects
-    # inside the container are torn down at the end of a test
-    def mock_container
-      @mock.mock_container
-    end
-
-    # Set the container for this mock object.
-    def mock_container=(container)
-      @mock.mock_container = container
-    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 @obj.respond_to?(method_name)
-        new_alias = new_name(method_name)
-        unless @obj.respond_to?(new_alias)
-          sclass.class_eval do
-            alias_method(new_alias, method_name)
-          end
-        end
-        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)
-        }
-      end
-      remove_current_method(method_name) if singleton?(method_name)
-      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
-        the_alias = new_name(method_name)
-        sclass.class_eval do
-          alias_method(method_name, the_alias)
-        end
-      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
-
-    # 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
+require 'flexmock/base'
+require 'flexmock/test_unit_integration'