flexmock 0.1.3 → 0.1.4

data/CHANGELOG

@@ -1,5 +1,10 @@
 = Changes for FlexMock
 
+== Version 0.1.4
+
+* Added eq and any methods for argument matching.
+* Added tests for the "first match" argument matching policy.
+
 == Version 0.1.3
 
 * Improved the definition of ordered so that it takes group names

data/README

@@ -3,7 +3,7 @@
 FlexMock is a simple mock object for unit testing.  The interface is
 simple, but still provides a good bit of flexibility.
 
-Version :: 0.1.3
+Version :: 0.1.4
 
 = Links
 
@@ -143,9 +143,12 @@ values to figure out what value to return.
 
    FlexMock('db').use |db|
      db.should_receive(:startup).once.ordered
-     db.should_receive(:query).with("CPWR").and_return(12.3).once.ordered(10)
-     db.should_receive(:query).with("MSFT").and_return(10.0).once.ordered(10)
-     db.should_receive(:query).with(/^....$/).and_return(3.3).at_least.once.ordered(10)
+     db.should_receive(:query).with("CPWR").and_return(12.3).
+       once.ordered(:queries)
+     db.should_receive(:query).with("MSFT").and_return(10.0).
+       once.ordered(:queries)
+     db.should_receive(:query).with(/^....$/).and_return(3.3).
+       at_least.once.ordered(:queries)
      db.should_receive(:finish).once.ordered
      # test code here
    end

data/Rakefile

@@ -8,7 +8,7 @@ require 'rake/testtask'
 
 CLOBBER.include("html", 'pkg')
 
