hardmock 1.2.3 → 1.3.0

data/Rakefile

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

data/lib/assert_error.rb

@@ -1,20 +1,22 @@
 require 'test/unit/assertions'
 
-module Test::Unit::Assertions
-  # A better 'assert_raise'.  +patterns+ can be one or more Regexps, or a literal String that 
-  # must match the entire error message.
-  def assert_error(err_type,*patterns,&block)
-    assert_not_nil block, "assert_error requires a block"
-    assert((err_type and err_type.kind_of?(Class)), "First argument to assert_error has to be an error type")
-    err = assert_raise(err_type) do
-      block.call
-    end
-    patterns.each do |pattern|
-      case pattern
-      when Regexp
-        assert_match(pattern, err.message) 
-      else
-        assert_equal pattern, err.message
+module Test::Unit #:nodoc:#
+  module Assertions #:nodoc:#
+    # A better 'assert_raise'.  +patterns+ can be one or more Regexps, or a literal String that 
+    # must match the entire error message.
+    def assert_error(err_type,*patterns,&block)
+      assert_not_nil block, "assert_error requires a block"
+      assert((err_type and err_type.kind_of?(Class)), "First argument to assert_error has to be an error type")
+      err = assert_raise(err_type) do
+        block.call
+      end
+      patterns.each do |pattern|
+        case pattern
+        when Regexp
+          assert_match(pattern, err.message) 
+        else
+          assert_equal pattern, err.message
+        end
       end
     end
   end

data/lib/hardmock/errors.rb

@@ -7,6 +7,9 @@ module Hardmock
   # Raised for methods that should no longer be called.  Hopefully, the exception message contains helpful alternatives.
   class DeprecationError < StandardError; end
 
+  # Raised when stubbing fails
+  class StubbingError < StandardError; end
+
   # Raised when it is discovered that an expected method call was never made.
   class VerifyError < StandardError
     def initialize(msg,unmet_expectations)

data/lib/hardmock/expectation.rb

@@ -176,7 +176,7 @@ module Hardmock
         # Yield once
         @options[:block] = lambda do |block|
           if block.arity != 0 and block.arity != -1
-            raise ExpectationError.new("Can't pass #{item.inspect} to block with arity #{block.arity} to <#{to_s}>")
+            raise ExpectationError.new("The given block was expected to have no parameter count; instead, got #{block.arity} to <#{to_s}>")
           end
           block.call
         end

data/lib/hardmock/mock_control.rb

@@ -6,8 +6,7 @@ module Hardmock
     attr_accessor :name
 
     def initialize
-      @expectations = []
-      @disappointed = false
+      clear_expectations
     end
 
     def happy?
@@ -19,6 +18,7 @@ module Hardmock
     end
 
     def add_expectation(expectation)
+#      puts "MockControl #{self.object_id.to_s(16)} adding expectation: #{expectation}"
       @expectations << expectation
     end
 
@@ -38,8 +38,16 @@ module Hardmock
     end
 
     def verify
+#      puts "MockControl #{self.object_id.to_s(16)} verify: happy? #{happy?}"
       @disappointed = !happy?
       raise VerifyError.new("Unmet expectations", @expectations) unless happy?
     end
+
+    def clear_expectations
+      @expectations = []
+      @disappointed = false
+    end
+
   end
+
 end

data/lib/hardmock/stubbing.rb

