hardmock 1.1.0

data/test/unit/mock_test.rb

@@ -0,0 +1,275 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class MockTest < Test::Unit::TestCase
+
+  def test_build_with_control
+    mc1 = MockControl.new
+    mock = Mock.new('hi', mc1)
+    assert_equal 'hi', mock._name, "Wrong name"
+    assert_same mc1, mock._control, "Wrong contol"
+  end
+
+  def test_basics
+    mock = Mock.new('a name')
+    assert_equal 'a name', mock._name, "Wrong name for mock"
+    assert_not_nil mock._control, "Nil control in mock"
+  end
+
+  def test_expects
+    mock = Mock.new('order')
+    control = mock._control
+    assert control.happy?, "Mock should start out satisfied"
+
+    mock.expects.absorb_something(:location, 'garbage')
+    assert !control.happy?, "mock control should be unhappy"
+
+    # Do the call
+    mock.absorb_something(:location, 'garbage')
+    assert control.happy?, "mock control should be happy again"
+
+    # Verify
+    assert_nothing_raised Exception do
+      mock._verify
+    end 
+  end
+
+  def test_expects_using_arguments_for_method_and_arguments
+    mock = Mock.new('order')
+    mock.expects(:absorb_something, :location, 'garbage')
+    mock.absorb_something(:location, 'garbage')
+    mock._verify
+  end
+
+  def test_expects_using_arguments_for_method_and_arguments_with_block
+    mock = Mock.new('order')
+    mock.expects(:absorb_something, :location, 'garbage') { |a,b,block|
+      assert_equal :location, a, "Wrong 'a' argument"
+      assert_equal 'garbage', b, "Wrong 'b' argument"
+      assert_equal 'innards', block.call, "Wrong block"
+    }
+    mock.absorb_something(:location, 'garbage') do "innards" end
+    mock._verify
+  end
+
+  def test_expects_using_string_method_name
+    mock = Mock.new('order')
+    mock.expects('absorb_something', :location, 'garbage')
+    mock.absorb_something(:location, 'garbage')
+    mock._verify
+  end
+
+
+  def test_expects_assignment
+    mock = Mock.new('order')
+    mock.expects.account_number = 1234
+
+    mock.account_number = 1234
+
+    mock._verify
+  end
+
+  def test_expects_assigment_using_arguments_for_method_and_arguments
+    mock = Mock.new('order')
+    mock.expects(:account_number=, 1234)
+    mock.account_number = 1234
+    mock._verify
+  end
+
+  def test_expects_assigment_using_string_method_name
+    mock = Mock.new('order')
+    mock.expects('account_number=', 1234)
+    mock.account_number = 1234
+    mock._verify
+  end
+
+  def test_expects_assignment_and_return_is_overruled_by_ruby_syntax
+    # Prove that we can set up a return but that it doesn't mean much,
+    # because ruby's parser will 'do the right thing' as regards semantic
+    # values for assignment.  (That is, the rvalue of the assignment)
+    mock = Mock.new('order')
+    mock.expects(:account_number=, 1234).returns "gold"
+    got = mock.account_number = 1234
+    mock._verify
+    assert_equal 1234, got, "Expected rvalue"
+  end
+
+  def test_expects_assignment_and_raise
+    mock = Mock.new('order')
+    mock.expects(:account_number=, 1234).raises StandardError.new("kaboom")
+    err = assert_raise StandardError do
+      mock.account_number = 1234
+    end
+    assert_match(/kaboom/i, err.message) 
+    mock._verify
+  end
+
+
+  def test_expects_multiple
+    mock = Mock.new('order')
+    control = mock._control
+
+    assert control.happy?
+
+    mock.expects.one_thing :hi, { :goose => 'neck' }
+    mock.expects.another 5,6,7
+    assert !control.happy?
+
+    mock.one_thing :hi, { :goose => 'neck' }
+    assert !control.happy?
+
+    mock.another 5,6,7
+    assert control.happy?
+  end
+
+  def test_surprise_call
+    mock = Mock.new('order')
+    err = assert_raise ExpectationError do
+      mock.uh_oh
+    end
+    assert_match(/surprise/i, err.message) 
+    assert_match(/uh_oh/i, err.message) 
+    
+    err = assert_raise ExpectationError do
+      mock.whoa :horse  
+    end
+    assert_match(/surprise/i, err.message) 
+    assert_match(/order\.whoa\(:horse\)/i, err.message) 
+  end
+
+  def test_wrong_call
+    mock = Mock.new('order')
+    mock.expects.pig 'arse'
+    err = assert_raise ExpectationError do
+      mock.whoa :horse  
+    end
+    assert_match(/wrong method/i, err.message) 
+    assert_match(/order\.whoa\(:horse\)/i, err.message) 
+    assert_match(/order\.pig\("arse"\)/i, err.message) 
+  end
+
+  def test_wrong_arguments
+    mock = Mock.new('order')
+    mock.expects.go_fast(:a, 1, 'three')
+
+    err = assert_raise ExpectationError do
+      mock.go_fast :a, 1, 'not right'  
+    end
+    assert_match(/wrong argument/i, err.message) 
+    assert_match(/order\.go_fast\(:a, 1, "three"\)/i, err.message) 
+    assert_match(/order\.go_fast\(:a, 1, "not right"\)/i, err.message) 
+  end
+
+  def test_expects_and_return
+    mock = Mock.new('order')
+    mock.expects.delivery_date.returns Date.today
+    assert_equal Date.today, mock.delivery_date
+    mock._verify
+  end
+
+  def test_expects_and_return_with_arguments
+    mock = Mock.new('order')
+    mock.expects.delivery_date(:arf,14).returns(Date.today)
+    assert_equal Date.today, mock.delivery_date(:arf,14)
+    mock._verify
+  end
+
+  def test_expects_and_raise
+    mock = Mock.new('order')
+    mock.expects.delivery_date.raises StandardError.new("bloof")
+
+    err = assert_raise StandardError do
+      mock.delivery_date
+    end
+    assert_match(/bloof/i, err.message) 
+
+    mock._verify
+    
+    # Try convenience argument String 
+    mock.expects.pow.raises "hell"
+    err = assert_raise RuntimeError do
+      mock.pow
+    end
+    assert_match(/hell/i, err.message) 
+
+    mock._verify
+
+    # Try convenience argument nothing
+    mock.expects.pow.raises 
+    err = assert_raise RuntimeError do
+      mock.pow
+    end
+    assert_match(/an error/i, err.message) 
+
+    mock._verify
+  end
+
+  def test_expects_a_runtime_block
+    mock = Mock.new('order')
+    got_val = nil
+
+    mock.expects.when(:something) { |e,block|
+      got_val = block.call
+    }
+
+    mock.when :something do "hi there" end
+
+    assert_equal "hi there", got_val, "Expectation block not invoked"
+    mock._verify
+  end
+
+  def test_trap_block
+    mock = Mock.new('order')
+    exp = mock.trap.observe
+
+    # use it
+    mock.observe { "burp" }
+
+    assert_equal "burp", exp.block_value.call
+  end
+
+  def test_trap_arguments_and_block
+    mock = Mock.new('order')
+    exp = mock.trap.subscribe(:data_changed)
+
+    # use it
+    mock.subscribe(:data_changed) { "burp" }
+    assert_equal "burp", exp.block_value.call
+    mock._verify
+  end
+
+  def test_trap_arguments_and_block_wrong_num_args
+    mock = Mock.new('order')
+    exp = mock.trap.subscribe(:data_changed)
+
+    assert_raise ExpectationError do
+      mock.subscribe(:data_changed,1) { "burp" }
+    end
+    mock._verify
+  end
+
+  def test_trap_arguments_and_block_wrong_args
+    mock = Mock.new('order')
+    exp = mock.trap.subscribe(:data_changed)
+
+    assert_raise ExpectationError do
+      mock.subscribe("no good") { "burp" }
+    end
+
+    mock._verify
+  end
+
+  def test_trap_is_not_leniant_about_arguments
+    mock = Mock.new('order')
+    exp = mock.trap.subscribe
+
+    assert_raise ExpectationError do
+      mock.subscribe("no good") { "burp" }
+    end
+
+    mock._verify
+  end
+
+
+
+end

