flexmock 0.5.0 → 0.5.1

data/CHANGELOG

@@ -2,13 +2,23 @@
 
 = Changes for FlexMock
 
+== Pre Version 0.5.1
+
+* Changed the name of any_instance to new_instances.  
+  Deprecated any_instance.
+* Added ability to stub any class method in new_instances.
+* Added RCov task
+* Reworked original behavior hooks to use method aliasing rather than method
+  procs.
+* Fixed bug in stubbing File class methods.
+
 == Version 0.5.0
 
 * Added any_instance stubbing to class objects.
 
 == Version 0.4.5
 
-* Fixed version typo in 0.4.4 (internall claimed to be 0.4.3.1)
+* Fixed version typo in 0.4.4 (internally claimed to be 0.4.3.1)
 
 == Version 0.4.4
 

data/README

@@ -3,7 +3,7 @@
 FlexMock is a simple, but flexible, mock object library for Ruby unit
 testing.
 
-Version :: 0.5.0
+Version :: 0.5.1
 
 = Links
 
@@ -320,8 +320,8 @@ version of the object.
   <em>Class Interception is now deprecated. It only worked in a
   small number of cases. See the "Mocking Existing Objects"
   example above for a much better approach to the same problem. 
-  The Class Interception API will probably disappear in a future 
-  version of FlexMock.</em>
+  Version 0.5.x will be the last version of FlexMock that supports the
+  Class Interception API.</em>
 
 FlexMock now supports simple class interception. For the duration of a test, a
 mock class take the place of a named class inside the class to be tested.
@@ -380,7 +380,7 @@ but the third query (which matches any query call with a four
 character parameter) may be called multiple times (but at least once).
 Startup and finish must also happen exactly once.
 
-Also note that we use the +with+ method to match different arguement
+Also note that we use the +with+ method to match different argument
 values to figure out what value to return.
 
    def test_ordered_queries
@@ -482,6 +482,7 @@ following:
 ruby-mock      :: http://www.b13media.com/dev/ruby/mock.html
 test-unit-mock :: http://www.deveiate.org/code/Test-Unit-Mock.shtml
 mocha/stubba   :: http://mocha.rubyforge.org/
+
 == License
 
 Copyright 2003, 2004, 2005, 2006 by Jim Weirich (jim@weirichhouse.org).

data/Rakefile

@@ -9,7 +9,7 @@ require 'rake/testtask'
 CLEAN.include('*.tmp')
 CLOBBER.include("html", 'pkg')
 
