flexmock 0.2.0 → 0.2.1

data/CHANGELOG

@@ -1,5 +1,12 @@
 = Changes for FlexMock
 
+== Version 0.2.1
+
+* Added strict mode in record mode interface to facility using known
+  good algorithms for comparison testing.
+* Improved the docs and examples.  Fixed garbled first example in
+  README. 
+	
 == Version 0.2.0
 
 * Added record mode for building expectations.

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.2.0
+Version :: 0.2.1
 
 = Links
 
@@ -40,10 +40,11 @@ Here's the complete example:
     def test_tempurature_sampler
       readings = [10, 12, 14]
       FlexMock.use("temp") do |sensor|
-        sensor = FlexMock.new
         sensor.should_receive(:read_temperature).and_return { readings.shift }
-      sampler = TemperatureSampler.new(sensor)
-      assert_equal 12, sampler.average_temp
+
+        sampler = TemperatureSampler.new(sensor)
+        assert_equal 12, sampler.average_temp
+      end
     end
   end
 
@@ -226,7 +227,7 @@ All the query message must occur before any of the update messages.
 
    FlexMock('db').use |db|
      db.should_receive(:query).and_return([1,2,3]).ordered
-     db.should_receive(:update).and_return(nil).ordered
+     db.should_recieve(:update).and_return(nil).ordered
      # test code here
    end
 
@@ -254,19 +255,45 @@ values to figure out what value to return.
      # test code here
    end
 
-=== Same as above, but using the record mode interface
+=== Same as above, but using the Record Mode interface
+
+The record mode interface offers much the same features as the
++should_receive+ interface introduced so far, but it allows the
+messages to be sent directly to a recording object rather than be
+specified indirectly using a symbol. 
 
    FlexMock('db').use |db|
      db.should_expect do |rec|
        rec.startup.once.ordered
        rec.query("CPWR") { 12.3 }.once.ordered(:queries)
        rec.query("MSFT") { 10.0 }.once.ordered(:queries)
-       rec.query(/^....$/) { 3.3 }.at_least.once.ordered(:queries)
-       rec.finish.once.ordered
+       rec.query("^....$/) { 3.3 }.at_least.once.ordered(:queries)
+       rec.finish)once.ordered
      end
-     # test code here
+     # test code here using +db+.
    end
 
+=== Using Record Mode to record a known, good algorithm for testing
+
+Record mode is nice when you have a known, good algorithm that can use
+a recording mock object to record the steps.  Then you compare the
+execution of a new algorithm to behavior of the old using the recorded
+expectations in the mock.  For this you probably want to put the
+recorder in _strict_ mode so that the recorded expectations use exact
+matching on argument lists, and strict ordering of the method calls.
+
+<b>Note:</b> This is most useful when there are no queries on the mock
+objects, because the query responses cannot be programmed into the
+recorder object.
+
+  FlexMock.use('builder') do |builder|
+    builder.should_expect do |rec|
+      rec.should_be_strict
+      known_good_way_to_build_xml(rec)  # record the messages
+    end
+    new_way_to_build_xml(builder)       # compare to new way
+  end
+
 === Expect multiple calls, returning a different value each time
 
 Sometimes you need to return different values for each call to a

data/Rakefile

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

data/lib/flexmock.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 #---
-# Copyright 2003, 2004, 2005 by Jim Weirich (jim@weirichhouse.org).
+# Copyright 2003, 2004, 2005, 2006 by Jim Weirich (jim@weirichhouse.org).
 # All rights reserved.
 
 # Permission is granted for use, copying, modification, distribution,
@@ -213,8 +213,16 @@ class FlexMock
     end
 
     # Invoke the expectations for a given set of arguments.
+    #
+    # First, look for an expectation that matches the arguements and
+    # is eligible to be called.  Failing that, look for a expectation
+    # that matches teh 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) } ||
+      exp = @expectations.find { |e| e.match_args(args) && e.eligible? } ||
+        @expectations.find { |e| e.match_args(args) } ||
 	@expectations.find { |e| e.expected_args.nil? }
       FlexMock.check("no matching handler found for " +
  	FlexMock.format_args(@sym, args)) { ! exp.nil? }