data/test/unit/simple_expectation_test.rb

@@ -0,0 +1,345 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class SimpleExpectationTest < Test::Unit::TestCase
+
+  def setup
+    @mock = TheMock.new
+  end
+  #
+  # HELPERS
+  #
+   
+  class TheMock
+    def _name; 'the_mock'; end
+  end
+  class OtherMock
+    def _name; 'other_mock'; end
+  end
+
+  #
+  # TESTS
+  #
+
+  def test_to_s
+    ex = SimpleExpectation.new( :mock => @mock, :method => 'a_func', :arguments => [1, "two", :three, { :four => 4 }] )  
+    assert_equal %|the_mock.a_func(1, "two", :three, {:four=>4})|, ex.to_s
+  end
+   
+  def test_apply_method_call
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+      :arguments => [1,'two',:three] )
+
+    # Try it good:
+    assert_nothing_raised ExpectationError do
+      se.apply_method_call( @mock, 'some_func', [1,'two',:three], nil )
+    end 
+
+    # Bad func name:
+    err = assert_raise ExpectationError do
+      se.apply_method_call( @mock, 'wrong_func', [1,'two',:three], nil )
+    end
+    assert_match(/wrong method/i, err.message) 
+    assert_match(/wrong_func/i, err.message) 
+    assert_match(/[1, "two", :three]/i, err.message) 
+    assert_match(/some_func/i, err.message) 
+    assert_match(/the_mock/i, err.message) 
+
+    # Wrong mock
+    err = assert_raise ExpectationError do
+      se.apply_method_call( OtherMock.new, 'some_func', [1,'two',:three], nil )
+    end
+    assert_match(/[1, "two", :three]/i, err.message) 
+    assert_match(/some_func/i, err.message) 
+    assert_match(/the_mock/i, err.message) 
+    assert_match(/other_mock/i, err.message) 
+    
+    # Wrong args
+    err = assert_raise ExpectationError do
+      se.apply_method_call( @mock, 'some_func', [1,'two',:four], nil)
+    end
+    assert_match(/[1, "two", :three]/i, err.message) 
+    assert_match(/[1, "two", :four]/i, err.message) 
+    assert_match(/wrong arguments/i, err.message) 
+    assert_match(/some_func/i, err.message) 
+  end
+
+  def test_apply_method_call_should_call_proc_when_given
+    # now with a proc
+    thinger = nil
+    the_proc = Proc.new { thinger = :shaq }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+      :block => the_proc)
+
+    # Try it good:
+    assert_nil thinger
+    assert_nothing_raised ExpectationError do
+      se.apply_method_call(@mock, 'some_func', [], nil)
+    end 
+    assert_equal :shaq, thinger, 'wheres shaq??'
+  end
+
+  def test_apply_method_call_passes_runtime_block_as_last_argument_to_expectation_block
+
+    passed_block = nil
+    exp_block_called = false
+    exp_block = Proc.new { |blk| 
+      exp_block_called = true
+      passed_block = blk 
+    }
+
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func', :block => exp_block,
+      :arguments => [])
+
+    set_flag = false
+    runtime_block = Proc.new { set_flag = true }
+
+    assert_nil passed_block, "Passed block should be nil"
+    assert !set_flag, "set_flag should be off"
+
+    # Go
+    se.apply_method_call( @mock, 'some_func', [], runtime_block)
+
+    # Examine the passed block
+    assert exp_block_called, "Expectation block not called"
+    assert_not_nil passed_block, "Should have been passed a block"
+    assert !set_flag, "set_flag should still be off"
+    passed_block.call
+    assert set_flag, "set_flag should be on"
+  end
+
+  def test_apply_method_call_fails_when_theres_no_expectation_block_to_handle_the_runtime_block
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func', :arguments => [])
+    runtime_block = Proc.new { set_flag = true }
+    err = assert_raise ExpectationError do
+      se.apply_method_call( @mock, 'some_func', [], runtime_block)
+    end
+    assert_match(/unexpected block/i, err.message) 
+    assert_match(/the_mock.some_func()/i, err.message) 
+  end
+
+  def test_returns
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+      :arguments => [1,'two',:three])
+
+    se.returns "A value"
+
+    assert_equal "A value", se.apply_method_call(@mock, 'some_func', [1,'two',:three], nil)
+  end
+
+  def test_apply_method_call_captures_block_value
+    the_proc = lambda { "in the block" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_nil se.block_value, "Block value starts out nil"
+    
+    se.apply_method_call(@mock, 'do_it', [], nil)
+
+    assert_equal "in the block", se.block_value, "Block value not captured"
+  end
+
+  def test_trigger
+    # convenience method for block_value.call
+    target = false
+    inner_proc = lambda { target = true }
+    the_proc = lambda { inner_proc }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_nil se.block_value, "Block value starts out nil"
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_not_nil se.block_value, "Block value not set"
+
+    assert !target, "Target should still be false"
+    se.trigger
+    assert target, "Target not true!"
+  end
+
+  def test_trigger_with_arguments
+    # convenience method for block_value.call
+    target = nil
+    inner_proc = lambda { |one,two| target = [one,two] }
+    the_proc = lambda { inner_proc }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_nil se.block_value, "Block value starts out nil"
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_not_nil se.block_value, "Block value not set"
+
+    assert_nil target, "target should still be nil"
+    se.trigger 'cat','dog'
+    assert_equal ['cat','dog'], target
+  end
+
+  def test_trigger_nil_block_value
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [])
+
+    assert_nil se.block_value, "Block value starts out nil"
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_nil se.block_value, "Block value should still be nil"
+
+    err = assert_raise ExpectationError do
+      se.trigger
+    end
+    assert_match(/do_it/i, err.message) 
+    assert_match(/block value/i, err.message) 
+  end
+
+  def test_trigger_non_proc_block_value
+    the_block = lambda { "woops" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_block)
+
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_equal "woops", se.block_value
+
+    err = assert_raise ExpectationError do
+      se.trigger
+    end
+    assert_match(/do_it/i, err.message) 
+    assert_match(/trigger/i, err.message) 
+    assert_match(/woops/i, err.message) 
+  end
+
+
+
+  def test_proc_used_for_return
+    the_proc = lambda { "in the block" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_equal "in the block", se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_equal "in the block", se.block_value, "Captured block value affected wrongly"
+  end
+
+  def test_explicit_return_overrides_proc_return
+    the_proc = lambda { "in the block" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+    se.returns "the override"
+    assert_equal "the override", se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_equal "in the block", se.block_value, "Captured block value affected wrongly"
+  end
+
+  def test_yields
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields :bean1, :bean2
+
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [:bean1,:bean2], things, "Wrong things"
+  end
+
+  def test_yields_block_takes_no_arguments
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields
+
+    things = []
+    a_block = lambda { things << 'OOF' }
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal ['OOF'], things
+  end
+
+  def test_yields_params_to_block_takes_no_arguments
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields :wont_fit
+
+    things = []
+    a_block = lambda { things << 'WUP' }
+
+    err = assert_raise ExpectationError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/wont_fit/i, err.message) 
+    assert_match(/arity -1/i, err.message) 
+    assert_equal [], things, "Wrong things"
+  end
+
+  def test_yields_with_returns
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] ,
+      :returns => 'the results')
+    
+    exp = se.yields :bean1, :bean2
+    assert_same se, exp, "'yields' needs to return a reference to the expectation"
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+    returned = se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [:bean1,:bean2], things, "Wrong things"
+    assert_equal 'the results', returned, "Wrong return value"
+  end
+
+  def test_yields_with_raises
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot],
+      :raises => RuntimeError.new("kerboom"))
+    
+    exp = se.yields :bean1, :bean2
+    assert_same se, exp, "'yields' needs to return a reference to the expectation"
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+    err = assert_raise RuntimeError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/kerboom/i, err.message) 
+    assert_equal [:bean1,:bean2], things, "Wrong things"
+  end
+
+  def test_yields_and_inner_block_explodes
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot])
+    
+    exp = se.yields :bean1, :bean2
+    assert_same se, exp, "'yields' needs to return a reference to the expectation"
+    things = []
+    a_block = lambda { |thinger| 
+      things << thinger 
+      raise "nasty"
+    } 
+    err = assert_raise RuntimeError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/nasty/i, err.message) 
+    assert_equal [:bean1], things, "Wrong things"
+  end
+
+  def test_yields_with_several_arrays
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields ['a','b'], ['c','d']
+
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [ ['a','b'], ['c','d'] ], things, "Wrong things"
+  end
+
+  def test_yields_tuples
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields ['a','b','c'], ['d','e','f']
+
+    things = []
+    a_block = lambda { |left,mid,right| 
+      things << { :left => left, :mid => mid, :right => right }
+    } 
+
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [ 
+      {:left => 'a', :mid => 'b', :right => 'c' }, 
+      {:left => 'd', :mid => 'e', :right => 'f' },
+      ], things, "Wrong things"
+  end
+
+  def test_yields_tuples_size_mismatch
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields ['a','b','c'], ['d','e','f']
+
+    things = []
+    a_block = lambda { |left,mid| 
+      things << { :left => left, :mid => mid }
+    } 
+
+    err = assert_raise ExpectationError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/arity/i, err.message) 
+    assert_match(/the_mock.each_bean/i, err.message) 
+    assert_match(/"a", "b", "c"/i, err.message) 
+    assert_equal [], things, "Wrong things"
+  end
+end