@@ -0,0 +1,174 @@
+#
+# Stubbing support
+#
+# Stubs methods on classes and instances
+#
+
+# Why's "metaid.rb":
+class Object #:nodoc:#
+	# The hidden singleton lurks behind everyone
+	def metaclass #:nodoc:#
+    class << self
+      self
+    end
+  end
+	
+  # Evaluate a block of code within the metaclass
+	def meta_eval(&blk) #:nodoc:#
+    metaclass.instance_eval(&blk)
+  end
+
+	# Adds methods to a metaclass
+	def meta_def(name, &blk) #:nodoc:#
+		meta_eval { define_method name, &blk }
+	end
+
+	# Defines an instance method within a class
+#	def class_def(name, &blk) #:nodoc:#
+#		class_eval { define_method name, &blk }
+#	end
+end
+
+
+
+module Hardmock
+
+  # == Hardmock: Stubbing and Mocking Concrete Methods
+  #
+  # Hardmock lets you stub and/or mock methods on concrete classes or objects.
+  #
+  # * To "stub" a concrete method is to rig it to return the same thing always, disregarding any arguments.
+  # * To "mock" a concrete method is to surplant its funcionality by delegating to a mock object who will cover this behavior.
+  #
+  # Mocked methods have their expectations considered along with all other mock object expectations.
+  #
+  # If you use stubbing or concrete mocking in the absence (or before creation) of other mocks, you need to invoke <tt>prepare_hardmock_control</tt>.
+  # Once <tt>verify_mocks</tt> or <tt>clear_expectaions</tt> is called, the overriden behavior in the target objects is restored.
+  #
+  # == Examples
+  #
+  #   River.stubs!(:sounds_like).returns("gurgle")
+  #
+  #   River.expects!(:jump).returns("splash")
+  #
+  #   rogue.stubs!(:sounds_like).returns("pshshsh")
+  #
+  #   rogue.expects!(:rawhide_tanning_solvents).returns("giant snapping turtles")
+  #
+  module Stubbing
+    # Exists only for documentation 
+  end
+
+  class StubbedMethod #:nodoc:#
+    attr_reader :target, :method_name
+
+    def initialize(target, method_name)
+      @target = target
+      @method_name = method_name
+
+      Hardmock.add_stubbed_method self
+    end
+
+    def invoke(args)
+      @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)
+    end
+
+  end
+
+  class ::Object
+    def stubs!(method_name)
+      _ensure_stubbable method_name
+
+      method_name = method_name.to_s
+      stubbed_method = Hardmock::StubbedMethod.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)
+      end
+
+      stubbed_method
+    end
+
+    def expects!(method_name, *args, &block)
+      _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)
+        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)
+        end
+      end
+
+      return @_my_mock.expects(method_name, *args, &block)
+    end
+      
+    def _ensure_stubbable(method_name)
+      unless self.respond_to?(method_name.to_sym)
+        msg = "Cannot stub non-existant "
+        if self.kind_of?(Class) 
+          msg += "class method #{_my_name}."
+        else
+          msg += "method #{_my_name}#"
+        end
+        msg += method_name.to_s
+        raise Hardmock::StubbingError.new(msg)
+      end
+    end
+
+    def _my_name
+      self.kind_of?(Class) ? self.name : self.class.name
+    end
+
+    def _clear_mock
+      @_my_mock = nil
+    end
+
+  end
+
+  class << self
+    def add_stubbed_method(stubbed_method)
+      all_stubbed_methods << stubbed_method
+    end
+
+    def all_stubbed_methods
+      $all_stubbed_methods ||= []
+    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 
+        end
+        sm.target._clear_mock
+      end
+    end
+  end
+
+end
+

data/lib/hardmock.rb

@@ -7,6 +7,7 @@ require 'hardmock/trapper'
 require 'hardmock/expector'
 require 'hardmock/expectation'
 require 'hardmock/expectation_builder'
+require 'hardmock/stubbing'
 
 module Hardmock
 
@@ -73,7 +74,7 @@ module Hardmock
   # For more info on how to use your mocks, see Mock and Expectation
   #
   def create_mocks(*mock_names)
-    @main_mock_control ||= MockControl.new
+    prepare_hardmock_control unless @main_mock_control
 
     mocks = {}
     mock_names.each do |mock_name|
@@ -89,6 +90,15 @@ module Hardmock
     return mocks.clone
   end
 
+  def prepare_hardmock_control
+    if @main_mock_control.nil?
+      @main_mock_control = MockControl.new
+      $main_mock_control = @main_mock_control
+    else
+      raise "@main_mock_control is already setup for this test!"
+    end
+  end
+
   alias :create_mock :create_mocks
 
   # Ensures that all expectations have been met.  If not, VerifyException is
@@ -101,17 +111,34 @@ module Hardmock
     return unless @main_mock_control
     return if @main_mock_control.disappointed? and !force
     @main_mock_control.verify
+  ensure
+    @main_mock_control.clear_expectations if @main_mock_control
+    Hardmock.restore_all_stubbed_methods
+    $main_mock_control = nil
   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
+    $main_mock_control = nil
+  end
 
+#  def self.set_main_mock_control(control)
+#    $main_mock_control = control
+#  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
 require 'test/unit/testcase'
 unless Test::Unit::TestCase.instance_methods.include?('hardmock_teardown')
-  class Test::Unit::TestCase
+  class Test::Unit::TestCase #:nodoc:#
     include Hardmock
   end
 end

data/test/functional/assert_error_test.rb

@@ -3,13 +3,13 @@ require 'assert_error'
 
 class AssertErrorTest < Test::Unit::TestCase
 
-  def test_assert_error
+  it "specfies an error type and message that should be raised" do
     assert_error RuntimeError, "Too funky" do
       raise RuntimeError.new("Too funky")
     end
   end
 
-  def test_assert_error_message_doesnt_match
+  it "flunks if the error message is wrong" do
     err = assert_raise Test::Unit::AssertionFailedError do
       assert_error RuntimeError, "not good" do
         raise RuntimeError.new("Too funky")
@@ -19,7 +19,7 @@ class AssertErrorTest < Test::Unit::TestCase
     assert_match(/too funky/i, err.message) 
   end
 
-  def test_assert_error_type_doesnt_match
+  it "flunks if the error type is wrong" do
     err = assert_raise Test::Unit::AssertionFailedError do
       assert_error StandardError, "Too funky" do
         raise RuntimeError.new("Too funky")
@@ -29,13 +29,13 @@ class AssertErrorTest < Test::Unit::TestCase
     assert_match(/RuntimeError/i, err.message) 
   end
 
