flexmock 0.3.0 → 0.3.1

data/CHANGELOG

@@ -1,5 +1,13 @@
 = Changes for FlexMock
 
+== Version 0.3.1
+
+* Fixed some warnings regarding uniniitalized 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
+  test has already failed for some reason.
+
 == Version 0.3.0
 
 * Added Test::Unit integration.

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.3.0
+Version :: 0.3.1
 
 = Links
 
@@ -215,6 +215,25 @@ The following rules are used for argument matching:
 
   will match any even integer.
 
+=== 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.
+
+Example:
+
+Suppose we are testing class Foo, and Foo uses Bar internally.  We
+would like for Bar.new to return a mock object during the test.
+
+   def test_foo_with_an_intercepted_bar
+     my_mock = flexmock("my_mock").should_receive(....).mock
+     intercept(Bar).in(Foo).with(my_mock.mock_factory)
+
+     bar = Bar.new
+     bar.do_something
+   end
+
 == Examples
 
 === Expect multiple queries and a single update

data/Rakefile

@@ -8,7 +8,7 @@ require 'rake/testtask'
 
 CLOBBER.include("html", 'pkg')
 
-PKG_VERSION = '0.3.0'
+PKG_VERSION = '0.3.1'
 
 PKG_FILES = FileList[
   '[A-Z]*',
@@ -34,6 +34,7 @@ task :default => [:test]
 Rake::TestTask.new do |t|
   t.pattern = 'test/test*.rb'
   t.verbose = true
+  t.warning = true
 end
 
 # RDoc Target --------------------------------------------------------

data/lib/flexmock.rb

@@ -60,6 +60,7 @@ class FlexMock
     @allocated_order = 0
     @mock_current_order = 0
     @mock_groups = {}
+    @ignore_missing = false
   end
   
   # Handle all messages denoted by +sym+ by calling the given block
@@ -150,6 +151,12 @@ class FlexMock
     yield Recorder.new(self)
   end
 
+  # Return a factory object that returns this mock.  This is useful in
+  # Class Interception.
+  def mock_factory
+    Factory.new(self)
+  end
+
   class << self
     include Test::Unit::Assertions
 
@@ -216,6 +223,27 @@ class FlexMock
       ex.backtrace
   end
 
+  ####################################################################
+  # A Factory object is returned from a mock_factory method call.  The
+  # factory merely returns the manufactured object it is initialized
+  # with.  The factory is handy to use with class interception,
+  # allowing the intercepted class to return the mock object.
+  #
+  # If the user needs more control over the mock factory, they are
+  # free to create their own.
+  #
+  # Typical Usage:
+  #    intercept(Bar).in(Foo).with(a_mock.mack_factory)
+  #
+  class Factory
+    def initialize(manufactured_object)
+      @obj = manufactured_object
+    end
+    def new(*args, &block)
+      @obj
+    end
+  end
+
   ####################################################################
   # The expectation director is responsible for routing calls to the
   # correct expectations for a given argument list.
@@ -691,9 +719,15 @@ class FlexMock
     
     # Do the flexmock specific teardown stuff.
     def flexmock_teardown
-      return if @flexmock_created_mocks.nil?
-      @flexmock_created_mocks.each do |m|
-        m.mock_verify
+      @flexmock_created_mocks ||= []
+      if passed?
+        @flexmock_created_mocks.each do |m|
+          m.mock_verify
+        end
+      end
+      @flexmock_interceptors ||= []
+      @flexmock_interceptors.each do |i|
+        i.restore
       end
     end
 
@@ -706,5 +740,133 @@ class FlexMock
       @flexmock_created_mocks << result
       result
     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
+    # reference in the tested class via a simple constant name
+    # (e.g. no scoped names using "::") that is not directly defined
+    # in the class itself.  After the test, a proxy class constant
+    # will be left behind that will forward all calls to the original
+    # class.
+    #
+    # Usage:
+    #   intercept(SomeClass).in(ClassBeingTested).with(MockClass)
+    #   intercept(SomeClass).with(MockClass).in(ClassBeingTested)
+    #
+    def intercept(intercepted_class)
+      result = Interception.new(intercepted_class)
+      @flexmock_interceptors ||= []
+      @flexmock_interceptors << result
+      result
+    end
   end
+
+  ####################################################################
+  # A Class Interception defines a constant in the target class to be
+  # a proxy that points to a replacement class for the duration of a
+  # test.  When an interception is restored, the proxy will point to
+  # the original intercepted class.
+  #
+  class Interception
+    # Create an interception object with the class to intercepted.
+    def initialize(intercepted_class)
+      @intercepted = nil
+      @target  = nil
+      @replacement = nil
+      intercept(intercepted_class)
+      update
+    end
+
+    # Intercept this class in the class to be tested.
+    def intercept(intercepted_class)
+      @intercepted = intercepted_class
+      update
+      self
+    end
+    
+    # Define the class number test that will receive the
+    # interceptioned definition.
+    def in(target_class)
+      @target = target_class
+      update
+      self
+    end
+
+    # Define the replacement class.  This is normally a proxy or a
+    # stub.
+    def with(replacement_class)
+      @replacement = replacement_class
+      update
+      self
+    end
+
+    # Restore the original class.  The proxy remains in place however.
+    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?
+      @intercepted && @target && @replacement
+    end
+
+    # Implement interception on the classes defined.
+    def do_interception
+      @target_class = coerce_class(@target)
+      @replacement_class = coerce_class(@replacement)
+      case @intercepted
+      when String, Symbol
+        @intercepted_name = @intercepted.to_s
+      when Class
+        @intercepted_name = @intercepted.name
+      end
+      @intercepted_class = coerce_class(@intercepted)
+      current_class = @target_class.const_get(@intercepted_name)
+      if ClassProxy === current_class
+        @proxy = current_class
+        @restore_class = @proxy.proxied_class
+        @proxy.proxied_class = @replacement_class
+      else
+        @proxy = ClassProxy.new(@replacement_class)
+        @restore_class = current_class
+        @target_class.const_set(@intercepted_name, @proxy)
+      end
+    end
+
+    # Coerce a class object, string to symbol to be the class object.
+    def coerce_class(klass)
+      case klass
+      when String, Symbol
+        Object.const_get(klass.to_s)
+      when Class
+        klass
+      end
+    end
+  end
+
+  ####################################################################
+  # Class Proxy for class interception.  Forward all method calls to
+  # whatever is the proxied_class.
+  #
+  class ClassProxy
+    attr_accessor :proxied_class
+    def initialize(default_class)
+      @proxied_class = default_class
+    end
+    def method_missing(sym, *args, &block)
+      @proxied_class.__send__(sym, *args, &block)
+    end
+  end
+  
 end

data/test/test_class_interception.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'flexmock'
+
+module A
+  class B
+    def sample
+      :ab
+    end
+  end
+end
+
+class Bark
+  def listen
+    :woof
+  end
+  def Bark.identify
+    :barking
+  end
+end
+
+class Meow
+  def listen
+    :meow
+  end
+end
+
+class Dog
+  def bark
+    Bark.new
+  end
+  def wag
+    A::B.new
+  end
+  def bark_id
+    Bark.identify
+  end
+end
+
+class TestClassInterception < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def test_original_functionality
+    dog = Dog.new
+    assert_equal :woof, dog.bark.listen
+    assert_equal :ab, dog.wag.sample
+  end
+
+  def test_interception
+    interceptor = intercept(Bark).in(Dog).with(Meow)
+    assert_kind_of FlexMock::ClassProxy, Dog::Bark
+    assert_equal Meow, Dog::Bark.proxied_class
+    dog = Dog.new
+    assert_equal :meow, dog.bark.listen
+  ensure
+    interceptor.restore if interceptor
+  end
+
+  # Since interception leaves a proxy class behind, we want to make
+  # sure interception works twice on the same object.  So we repeat
+  # this test in full.  We don't know which tests will _actually_ run
+  # first, but it doesn't matter as long as it is done twice.
+  def test_interception_repeated
+    test_interception
+  end
+
+  def test_interception_with_strings
+    interceptor = intercept("Bark").in("Dog").with("Meow")
+    assert_equal :meow, Dog.new.bark.listen
+  ensure
+    interceptor.restore if interceptor
+  end
+
+  def test_interception_with_symbols
+    interceptor = intercept(:Bark).in(:Dog).with(:Meow)
+    assert_equal :meow, Dog.new.bark.listen
+  ensure
+    interceptor.restore if interceptor
+  end
+
+  def test_interception_with_mixed_identifiers
+    interceptor = intercept(:Bark).in("Dog").with(Meow)
+    assert_equal :meow, Dog.new.bark.listen
+  ensure
+    interceptor.restore if interceptor
+  end
+
+  def test_interception_proxy_forward_other_methods
+    d = Dog.new
+    assert_equal :barking, d.bark_id
+
+    interceptor = intercept(:Bark).in("Dog").with(Meow)
+    interceptor.restore
+
+    d = Dog.new
+    assert_equal :barking, d.bark_id
+  end
+
+end
+
+class TestMockFactory < Test::Unit::TestCase
+  def test_mock_returns_factory
+    m = FlexMock.new("m")
+    f = m.mock_factory
+    assert_equal m, f.new
+  end
+end

data/test/test_mock.rb

@@ -38,7 +38,7 @@ class TestFlexMock < Test::Unit::TestCase
     ex = assert_raises(expected_error) {
       @mock.not_defined
     }
-    assert_match /not_defined/, ex.message
+    assert_match(/not_defined/, ex.message)
   end
 
   def test_ignore_missing_method
@@ -116,7 +116,7 @@ class TestFlexMock < Test::Unit::TestCase
 	xyz
       end
     }
