flexmock 0.3.2 → 0.4.0

data/CHANGELOG

@@ -1,5 +1,11 @@
 = Changes for FlexMock
 
+== Pre Version 0.3.3
+
+* Added stubbing for mocking methods of existing objects.
+* Added multiple return values for the +and_returns+ method.
+* Added block initialization to the flexmock method.
+
 == Version 0.3.2
 
 * Fixed bug when mock is used as a replacement class in class
@@ -7,7 +13,7 @@
 
 == Version 0.3.1
 
-* Fixed some warnings regarding uniniitalized variables.
+* Fixed some warnings regarding uninitialized variables.
 * Added (very) simple class interception.
 * Added the mock_factory method to go along with class interception.
 * When using Test::Unit integration, avoid mock verification if the

data/README

@@ -1,14 +1,15 @@
 = Flex Mock -- Making Mock Easy
 
-FlexMock is a simple mock object for unit testing.  The interface is
-simple, but still provides a good bit of flexibility.
+FlexMock is a simple, but flexible, mock object library for Ruby unit
+testing.
 
-Version :: 0.3.2
+Version :: 0.4.0
 
 = Links
 
 <b>Documents</b>   :: http://onestepback.org/software/flexmock
-<b>Download</b>    :: Use RubyGems to download the flexmock gem from http://gems.rubyforge.org
+<b>RubyGems</b>    :: Install with: <b>gem install flexmock</b>
+<b>Download</b>    :: Download from RubyForge at http://rubyforge.org/frs/?group_id=170
 
 == Installation
 
@@ -25,6 +26,9 @@ mock object that responds to the +read_temperature+ message.
 
 Here's the complete example:
 
+  require 'test/unit'
+  require 'flexmock'
+
   class TemperatureSampler
     def initialize(sensor)
       @sensor = sensor
@@ -39,16 +43,15 @@ Here's the complete example:
   class TestTemperatureSampler < Test::Unit::TestCase
     include FlexMock::TestCase
 
-    def test_tempurature_sampler
-      readings = [10, 12, 14]
+    def test_temperature_sampler
       sensor = flexmock("temp")
-      sensor.should_receive(:read_temperature).and_return { readings.shift }
+      sensor.should_receive(:read_temperature).times(3).and_return(10, 12, 14)
 
       sampler = TemperatureSampler.new(sensor)
       assert_equal 12, sampler.average_temp
 
       # NOTE:
-      # all mocks created by the +flexmock+ method will be
+      # all mocks created by the flexmock method will be
       # automatically verified during the test teardown.
     end
   end
@@ -86,8 +89,19 @@ create the proper expectations on a FlexMock object.
 * <b><tt>with_no_args</tt></b> -- Declares that this expectation
   matches messages with no arguments
 
-* <b><tt>returns(<em>value</em>)</tt></b> -- Declares that the message
-  will return the given value (<tt>returns(nil)</tt> is the default).
+* <b><tt>and_return(<em>value, ...</em>)</tt></b> -- Declares 
+  that the message will return the given value.
+  * If a single value is given, it will be returned for all matching calls.
+  * If multiple values are given, they will be returned in sequence
+    for each successive matching calls.  The last value will be 
+    repeatably returned if the number of matching calls exceeds the
+    number of values.
+  * If a block is given, its yielded value will be returned. (the 
+    block will receive all the arguments given to the mocked method)
+  * The default return value is nil. 
+
+* <b><tt>returns(<em>value, ...</em>)</tt></b> -- Alias for
+  <tt>and_return</tt>.
 
 * <b><tt>returns { |args| code ... }</tt></b> -- Declares that the
   message will return whatever the block calculates.  The actual
@@ -178,7 +192,7 @@ The following rules are used for argument matching:
       with("hello")   will match    f("hello")
   
 * If you wish to override the default matching behavior and force