-PKG_VERSION = '0.5.0'
+PKG_VERSION = '0.5.1'
 
 PKG_FILES = FileList[
   '[A-Z]*',
@@ -29,6 +29,7 @@ RDOC_FILES = FileList[
 
 task :default => [:test_all]
 task :test_all => [:test]
+task :test_units => [:test]
 task :ta => [:test_all]
 
 # Test Targets -------------------------------------------------------
@@ -39,6 +40,23 @@ Rake::TestTask.new do |t|
   t.warning = true
 end
 
+Rake::TestTask.new(:test_extended) do |t|
+  t.test_files = FileList['test/extended/test_*.rb']
+  t.verbose = true
+  t.verbose = true
+end
+
+# RCov Target --------------------------------------------------------
+
+require 'rcov/rcovtask'
+
+Rcov::RcovTask.new do |t|
+  t.libs << "test"
+  t.rcov_opts = ['-xRakefile', '-xrakefile', '-xpublish.rf', '--text-report']
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
 # RDoc Target --------------------------------------------------------
 
 task :rdoc => ["README"]

data/doc/releases/flexmock-0.5.1.rdoc

@@ -0,0 +1,86 @@
+= FlexMock 0.5.0 Released
+
+FlexMock is a flexible mocking library for use in Ruby's Test::Unit
+test framework.  Version 0.5.1 is a minor bug fix release.
+
+== New in 0.5.1
+
+* Version 0.5.1 fixes a problem that caused some older versions of
+  RCov to core dump.
+  
+== What is FlexMock?
+
+FlexMock is a flexible Ruby mocking library that works with Ruby's
+Test::Unit framework to create easy to use mocks.
+
+=== Features
+
+* Easy integration with Test::Unit.  Mocks created with the flexmock
+  method are automatically verified at the end of the test.
+
+* A fluent interface that allows mock behavior to be specified very
+  easily.
+
+* A "record mode" where an existing implementation can record its
+  interaction with a mock for later validation against a new
+  implementation.
+
+* Easy mocking of individual methods in existing, non-mock objects.
+
+=== Example
+
+Suppose you had a Dog object that wagged a tail when it was happy.
+Something like this:
+
+  class Dog
+    def initialize(a_tail)
+      @tail = a_tail
+    end
+    def happy
+      @tail.wag
+    end
+  end
+
+To test the +Dog+ class without a real +Tail+ object (perhaps because
+real +Tail+ objects activate servos in some robotic equipment), you
+can do something like this:
+
+require 'test/unit'
+require 'flexmock'
+
+  class TestDog < Test::Unit::TestCase
+    include FlexMock::TestCase
+
+    def test_dog_wags_tail_when_happy
+      tail = flexmock("tail")
+      tail.should_receive(:wag).once
+      dog = Dog.new(tail)
+      dog.happy
+    end
+  end
+
+FlexMock will automatically verify that the mocked tail object
+received the message +wag+ exactly one time.  If it doesn't, the test
+will not pass.
+
+See the FlexMock documentation at
+http://onestepback.org/software/flexmock for details on specifying
+arguments and return values on mocked methods, as well as a simple
+technique for mocking tail objects when the Dog class creates the tail
+objects directly.
+
+== Availability
+
+You can make sure you have the latest version with a quick RubyGems command:
+
+  gem install flexmock    (you may need root/admin privileges)
+
+Otherwise, you can get it from the more traditional places:
+
+Download::  http://rubyforge.org/project/showfiles.php?group_id=170
+
+You will find documentation at:
+http://onestepback.org/software/flexmock/
+
+-- Jim Weirich
+

data/lib/flexmock.rb

@@ -66,7 +66,7 @@ class FlexMock
     @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
@@ -155,10 +155,14 @@ class FlexMock
   # 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"
+    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
@@ -208,7 +212,7 @@ class FlexMock
     #
     # 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. 
+    # the test teardown by using the +flexmock+ method.
     #
     def use(*names)
       names = ["unknown"] if names.empty?
@@ -223,7 +227,7 @@ class FlexMock
         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)
@@ -233,7 +237,7 @@ class FlexMock
         "#{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)
@@ -248,9 +252,9 @@ class FlexMock
   def mock_wrap(&block)
     yield
   rescue Test::Unit::AssertionFailedError => ex
-    raise Test::Unit::AssertionFailedError, 
-      "in mock '#{@mock_name}': #{ex.message}",
-      ex.backtrace
+    raise Test::Unit::AssertionFailedError,
+    "in mock '#{@mock_name}': #{ex.message}",
+    ex.backtrace
   end
 
   ####################################################################
@@ -297,18 +301,12 @@ class FlexMock
     # 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? }
+        @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
 
-    # Same as call.
-    def [](*args)
-      call(*args)
-    end
-
     # Append an expectation to this director.
     def <<(expectation)
       @expectations << expectation
@@ -333,7 +331,7 @@ class FlexMock
       "ANY"
     end
   end
-  
+
   ####################################################################
   # Match only things that are equal.
   class EqualMatcher
@@ -347,7 +345,7 @@ class FlexMock
       "==(#{@obj.inspect})"
     end
   end
-  
+
   ANY = AnyMatcher.new
 
   ####################################################################
@@ -415,8 +413,8 @@ class FlexMock
     # Validate that the method expectation was called exactly +n+
     # times.
     def validate(n)
-      assert_equal @limit, n, 
-        "method '#{@exp}' called incorrect number of times"
+      assert_equal @limit, n,
+      "method '#{@exp}' called incorrect number of times"
     end
   end
 
@@ -428,8 +426,8 @@ class FlexMock
     # times.
     def validate(n)
       assert n >= @limit,
-        "Method '#{@exp}' should be called at least #{@limit} times,\n" +
-        "only called #{n} times"
+      "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
@@ -448,8 +446,8 @@ class FlexMock
     # 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"
+      "Method '#{@exp}' should be called at most #{@limit} times,\n" +
+      "only called #{n} times"
     end
   end
 
@@ -501,11 +499,11 @@ class FlexMock
       @count_validators.all? { |v| v.eligible?(@actual_count) }
     end
 
-    # Validate that the order 
+    # 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})") {
+      "(expected order #{@order_number}, was #{@mock.mock_current_order})") {
         @order_number >= @mock.mock_current_order
       }
       @mock.mock_current_order = @order_number