-PKG_VERSION = '0.1.3'
+PKG_VERSION = '0.1.4'
 
 PKG_FILES = FileList[
   '[A-Z]*',

data/lib/flexmock.rb

@@ -118,50 +118,54 @@ class FlexMock
     result
   end
 
-  # 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
-  #
-  def self.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 << self
+    include Test::Unit::Assertions
 
-  
-  # Class method to format a method name and argument list as a nice
-  # looking string.
-  def self.format_args(sym, args)
-    if args
-      "#{sym}(#{args.collect { |a| a.inspect }.join(', ')})"
-    else
-      "#{sym}(*args)"
+    # 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
+    #
+    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
-
-  # Class method to consistently form failure exceptions
-  def self.failure(msg)
-    fail Test::Unit::AssertionFailedError, msg
   end
 
   private
@@ -193,10 +197,8 @@ class FlexMock
     def call(*args)
       exp = @expectations.find { |e| e.match_args(args) } ||
 	@expectations.find { |e| e.expected_args.nil? }
-      if exp.nil?
-	FlexMock.failure "no matching handler found for " +
-	  FlexMock.format_args(@sym, args)
-      end
+      FlexMock.check("no matching handler found for " +
+ 	FlexMock.format_args(@sym, args)) { ! exp.nil? }
       exp.verify_call(*args)
     end
 
@@ -219,13 +221,58 @@ class FlexMock
     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
+
+  ####################################################################
+  # 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
+  end
+
   ####################################################################
   # Base class for all the count validators.
   #
   class CountValidator
     include Test::Unit::Assertions
-    def initialize(sym, limit)
-      @sym = sym
+    def initialize(expectation, limit)
+      @exp = expectation
       @limit = limit
     end
   end
@@ -238,7 +285,7 @@ class FlexMock
     # times.
     def validate(n)
       assert_equal @limit, n, 
-	"method '#{@sym}' called incorrect number of times"
+	"method '#{@exp}' called incorrect number of times"
     end
   end
 
@@ -250,7 +297,7 @@ class FlexMock
     # times.
     def validate(n)
       assert n >= @limit,
-	"Method '#{@sym}' should be called at least #{@limit} times,\n" +
+	"Method '#{@exp}' should be called at least #{@limit} times,\n" +
 	"only called #{n} times"
     end
   end
@@ -262,7 +309,7 @@ class FlexMock
     # Validate the method expectation was called at least +n+ times.
     def validate(n)
       assert n <= @limit,
-	"Method '#{@sym}' should be called at most #{@limit} times,\n" +
+	"Method '#{@exp}' should be called at most #{@limit} times,\n" +
 	"only called #{n} times"
     end
   end
@@ -312,10 +359,10 @@ class FlexMock
     # Validate that the order 
     def validate_order
       return if @order_number.nil?
-      if @order_number < @mock.mock_current_order
-	FlexMock.failure "method #{to_s} called out of order " +
-	  "(expected order #{@order_number}, was #{@mock.mock_current_order})"
-      end
+      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
@@ -388,7 +435,7 @@ class FlexMock
     # declared argument list.  This may be modified by the +at_least+
     # and +at_most+ declarators.
     def times(limit)
-      @count_validators << @count_validator_class.new(@sym, limit) unless limit.nil?
+      @count_validators << @count_validator_class.new(self, limit) unless limit.nil?
       @count_validator_class = ExactCountValidator
       self
     end
@@ -448,7 +495,7 @@ class FlexMock
     # 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
+    # a _group_ _name_ may be specified in the +ordered+ calls.  All
     # messages within the same group may be recieved in any order.
     #
     # For example, in the following, messages +flip+ and +flop+ may be
@@ -476,4 +523,6 @@ class FlexMock
       self
     end
   end
+
+  extend ArgumentTypes
 end

data/test/test_should_receive.rb

@@ -3,7 +3,7 @@
 require 'test/unit'
 require 'flexmock'
 
-class TestFlexMock < Test::Unit::TestCase
+class TestFlexMockShoulds < Test::Unit::TestCase
 
   def test_defaults
     FlexMock.use do |m|
@@ -64,7 +64,7 @@ class TestFlexMock < Test::Unit::TestCase
     end
   end
 
-  def test__with_any_args
+  def test_with_any_args
     FlexMock.use do |m|
       m.should_receive(:hi).with_any_args
       m.hi
@@ -74,6 +74,40 @@ class TestFlexMock < Test::Unit::TestCase
     end
   end
 
+  def test_with_any_single_arg_matching
+    FlexMock.use('greeter') do |m|
+      m.should_receive(:hi).with(1,FlexMock.any).twice
+      m.hi(1,2)
+      m.hi(1, "this is a test")
+    end
+  end
+
+  def test_with_any_single_arg_nonmatching
+    FlexMock.use('greeter') do |m|
+      m.should_receive(:hi).times(3)
+      m.should_receive(:hi).with(1,FlexMock.any).never
+      m.hi
+      m.hi(1)
+      m.hi(1, "hi", nil)
+    end
+  end
+
+  def test_with_equal_arg_matching
+    FlexMock.use('greeter') do |m|
+      m.should_receive(:hi).with(FlexMock.eq(Object)).once
+      m.hi(Object)
+    end
+  end
+
+  def test_with_equal_arg_nonmatching
+    FlexMock.use('greeter') do |m|
+      m.should_receive(:hi).with(FlexMock.eq(Object)).never
+      m.should_receive(:hi).never
+      m.should_receive(:hi).with(1).once
+      m.hi(1)
+    end
+  end
+
   def test_args_matching_with_regex
     FlexMock.use do |m|
       m.should_receive(:hi).with(/one/).returns(10)
@@ -113,6 +147,22 @@ class TestFlexMock < Test::Unit::TestCase
     end
   end
 
+  def test_arg_matching_precedence_when_best_first
+    FlexMock.use("greeter") do |m|
+      m.should_receive(:hi).with(1).once
+      m.should_receive(:hi).with(FlexMock.any).never
+      m.hi(1)
+    end
+  end
+
+  def test_arg_matching_precedence_when_best_last_but_still_matches_first
+    FlexMock.use("greeter") do |m|
+      m.should_receive(:hi).with(FlexMock.any).once
+      m.should_receive(:hi).with(1).never
+      m.hi(1)
+    end
+  end
+
   def test_never_and_never_called
     FlexMock.use do |m|
       m.should_receive(:hi).with(1).never
@@ -438,3 +488,13 @@ class TestFlexMock < Test::Unit::TestCase
   end
 
 end
+
+class TestFlexMockShouldsWithInclude < Test::Unit::TestCase
+  include FlexMock::ArgumentTypes
+  def test_include
+    FlexMock.use("x") do |m|
+      m.should_receive(:hi).with(any).once
+      m.hi(1)
+    end
+  end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10.100
+rubygems_version: 0.8.11.3
 specification_version: 1
 name: flexmock
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
-date: 2005-10-27 00:00:00 -04:00
+  version: 0.1.4
+date: 2005-11-02 00:00:00 -05:00
 summary: Simple and Flexible Mock Objects for Testing
 require_paths: 
   - lib