hardmock 1.3.0 → 1.3.1

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rake'
 require 'rubygems'
 
-HARDMOCK_VERSION = "1.3.0"
+HARDMOCK_VERSION = "1.3.1"
 
 Dir["lib/tasks/*.rake"].each { |f| load f }
 

data/lib/hardmock.rb

@@ -15,6 +15,11 @@ module Hardmock
   # with inherited, pre-mixed or post-added user teardowns.
   def self.included(base) #:nodoc:#
     base.class_eval do 
+      # Core of our actual setup behavior
+      def hardmock_setup
+        prepare_hardmock_control
+      end
+      
       # Core of our actual teardown behavior
       def hardmock_teardown
         verify_mocks
@@ -24,6 +29,24 @@ module Hardmock
       def self.method_added(symbol) #:nodoc:
       end
 
+      if method_defined?(:setup) then
+        # Wrap existing setup
+        alias_method :old_setup, :setup
+        define_method(:new_setup) do
+          begin
+            hardmock_setup
+          ensure
+            old_setup
+          end
+        end
+      else
+        # We don't need to account for previous setup
+        define_method(:new_setup) do
+          hardmock_setup
+        end
+      end
+      alias_method :setup, :new_setup
+
       if method_defined?(:teardown) then
         # Wrap existing teardown
         alias_method :old_teardown, :teardown
@@ -55,6 +78,17 @@ module Hardmock
               end
             end
           end
+        when :setup
+          unless method_defined?(:user_setup)
+            alias_method :user_setup, :setup
+            define_method(:setup) do
+              begin
+                new_setup 
+              ensure
+                user_setup
+              end
+            end
+          end
         end
       end
     end
@@ -113,26 +147,21 @@ module Hardmock
     @main_mock_control.verify
   ensure
     @main_mock_control.clear_expectations if @main_mock_control
-    Hardmock.restore_all_stubbed_methods
     $main_mock_control = nil
+    reset_stubs
   end
 
   # Purge the main MockControl of all expectations, restore all concrete stubbed/mocked methods
   def clear_expectations
     @main_mock_control.clear_expectations if @main_mock_control
-    Hardmock.restore_all_stubbed_methods
+    reset_stubs
     $main_mock_control = nil
   end
 
-#  def self.set_main_mock_control(control)
-#    $main_mock_control = control
-#  end
+  def reset_stubs
+    Hardmock.restore_all_replaced_methods
+  end
 
-#  def self.main_mock_control
-#    raise "No main mock control set yet... chickening out" if $main_mock_control.nil?
-#    $main_mock_control
-#  end
-  
 end
 
 # Insert Hardmock functionality into the TestCase base class

data/lib/hardmock/stubbing.rb

@@ -23,6 +23,10 @@ class Object #:nodoc:#
 		meta_eval { define_method name, &blk }
 	end
 
+#  def meta_eval_string(str)
+#    metaclass.instance_eval(str)
+#  end
+
 	# Defines an instance method within a class
 #	def class_def(name, &blk) #:nodoc:#
 #		class_eval { define_method name, &blk }
@@ -59,47 +63,47 @@ module Hardmock
     # Exists only for documentation 
   end
 
-  class StubbedMethod #:nodoc:#
+  class ReplacedMethod
     attr_reader :target, :method_name
 
     def initialize(target, method_name)
       @target = target
       @method_name = method_name
 
-      Hardmock.add_stubbed_method self
+      Hardmock.track_replaced_method self
     end
+  end
 
+  class StubbedMethod < ReplacedMethod #:nodoc:#
     def invoke(args)
+      raise @raises if @raises
       @return_value
     end
 
     def returns(stubbed_return)
       @return_value = stubbed_return
     end
-  end
-
-  class MockedMethod < StubbedMethod #:nodoc:#
-
-    def initialize(target, method_name, mock)
-      super target,method_name
-      @mock = mock
-    end
 
-    def invoke(args)
-      @mock.__send__(self.method_name.to_sym, *args)
+    def raises(err)
+      err = RuntimeError.new(err) unless err.kind_of?(Exception)
+      @raises = err
+#      puts "Setup to raise #{@raises}"
     end