-    assert_match /undefined local variable or method/, ex.message
+    assert_match(/undefined local variable or method/, ex.message)
   end
 
   def test_sequential_values

data/test/test_naming.rb

@@ -15,7 +15,7 @@ class TestNaming < Test::Unit::TestCase
       m.should_receive(:xx).with(1)
       m.xx(2)
     }
-    assert_match /'mmm'/, ex.message
+    assert_match(/'mmm'/, ex.message)
   end
 
   def test_name_in_received_count_error
@@ -24,7 +24,7 @@ class TestNaming < Test::Unit::TestCase
       m.should_receive(:xx).once
       m.mock_verify
     }
-    assert_match /'mmm'/, ex.message
+   assert_match(/'mmm'/, ex.message)
   end
 
   def test_naming_with_use

data/test/test_should_receive.rb

@@ -171,6 +171,26 @@ class TestFlexMockShoulds < Test::Unit::TestCase
     end
   end
 
+  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 }
+      }
+    end
+  end
+
+  def test_block_arg_given_to_matching_proc
+    FlexMock.use do |m|
+      arg = nil
+      m.should_receive(:hi).with(Proc).once.
+        and_return { |block| arg = block; block.call }
+      result = m.hi { 1 }
+      assert_equal 1, arg.call
+      assert_equal 1, result
+    end
+  end
+
   def test_arg_matching_precedence_when_best_first
     FlexMock.use("greeter") do |m|
       m.should_receive(:hi).with(1).once