-  def test_assert_error_regexp_matching 
+  it "can match error message text using a series of Regexps" do 
     assert_error StandardError, /too/i, /funky/i do
       raise StandardError.new("Too funky")
     end
   end
 
-  def test_assert_error_regexp_matching_fails
+  it "flunks if the error message doesn't match all the Regexps" do
     err = assert_raise Test::Unit::AssertionFailedError do
       assert_error StandardError, /way/i, /too/i, /funky/i do
         raise StandardError.new("Too funky")
@@ -44,7 +44,7 @@ class AssertErrorTest < Test::Unit::TestCase
     assert_match(/way/i, err.message) 
   end
 
-  def test_assert_error_no_matchine
+  it "can operate without any message specification" do
     assert_error StandardError do 
       raise StandardError.new("ooof")
     end

data/test/functional/auto_verify_test.rb

@@ -15,11 +15,11 @@ class AutoVerifyTest < Test::Unit::TestCase
   # TESTS
   #
 
-  def test_should_auto_verify_mocks_in_teardown
+  it "auto-verifies all mocks in teardown" do
     write_and_execute_test 
   end
 
-  def test_should_auto_verify_mocks_even_if_user_has_own_teardown
+  it "auto-verifies even if user defines own teardown" do
     @teardown_code =<<-EOM 
       def teardown
         # just in the way
@@ -28,7 +28,7 @@ class AutoVerifyTest < Test::Unit::TestCase
     write_and_execute_test 
   end
 
-  def test_should_auto_verify_mocks_but_not_obscure_natural_failures
+  should "not obscure normal failures when verification fails" do
     @test_code =<<-EOM
         def test_setup_doomed_expectation
           create_mock :automobile
@@ -40,7 +40,7 @@ class AutoVerifyTest < Test::Unit::TestCase
     write_and_execute_test
   end
 
-  def test_should_not_prevent_user_teardown_even_if_verification_fails
+  should "not skip user-defined teardown when verification fails" do
     @teardown_code =<<-EOM 
       def teardown
         puts "User teardown"
@@ -50,7 +50,8 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_output_contains(/User teardown/)
   end
 
-  def test_should_not_raise_error_if_verification_goes_according_to_plan
+  it "is quiet when verification is ok" do
+#  def test_should_not_raise_error_if_verification_goes_according_to_plan
     @test_code =<<-EOM
         def test_ok
           create_mock :automobile
@@ -70,7 +71,8 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_output_contains(/User teardown/)
   end
 
-  def test_should_not_do_verification_if_user_teardown_explodes
+  should "not auto-verify if user teardown explodes" do
+#  def test_should_not_do_verification_if_user_teardown_explodes
     @teardown_code =<<-EOM 
       def teardown
         raise "self destruct"
@@ -81,7 +83,7 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_output_contains(/self destruct/)
   end
 
-  def test_should_not_obscure_inherited_teardown
+  it "plays nice with inherited teardown methods" do
     @full_code ||=<<-EOTEST
       require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
       require 'hardmock'
@@ -101,7 +103,7 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_output_contains(/Test helper teardown/)
   end
 
-  def test_should_simultaneously_support_inherited_and_user_and_hardmock_teardown
+  it "plays nice with inherited and user-defined teardowns at the same time" do
     @full_code ||=<<-EOTEST
       require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
       class Test::Unit::TestCase 
@@ -135,9 +137,6 @@ class AutoVerifyTest < Test::Unit::TestCase
   def run_test(tbody)
     File.open(temp_test_file,"w") { |f| f.print(tbody) }
     @test_output = `ruby #{temp_test_file} 2>&1`
-#    puts "------------------------"
-#    puts @test_output
-#    puts "------------------------"
   end
 
   def remove_temp_test_file

data/test/functional/direct_mock_usage_test.rb

@@ -14,7 +14,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
   # TESTS
   #
 
-  def test_verify_should_raise_verify_error_if_expected_method_not_called
+  it "raises VerifyError if expected method not called" do
     @bird.expects.flap_flap
 
     err = assert_raise VerifyError do
@@ -23,7 +23,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     assert_match(/unmet expectations/i, err.message)
   end
 
-  def test_verify_should_not_raise_when_expected_calls_made_in_order
+  should "not raise when expected calls are made in order" do
     @bird.expects.flap_flap
     @bird.expects.bang
     @bird.expects.plop
@@ -35,7 +35,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_should_raise_expectation_error_when_unexpected_method_called
+  it "raises ExpectationError when unexpected method are called" do
     @bird.expects.flap_flap
 
     err = assert_raise ExpectationError do
@@ -44,7 +44,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     assert_match(/wrong method/i, err.message) 
   end
 
-  def test_bad_argument_call
+  it "raises ExpectationError on bad arguments" do
     @bird.expects.flap_flap(:swoosh)
 
     err = assert_raise ExpectationError do
@@ -53,7 +53,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     assert_match(/wrong arguments/i, err.message) 
   end
   
-  def test_verify_should_raise_verify_error_when_not_all_expected_methods_called
+  it "raises VerifyError when not all expected methods are called" do
     @bird.expects.flap_flap
     @bird.expects.bang
     @bird.expects.plop
