flexmock 0.5.1 → 0.6.0

data/lib/flexmock/noop.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 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.
+#+++
+
+# No-op include file.  Used as a kludge so that only the comments in the
+# core.rb file are applied to the FlexMock class.

data/lib/flexmock/partial_mock.rb

@@ -0,0 +1,226 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 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 'flexmock/noop'
+
+class FlexMock
+  
+  ####################################################################
+  # PartialMock 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, PartialMock
+  # will erase the mocking infrastructure from the object being
+  # mocked (e.g. remove instance variables and mock singleton
+  # methods).
+  #
+  class PartialMock
+    attr_reader :mock
+
+    # Initialize a PartialMock object.
+    def initialize(obj, mock)
+      @obj = obj
+      @mock = mock
+      @method_definitions = {}
+      @methods_proxied = []
+    end
+
+    # :call-seq:
+    #    should_receive(:method_name)
+    #    should_receive(:method1, method2, ...)
+    #    should_receive(:meth1 => result1, :meth2 => result2, ...)
+    #
+    # Declare that the partial mock should receive a message with the given
+    # name.
+    #
+    # If more than one method name is given, then the mock object should
+    # expect to receive all the listed melthods.  If a hash of method
+    # name/value pairs is given, then the each method will return the
+    # associated result.  Any expectations applied to the result of
+    # +should_receive+ will be applied to all the methods defined in the
+    # argument list.
+    #
+    # 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(*args)
+      FlexMock.should_receive(args) do |sym|
+        unless @methods_proxied.include?(sym)
+          hide_existing_method(sym)
+          @methods_proxied << sym
+        end
+        ex = @mock.should_receive(sym)
+        ex.mock = self
+        ex
+      end
+    end
+
+    # :call-seq:
+    #   new_instances.should_receive(...)
+    #   new_instances { |instance|  instance.should_receive(...) }
+    #
+    # new_instances is a short cut method for overriding the behavior of any
+    # new instances created via a mocked class object.
+    #
+    # By default, new_instances will mock the behaviour of the :new and
+    # :allocate methods.  If you wish to mock 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:
+    #
+    #    flexmock(ClassName).new_instances(:make).should_receive(...)
+    #
+    def new_instances(*allocators, &block)
+      fail ArgumentError, "new_instances requires a Class to stub" unless Class === @obj
+      allocators = [:new, :allocate] if allocators.empty?
+      result = ExpectationRecorder.new
+      allocators.each do |m|
+        self.should_receive(m).and_return { |*args|
+          new_obj = invoke_original(m, args)
+          mock = mock_container.flexmock(new_obj)
+          block.call(mock) if block_given?
+          result.apply(mock)
+          new_obj
+        }
+      end
+      result
+    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

data/lib/flexmock/recorder.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 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 'flexmock/argument_types'
+
+class FlexMock
+
+  ####################################################################
+  # 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
+
+end

data/lib/flexmock/rspec.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 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 'flexmock/base'
+
+class FlexMock
+  
+  class RSpecFrameworkAdapter
+    def assert_block(msg, &block)
+      Spec::Expectations.fail_with(msg) unless yield
+    end
+
+    def assert_equal(a, b, msg=nil)
+      message = msg || "Expected equal"
+      assert_block(message + "\n<#{a}> expected, but was\n<#{b}>") { a == b }
+    end
+
+    class AssertionFailedError < StandardError; end
+    def assertion_failed_error
+      Spec::Expectations::ExpectationNotMetError
+    end
+  end
+
+  @framework_adapter = RSpecFrameworkAdapter.new
+
+end

data/lib/flexmock/test_unit.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 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 'flexmock/test_unit_integration'
+
+module Test
+  module Unit
+    class TestCase
+      include FlexMock::ArgumentTypes
+      include FlexMock::MockContainer
+
+      # Alias the original teardown behavior for later use.
+      alias :flexmock_original_teardown :teardown
+
+      # Teardown the test case, verifying any mocks that might have been
+      # defined in this test case.
+      def teardown
+        flexmock_teardown
+        flexmock_original_teardown
+      end
+
+    end
+  end
+end

data/lib/flexmock/test_unit_integration.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 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'
+require 'flexmock/base'
+
+class FlexMock
+  
+  ####################################################################
+  # 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, the mock container methods (e.g. flexmock(), flexstub()) 
+  # will be available.
+  #
+  # <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
+    include MockContainer
+
+    # Teardown the test case, verifying any mocks that might have been
+    # defined in this test case.
+    def teardown
+      super
+      flexmock_teardown
+    end
+
+  end
+  
+  ####################################################################
+  # Adapter for adapting FlexMock to the Test::Unit framework.
+  #
+  class TestUnitFrameworkAdapter
+    include Test::Unit::Assertions
+    def assertion_failed_error
+      Test::Unit::AssertionFailedError
+    end
+  end
+
+  @framework_adapter = TestUnitFrameworkAdapter.new
+end

data/lib/flexmock/validators.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005, 2006, 2007 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 'flexmock/noop'
+
+class FlexMock
+
+  ####################################################################
+  # Base class for all the count validators.
+  #
+  class CountValidator
+    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)
+      FlexMock.framework_adapter.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)
+      FlexMock.framework_adapter.assert_block(
+        "Method '#{@exp}' should be called at least #{@limit} times,\n" +
+        "only called #{n} times") { n >= @limit }
+    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)
+      FlexMock.framework_adapter.assert_block(
+        "Method '#{@exp}' should be called at most #{@limit} times,\n" +
+        "only called #{n} times") { n <= @limit }
+    end
+  end  
+end