@@ -523,7 +521,9 @@ class FlexMock
     # Does the argument list match this expectation's argument
     # specification.
     def match_args(args)
-      return false if @expected_args.nil?
+      # 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
@@ -531,8 +531,8 @@ class FlexMock
     # Does the expected argument match the corresponding actual value.
     def match_arg(expected, actual)
       expected === actual ||
-        expected == actual ||
-        ( Regexp === expected && expected === actual.to_s )
+      expected == actual ||
+      ( Regexp === expected && expected === actual.to_s )
     end
 
     # Declare that the method should expect the given argument list.
@@ -558,15 +558,15 @@ class FlexMock
     #
     # * 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 
+    # * 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 
+    #   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.  
-    # 
+    # * 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
@@ -575,9 +575,12 @@ class FlexMock
     # +and_return+ is an alias for +returns+.
     #
     def returns(*args, &block)
-      @return_block = block_given? ? 
-        block : 
-        lambda { args.size == 1 ? args.first : args.shift }
+      @return_block = 
+        if block_given? 
+           block
+        else
+          lambda { args.size == 1 ? args.first : args.shift }
+        end
       self
     end
     alias :and_return :returns  # :nodoc:
@@ -725,7 +728,7 @@ class FlexMock
     # given arguments.
     def method_missing(sym, *args, &block)
       expectation = @mock.should_receive(sym).and_return(&block)
-      if @strict
+      if strict?
         args = args.collect { |arg| eq(arg) }
         expectation.with(*args).ordered.once
       else
@@ -734,7 +737,7 @@ class FlexMock
       expectation
     end
   end
-  
+
   ####################################################################
   # Test::Unit::TestCase Integration.
   #
@@ -757,7 +760,7 @@ class FlexMock
       super
       flexmock_teardown
     end
-    
+
     # Do the flexmock specific teardown stuff.
     def flexmock_teardown
       @flexmock_created_mocks ||= []
@@ -770,6 +773,7 @@ class FlexMock
       @flexmock_created_mocks.each do |m|
         m.mock_teardown
       end
+      @flexmock_created_mocks = []
       @flexmock_interceptors ||= []
       @flexmock_interceptors.each do |i|
         i.restore
@@ -788,10 +792,10 @@ class FlexMock
       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.  
+    # +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.
@@ -815,7 +819,7 @@ class FlexMock
       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
@@ -838,9 +842,9 @@ class FlexMock
       @flexmock_interceptors << result
       result
     end
-    
+
     private
-    
+
     def flexmock_remember(mocking_object)
       @flexmock_created_mocks ||= []
       @flexmock_created_mocks << mocking_object
@@ -868,11 +872,12 @@ class FlexMock
 
     # 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)
@@ -893,16 +898,16 @@ class FlexMock
     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?
@@ -949,6 +954,17 @@ class FlexMock
         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
 
   ####################################################################
@@ -964,21 +980,21 @@ class FlexMock
       @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 
+  # 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 
+  # 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
@@ -986,8 +1002,8 @@ class FlexMock
       @method_definitions = {}
       @methods_proxied = []
     end
-    
-    # Stub out the given method in the existing object and then let the 
+
+    # 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
@@ -997,34 +1013,52 @@ class FlexMock
       end
       @mock.should_receive(method_name)
     end
-    
-    # any_instance is a short cut method for overriding the behavior of any 
-    # instance created via a stubbed class object.
-    def any_instance(&block)
-      fail ArgumentError, "any_instance requires a Class to stub" unless Class === @obj
-      self.should_receive(:new).and_return { |*args|
-        new_obj = invoke_original(:new, args)
-        mock = mock_container.flexstub(new_obj)
-        block.call(mock)
-        new_obj
-      }
+
+    # 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
 
-    # Invoke the original definition of method on the object supported by 
+    # 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[:new]
-      block = nil
-      if Proc === args.last
-        block = args.last
-        args = args[0...-1]
-      end
-      method_proc.call(*args, &block)
+      method_proc = @method_definitions[method]
+      method_proc.call(*args)
     end
     private :invoke_original
 