@@ -315,6 +323,13 @@ class FlexMock
       @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
 
   ####################################################################
@@ -340,6 +355,14 @@ class FlexMock
 	"Method '#{@exp}' should be called at least #{@limit} times,\n" +
 	"only called #{n} times"
     end
+
+    # If the expectation has been called +n+ times, is it still
+    # eligible to be called again?  Since this validator only
+    # establishes a lower limit, not an upper limit, then the answer
+    # is always true.
+    def eligible?(n)
+      true
+    end
   end
 
   ####################################################################
@@ -396,6 +419,12 @@ class FlexMock
       @return_block.call(*args)
     end
 
+    # Is this expectation eligible to be called again?  It is eligible
+    # only if all of its count validators agree that it is eligible.
+    def eligible?
+      @count_validators.all? { |v| v.eligible?(@actual_count) }
+    end
+
     # Validate that the order 
     def validate_order
       return if @order_number.nil?
@@ -569,15 +598,53 @@ class FlexMock
   # 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)
-      @mock.should_receive(sym).and_return(&block).with(*args)
+      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
   

data/test/test_record_mode.rb

@@ -106,4 +106,55 @@ class TestRecordMode < Test::Unit::TestCase
     end
   end
 
+  def test_strict_record_mode_requires_exact_argument_matches
+    assert_fails do
+      FlexMock.use("mock") do |mock|
+        mock.should_expect do |rec|
+          rec.should_be_strict
+          rec.f(Integer)
+        end
+        mock.f(3)
+      end
+    end
+  end
+
+  def test_strict_record_mode_requires_exact_ordering
+    assert_fails do
+      FlexMock.use("mock") do |mock|
+        mock.should_expect do |rec|
+          rec.should_be_strict
+          rec.f(1)
+          rec.f(2)
+        end
+        mock.f(2)
+        mock.f(1)
+      end
+    end
+  end
+
+  def test_strict_record_mode_requires_once
+    assert_fails do
+      FlexMock.use("mock") do |mock|
+        mock.should_expect do |rec|
+          rec.should_be_strict
+          rec.f(1)
+        end
+        mock.f(1)
+        mock.f(1)
+      end
+    end
+  end
+
+  def test_strict_record_mode_can_not_fail
+    FlexMock.use("mock") do |mock|
+      mock.should_expect do |rec|
+        rec.should_be_strict
+        rec.f(Integer)
+        rec.f(2)
+      end
+      mock.f(Integer)
+      mock.f(2)
+    end
+  end
+
 end

data/test/test_should_receive.rb

@@ -507,6 +507,25 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     assert_equal 'f(1, "two", /^3$/)', exp.to_s
   end
 
+  def test_explicit_ordering_with_limits_allow_multiple_return_values
+    FlexMock.use('mock') do |m|
+      m.should_receive(:f).with(2).once.and_return { :first_time }
+      m.should_receive(:f).with(2).twice.and_return { :second_or_third_time }
+      m.should_receive(:f).with(2).and_return { :forever }
+
+      assert_equal :first_time, m.f(2)
+      assert_equal :second_or_third_time, m.f(2)
+      assert_equal :second_or_third_time, m.f(2)
+      assert_equal :forever, m.f(2)
+      assert_equal :forever, m.f(2)
+      assert_equal :forever, m.f(2)
+      assert_equal :forever, m.f(2)
+      assert_equal :forever, m.f(2)
+      assert_equal :forever, m.f(2)
+      assert_equal :forever, m.f(2)
+    end
+  end
+
   def assert_failure
     assert_raises(Test::Unit::AssertionFailedError) do yield end
   end

metadata

@@ -1,9 +1,9 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11.6
+rubygems_version: 0.8.11.5
 specification_version: 1
 name: flexmock
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 date: 2006-03-21 00:00:00 -05:00
 summary: Simple and Flexible Mock Objects for Testing
 require_paths: 
@@ -32,8 +32,8 @@ files:
 - Rakefile
 - README
 - lib/flexmock.rb
-- test/test_record_mode.rb
 - test/test_should_receive.rb
+- test/test_record_mode.rb
 - test/test_samples.rb
 - test/test_mock.rb
 - test/test_naming.rb