data/test/unit/trapper_test.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class TrapperTest < Test::Unit::TestCase
+
+  def setup
+    @mock = Object.new
+    @mock_control = MyControl.new
+    @builder = ExpBuilder.new
+    @trapper = Trapper.new(@mock, @mock_control, @builder)
+  end
+
+  #
+  # HELPERS
+  #
+   
+  class MyControl
+    attr_reader :added
+    def add_expectation(expectation)
+      @added ||= []
+      @added << expectation
+    end
+  end
+
+  class ExpBuilder
+    attr_reader :options
+    def build_expectation(options)
+      @options = options
+      "dummy expectation"
+    end
+  end
+
+  #
+  # TESTS
+  #
+
+  def test_method_missing
+
+    output = @trapper.change(:less)
+
+    assert_same @mock, @builder.options[:mock]
+    assert_equal :change, @builder.options[:method]
+    assert_equal [:less], @builder.options[:arguments]
+    assert_not_nil @builder.options[:block]
+    assert @builder.options[:suppress_arguments_to_block], ":suppress_arguments_to_block should be set"
+    assert_equal [ "dummy expectation" ], @mock_control.added,
+      "Wrong expectation added to control"
+
+    assert_equal "dummy expectation", output, "Expectation should have been returned"
+
+    # Examine the block.  It should take one argument and simply return
+    # that argument.  because of the 'suppress arguments to block' 
+    # setting, the argument can only end up being a block, in practice.
+    trapper_block = @builder.options[:block]
+    assert_equal "the argument", trapper_block.call("the argument"),
+      "The block should merely return the passed argument"
+  end
+
+
+end