-  matching by equality, you can use teh FlexMock.eq convenience
+  matching by equality, you can use the FlexMock.eq convenience
   method.  This is mostly used when you wish to match class objects,
   since the default matching behavior for class objects is to match
   instances, not themselves.
@@ -215,11 +229,71 @@ The following rules are used for argument matching:
 
   will match any even integer.
 
+=== Stubbing Behavior in Existing Objects
+
+Sometimes it is useful to mock the behavior of one or two methods in an
+existing object without changing the behavior of the rest of the object. By
+using the +flexstub+ method, tests can now do exactly that.
+
+For example, suppose that a Dog object uses a Woofer object to
+bark. The code for Dog looks like this (we will leave the code for
+Woofer to your imagination):
+
+  class Dog
+    def initialize
+      @woofer = Woofer.new
+    end
+    def bark
+      @woofer.woof
+    end
+  end
+
+Now we want to test Dog, but using a real Woofer object in the test is
+a real pain (why? ... well because Woofer plays a sound file of a dog
+barking, and that's really annoying during testing).
+
+So, how can we create a Dog object with mocked Woofer?  All we need to
+do is stub out the +new+ method of the Woofer class object and tell to
+to return anything we want.
+
+Here's the test code:
+
+  class TestDogBarking < Test::Unit::TestCase
+    include FlexMock::TestCase
+
+    # Setup the tests by stubbing the +new+ method of 
+    # Woofer and return a mock woofer.
+    def setup
+      flexstub(Woofer).should_receive(:new).and_return {
+        flexmock("woofer") do |mock|
+          mock.should_receive(:woof).and_return(:grrrr)
+        end
+      }
+    end
+
+    def test_bark
+      assert_equal :grrrr, @dog.bark
+    end
+  end
+
+The nice thing about stub is that after the test is over, the stubbed
+out methods are returned to their normal state.  Outside the test
+everything is back to normal.
+
+The stub technique was inspired by the +Stuba+ library in the +Mocha+
+project.
+
 === Class Interception
 
-FlexMock now support 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.
+<b>NOTE:</b> :: 
+  <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>
+
+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.
 
 Example:
 
@@ -340,8 +414,8 @@ effect.
 
    def test_multiple_gets
      file = flexmock('file')
-     return_values = ["line 1\n", "line 2\n"]
-     file.should_receive(:gets).with_no_args.and_return { return_values.shift }
+     file.should_receive(:gets).with_no_args.
+        and_return("line 1\n", "line 2\n")
      # test code here
    end
 
@@ -386,7 +460,6 @@ 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.
 
-
 = Other stuff
 
 Author::   Jim Weirich <jim@weirichhouse.org>

data/Rakefile

@@ -6,9 +6,10 @@ require 'rake/clean'
 require 'rake/rdoctask'
 require 'rake/testtask'
 
+CLEAN.include('*.tmp')
 CLOBBER.include("html", 'pkg')
 
-PKG_VERSION = '0.3.2'
+PKG_VERSION = '0.4.0'
 
 PKG_FILES = FileList[
   '[A-Z]*',
@@ -23,7 +24,6 @@ RDOC_FILES = FileList[
   'CHANGELOG',
   'lib/**/*.rb',
   'doc/**/*.rdoc',
-  'test/*.rb'
 ]
 
 
@@ -47,8 +47,7 @@ rd = Rake::RDocTask.new("rdoc") do |rdoc|
 #  rdoc.template = 'css2'
   rdoc.title    = "Flex Mock"
   rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
-  rdoc.rdoc_files.include('[A-Z][A-Z]*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include(RDOC_FILES)
 end
 
 task :rdoc => ["README"]
@@ -148,3 +147,6 @@ task :tag do
   sh %{svn copy #{SVNHOME}/trunk #{SVNHOME}/tags/rel-#{PKG_VERSION} -m 'Release #{PKG_VERSION}'}
 end
 
+task :dbg do
+  FileList['**/*.rb'].egrep(/DBG/)
+end

data/doc/releases/flexmock-0.4.0.rdoc

@@ -0,0 +1,99 @@
+= FlexMock 0.4.0 Released
+
+FlexMock is a flexible mocking library for use in Ruby's Test::Unit
+test framework.  Version 0.4.0 enhances FlexMock with the ability to
+stub and mock methods in existing objects.
+
+== Changes
+
+=== New Features in 0.4.0
+
+* You can now use the flexstub(object) method to mock or stub
+  individual methods in an existing object.  The original definitions
+  of the methods are restored at the end of a test.
+
+* The and_return (and its alias, returns) now accepts a list of
+  arguments and will return the values in the list one at a time for
+  each successive call to the mocked method.
+
+* The flexmock() method now accepts an initialization block so that a
+  mock can be created and configured in one step without using a local
+  variable.  This is really handy when mocking factory or creation
+  methods that in turn return a mock.
+
+== 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
+
+FlexMock is distributed with Rails, or 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

@@ -63,6 +63,7 @@ class FlexMock
     @mock_current_order = 0
     @mock_groups = {}
     @ignore_missing = false
+    @verified = false
   end
   
   # Handle all messages denoted by +sym+ by calling the given block
@@ -77,13 +78,19 @@ class FlexMock
   # 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
+        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
@@ -100,10 +107,10 @@ class FlexMock
   def method_missing(sym, *args, &block)
     mock_wrap do
       if handler = @expectations[sym]
-	args << block  if block_given?
-	handler.call(*args)
+        args << block  if block_given?
+        handler.call(*args)
       else
-	super(sym, *args, &block)  unless @ignore_missing
+        super(sym, *args, &block)  unless @ignore_missing
       end
     end
   end
@@ -179,7 +186,7 @@ class FlexMock
     #   end                               # mock is verified here
     #
     # NOTE: If you include FlexMock::TestCase into your test case
-    # file, you can create moks that will be automatically verified in
+    # file, you can create mocks that will be automatically verified in
     # the test teardown by using the +flexmock+ method. 
     #
     def use(*names)
@@ -192,7 +199,7 @@ class FlexMock
       raise
     ensure
       mocks.each do |mock|
-	mock.mock_verify     unless got_exception
+        mock.mock_verify     unless got_exception
       end
     end
     
@@ -200,9 +207,9 @@ class FlexMock
     # looking string.
     def format_args(sym, args)
       if args
-	"#{sym}(#{args.collect { |a| a.inspect }.join(', ')})"
+        "#{sym}(#{args.collect { |a| a.inspect }.join(', ')})"
       else
-	"#{sym}(*args)"
+        "#{sym}(*args)"
       end
     end
     
@@ -263,16 +270,16 @@ class FlexMock
     #
     # First, look for an expectation that matches the arguements and
     # is eligible to be called.  Failing that, look for a expectation
-    # that matches teh arguments (at this point it will be ineligible,
+    # that matches the arguments (at this point it will be ineligible,
     # but at least we will get a good failure message).  Finally,
     # check for expectations that don't have any argument matching
     # criteria.
     def call(*args)
       exp = @expectations.find { |e| e.match_args(args) && e.eligible? } ||
         @expectations.find { |e| e.match_args(args) } ||
-	@expectations.find { |e| e.expected_args.nil? }
+        @expectations.find { |e| e.expected_args.nil? }
       FlexMock.check("no matching handler found for " +
- 	FlexMock.format_args(@sym, args)) { ! exp.nil? }
+        FlexMock.format_args(@sym, args)) { ! exp.nil? }
       exp.verify_call(*args)
     end
 
@@ -290,7 +297,7 @@ class FlexMock
     # expectations.
     def mock_verify
       @expectations.each do |exp|
-	exp.mock_verify
+        exp.mock_verify
       end
     end
   end
@@ -388,7 +395,7 @@ class FlexMock
     # times.
     def validate(n)
       assert_equal @limit, n, 
-	"method '#{@exp}' called incorrect number of times"
+        "method '#{@exp}' called incorrect number of times"
     end
   end
 
@@ -400,8 +407,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
@@ -420,8 +427,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
 
@@ -477,8 +484,8 @@ class FlexMock
     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
+        "(expected order #{@order_number}, was #{@mock.mock_current_order})") {
+        @order_number >= @mock.mock_current_order
       }
       @mock.mock_current_order = @order_number
     end
@@ -488,7 +495,7 @@ class FlexMock
     # the teardown process.
     def mock_verify
       @count_validators.each do |v|
-	v.validate(@actual_count)
+        v.validate(@actual_count)
       end
     end
 
@@ -503,8 +510,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.
@@ -526,10 +533,17 @@ class FlexMock
     end
 
     # Declare that the method returns a particular value (when the
-    # argument list is matched).  If a block is given, it is evaluated
-    # on each call and its value is returned.  +and_return+ is an
-    # alias for +returns+.
+    # 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
@@ -537,11 +551,15 @@ class FlexMock
     #  mock.should_receive(:f).with(String). # returns an
     #    returns { |str| str.upcase }        # upcased string
     #
-    def returns(value=nil, &block)
-      @return_block = block_given? ? block : lambda { value }
+    # +and_return+ is an alias for +returns+.
+    #
+    def returns(*args, &block)
+      @return_block = block_given? ? 
+        block : 
+        lambda { args.size == 1 ? args.first : args.shift }
       self
     end
-    alias :and_return :returns	# :nodoc:
+    alias :and_return :returns  # :nodoc:
 
     # Declare that the method may be called any number of times.
     def zero_or_more_times
@@ -630,12 +648,12 @@ class FlexMock
     #
     def ordered(group_name=nil)
       if group_name.nil?
-	@order_number = @mock.mock_allocate_order
+        @order_number = @mock.mock_allocate_order
       elsif (num = @mock.mock_groups[group_name])
-	@order_number = num
+        @order_number = num
       else
-	@order_number = @mock.mock_allocate_order
-	@mock.mock_groups[group_name] = @order_number
+        @order_number = @mock.mock_allocate_order
+        @mock.mock_groups[group_name] = @order_number
       end
       self
     end
@@ -727,6 +745,10 @@ class FlexMock
           m.mock_verify
         end
       end
+    ensure
+      @flexmock_created_mocks.each do |m|
+        m.mock_teardown
+      end
       @flexmock_interceptors ||= []
       @flexmock_interceptors.each do |i|
         i.restore
@@ -736,13 +758,37 @@ class FlexMock
     # Create a FlexMock object with the given name.  Mocks created
     # with this method will be automatically verify during teardown
     # (assuming the the flexmock teardown isn't overridden).
+    #
+    # If a block is given, then the mock object is passed to the block and
+    # may be configured in the block.
     def flexmock(name="unknown")
-      result = FlexMock.new(name)
-      @flexmock_created_mocks ||= []
-      @flexmock_created_mocks << result
-      result
+      mock = FlexMock.new(name)
+      yield(mock) if block_given?
+      flexmock_remember(mock)
+      mock
     end
-
+    
+    # Stub the given object by overriding the behavior of individual methods.
+    # The stub object returned will respond to the +should_receive+ 
+    # method, just like normal stubs.  Singleton methods cannot be 
+    # stubbed.
+    #
+    # Example:  Stub out DBI to return a fake db connection.
+    #
+    #   flexstub(DBI).should_receive(:connect).and_return {
+    #     fake_db = flexmock("db connection")
+    #     fake_db.should_receive(:select_all).and_return(...)
+    #     fake_db
+    #   }
+    #
+    def flexstub(obj, name=nil)
+      name ||= "flexstub(#{obj.class.to_s})"
+      obj.instance_eval {
+        @flexmock_proxy ||= StubProxy.new(obj, FlexMock.new(name))
+      }
+      flexmock_remember(obj.instance_variable_get("@flexmock_proxy"))
+    end
+    
     # Intercept the named class in the target class for the duration
     # of the test.  Class interception is very simple-minded and has a
     # number of restrictions.  First, the intercepted class must be
@@ -762,6 +808,14 @@ class FlexMock
       @flexmock_interceptors << result
       result
     end
+    
+    private
+    
+    def flexmock_remember(mocking_object)
+      @flexmock_created_mocks ||= []
+      @flexmock_created_mocks << mocking_object
+      mocking_object
+    end
   end
 
   ####################################################################
@@ -880,4 +934,115 @@ class FlexMock
     end
   end
   
+  ####################################################################
+  # StubProxy is used to mate the mock framework to an existing
+  # object.  The object is "enhanced" with a reference to a mock
+  # object (stored in <tt>@flexmock_mock</tt>).  When the 
+  # +should_receive+ method is sent to the proxy, it overrides the 
+  # existing object's method by creating  singleton method that 
+  # forwards to the mock.  When testing is complete, StubProxy
+  # will erase the mocking infrastructure from the object being 
+  # stubbed (e.g. remove instance variables and mock singleton 
+  # methods).
+  #
+  class StubProxy
+    attr_reader :mock
+    
+    def initialize(obj, mock)
+      @obj = obj
+      @mock = mock
+      @methods_to_restore = []
+      @method_definitions = {}
+    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
+      if @obj.methods.include?(method_name.to_s)
+        @methods_to_restore << method_name
+      end
+      hide_existing_method(method_name)
+      @mock.should_receive(method_name)
+    end
+    
+    # Verify that the mock has been properly called.  After verification, 
+    # detach the mocking infrastructure from the existing object.
+    def mock_verify
+      @mock.mock_verify
+    end
+
+    # Remove all traces of the mocking framework from the existing object.
+    def mock_teardown
+      if ! detached?
+        @methods_to_restore.each do |method_name|
+          remove_current_method(method_name)
+          restore_original_definition(method_name) if @method_definitions[method_name]
+        end
+        @obj.instance_variable_set("@flexmock_proxy", nil)
+        @obj = nil
+      end
+    end
+
+    private
+
+    # The singleton class of the object.
+    def sclass
+      class << @obj; self; end
+    end
+
+    # Is the current method a singleton method in the object we are
+    # mocking?
+    def singleton?(method_name)
+      @obj.methods(false).include?(method_name.to_s)
+    end
+
+    # Hide the existing method definition with a singleton defintion
+    # that proxies to our mock object.  If the current definition is a
+    # singleton, we need to record the definition and remove it before
+    # creating our own singleton method.  If the current definition is
+    # not a singleton, all we need to do is override it with our own
+    # singleton.
+    def hide_existing_method(method_name)
+      if singleton?(method_name)
+        @method_definitions[method_name] = @obj.method(method_name)
+        remove_current_method(method_name)
+      end
+      define_proxy_method(method_name)
+    end
+
+    # Define a proxy method that forwards to our mock object.  The
+    # proxy method is defined as a singleton method on the object
+    # being mocked.
+    def define_proxy_method(method_name)
+      sclass.class_eval %{
+        def #{method_name}(*args, &block)
+          @flexmock_proxy.mock.#{method_name}(*args, &block)
+        end  
+      }
+    end
+
+    # Restore the original singleton defintion for method_name that
+    # was saved earlier.
+    def restore_original_definition(method_name)
+      method_def = @method_definitions[method_name]
+      if method_def
+        sclass.class_eval {
+          define_method(method_name, &method_def)
+        }
+      end
+    end
+
+    # Remove the current method if it is a singleton method of the
+    # object being mocked.
+    def remove_current_method(method_name)
+      sclass.class_eval { remove_method(method_name)  }
+    end
+
+    # Have we been detached from the existing object?
+    def detached?
+      @obj.nil?
+    end
+    
+  end
 end

data/test/test_class_interception.rb

@@ -1,5 +1,14 @@
 #!/usr/bin/env ruby
 
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
 

data/test/test_example.rb

@@ -1,5 +1,14 @@
 #!/usr/bin/env ruby
 
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
 

data/test/test_mock.rb

@@ -1,5 +1,14 @@
 #!/usr/bin/env ruby
 
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
 
@@ -78,8 +87,8 @@ class TestFlexMock < Test::Unit::TestCase
   def test_zero_counts
     assert_raises(Test::Unit::AssertionFailedError) do
       FlexMock.use { |m|
-	m.mock_handle(:blip, 0)
-	m.blip
+        m.mock_handle(:blip, 0)
+        m.blip
       }
     end
   end

data/test/test_naming.rb

@@ -1,5 +1,14 @@
 #!/usr/bin/env ruby
 
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
 

data/test/test_record_mode.rb

@@ -1,5 +1,14 @@
 #!/usr/bin/env ruby
 
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
 

data/test/test_samples.rb

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

data/test/test_should_receive.rb

@@ -1,5 +1,14 @@
 #!/usr/bin/env ruby
 
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
 
@@ -21,6 +30,17 @@ class TestFlexMockShoulds < Test::Unit::TestCase
       assert_equal 1, m.hi(123)
     end
   end
+  
+  def test_returns_with_multiple_values
+    FlexMock.use do |m|
+      m.should_receive(:hi).and_return(1,2,3)
+      assert_equal 1, m.hi
+      assert_equal 2, m.hi
+      assert_equal 3, m.hi
+      assert_equal 3, m.hi
+      assert_equal 3, m.hi
+    end
+  end
 
   def test_returns_with_block
     FlexMock.use do |m|

data/test/test_stubbing.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
+
+class TestStubbing < Test::Unit::TestCase
+  include FlexMock::TestCase
+  
+  class Dog
+    def bark
+      :woof
+    end
+    def Dog.create
+      :new_dog
+    end
+  end
+
+  def test_stub_command_add_behavior_to_arbitrary_objects
+    obj = Object.new
+    flexstub(obj).should_receive(:hi).once.and_return(:stub_hi)
+    assert_equal :stub_hi, obj.hi
+  end
+  
+  def test_stubbed_methods_can_take_blocks
+    obj = Object.new
+    flexstub(obj).should_receive(:with_block).once.with(Proc).
+      and_return { |block| block.call }
+    assert_equal :block, obj.with_block { :block }
+  end
+  
+  def test_multiple_stubs_on_the_same_object_reuse_the_same_stub_proxy
+    obj = Object.new
+    assert_equal flexstub(obj), flexstub(obj)
+  end
+  
+  def test_multiple_methods_can_be_stubbed
+    dog = Dog.new
+    flexstub(dog).should_receive(:bark).and_return(:grrrr)
+    flexstub(dog).should_receive(:wag).and_return(:happy)
+    assert_equal :grrrr, dog.bark
+    assert_equal :happy, dog.wag
+  end
+  
+  def test_original_behavior_can_be_restored
+    dog = Dog.new
+    stub_proxy = flexstub(dog)
+    stub_proxy.should_receive(:bark).once.and_return(:growl)
+    assert_equal :growl, dog.bark
+    stub_proxy.mock_teardown
+    assert_equal :woof, dog.bark
+    assert_equal nil, dog.instance_variable_get("@flexmock_proxy")
+    assert ! dog.methods.include?("flexmock_old_bark")
+  end
+  
+  def test_original_missing_behavior_can_be_restored
+    obj = Object.new
+    stub_proxy = flexstub(obj)
+    stub_proxy.should_receive(:hi).once.and_return(:ok)
+    assert_equal :ok, obj.hi
+    stub_proxy.mock_teardown
+    assert_raise(NoMethodError) { obj.hi }
+  end
+  
+  def test_original_behavior_is_restored_when_multiple_methods_are_mocked
+    dog = Dog.new
+    flexstub(dog).should_receive(:bark).and_return(:grrrr)
+    flexstub(dog).should_receive(:wag).and_return(:happy)
+    flexstub(dog).mock_teardown
+    assert_equal :woof, dog.bark
+    assert_raise(NoMethodError) { dog.wag }
+  end
+
+  def test_original_behavior_is_restored_on_class_objects
+    flexstub(Dog).should_receive(:create).once.and_return(:new_stub)
+    assert_equal :new_stub, Dog.create
+    flexstub(Dog).mock_teardown
+    assert_equal :new_dog, Dog.create    
+  end
+
+  def test_original_behavior_is_restored_on_singleton_methods
+    obj = Object.new
+    def obj.hi() :hello end
+    flexstub(obj).should_receive(:hi).once.and_return(:hola)
+
+    assert_equal :hola, obj.hi
+    flexstub(obj).mock_teardown
+    assert_equal :hello, obj.hi
+  end
+
+  def test_original_behavior_is_restored_even_when_errors
+    flexstub(Dog).should_receive(:create).once.and_return(:mock)
+    flexmock_teardown rescue nil
+    assert_equal :new_dog, Dog.create
+
+    # Now disable the mock so that it doesn't cause errors on normal
+    # test teardown
+    m = flexstub(Dog).mock
+    def m.mock_verify() end
+  end
+
+  def test_mock_is_verified_when_the_stub_is_verified
+    obj = Object.new
+    stub_proxy = flexstub(obj)
+    stub_proxy.should_receive(:hi).once.and_return(:ok)
+    assert_raise(Test::Unit::AssertionFailedError) { 
+      stub_proxy.mock_verify
+    }
+  end
+  
+  def test_stub_can_have_explicit_name
+    obj = Object.new
+    stub_proxy = flexstub(obj, "Charlie")
+    assert_equal "Charlie", stub_proxy.mock.mock_name
+  end
+
+  def test_unamed_stub_will_use_default_naming_convention
+    obj = Object.new
+    stub_proxy = flexstub(obj)
+    assert_equal "flexstub(Object)", stub_proxy.mock.mock_name
+  end
+  
+end

data/test/test_tu_integration.rb

@@ -1,8 +1,34 @@
 #!/usr/bin/env ruby
 
+#---
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# 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'
 
+class TestTuIntegrationFlexMockMethod < Test::Unit::TestCase
+  include FlexMock::TestCase
+  
+  def test_can_construct_flexmock
+    mock = flexmock("x")
+    mock.should_receive(:hi).and_return(:hello)
+    assert_equal :hello, mock.hi
+  end
+  
+  def test_can_construct_flexmock_with_block
+    mock = flexmock("x") do |m|
+      m.should_receive(:hi).and_return(:hello)
+    end
+    assert_equal :hello, mock.hi
+  end
+end
+
 class TestTuIntegrationMockVerificationInTeardown < Test::Unit::TestCase
   include FlexMock::TestCase
 

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.99.1
+rubygems_version: 0.9.0.1
 specification_version: 1
 name: flexmock
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
-date: 2006-06-17 00:00:00 -04:00
+  version: 0.4.0
+date: 2006-09-04 00:00:00 -04:00
 summary: Simple and Flexible Mock Objects for Testing
 require_paths: 
 - lib
@@ -40,9 +40,11 @@ files:
 - test/test_record_mode.rb
 - test/test_samples.rb
 - test/test_should_receive.rb
+- test/test_stubbing.rb
 - test/test_tu_integration.rb
 - flexmock.blurb
 - install.rb
+- doc/releases/flexmock-0.4.0.rdoc
 test_files: []
 
 rdoc_options: 
@@ -52,8 +54,9 @@ rdoc_options:
 - README
 - --line-numbers
 extra_rdoc_files: 
-- CHANGELOG
 - README
+- CHANGELOG
+- doc/releases/flexmock-0.4.0.rdoc
 executables: []
 
 extensions: []