data/test/test_tu_integration.rb

@@ -6,10 +6,6 @@ require 'flexmock'
 class TestTuIntegrationMockVerificationInTeardown < Test::Unit::TestCase
   include FlexMock::TestCase
 
-  def setup
-    super
-  end
-
   def teardown
     assert_raise(Test::Unit::AssertionFailedError) do
       super
@@ -38,9 +34,6 @@ end
 class TestTuIntegrationMockVerificationForgetfulSetup < Test::Unit::TestCase
   include FlexMock::TestCase
 
-  def setup
-  end
-
   def teardown
     assert_raise(Test::Unit::AssertionFailedError) do
       super
@@ -55,9 +48,21 @@ end
 class TestTuIntegrationSetupOverridenAndNoMocksOk < Test::Unit::TestCase
   include FlexMock::TestCase
 
-  def setup
+  def test_mock_verification_occurs_during_teardown
   end
+end
+
+class TestTuIntegrationFailurePreventsVerification < Test::Unit::TestCase
+  include FlexMock::TestCase
 
   def test_mock_verification_occurs_during_teardown
+    flexmock('m').should_receive(:hi).once
+    simulate_failure
+  end
+
+  private
+
+  def simulate_failure
+    @test_passed = false
   end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11.15
+rubygems_version: 0.8.11
 specification_version: 1
 name: flexmock
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
-date: 2006-05-14 00:00:00 -04:00
+  version: 0.3.1
+date: 2006-06-17 00:00:00 -04:00
 summary: Simple and Flexible Mock Objects for Testing
 require_paths: 
 - lib
@@ -25,7 +25,6 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
-post_install_message: 
 authors: 
 - Jim Weirich
 files: 
@@ -33,12 +32,13 @@ files:
 - Rakefile
 - README
 - lib/flexmock.rb
-- test/test_record_mode.rb
-- test/test_should_receive.rb
-- test/test_samples.rb
+- test/test_class_interception.rb
+- test/test_example.rb
 - test/test_mock.rb
 - test/test_naming.rb
-- test/test_example.rb
+- test/test_record_mode.rb
+- test/test_samples.rb
+- test/test_should_receive.rb
 - test/test_tu_integration.rb
 - flexmock.blurb
 - install.rb