@@ -66,7 +66,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     assert_match(/unmet expectations/i, err.message)
   end
 
-  def test_should_raise_expectation_error_when_calls_made_out_of_order
+  it "raises ExpectationError when calls are made out of order" do
     @bird.expects.flap_flap
     @bird.expects.bang
     @bird.expects.plop
@@ -78,7 +78,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     assert_match(/wrong method/i, err.message) 
   end
 
-  def test_should_return_given_value_when_specified
+  it "returns the configured value" do 
     @bird.expects.plop.returns(':P')
     assert_equal ':P', @bird.plop
     @bird._verify
@@ -88,13 +88,13 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_should_return_nil_value_when_none_specified
+  it "returns nil when no return is specified" do
     @bird.expects.plop
     assert_nil @bird.plop
     @bird._verify
   end
 
-  def test_raise_should_raise_given_exception_when_specified
+  it "raises the configured exception" do
     err = RuntimeError.new('shaq')
     @bird.expects.plop.raises(err)
     actual_err = assert_raise RuntimeError do
@@ -104,7 +104,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_raise_should_raise_given_string_wrapped_in_runtime_error
+  it "raises a RuntimeError when told to 'raise' a string" do
     @bird.expects.plop.raises('shaq')
     err = assert_raise RuntimeError do
       @bird.plop
@@ -113,7 +113,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_raise_should_raise_a_canned_runtime_error_if_nothing_given
+  it "raises a default RuntimeError" do
     @bird.expects.plop.raises
     err = assert_raise RuntimeError do
       @bird.plop
@@ -122,14 +122,14 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_should_be_happy_with_correct_expected_arguments
+  it "is quiet when correct arguments given" do
     thing = Object.new
     @bird.expects.plop(:big,'one',thing)
     @bird.plop(:big,'one',thing)
     @bird._verify
   end
 
-  def test_should_raise_expectation_error_when_wrong_number_of_arguemnts_specified
+  it "raises ExpectationError when wrong number of arguments specified" do
     thing = Object.new
     @bird.expects.plop(:big,'one',thing)
     err = assert_raise ExpectationError do
@@ -156,7 +156,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_should_raise_expectation_error_when_arguemnts_dont_match
+  it "raises ExpectationError when arguments don't match" do
     thing = Object.new
     @bird.expects.plop(:big,'one',thing)
     err = assert_raise ExpectationError do
@@ -166,7 +166,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_should_yield_to_block_given
+  it "can use a block for custom reactions" do
     mitt = nil
     @bird.expects.plop { mitt = :ball }
     assert_nil mitt
