minilab 1.0.0-mswin32

data/vendor/hardmock/test/unit/method_cleanout_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'method_cleanout'
+
+class MethodCleanoutTest < Test::Unit::TestCase
+  class Victim
+    OriginalMethods = instance_methods
+    include Hardmock::MethodCleanout
+  end
+  
+  def setup
+    @victim = Victim.new
+  end
+
+  def test_should_remove_most_methods_from_a_class
+    expect_removed = Victim::OriginalMethods.reject { |m| 
+      Hardmock::MethodCleanout::SACRED_METHODS.include?(m)
+    }
+    expect_removed.each do |m|
+      assert !@victim.respond_to?(m), "should not have method #{m}"
+    end
+  end
+
+  def test_should_leave_the_sacred_methods_defined
+    Hardmock::MethodCleanout::SACRED_METHODS.each do |m|
+      assert @victim.respond_to?(m)
+    end
+  end
+
+  def test_should_include_certain_important_methods_in_the_sacred_methods_list
+    %w|__id__ __send__ equal? object_id send nil? class kind_of? respond_to? inspect method to_s instance_variables instance_eval|.each do |m|
+      assert Hardmock::MethodCleanout::SACRED_METHODS.include?(m), "important method #{m} is not included in SACRED_METHODS"
+    end
+  end
+
+end

data/vendor/hardmock/test/unit/mock_control_test.rb

@@ -0,0 +1,172 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class MockControlTest < Test::Unit::TestCase
+
+  def setup
+    @unmock = OpenStruct.new( :_name => 'fakemock' )
+
+    @control = MockControl.new
+    assert @control.happy?, "Control should start out happy"
+  end
+
+  def teardown
+  end
+
+  #
+  # HELPERS
+  #
+
+  class MyExp  
+    attr_reader :mock, :mname, :args, :block
+    def apply_method_call(mock, mname, args, block)
+      @mock = mock
+      @mname = mname
+      @args = args
+      @block = block
+    end
+  end
+
+  class BoomExp < MyExp
+    def apply_method_call(mock, mname, args, block)
+      super
+      raise "BOOM"
+    end
+  end
+
+  #
+  # TESTS
+  #
+
+  def test_add_exepectation_and_apply_method_call
+    e1 = MyExp.new
+
+    @control.add_expectation e1
+    assert !@control.happy?
+
+    @control.apply_method_call @unmock, 'some_func', [ 'the', :args ], nil
+    assert @control.happy?
+    
+    assert_same @unmock, e1.mock, "Wrong mock"
+    assert_equal 'some_func', e1.mname, "Wrong method"
+    assert_equal [ 'the', :args ], e1.args, "Wrong args"
+
+    @control.verify
+  end
+
+  def test_add_exepectation_and_apply_method_call_with_block
+    e1 = MyExp.new
+
+    @control.add_expectation e1
+    assert !@control.happy?
+
+    runtime_block = Proc.new { "hello" }
+    @control.apply_method_call @unmock, 'some_func', [ 'the', :args ], runtime_block
+    assert @control.happy?
+    
+    assert_same @unmock, e1.mock, "Wrong mock"
+    assert_equal 'some_func', e1.mname, "Wrong method"
+    assert_equal [ 'the', :args ], e1.args, "Wrong args"
+    assert_equal "hello", e1.block.call, "Wrong block in expectation"
+
+    @control.verify
+  end
+
+  def test_add_expectation_then_verify
+    e1 = MyExp.new
+
+    @control.add_expectation e1
+    assert !@control.happy?, "Shoudn't be happy"
+    err = assert_raise VerifyError do
+      @control.verify
+    end
+    assert_match(/unmet expectations/i, err.message) 
+
+    @control.apply_method_call @unmock, 'some_func', [ 'the', :args ], nil
+    assert @control.happy?
+    
+    assert_same @unmock, e1.mock, "Wrong mock"
+    assert_equal 'some_func', e1.mname, "Wrong method"
+    assert_equal [ 'the', :args ], e1.args, "Wrong args"
+
+    @control.verify
+  end
+
+  def test_expectation_explosion
+    be1 = BoomExp.new
+
+    @control.add_expectation be1
+
+    err = assert_raise RuntimeError do
+      @control.apply_method_call @unmock, 'a func', [:arg], nil
+    end
+    assert_match(/BOOM/i, err.message) 
+
+    assert_same @unmock, be1.mock
+    assert_equal 'a func', be1.mname
+    assert_equal [:arg], be1.args
+  end
+
+  def test_disappointment_on_bad_verify
+    @control.add_expectation MyExp.new
+    assert !@control.happy?, "Shouldn't be happy"
+    assert !@control.disappointed?, "too early to be disappointed"
+
+    # See verify fails
+    err = assert_raise VerifyError do
+      @control.verify
+    end
+    assert_match(/unmet expectations/i, err.message) 
+
+    assert !@control.happy?, "Still have unmet expectation"
+    assert @control.disappointed?, "We should be disappointed following that failure"
+
+    @control.apply_method_call @unmock, 'something', [], nil
+    assert @control.happy?, "Should be happy"
+    assert @control.disappointed?, "We should be skeptical"
+
+    @control.verify
+
+    assert !@control.disappointed?, "Should be non-disappointed"
+  end
+
+  def test_disappointment_from_surprise_calls
+    assert @control.happy?, "Should be happy"
+    assert !@control.disappointed?, "too early to be disappointed"
+
+    # See verify fails
+    err = assert_raise ExpectationError do
+      @control.apply_method_call @unmock, "something", [], nil
+    end
+    assert_match(/surprise/i, err.message) 
+
+    assert @control.happy?, "Happiness is an empty list of expectations"
+    assert @control.disappointed?, "We should be disappointed following that failure"
+
+    @control.verify
+    assert !@control.disappointed?, "Disappointment should be gone"
+  end
+
+  def test_disappointment_from_bad_calls
+    be1 = BoomExp.new
+    assert !@control.disappointed?, "Shouldn't be disappointed"
+    @control.add_expectation be1
+    assert !@control.disappointed?, "Shouldn't be disappointed"
+
+    err = assert_raise RuntimeError do
+      @control.apply_method_call @unmock, 'a func', [:arg], nil
+    end
+    assert_match(/BOOM/i, err.message) 
+    assert @control.disappointed?, "Should be disappointed"
+
+    assert_same @unmock, be1.mock
+    assert_equal 'a func', be1.mname
+    assert_equal [:arg], be1.args
+
+    assert @control.happy?, "Happiness is an empty list of expectations"
+    @control.verify
+    assert !@control.disappointed?, "Disappointment should be gone"
+  end
+
+
+end

data/vendor/hardmock/test/unit/mock_test.rb

@@ -0,0 +1,273 @@
+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