-
   end
 
   class ::Object
     def stubs!(method_name)
       _ensure_stubbable method_name
-
       method_name = method_name.to_s
+      already_stubbed = Hardmock.has_replaced_method?(self, method_name)
+
       stubbed_method = Hardmock::StubbedMethod.new(self, method_name)
 
-      meta_eval do 
-        alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
+
+      unless _is_mock? or already_stubbed
+        meta_eval do 
+          alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
+        end
       end
 
       meta_def method_name do |*args|
@@ -110,26 +114,41 @@ module Hardmock
     end
 
     def expects!(method_name, *args, &block)
+      if self._is_mock?
+        raise Hardmock::StubbingError, "Cannot use 'expects!(:#{method_name})' on a Mock object; try 'expects' instead"
+      end
       _ensure_stubbable method_name
 
       method_name = method_name.to_s
 
       if @_my_mock.nil?
         @_my_mock = Mock.new(_my_name, $main_mock_control)
-        stubbed_method = Hardmock::MockedMethod.new(self, method_name, @_my_mock)
+        Hardmock::ReplacedMethod.new(self, method_name)
+
         meta_eval do 
           alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
         end
-        meta_def(method_name) do |*args|
-          stubbed_method.invoke(args)
+
+        begin
+          $method_text_temp = %{
+            def #{method_name}(*args,&block)
+              @_my_mock.__send__(:#{method_name}, *args, &block)
+            end
+          }
+          class << self
+            eval $method_text_temp
+          end
+        ensure
+          $method_text_temp = nil
         end
+
       end
 
       return @_my_mock.expects(method_name, *args, &block)
     end
       
     def _ensure_stubbable(method_name)
-      unless self.respond_to?(method_name.to_sym)
+      unless self.respond_to?(method_name.to_sym) or self._is_mock?
         msg = "Cannot stub non-existant "
         if self.kind_of?(Class) 
           msg += "class method #{_my_name}."
@@ -141,6 +160,10 @@ module Hardmock
       end
     end
 
+    def _is_mock?
+      self.kind_of?(Mock)
+    end
+
     def _my_name
       self.kind_of?(Class) ? self.name : self.class.name
     end
@@ -152,21 +175,31 @@ module Hardmock
   end
 
   class << self
-    def add_stubbed_method(stubbed_method)
-      all_stubbed_methods << stubbed_method
+    def track_replaced_method(replaced_method)
+      all_replaced_methods << replaced_method
     end
 
-    def all_stubbed_methods
-      $all_stubbed_methods ||= []
+    def all_replaced_methods
+      $all_replaced_methods ||= []
+    end
+
+    def has_replaced_method?(obj, method_name)
+      hits = all_replaced_methods.select do |replaced|
+        (replaced.target.object_id == obj.object_id) and (replaced.method_name.to_s == method_name.to_s)
+      end
+      return !hits.empty?
     end
 
-    def restore_all_stubbed_methods
-      all_stubbed_methods.each do |sm|
-        sm.target.meta_eval do
-          alias_method sm.method_name.to_sym, "_hardmock_original_#{sm.method_name}".to_sym 
+    def restore_all_replaced_methods
+      all_replaced_methods.each do |replaced|
+        unless replaced.target._is_mock?
+          replaced.target.meta_eval do
+            alias_method replaced.method_name.to_sym, "_hardmock_original_#{replaced.method_name}".to_sym 
+          end
+          replaced.target._clear_mock
         end
-        sm.target._clear_mock
       end
+      all_replaced_methods.clear
     end
   end
 

data/test/functional/hardmock_test.rb

@@ -9,11 +9,9 @@ class HardmockTest < Test::Unit::TestCase
   # 
 
   it "conveniently creates mocks using create_mock and create_mocks" do
-    assert_nil @main_mock_control, "@main_mock_control not expected yet"
 
     h = create_mock :donkey
     assert_equal [ :donkey ], h.keys
-    assert_not_nil @main_mock_control, "@main_mock_control should be here"
 
     assert_mock_exists :donkey
     assert_same @donkey, h[:donkey]
@@ -380,7 +378,7 @@ class HardmockTest < Test::Unit::TestCase
     assert_equal "<Mock hay_bailer>", @hay_bailer.inspect, "Wrong output from 'inspect'"
   end
 
-  it "raises is prepare_hardmock_control is invoked after create_mocks, or more than once" do
+  it "raises if prepare_hardmock_control is invoked after create_mocks, or more than once" do
     create_mock :hi_there
     create_mocks :another, :one
     assert_error RuntimeError, /already setup/ do

data/test/functional/stubbing_test.rb

@@ -8,7 +8,7 @@ class StubbingTest < Test::Unit::TestCase
   # TESTS
   # 
 
-  it "stubs a class method (and un-stubs after verify)" do
+  it "stubs a class method (and un-stubs after reset_stubs)" do
     assert_equal "stones and gravel", Concrete.pour
     assert_equal "glug glug", Jug.pour
 
@@ -23,7 +23,7 @@ class StubbingTest < Test::Unit::TestCase
 
     assert_equal "For roads", Concrete.describe, "'describe' method broken"
 
-    verify_mocks
+    reset_stubs
 
     assert_equal "stones and gravel", Concrete.pour, "'pour' method not restored"
     assert_equal "For roads", Concrete.describe, "'describe' method broken after verify"
@@ -39,7 +39,7 @@ class StubbingTest < Test::Unit::TestCase
     assert_equal "awful", Concrete.describe
     assert_equal "milk", Jug.pour
 
-    verify_mocks
+    reset_stubs
 
     assert_equal "stones and gravel", Concrete.pour
     assert_equal "For roads", Concrete.describe
@@ -53,7 +53,7 @@ class StubbingTest < Test::Unit::TestCase
     slab.stubs!(:hit).returns("slap")
     assert_equal "slap", slab.hit, "'hit' not stubbed"
 
-    verify_mocks
+    reset_stubs
 
     assert_equal "bonk", slab.hit, "'hit' not restored"
   end
@@ -70,7 +70,7 @@ class StubbingTest < Test::Unit::TestCase
     assert_equal "an instance", scrape.describe, "'describe' on 'scrape' instance broken"
     assert_equal "For roads", Concrete.describe, "'describe' class method broken"
 
-    verify_mocks
+    reset_stubs
 
     assert_equal "an instance", slab.describe, "'describe' instance method not restored"
     assert_equal "an instance", scrape.describe, "'describe' on 'scrape' instance broken after restore"
@@ -89,14 +89,47 @@ class StubbingTest < Test::Unit::TestCase
     end
   end
 
+  should "allow re-stubbing" do
+    Concrete.stubs!(:pour).returns("one")
+    assert_equal "one", Concrete.pour
+
+    Concrete.stubs!(:pour).raises("hell")
+    assert_error RuntimeError, /hell/ do
+      Concrete.pour
+    end
+
+    Concrete.stubs!(:pour).returns("two")
+    assert_equal "two", Concrete.pour
+
+    reset_stubs
+
+    assert_equal "stones and gravel", Concrete.pour
+  end
+
   it "does nothing with a runtime block when simply stubbing" do
-    prepare_hardmock_control
+    
     slab = Concrete.new
     slab.stubs!(:hit) do |nothing|
       raise "BOOOMM!"
     end
     slab.hit
-    verify_mocks
+    reset_stubs
+  end
+
+  it "can raise errors from a stubbed method" do
+    
+    Concrete.stubs!(:pour).raises(StandardError.new("no!"))
+    assert_error StandardError, /no!/ do
+      Concrete.pour
+    end
+  end
+
+  it "provides string syntax for convenient raising of RuntimeErrors" do
+    
+    Concrete.stubs!(:pour).raises("never!")
+    assert_error RuntimeError, /never!/ do
+      Concrete.pour
+    end
   end
 
 
@@ -105,7 +138,7 @@ class StubbingTest < Test::Unit::TestCase
   #
 
   it "mocks specific methods on existing classes, and returns the class method to normal after verification" do
-    prepare_hardmock_control
+    
     assert_equal "stones and gravel", Concrete.pour, "Concrete.pour is already messed up"
 
     Concrete.expects!(:pour).returns("ALIGATORS")
@@ -116,7 +149,7 @@ class StubbingTest < Test::Unit::TestCase
   end
    
   it "flunks if expected class method is not invoked" do
-    prepare_hardmock_control
+    
     Concrete.expects!(:pour).returns("ALIGATORS")
     assert_error(Hardmock::VerifyError, /Concrete.pour/, /unmet expectations/i) do
       verify_mocks
@@ -125,7 +158,7 @@ class StubbingTest < Test::Unit::TestCase
   end
 
   it "supports all normal mock functionality for class methods" do
-    prepare_hardmock_control
+    
     Concrete.expects!(:pour, "two tons").returns("mice")
     Concrete.expects!(:pour, "three tons").returns("cats")
     Concrete.expects!(:pour, "four tons").raises("Can't do it")
@@ -160,14 +193,14 @@ class StubbingTest < Test::Unit::TestCase
   end
 
   should "not allow mocking non-existant class methods" do
-    prepare_hardmock_control
+    
     assert_error Hardmock::StubbingError, /non-existant/, /something/ do
       Concrete.expects!(:something)
     end
   end
 
   it "mocks specific methods on existing instances, then restore them after verify" do
-    prepare_hardmock_control
+    
     slab = Concrete.new
     assert_equal "bonk", slab.hit
 
@@ -179,7 +212,7 @@ class StubbingTest < Test::Unit::TestCase
   end
 
   it "flunks if expected instance method is not invoked" do
-    prepare_hardmock_control
+    
     slab = Concrete.new
     slab.expects!(:hit)
 
@@ -190,7 +223,7 @@ class StubbingTest < Test::Unit::TestCase
   end
 
   it "supports all normal mock functionality for instance methods" do
-    prepare_hardmock_control
+    
     slab = Concrete.new
 
     slab.expects!(:hit, "soft").returns("hey")
@@ -233,14 +266,50 @@ class StubbingTest < Test::Unit::TestCase
   end
 
   should "not allow mocking non-existant instance methods" do
-    prepare_hardmock_control
+    
     slab = Concrete.new
     assert_error Hardmock::StubbingError, /non-existant/, /something/ do
       slab.expects!(:something)
     end
   end
 
-  should "support expectations that deal with runtime blocks"
+  should "support concrete expectations that deal with runtime blocks" do
+
+    Concrete.expects!(:pour, "a lot") do |how_much, block|
+      assert_equal "a lot", how_much, "Wrong how_much arg"
+      assert_not_nil block, "nil runtime block"
+      assert_equal "the block value", block.call, "Wrong runtime block value"
+    end
+
+    Concrete.pour("a lot") do
+      "the block value"
+    end
+
+  end
+
+  it "can stub methods on mock objects" do
+    create_mock :horse
+    @horse.stubs!(:speak).returns("silence")
+    @horse.stubs!(:hello).returns("nothing")
+    @horse.expects(:canter).returns("clip clop")
+
+    assert_equal "silence", @horse.speak
+    assert_equal "clip clop", @horse.canter
+    assert_equal "silence", @horse.speak
+    assert_equal "silence", @horse.speak
+    assert_equal "nothing", @horse.hello
+    assert_equal "nothing", @horse.hello
+
+    verify_mocks
+    reset_stubs
+  end
+
+  it "will not allow expects! to be used on a mock object" do
+    create_mock :cow
+    assert_error Hardmock::StubbingError, /expects!/, /mock/i, /something/ do
+      @cow.expects!(:something)
+    end
+  end
 
   #
   # HELPERS

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: hardmock
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
-date: 2007-11-12 00:00:00 -05:00
+  version: 1.3.1
+date: 2007-11-17 00:00:00 -05:00
 summary: A strict, ordered, expectation-oriented mock object library.
 require_paths: 
 - lib