-    # Verify that the mock has been properly called.  After verification, 
+    # Verify that the mock has been properly called.  After verification,
     # detach the mocking infrastructure from the existing object.
     def mock_verify
       @mock.mock_verify
@@ -1041,14 +1075,14 @@ class FlexMock
         @obj = nil
       end
     end
-    
-    # Return the container for this mocking object.  Returns nil if the   
+
+    # 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
@@ -1074,7 +1108,23 @@ class FlexMock
     # not a singleton, all we need to do is override it with our own
     # singleton.
     def hide_existing_method(method_name)
-      @method_definitions[method_name] = @obj.method(method_name) if @obj.respond_to?(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
@@ -1084,9 +1134,7 @@ class FlexMock
     # being mocked.
     def define_proxy_method(method_name)
       sclass.class_eval %{
-        def #{method_name}(*args, &block)
-          @flexmock_proxy.mock.#{method_name}(*args, &block)
-        end  
+        def #{method_name}(*args, &block)  @flexmock_proxy.mock.#{method_name}(*args, &block)  end
       }
     end
 
@@ -1095,9 +1143,10 @@ class FlexMock
     def restore_original_definition(method_name)
       method_def = @method_definitions[method_name]
       if method_def
-        sclass.class_eval {
-          define_method(method_name, &method_def)
-        }
+        the_alias = new_name(method_name)
+        sclass.class_eval do
+          alias_method(method_name, the_alias)
+        end
       end
     end
 
@@ -1111,6 +1160,11 @@ class FlexMock
     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/test/test_any_instance.rb

@@ -22,6 +22,9 @@ class TestStubbingOnNew < Test::Unit::TestCase
     def wag
       :tail
     end
+    def self.make
+      new
+    end
   end
 
   class Cat
@@ -43,25 +46,42 @@ class TestStubbingOnNew < Test::Unit::TestCase
       :unstubbed
     end
   end
+  
+  def test_new_instances_requires_block
+    ex = assert_raise(ArgumentError) {  
+      flexstub(Dog).new_instances
+    }
+  end
 
-  def test_any_instance_allows_stubbing_of_existing_methods
-    flexstub(Dog).any_instance do |obj|
+  def test_new_instances_allows_stubbing_of_existing_methods
+    flexstub(Dog).new_instances do |obj|
       obj.should_receive(:bark).and_return(:whimper)
     end
     m = Dog.new
     assert_equal :whimper,  m.bark
   end
   
-  def test_any_instance_stubs_still_have_existing_methods
-    flexstub(Dog).any_instance do |obj|
+  def test_any_instance_still_works_for_backwards_compatibility
+    message = redirect_error { 
+      flexstub(Dog).any_instance do |obj|
+        obj.should_receive(:bark).and_return(:whimper)
+        assert_match(/deprecated/, message)
+      end
+    }
+    m = Dog.new
+    assert_equal :whimper,  m.bark   
+  end
+  
+  def test_new_instances_stubs_still_have_existing_methods
+    flexstub(Dog).new_instances do |obj|
       obj.should_receive(:bark).and_return(:whimper)
     end
     m = Dog.new
     assert_equal :tail,  m.wag
   end
 
-  def test_any_instance_will_pass_args_to_new
-    flexstub(Cat).any_instance do |obj|
+  def test_new_instances_will_pass_args_to_new
+    flexstub(Cat).new_instances do |obj|
       obj.should_receive(:meow).and_return(:scratch)
     end
     x = :not_called
@@ -71,8 +91,23 @@ class TestStubbingOnNew < Test::Unit::TestCase
     assert_equal :called, x
   end
 
-  def test_any_instance_stub_verification_happens_on_teardown
-    flexstub(Dog).any_instance do |obj|
+  # Some versions of the software had problems invoking the block after a
+  # second stubbing.
+  def test_new_gets_block_after_restubbing
+    flexstub(Cat).new_instances { }
+    x = :not_called
+    m = Cat.new("Fido") { x = :called }
+    assert_equal :called, x
+    flexmock_teardown
+    
+    flexstub(Cat).new_instances { }
+    x = :not_called
+    m = Cat.new("Fido") { x = :called }
+    assert_equal :called, x
+  end
+
+  def test_new_instances_stub_verification_happens_on_teardown
+    flexstub(Dog).new_instances do |obj|
       obj.should_receive(:bark).once.and_return(nil)
     end
     
@@ -81,14 +116,54 @@ class TestStubbingOnNew < Test::Unit::TestCase
     assert_match(/method 'bark\(.*\)' called incorrect number of times/, ex.message)
   end
 
-  def test_any_instance_reports_error_on_non_classes
+  def test_new_instances_reports_error_on_non_classes
     ex = assert_raise(ArgumentError) { 
-      flexstub(Dog.new).any_instance do |obj|
+      flexstub(Dog.new).new_instances do |obj|
         obj.should_receive(:hi)
       end
     }
     assert_match(/Class/, ex.message)
-    assert_match(/any_instance/, ex.message)
+    assert_match(/new_instances/, ex.message)
+  end
+  
+  def test_can_stub_objects_created_with_allocate_instead_of_new
+    flexstub(Dog).new_instances do |obj|
+      obj.should_receive(:bark).and_return(:whimper)
+    end
+    m = Dog.allocate
+    assert_equal :whimper,  m.bark
+  end
+  
+  def test_can_stub_objects_created_with_arbitrary_class_methods
+    flexstub(Dog).new_instances(:make) do |obj|
+      obj.should_receive(:bark).and_return(:whimper)
+    end
+    assert_equal :whimper,  Dog.make.bark
+  end
+  
+  def test_stubbing_arbitrary_class_methods_leaves_new_alone
+    flexstub(Dog).new_instances(:make) do |obj|
+      obj.should_receive(:bark).and_return(:whimper)
+    end
+    assert_equal :woof,  Dog.new.bark
+  end
+
+  def test_stubbing_new_and_allocate_doesnt_double_stub_objects_on_new
+    counter = 0
+    flexstub(Dog).new_instances do |obj|
+      counter += 1
+    end
+    Dog.new
+    assert_equal 1, counter
+  end
+
+  def test_stubbing_new_and_allocate_doesnt_double_stub_objects_on_allocate
+    counter = 0
+    flexstub(Dog).new_instances do |obj|
+      counter += 1
+    end
+    Dog.allocate
+    assert_equal 1, counter
   end
   
   # Current behavior does not install stubs into the block passed to new. 
@@ -96,7 +171,7 @@ class TestStubbingOnNew < Test::Unit::TestCase
   # moment, we assure that they are not stubbed, but I am willing to change 
   # this in the future.
   def test_blocks_on_new_do_not_have_stubs_installed
-    flexstub(Connection).any_instance do |new_con|
+    flexstub(Connection).new_instances do |new_con|
       new_con.should_receive(:post).and_return {
         :stubbed
       }
@@ -108,4 +183,17 @@ class TestStubbingOnNew < Test::Unit::TestCase
     end
     assert block_run
   end
+  
+  def redirect_error
+    require 'stringio'
+    old_err = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  rescue
+    $stderr = old_err
+  end
+  private :redirect_error
 end
+
+

data/test/test_mock.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# Copyright 2006, 2007 by Jim Weirich (jim@weirichhouse.org).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,

data/test/test_should_receive.rb

@@ -25,6 +25,13 @@ end
 
 class TestFlexMockShoulds < Test::Unit::TestCase
 
+  # Expected error messages on failures
+  COUNT_ERROR_MESSAGE = /\bcalled\s+incorrect\s+number\s+of\s+times\b/
+  NO_MATCH_ERROR_MESSAGE = /\bno\s+matching\s+handler\b/
+  AT_LEAST_ERROR_MESSAGE = /\bshould\s+be\s+called\s+at\s+least\b/
+  AT_MOST_ERROR_MESSAGE = /\bshould\s+be\s+called\s+at\s+most\b/
+  OUT_OF_ORDER_ERROR_MESSAGE = /\bcalled\s+out\s+of\s+order\b/
+  
   def test_defaults
     FlexMock.use do |m|
       m.should_receive(:hi)
@@ -87,10 +94,10 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test__with_no_args_but_with_args
-    ex = assert_failure do
+    ex = assert_failure(NO_MATCH_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with_no_args
-	m.hi(1)
+        m.should_receive(:hi).with_no_args
+        m.hi(1)
       end
     end
   end
@@ -187,8 +194,8 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   def test_arg_matching_with_no_match
     FlexMock.use do |m|
       m.should_receive(:hi).with(1).returns(10)
-      assert_failure {
-	assert_equal 20, m.hi(2)
+      assert_failure(NO_MATCH_ERROR_MESSAGE) {
+        assert_equal 20, m.hi(2)
       }
     end
   end
@@ -196,8 +203,8 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   def test_arg_matching_with_string_doesnt_over_match
     FlexMock.use do |m|
       m.should_receive(:hi).with(String).returns(20)
-      assert_failure {
-	m.hi(1.0)
+      assert_failure(NO_MATCH_ERROR_MESSAGE) {
+        m.hi(1.0)
       }
     end
   end
@@ -205,8 +212,8 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   def test_block_arg_given_to_no_args
     FlexMock.use do |m|
       m.should_receive(:hi).with_no_args.returns(20)
-      assert_failure {
-	m.hi { 1 }
+      assert_failure(NO_MATCH_ERROR_MESSAGE) {
+        m.hi { 1 }
       }
     end
   end
@@ -245,10 +252,10 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_never_and_called_once
-    ex = assert_failure do    
+    ex = assert_failure(COUNT_ERROR_MESSAGE) do    
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).never
-	m.hi(1)
+        m.should_receive(:hi).with(1).never
+        m.hi(1)
       end
     end
   end
@@ -261,19 +268,19 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_once_but_never_called
-    ex = assert_failure do
+    ex = assert_failure(COUNT_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).returns(10).once
+        m.should_receive(:hi).with(1).returns(10).once
       end
     end
   end
 
   def test_once_but_called_twice
-    ex = assert_failure do
+    ex = assert_failure(COUNT_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).returns(10).once
-	m.hi(1)
-	m.hi(1)
+        m.should_receive(:hi).with(1).returns(10).once
+        m.hi(1)
+        m.hi(1)
       end
     end
   end
@@ -321,9 +328,9 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_at_least_but_never_called
-    ex = assert_failure do
+    ex = assert_failure(AT_LEAST_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).returns(10).at_least.once
+        m.should_receive(:hi).with(1).returns(10).at_least.once
       end
     end
   end
@@ -337,11 +344,11 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_at_least_and_exact
-    ex = assert_failure do
+    ex = assert_failure(COUNT_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).returns(10).at_least.once.once
-	m.hi(1)
-	m.hi(1)
+        m.should_receive(:hi).with(1).returns(10).at_least.once.once
+        m.hi(1)
+        m.hi(1)
       end
     end
   end
@@ -360,19 +367,19 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_at_most_called_twice
-    ex = assert_failure do
+    ex = assert_failure(AT_MOST_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).returns(10).at_most.once
-	m.hi(1)
-	m.hi(1)
+        m.should_receive(:hi).with(1).returns(10).at_most.once
+        m.hi(1)
+        m.hi(1)
       end
     end
   end
 
   def test_at_most_and_at_least_called_never
-    ex = assert_failure do
+    ex = assert_failure(AT_LEAST_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
+        m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
       end
     end
   end
@@ -393,12 +400,12 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_at_most_and_at_least_called_three_times
-    ex = assert_failure do
+    ex = assert_failure(AT_MOST_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
-	m.hi(1)
-	m.hi(1)
-	m.hi(1)
+        m.should_receive(:hi).with(1).returns(10).at_least.once.at_most.twice
+        m.hi(1)
+        m.hi(1)
+        m.hi(1)
       end
     end
   end
@@ -416,18 +423,19 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_call_counts_only_apply_to_matching_args_with_mismatch
-    ex = assert_failure do
+    ex = assert_failure(COUNT_ERROR_MESSAGE) do
       FlexMock.use do |m|
-	m.should_receive(:hi).with(1).once
-	m.should_receive(:hi).with(2).twice
-	m.should_receive(:hi).with(3)
-	m.should_receive(:lo)
-	m.hi(1)
-	m.hi(2)
-	m.lo
-	20.times { m.hi(3) }
+        m.should_receive(:hi).with(1).once
+        m.should_receive(:hi).with(2).twice
+        m.should_receive(:hi).with(3)
+        m.should_receive(:lo)
+        m.hi(1)
+        m.hi(2)
+        m.lo
+        20.times { m.hi(3) }
       end
     end
+    assert_match(/hi\(2\)/, ex.message)
   end
 
   def test_ordered_calls_in_order
@@ -441,13 +449,13 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_ordered_calls_out_of_order
-    ex = assert_failure do
+    ex = assert_failure(OUT_OF_ORDER_ERROR_MESSAGE) do
       FlexMock.use 'm' do |m|
-	m.should_receive(:hi).ordered
-	m.should_receive(:lo).ordered
-	
-	m.lo
-	m.hi
+        m.should_receive(:hi).ordered
+        m.should_receive(:lo).ordered
+
+        m.lo
+        m.hi
       end
     end
   end
@@ -463,13 +471,13 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_order_calls_with_different_arg_lists_and_out_of_order
-    ex = assert_failure do
+    ex = assert_failure(OUT_OF_ORDER_ERROR_MESSAGE) do
       FlexMock.use 'm' do |m|
-	m.should_receive(:hi).with("one").ordered
-	m.should_receive(:hi).with("two").ordered
-	
-	m.hi("two")
-	m.hi("one")
+        m.should_receive(:hi).with("one").ordered
+        m.should_receive(:hi).with("two").ordered
+
+        m.hi("two")
+        m.hi("one")
       end
     end
   end
@@ -500,11 +508,11 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
-  def test_grouped_ordering
+  def test_grouped_ordering_with_numbers
     FlexMock.use 'm' do |m|
-      m.should_receive(:start).ordered(:start_group)
-      m.should_receive(:flip).ordered(:flip_flop_group)
-      m.should_receive(:flop).ordered(:flip_flop_group)
+      m.should_receive(:start).ordered(1)
+      m.should_receive(:flip).ordered(2)
+      m.should_receive(:flop).ordered(2)
       m.should_receive(:final).ordered
       
       m.start
@@ -517,9 +525,9 @@ class TestFlexMockShoulds < Test::Unit::TestCase
 
   def test_grouped_ordering_with_symbols
     FlexMock.use 'm' do |m|
-      m.should_receive(:start).ordered(:group_one)
-      m.should_receive(:flip).ordered(:group_two)
-      m.should_receive(:flop).ordered(:group_two)
+      m.should_receive(:start).ordered(:start_group)
+      m.should_receive(:flip).ordered(:flip_flop_group)
+      m.should_receive(:flop).ordered(:flip_flop_group)
       m.should_receive(:final).ordered
       
       m.start
@@ -541,17 +549,44 @@ class TestFlexMockShoulds < Test::Unit::TestCase
   end
 
   def test_explicit_ordering_with_explicit_misorders
-    assert_failure do 
+    ex = assert_failure(OUT_OF_ORDER_ERROR_MESSAGE) do 
       FlexMock.use 'm' do |m|
-	m.should_receive(:hi).ordered(:first_group)
-	m.should_receive(:lo).ordered(:second_group)
-	
-	m.lo
-	m.hi
+        m.should_receive(:hi).ordered(:first_group)
+        m.should_receive(:lo).ordered(:second_group)
+
+        m.lo
+        m.hi
       end
     end
+    # TODO: It would be nice to get the group names in the error message.
+    # assert_match /first_group/, ex.message
+    # assert_match /second_group/, ex.message
   end
-
+  
+  # Test submitted by Mikael Pahmp to correct expectation matching.
+  def test_ordering_with_explicit_no_args_matches_correctly
+    FlexMock.use("m") do |m|
+      m.should_receive(:foo).with_no_args.once.ordered
+      m.should_receive(:bar).with_no_args.once.ordered
+      m.should_receive(:foo).with_no_args.once.ordered
+      m.foo
+      m.bar
+      m.foo  
+    end
+  end
+
+  # Test submitted by Mikael Pahmp to correct expectation matching.  
+  def test_ordering_with_any_arg_matching_correctly_matches
+    FlexMock.use("m") do |m|
+      m.should_receive(:foo).with_any_args.once.ordered
+      m.should_receive(:bar).with_any_args.once.ordered
+      m.should_receive(:foo).with_any_args.once.ordered
+      m.foo
+      m.bar
+      m.foo  
+    end  
+  end
+  
   def test_expectation_formating
     m = FlexMock.new("m")
     exp = m.should_receive(:f).with(1,"two", /^3$/).and_return(0).at_least.once
@@ -597,18 +632,41 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     assert_equal :mkf, m2.mock_kernel_function
   end
 
-  def assert_failure
-    assert_raises(Test::Unit::AssertionFailedError) do yield end
+  # Assertion helper used to assert validation failure.  If a 
+  # message is given, then the error message should match the 
+  # expected error message.
+  def assert_failure(message=nil)
+    ex = assert_raises(Test::Unit::AssertionFailedError) { yield }
+    if message
+      case message
+      when Regexp
+        assert_match message, ex.message
+      when String
+        assert ex.message.index(message), "Error message '#{ex.message}' should contain '#{message}'"
+      end
+    end
+    ex
   end
-
 end
 
 class TestFlexMockShouldsWithInclude < Test::Unit::TestCase
   include FlexMock::ArgumentTypes
-  def test_include
+  def test_include_enables_unqualified_arg_type_references
     FlexMock.use("x") do |m|
       m.should_receive(:hi).with(any).once
       m.hi(1)
     end
   end
 end
+
+class TestFlexMockArgTypesDontLeak < Test::Unit::TestCase
+  def test_unqualified_arg_type_references_are_undefined_by_default
+    ex = assert_raise(NameError) do
+      FlexMock.use("x") do |m|
+        m.should_receive(:hi).with(any).once
+        m.hi(1)
+      end
+    end
+    assert_match(/\bany\b/, ex.message, "Error message should mention 'any'")
+  end
+end

data/test/test_stubbing.rb

@@ -10,6 +10,7 @@
 #+++
 
 require 'test/unit'
+require 'fileutils'
 require 'flexmock'
 
 class TestStubbing < Test::Unit::TestCase
@@ -127,11 +128,35 @@ class TestStubbing < Test::Unit::TestCase
   end
 
   def test_original_behavior_is_restored_on_nonsingleton_methods_with_multiple_stubs
-    flexstub(File).should_receive(:open).with("foo").once.and_return(:ok)
-    flexstub(File).should_receive(:open).with("bar").once.and_return(:ok)
+    flexstub(Dir).should_receive(:chdir).with("xx").once.and_return(:ok1)
+    flexstub(Dir).should_receive(:chdir).with("yy").once.and_return(:ok2)
+    assert_equal :ok1, Dir.chdir("xx")
+    assert_equal :ok2, Dir.chdir("yy")
+
+    flexstub(Dir).mock_teardown
+
+    x = :not_called
+    Dir.chdir("test") do
+      assert_match %r{/test$}, Dir.pwd
+      x = :called
+    end
+    assert_equal :called, x
+  end
 
+  def test_stubbing_file_shouldnt_break_writing
+    flexstub(File).should_receive(:open).with("foo").once.and_return(:ok)
     assert_equal :ok, File.open("foo")
-    assert_equal :ok, File.open("bar")
+    flexstub(File).mock_teardown
+
+    File.open("dummy.txt", "w") do |out|
+      assert out.is_a?(IO)
+      out.puts "XYZ"
+    end
+    text = nil
+    File.open("dummy.txt") { |f| text = f.read }
+    assert_equal "XYZ\n", text
+  ensure
+    FileUtils.rm_f("dummy.txt")
   end
 
   def test_original_behavior_is_restored_even_when_errors

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: flexmock
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
-date: 2007-02-10 00:00:00 -05:00
+  version: 0.5.1
+date: 2007-04-09 00:00:00 -04:00
 summary: Simple and Flexible Mock Objects for Testing
 require_paths: 
 - lib
@@ -50,6 +50,7 @@ files:
 - doc/releases/flexmock-0.4.2.rdoc
 - doc/releases/flexmock-0.4.3.rdoc
 - doc/releases/flexmock-0.5.0.rdoc
+- doc/releases/flexmock-0.5.1.rdoc
 test_files: []
 
 rdoc_options: 
@@ -66,6 +67,7 @@ extra_rdoc_files:
 - doc/releases/flexmock-0.4.2.rdoc
 - doc/releases/flexmock-0.4.3.rdoc
 - doc/releases/flexmock-0.5.0.rdoc
+- doc/releases/flexmock-0.5.1.rdoc
 executables: []
 
 extensions: []