@@ -182,7 +182,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_shouldnt_care_about_arguments_if_block_given
+  it "passes mock-call arguments to the expectation block" do
     ball = nil
     mitt = nil
     @bird.expects.plop {|arg1,arg2| 
@@ -197,7 +197,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_should_check_arguments_if_specified_when_block_given
+  it "validates arguments if specified in addition to a block" do
     ball = nil
     mitt = nil
     @bird.expects.plop(:ball,:mitt) {|arg1,arg2| 
@@ -244,7 +244,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_runtime_blocks_get_passed_to_expectation_blocks
+  it "passes runtime blocks to the expectation block as the final argument" do
     runtime_block_called = false
     got_arg = nil
 
@@ -271,7 +271,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_runtime_blocks_get_passed_to_expectation_blocks__no_arguments
+  it "passes the runtime block to the expectation block as sole argument if no other args come into play" do
     runtime_block_called = false
     @bird.expects.subscribe { |block| block.call }
     @bird.subscribe do 
@@ -280,7 +280,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     assert runtime_block_called, "The runtime block should have been invoked by the user block"
   end
 
-  def test_expect_runtime_block_but_none_sent
+  it "provides nil as final argument if expectation block seems to want a block" do
     invoked = false
     @bird.expects.kablam(:scatter) { |shot,block| 
       assert_equal :scatter, shot, "Wrong shot"
@@ -293,7 +293,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_can_set_return_after_blocks
+  it "can set explicit return after an expectation block" do
     got = nil
     @bird.expects.kablam(:scatter) { |shot|
       got = shot
@@ -305,7 +305,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_can_set_raises_after_blocks
+  it "can raise after an expectation block" do
     got = nil
     @bird.expects.kablam(:scatter) do |shot|
       got = shot
@@ -319,7 +319,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_expectation_block_value_is_captured
+  it "stores the semantic value of the expectation block after it executes" do
     expectation = @bird.expects.kablam(:slug) { |shot|
       "The shot was #{shot}"
     }
@@ -336,7 +336,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
   end
 
 
-  def test_expectation_block_value_is_used_for_return_value
+  it "uses the value of the expectation block as the default return value" do 
     @bird.expects.kablam(:scatter) { |shot|
       "The shot was #{shot}"
     }
@@ -345,7 +345,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_expectation_is_still_returned_when_using_returns
+  it "returns the Expectation even if 'returns' is used" do
     expectation = @bird.expects.kablam(:slug) { |shot|
       "The shot was #{shot}"
     }.returns :hosed
@@ -361,7 +361,7 @@ class DirectMockUsageTest < Test::Unit::TestCase
     @bird._verify
   end
 
-  def test_expectation_is_still_returned_when_using_raises
+  it "returns the Expectation even if 'raises' is used" do
     expectation = @bird.expects.kablam(:slug) { |shot|
       "The shot was #{shot}"
     }.raises "aiee!"
@@ -378,13 +378,13 @@ class DirectMockUsageTest < Test::Unit::TestCase
   end
 
 
-  def test_expect_assignment
+  it "supports assignment-style methods" do
     @bird.expects.size = "large"
     @bird.size = "large"
     @bird._verify
   end
 
-  def test_expect_assignment_with_raise
+  it "supports assignments and raising (using explicit-method syntax)" do
     @bird.expects('size=','large').raises "boom"
 
     err = assert_raise RuntimeError do

data/test/functional/hardmock_test.rb

@@ -4,33 +4,11 @@ require 'assert_error'
 
 class HardmockTest < Test::Unit::TestCase
 
-  def setup
-  end
-
-  def teardown
-  end
-
-  #
-  # HELPERS
-  #
-
-  def assert_mock_exists(name)
-    assert_not_nil @all_mocks, "@all_mocks not here yet"
-    mo = @all_mocks[name]
-    assert_not_nil mo, "Mock '#{name}' not in @all_mocks"
-    assert_kind_of Mock, mo, "Wrong type of object, wanted a Mock"
-    assert_equal name.to_s, mo._name, "Mock '#{name}' had wrong name"
-    ivar = self.instance_variable_get("@#{name}")
-    assert_not_nil ivar, "Mock '#{name}' not set as ivar"
-    assert_same mo, ivar, "Mock '#{name}' ivar not same as instance in @all_mocks"
-    assert_same @main_mock_control, mo._control, "Mock '#{name}' doesn't share the main mock control"
-  end
-  
   #
   # TESTS
   # 
 
-  def test_create_mock_and_create_mocks
+  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
@@ -54,7 +32,7 @@ class HardmockTest < Test::Unit::TestCase
     assert_mock_exists :donkey
   end
 
-  def test_expect
+  it "provides literal 'expects' syntax" do 
     assert_nil @order, "Should be no @order yet"
     create_mock :order
     assert_not_nil @order, "@order should be built"
@@ -72,7 +50,7 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks
   end
 
-  def test_typical_multi_mock_use
+  it "supports several mocks at once" do
     create_mocks :order_builder, :order, :customer
 
     @order_builder.expects.create_new_order.returns @order
@@ -88,7 +66,7 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks
   end
 
-  def test_typical_multi_mock_use_out_of_order
+  it "enforces inter-mock call ordering" do
     create_mocks :order_builder, :order, :customer
 
     @order_builder.expects.create_new_order.returns @order
@@ -108,10 +86,6 @@ class HardmockTest < Test::Unit::TestCase
     assert_error VerifyError, /unmet expectations/i do
       verify_mocks
     end
-
-    # Appease the verifier
-    @order.account_no = 1234
-    @order.save!
   end
 
   class UserPresenter
@@ -127,7 +101,7 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_mvp_usage_pattern
+  it "makes MVP testing simple" do
     mox = create_mocks :model, :view
 
     data_change = @model.expects.when(:data_changes) { |evt,block| block }
@@ -150,7 +124,7 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks 
   end
 
-  def test_verify_mocks_repeated_anger
+  it "continues to function after verify, if verification error is controlled" do
     mox = create_mocks :model, :view
     data_change = @model.expects.when(:data_changes) { |evt,block| block }
     user_edit = @view.expects.when(:user_edited) { |evt,block| block }
@@ -174,18 +148,11 @@ class HardmockTest < Test::Unit::TestCase
       verify_mocks(false)
     end
     
-    # Finish meeting expectations and see good verification behavior
-    @view.user_name = "Da Croz"    
-    verify_mocks
-    
     @model.expects.never_gonna_happen
     
     assert_error VerifyError, /unmet expectations/i, /never_gonna_happen/i do
       verify_mocks
     end
-
-    # Appease the verifier
-    @model.never_gonna_happen
   end
 
   class UserPresenterBroken
@@ -199,7 +166,7 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_mvp_usage_with_failures_in_constructor
+  it "flunks for typical Presenter constructor wiring failure" do
     mox = create_mocks :model, :view
 
     data_change = @model.expects.when(:data_changes) { |evt,block| block }
@@ -213,16 +180,9 @@ class HardmockTest < Test::Unit::TestCase
     assert_match(/unmet expectations/i, err.message) 
     assert_match(/view.when\(:user_edited\)/i, err.message) 
 
-    assert_error VerifyError, /unmet expectations/i do
-      verify_mocks
-    end 
-
-    # Appease the verifier
-    @view.when(:user_edited)
-
   end
 
-  def test_mvp_usage_pattern_with_convenience_trap
+  it "provides convenient event-subscription trap syntax for MVP testing" do
     mox = create_mocks :model, :view
 
     data_change = @model.trap.when(:data_changes) 
@@ -245,6 +205,13 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks 
   end
 
+  it "raises if you try to pass an expectation block to 'trap'" do
+    create_mock :model
+    assert_error Hardmock::ExpectationError, /blocks/i, /trap/i do
+      @model.trap.when(:some_event) do raise "huh?" end
+    end
+  end
+
   class Grinder
     def initialize(objects)
       @chute = objects[:chute]
@@ -259,7 +226,7 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_internal_iteration_usage
+  it "lets you write clear iteration-oriented expectations" do
     grinder = Grinder.new create_mocks(:blade, :chute, :bucket)
     
     # Style 1: assertions on method args is done explicitly in block
@@ -290,7 +257,7 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks
   end
 
-  def test_internal_iteration_using_yield
+  it "further supports iteration testing using 'yield'" do
     grinder = Grinder.new create_mocks(:blade, :chute, :bucket)
     
     @chute.expects.each_bean(:side_slot).yields :bean1, :bean2
@@ -322,7 +289,7 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_internal_locking_scenario
+  it "makes mutex-style locking scenarios easy to test" do
     hurt = HurtLocker.new create_mocks(:locker, :store)
 
     @locker.expects.with_lock(:main).yields
@@ -333,7 +300,7 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks
   end
 
-  def test_internal_locking_scenario_with_inner_error
+  it "makes it easy to simulate error in mutex-style locking scenarios" do 
     hurt = HurtLocker.new create_mocks(:locker, :store)
     err = StandardError.new('fmshooop')  
     @locker.expects.with_lock(:main).yields
@@ -345,7 +312,7 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks
   end
 	
-	def test_returning_false_actually_returns_false_and_not_nil
+  it "actually returns 'false' instead of nil when mocking boolean return values" do
 		create_mock :car
 		@car.expects.ignition_on?.returns(true)
 		assert_equal true, @car.ignition_on?, "Should be true"
@@ -353,7 +320,7 @@ class HardmockTest < Test::Unit::TestCase
 		assert_equal false, @car.ignition_on?, "Should be false"
 	end
 
-  def test_should_be_able_to_mock_some_methods_inherited_from_object
+  it "can mock most methods inherited from object using literal syntax" do
     target_methods = %w|id clone display dup eql? ==|
     create_mock :foo
     target_methods.each do |m|
@@ -362,14 +329,14 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_should_support_expect_as_an_alias_for_expects 
+  it "provides 'expect' as an alias for 'expects'" do
     create_mock :foo
     @foo.expect.boomboom
     @foo.boomboom
     verify_mocks 
   end
 
-  def test_should_not_raise_expectation_errors_for_some_methods_defined_on_object
+  it "does not interfere with a core subset of Object methods" do 
     create_mock :foo
     @foo.method(:inspect)
     @foo.inspect
@@ -379,7 +346,7 @@ class HardmockTest < Test::Unit::TestCase
     verify_mocks 
   end
 
-  def test_should_support_raising_errors_within_expectation_blocks
+  it "can raise errors from within an expectation block" do
     create_mock :cat
     @cat.expects.meow do |arg|
       assert_equal "mix", arg
@@ -390,7 +357,7 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_should_support_raising_errors_after_expectation_blocks
+  it "can raise errors AFTER an expectation block" do
     create_mock :cat
     @cat.expects.meow do |arg|
       assert_equal "mix", arg
@@ -400,7 +367,7 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_should_raise_when_create_mocks_is_given_a_nil_name
+  it "raises an immediate error if a mock is created with a nil name (common mistake: create_mock @cat)" do
     # I make this mistake all the time: Typing in an instance var name instead of a symbol in create_mocks.
     # When you do that, you're effectively passing nil(s) in as mock names.
     assert_error ArgumentError, /'nil' is not a valid name for a mock/ do
@@ -408,10 +375,33 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_should_display_mock_name_in_inspect_output
+  it "overrides 'inspect' to make nice output" do
     create_mock :hay_bailer
     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
+    create_mock :hi_there
+    create_mocks :another, :one
+    assert_error RuntimeError, /already setup/ do
+      prepare_hardmock_control
+    end
+  end
+
+  #
+  # HELPERS
+  #
+
+  def assert_mock_exists(name)
+    assert_not_nil @all_mocks, "@all_mocks not here yet"
+    mo = @all_mocks[name]
+    assert_not_nil mo, "Mock '#{name}' not in @all_mocks"
+    assert_kind_of Mock, mo, "Wrong type of object, wanted a Mock"
+    assert_equal name.to_s, mo._name, "Mock '#{name}' had wrong name"
+    ivar = self.instance_variable_get("@#{name}")
+    assert_not_nil ivar, "Mock '#{name}' not set as ivar"
+    assert_same mo, ivar, "Mock '#{name}' ivar not same as instance in @all_mocks"
+    assert_same @main_mock_control, mo._control, "Mock '#{name}' doesn't share the main mock control"
+  end
 end
 

data/test/functional/stubbing_test.rb

@@ -0,0 +1,274 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+require 'assert_error'
+
+class StubbingTest < Test::Unit::TestCase
+
+  #
+  # TESTS
+  # 
+
+  it "stubs a class method (and un-stubs after verify)" do
+    assert_equal "stones and gravel", Concrete.pour
+    assert_equal "glug glug", Jug.pour
+
+    Concrete.stubs!(:pour).returns("dust and plaster")
+
+    3.times do
+      assert_equal "dust and plaster", Concrete.pour
+    end
+
+    assert_equal "glug glug", Jug.pour, "Jug's 'pour' method broken"
+    assert_equal "stones and gravel", Concrete._hardmock_original_pour, "Original 'pour' method not aliased"
+
+    assert_equal "For roads", Concrete.describe, "'describe' method broken"
+
+    verify_mocks
+
+    assert_equal "stones and gravel", Concrete.pour, "'pour' method not restored"
+    assert_equal "For roads", Concrete.describe, "'describe' method broken after verify"
+
+  end
+
+  it "stubs several class methods" do
+    Concrete.stubs!(:pour).returns("sludge")
+    Concrete.stubs!(:describe).returns("awful")
+    Jug.stubs!(:pour).returns("milk")
+
+    assert_equal "sludge", Concrete.pour
+    assert_equal "awful", Concrete.describe
+    assert_equal "milk", Jug.pour
+
+    verify_mocks
+
+    assert_equal "stones and gravel", Concrete.pour
+    assert_equal "For roads", Concrete.describe
+    assert_equal "glug glug", Jug.pour
+  end
+
+  it "stubs instance methods" do
+    slab = Concrete.new
+    assert_equal "bonk", slab.hit
+
+    slab.stubs!(:hit).returns("slap")
+    assert_equal "slap", slab.hit, "'hit' not stubbed"
+
+    verify_mocks
+
+    assert_equal "bonk", slab.hit, "'hit' not restored"
+  end
+
+  it "stubs instance methods without breaking class methods or other instances" do
+    slab = Concrete.new
+    scrape = Concrete.new
+    assert_equal "an instance", slab.describe
+    assert_equal "an instance", scrape.describe
+    assert_equal "For roads", Concrete.describe
+
+    slab.stubs!(:describe).returns("new instance describe")
+    assert_equal "new instance describe", slab.describe, "'describe' on instance not stubbed"
+    assert_equal "an instance", scrape.describe, "'describe' on 'scrape' instance broken"
+    assert_equal "For roads", Concrete.describe, "'describe' class method broken"
+
+    verify_mocks
+
+    assert_equal "an instance", slab.describe, "'describe' instance method not restored"
+    assert_equal "an instance", scrape.describe, "'describe' on 'scrape' instance broken after restore"
+    assert_equal "For roads", Concrete.describe, "'describe' class method broken after restore"
+  end
+
+  should "not allow stubbing of nonexistant class methods" do
+    assert_error(Hardmock::StubbingError, /cannot stub/i, /class method/i, /Concrete.funky/) do   
+      Concrete.stubs!(:funky)
+    end
+  end
+
+  should "not allow stubbing of nonexistant instance methods" do
+    assert_error(Hardmock::StubbingError, /cannot stub/i, /method/i, /Concrete#my_inst_mth/) do   
+      Concrete.new.stubs!(:my_inst_mth)
+    end
+  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
+  end
+
+
+  #
+  # Per-method mocking on classes or instances
+  #
+
+  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")
+    assert_equal "ALIGATORS", Concrete.pour
+
+    verify_mocks
+    assert_equal "stones and gravel", Concrete.pour, "Concrete.pour not restored"
+  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
+    end
+    clear_expectations
+  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")
+    Concrete.expects!(:pour) do |some, args|
+      "==#{some}+#{args}=="
+    end
+
+    assert_equal "mice", Concrete.pour("two tons")
+    assert_equal "cats", Concrete.pour("three tons")
+    assert_error(RuntimeError, /Can't do it/) do 
+      Concrete.pour("four tons")
+    end
+    assert_equal "==first+second==", Concrete.pour("first","second")
+  end
+
+
+  it "enforces inter-mock ordering when mocking class methods" do
+    create_mocks :truck, :foreman
+    
+    @truck.expects.backup
+    Concrete.expects!(:pour, "something")
+    @foreman.expects.shout
+
+    @truck.backup
+    assert_error Hardmock::ExpectationError, /wrong/i, /expected call/i, /Concrete.pour/ do
+      @foreman.shout
+    end
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /foreman.shout/ do
+      verify_mocks
+    end
+    clear_expectations
+  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
+
+    slab.expects!(:hit).returns("slap")
+    assert_equal "slap", slab.hit, "'hit' not stubbed"
+
+    verify_mocks
+    assert_equal "bonk", slab.hit, "'hit' not restored"
+  end
+
+  it "flunks if expected instance method is not invoked" do
+    prepare_hardmock_control
+    slab = Concrete.new
+    slab.expects!(:hit)
+
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /Concrete.hit/ do
+      verify_mocks
+    end
+    clear_expectations
+  end
+
+  it "supports all normal mock functionality for instance methods" do
+    prepare_hardmock_control
+    slab = Concrete.new
+
+    slab.expects!(:hit, "soft").returns("hey")
+    slab.expects!(:hit, "hard").returns("OOF")
+    slab.expects!(:hit).raises("stoppit")
+    slab.expects!(:hit) do |some, args|
+      "==#{some}+#{args}=="
+    end
+
+    assert_equal "hey", slab.hit("soft")
+    assert_equal "OOF", slab.hit("hard")
+    assert_error(RuntimeError, /stoppit/) do 
+      slab.hit
+    end
+    assert_equal "==first+second==", slab.hit("first","second")
+    
+  end
+
+  it "enforces inter-mock ordering when mocking instance methods" do
+    create_mocks :truck, :foreman
+    slab1 = Concrete.new
+    slab2 = Concrete.new
+
+    @truck.expects.backup
+    slab1.expects!(:hit)
+    @foreman.expects.shout
+    slab2.expects!(:hit)
+    @foreman.expects.whatever
+
+    @truck.backup
+    slab1.hit
+    @foreman.shout
+    assert_error Hardmock::ExpectationError, /wrong/i, /expected call/i, /Concrete.hit/ do
+      @foreman.whatever
+    end
+    assert_error Hardmock::VerifyError, /unmet expectations/i, /foreman.whatever/ do
+      verify_mocks
+    end
+    clear_expectations
+  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"
+
+  #
+  # HELPERS
+  #
+
+  class Concrete
+    def self.pour
+      "stones and gravel"
+    end
+
+    def self.describe
+      "For roads"
+    end
+
+    def hit
+      "bonk"
+    end
+
+    def describe
+      "an instance"
+    end
+  end
+
+  class Jug
+    def self.pour
+      "glug glug"
+    end
+  end
+
+end
+

data/test/test_helper.rb

@@ -20,4 +20,27 @@ class Test::Unit::TestCase
     end
     return false
   end
+
+  def self.it(str, &block)
+    make_test_case "it", str, &block
+  end
+
+  def self.should(str, &block)
+    make_test_case "should", str, &block
+  end
+
+  def self.make_test_case(prefix, str, &block)
+    tname = self.name.sub(/Test$/,'')
+    if block
+      define_method "test #{prefix} #{str}" do
+#        phrase = str
+#        phrase = prefix + " " + phrase unless prefix == "it"
+#        puts "#{tname} #{phrase}..."
+        instance_eval &block
+      end
+    else
+      puts ">>> UNIMPLEMENTED CASE: #{tname}: #{str}"
+    end
+  end
+
 end

data/test/unit/expectation_test.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
 require 'hardmock/expectation'
 require 'hardmock/errors'
+require 'assert_error'
 
 class ExpectationTest < Test::Unit::TestCase
   include Hardmock
@@ -344,4 +345,14 @@ class ExpectationTest < Test::Unit::TestCase
     assert_match(/"a", "b", "c"/i, err.message) 
     assert_equal [], things, "Wrong things"
   end
+
+  def test_yields_bad_block_arity
+    se = Expectation.new(:mock => @mock, :method => 'do_later', :arguments => [] )
+    se.yields
+
+    assert_error Hardmock::ExpectationError, /block/i, /expected/i, /no param/i, /got 2/i do
+      se.apply_method_call(@mock,'do_later',[],lambda { |doesnt,match| raise "Surprise!" } )
+    end
+  end
+
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: hardmock
 version: !ruby/object:Gem::Version 
-  version: 1.2.3
-date: 2007-04-28 00:00:00 -04:00
+  version: 1.3.0
+date: 2007-11-12 00:00:00 -05:00
 summary: A strict, ordered, expectation-oriented mock object library.
 require_paths: 
 - lib
@@ -38,6 +38,7 @@ files:
 - lib/hardmock/method_cleanout.rb
 - lib/hardmock/mock.rb
 - lib/hardmock/mock_control.rb
+- lib/hardmock/stubbing.rb
 - lib/hardmock/trapper.rb
 - lib/hardmock/utils.rb
 - lib/tasks/rdoc_options.rb
@@ -46,6 +47,7 @@ files:
 - test/functional/auto_verify_test.rb
 - test/functional/direct_mock_usage_test.rb
 - test/functional/hardmock_test.rb
+- test/functional/stubbing_test.rb
 - test/unit/expectation_builder_test.rb
 - test/unit/expectation_test.rb
 - test/unit/expector_test.rb
@@ -66,6 +68,7 @@ test_files:
 - test/functional/auto_verify_test.rb
 - test/functional/direct_mock_usage_test.rb
 - test/functional/hardmock_test.rb
+- test/functional/stubbing_test.rb
 - test/unit/expectation_builder_test.rb
 - test/unit/expectation_test.rb
 - test/unit/expector_test.rb