minilab 1.0.0-mswin32

data/vendor/hardmock/lib/method_cleanout.rb

@@ -0,0 +1,14 @@
+
+module Hardmock #:nodoc:
+  module MethodCleanout #:nodoc:
+    SACRED_METHODS = %w|__id__ __send__ equal? object_id send nil? class kind_of? respond_to? inspect method to_s instance_variables instance_eval|
+
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        instance_methods.each { |m| 
+          undef_method m unless SACRED_METHODS.include?(m.to_s)
+        }
+      end
+    end
+  end
+end

data/vendor/hardmock/rcov.rake

@@ -0,0 +1,18 @@
+
+begin
+require 'rcov/rcovtask'
+
+namespace :rcov do
+
+  desc "Generate code coverage HTML report in pkg/coverage"
+  Rcov::RcovTask.new(:coverage) do |t|
+    t.test_files = FileList['test/unit/**/*.rb'] + FileList['test/functional/**/*.rb']
+    t.verbose = true
+    t.output_dir = "coverage"
+  end
+
+end
+
+rescue 
+  puts "RCOV TASK DISABLED"
+end

data/vendor/hardmock/test/functional/assert_error_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class AssertErrorTest < Test::Unit::TestCase
+
+  def test_assert_error
+    assert_error RuntimeError, "Too funky" do
+      raise RuntimeError.new("Too funky")
+    end
+  end
+
+  def test_assert_error_message_doesnt_match
+    err = assert_raise Test::Unit::AssertionFailedError do
+      assert_error RuntimeError, "not good" do
+        raise RuntimeError.new("Too funky")
+      end
+    end
+    assert_match(/not good/i, err.message) 
+    assert_match(/too funky/i, err.message) 
+  end
+
+  def test_assert_error_type_doesnt_match
+    err = assert_raise Test::Unit::AssertionFailedError do
+      assert_error StandardError, "Too funky" do
+        raise RuntimeError.new("Too funky")
+      end
+    end
+    assert_match(/StandardError/i, err.message) 
+    assert_match(/RuntimeError/i, err.message) 
+  end
+
+  def test_assert_error_regexp_matching 
+    assert_error StandardError, /too/i, /funky/i do
+      raise StandardError.new("Too funky")
+    end
+  end
+
+  def test_assert_error_regexp_matching_fails
+    err = assert_raise Test::Unit::AssertionFailedError do
+      assert_error StandardError, /way/i, /too/i, /funky/i do
+        raise StandardError.new("Too funky")
+      end
+    end
+    assert_match(/way/i, err.message) 
+  end
+
+  def test_assert_error_no_matchine
+    assert_error StandardError do 
+      raise StandardError.new("ooof")
+    end
+  end
+end

data/vendor/hardmock/test/functional/auto_verify_test.rb

@@ -0,0 +1,192 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'fileutils'
+
+class AutoVerifyTest < Test::Unit::TestCase
+
+  def setup
+    @expect_unmet_expectations = true
+  end
+
+  def teardown
+    remove_temp_test_file
+  end
+
+  #
+  # HELPERS
+  #
+
+  def temp_test_file
+    File.expand_path(File.dirname(__FILE__) + "/tear_down_verification_test.rb")
+  end
+
+  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
+    FileUtils::rm_f temp_test_file
+  end
+
+  def assert_results(h)
+    assert_match(/#{h[:tests]} tests, [0-9]+ assertions, #{h[:failures]} failures, #{h[:errors]} errors/,
+     @test_output)
+  end
+
+  def assert_output_contains(*patterns)
+    patterns.each do |pattern|
+      assert_match(pattern,@test_output)
+    end
+  end
+  
+  def assert_output_doesnt_contain(*patterns)
+    patterns.each do |pattern|
+      assert @test_output !~ pattern, "Output shouldn't match #{pattern.inspect} but it does."
+    end
+  end
+
+  def write_and_execute_test
+    @test_code ||=<<-EOM
+        def test_setup_doomed_expectation
+          create_mock :automobile
+          @automobile.expects.start
+        end
+    EOM
+    @full_code ||=<<-EOTEST
+      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+      require 'hardmock'
+      class DummyTest < Test::Unit::TestCase
+        #{@teardown_code}
+        #{@test_code}
+      end 
+    EOTEST
+    run_test @full_code
+
+    if @expect_unmet_expectations 
+      assert_output_contains(/unmet expectations/i, /automobile/, /start/)
+    else
+      assert_output_doesnt_contain(/unmet expectations/i, /automobile/, /start/)
+    end
+
+    @expect_tests ||= 1
+    @expect_failures ||= 0
+    @expect_errors ||= 1
+    assert_results :tests => @expect_tests, :failures => @expect_failures, :errors => @expect_errors
+  end
+  
+  #
+  # TESTS
+  #
+
+  def test_should_auto_verify_mocks_in_teardown
+    write_and_execute_test 
+  end
+
+  def test_should_auto_verify_mocks_even_if_user_has_own_teardown
+    @teardown_code =<<-EOM 
+      def teardown
+        # just in the way
+      end
+    EOM
+    write_and_execute_test 
+  end
+
+  def test_should_auto_verify_mocks_but_not_obscure_natural_failures
+    @test_code =<<-EOM
+        def test_setup_doomed_expectation
+          create_mock :automobile
+          @automobile.expects.start
+          flunk "natural failure"
+        end
+    EOM
+    @expect_failures = 1
+    write_and_execute_test
+  end
+
+  def test_should_not_prevent_user_teardown_even_if_verification_fails
+    @teardown_code =<<-EOM 
+      def teardown
+        puts "User teardown"
+      end
+    EOM
+    write_and_execute_test 
+    assert_output_contains(/User teardown/)
+  end
+
+  def test_should_not_raise_error_if_verification_goes_according_to_plan
+    @test_code =<<-EOM
+        def test_ok
+          create_mock :automobile
+          @automobile.expects.start
+          @automobile.start
+        end
+    EOM
+    @teardown_code =<<-EOM 
+      def teardown
+        puts "User teardown"
+      end
+    EOM
+    @expect_unmet_expectations = false
+    @expect_failures = 0
+    @expect_errors = 0
+    write_and_execute_test
+    assert_output_contains(/User teardown/)
+  end
+
+  def test_should_not_do_verification_if_user_teardown_explodes
+    @teardown_code =<<-EOM 
+      def teardown
+        raise "self destruct"
+      end
+    EOM
+    @expect_unmet_expectations = false
+    write_and_execute_test
+    assert_output_contains(/self destruct/)
+  end
+
+  def test_should_not_obscure_inherited_teardown
+    @full_code ||=<<-EOTEST
+      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+      require 'hardmock'
+      class Test::Unit::TestCase 
+        def teardown
+          puts "Test helper teardown"
+        end
+      end
+      class DummyTest < Test::Unit::TestCase
+        def test_prepare_to_die
+          create_mock :automobile
+          @automobile.expects.start
+        end
+      end 
+    EOTEST
+    write_and_execute_test
+    assert_output_contains(/Test helper teardown/)
+  end
+
+  def test_should_simultaneously_support_inherited_and_user_and_hardmock_teardown
+    @full_code ||=<<-EOTEST
+      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+      class Test::Unit::TestCase 
+        def teardown
+          puts "Test helper teardown"
+        end
+      end
+      require 'hardmock' # IMPORTANT TO DO THIS HERE, between the old and new teardown defs
+      class DummyTest < Test::Unit::TestCase
+        def teardown
+          puts "User teardown"
+        end
+        def test_prepare_to_die
+          create_mock :automobile
+          @automobile.expects.start
+        end
+      end 
+    EOTEST
+    write_and_execute_test
+    assert_output_contains(/Test helper teardown/, /User teardown/)
+  end
+end

data/vendor/hardmock/test/functional/direct_mock_usage_test.rb

@@ -0,0 +1,396 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class DirectMockUsageTest < Test::Unit::TestCase
+
+  def setup
+    @bird = Mock.new('bird')
+  end
+
+  def teardown
+  end
+
+  #
+  # TESTS
+  #
+
+  def test_verify_should_raise_verify_error_if_expected_method_not_called
+    @bird.expects.flap_flap
+
+    err = assert_raise VerifyError do
+      @bird._verify
+    end
+    assert_match(/unmet expectations/i, err.message)
+  end
+
+  def test_verify_should_not_raise_when_expected_calls_made_in_order
+    @bird.expects.flap_flap
+    @bird.expects.bang
+    @bird.expects.plop
+
+    @bird.flap_flap
+    @bird.bang
+    @bird.plop
+
+    @bird._verify
+  end
+
+  def test_should_raise_expectation_error_when_unexpected_method_called
+    @bird.expects.flap_flap
+
+    err = assert_raise ExpectationError do
+      @bird.shoot
+    end
+    assert_match(/wrong method/i, err.message) 
+  end
+
+  def test_bad_argument_call
+    @bird.expects.flap_flap(:swoosh)
+
+    err = assert_raise ExpectationError do
+      @bird.flap_flap(:rip)
+    end
+    assert_match(/wrong arguments/i, err.message) 
+  end
+  
+  def test_verify_should_raise_verify_error_when_not_all_expected_methods_called
+    @bird.expects.flap_flap
+    @bird.expects.bang
+    @bird.expects.plop
+
+    @bird.flap_flap
+
+    err = assert_raise VerifyError do
+      @bird._verify
+    end
+    assert_match(/unmet expectations/i, err.message)
+  end
+
+  def test_should_raise_expectation_error_when_calls_made_out_of_order
+    @bird.expects.flap_flap
+    @bird.expects.bang
+    @bird.expects.plop
+
+    @bird.flap_flap
+    err = assert_raise ExpectationError do
+      @bird.plop
+    end
+    assert_match(/wrong method/i, err.message) 
+  end
+
+  def test_should_return_given_value_when_specified
+    @bird.expects.plop.returns(':P')
+    assert_equal ':P', @bird.plop
+    @bird._verify
+
+    @bird.expects.plop.returns(':x')
+    assert_equal ':x', @bird.plop
+    @bird._verify
+  end
+
+  def test_should_return_nil_value_when_none_specified
+    @bird.expects.plop
+    assert_nil @bird.plop
+    @bird._verify
+  end
+
+  def test_raise_should_raise_given_exception_when_specified
+    err = RuntimeError.new('shaq')
+    @bird.expects.plop.raises(err)
+    actual_err = assert_raise RuntimeError do
+      @bird.plop
+    end
+    assert_same err, actual_err, 'should be the same error'
+    @bird._verify
+  end
+
+  def test_raise_should_raise_given_string_wrapped_in_runtime_error
+    @bird.expects.plop.raises('shaq')
+    err = assert_raise RuntimeError do
+      @bird.plop
+    end
+    assert_match(/shaq/i, err.message) 
+    @bird._verify
+  end
+
+  def test_raise_should_raise_a_canned_runtime_error_if_nothing_given
+    @bird.expects.plop.raises
+    err = assert_raise RuntimeError do
+      @bird.plop
+    end
+    assert_match(/error/i, err.message) 
+    @bird._verify
+  end
+
+  def test_should_be_happy_with_correct_expected_arguments
+    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
+    thing = Object.new
+    @bird.expects.plop(:big,'one',thing)
+    err = assert_raise ExpectationError do
+      # more
+      @bird.plop(:big,'one',thing,:other)
+    end
+    assert_match(/wrong arguments/i, err.message)
+    @bird._verify
+
+    @bird.expects.plop(:big,'one',thing)
+    err = assert_raise ExpectationError do
+      # less
+      @bird.plop(:big,'one')
+    end
+    assert_match(/wrong arguments/i, err.message)
+    @bird._verify
+    
+    @bird.expects.plop
+    err = assert_raise ExpectationError do
+      # less
+      @bird.plop(:big)
+    end
+    assert_match(/wrong arguments/i, err.message)
+    @bird._verify
+  end
+
+  def test_should_raise_expectation_error_when_arguemnts_dont_match
+    thing = Object.new
+    @bird.expects.plop(:big,'one',thing)
+    err = assert_raise ExpectationError do
+      @bird.plop(:big,'two',thing,:other)
+    end
+    assert_match(/wrong arguments/i, err.message)
+    @bird._verify
+  end
+
+  def test_should_yield_to_block_given
+    mitt = nil
+    @bird.expects.plop { mitt = :ball }
+    assert_nil mitt
+    @bird.plop
+    assert_equal :ball, mitt, 'didnt catch the ball'
+    @bird._verify
+
+    @bird.expects.plop { raise 'ball' }
+    err = assert_raise RuntimeError do
+      @bird.plop
+    end
+    assert_match(/ball/i, err.message) 
+    @bird._verify
+  end
+
+  def test_shouldnt_care_about_arguments_if_block_given
+    ball = nil
+    mitt = nil
+    @bird.expects.plop {|arg1,arg2| 
+      ball = arg1  
+      mitt = arg2  
+    }
+    assert_nil ball
+    assert_nil mitt
+    @bird.plop(:ball,:mitt)
+    assert_equal :ball, ball
+    assert_equal :mitt, mitt
+    @bird._verify
+  end
+
+  def test_should_check_arguments_if_specified_when_block_given
+    ball = nil
+    mitt = nil
+    @bird.expects.plop(:ball,:mitt) {|arg1,arg2| 
+      ball = arg1  
+      mitt = arg2  
+    }
+    assert_nil ball
+    assert_nil mitt
+    @bird.plop(:ball,:mitt)
+    assert_equal :ball, ball
+    assert_equal :mitt, mitt
+    @bird._verify
+
+    ball = nil
+    mitt = nil
+    @bird.expects.plop(:bad,:stupid) {|arg1,arg2| 
+      ball = arg1  
+      mitt = arg2  
+    }
+    assert_nil ball
+    assert_nil mitt
+    err = assert_raise ExpectationError do
+      @bird.plop(:ball,:mitt)
+    end
+    assert_match(/wrong arguments/i, err.message) 
+    assert_nil ball
+    assert_nil mitt
+    @bird._verify
+
+    ball = nil
+    mitt = nil
+    @bird.expects.plop(:ball,:mitt) {|arg1,arg2| 
+      ball = arg1  
+      mitt = arg2  
+    }
+    assert_nil ball
+    assert_nil mitt
+    err = assert_raise ExpectationError do
+      @bird.plop(:ball)
+    end
+    assert_match(/wrong arguments/i, err.message) 
+    assert_nil ball
+    assert_nil mitt
+    @bird._verify
+  end
+
+  def test_runtime_blocks_get_passed_to_expectation_blocks
+    runtime_block_called = false
+    got_arg = nil
+
+    # Eg, bird expects someone to subscribe to :tweet using the 'when' method
+    @bird.expects.when(:tweet) { |arg1, block| 
+      got_arg = arg1
+      block.call
+    }
+
+    @bird.when(:tweet) do 
+      runtime_block_called = true
+    end
+
+    assert_equal :tweet, got_arg, "Wrong arg"
+    assert runtime_block_called, "The runtime block should have been invoked by the user block"
+
+    @bird.expects.when(:warnk) { |e,blk| }
+
+    err = assert_raise ExpectationError do
+      @bird.when(:honk) { }
+    end
+    assert_match(/wrong arguments/i, err.message) 
+
+    @bird._verify
+  end
+
+  def test_runtime_blocks_get_passed_to_expectation_blocks__no_arguments
+    runtime_block_called = false
+    @bird.expects.subscribe { |block| block.call }
+    @bird.subscribe do 
+      runtime_block_called = true
+    end
+    assert runtime_block_called, "The runtime block should have been invoked by the user block"
+  end
+
+  def test_expect_runtime_block_but_none_sent
+    invoked = false
+    @bird.expects.kablam(:scatter) { |shot,block| 
+      assert_equal :scatter, shot, "Wrong shot"
+      assert_nil block, "The expectation block should get a nil block when user neglects to pass one"
+      invoked = true
+    }
+    @bird.kablam :scatter
+    assert invoked, "Expectation block not invoked"
+
+    @bird._verify
+  end
+
+  def test_can_set_return_after_blocks
+    got = nil
+    @bird.expects.kablam(:scatter) { |shot|
+      got = shot
+    }.returns(:death)
+
+    val = @bird.kablam :scatter 
+    assert_equal :death, val, "Wrong return value"
+    assert_equal :scatter, got, "Wrong argument"
+    @bird._verify
+  end
+
+  def test_can_set_raises_after_blocks
+    got = nil
+    @bird.expects.kablam(:scatter) do |shot|
+      got = shot
+    end.raises "hell"
+
+    err = assert_raise RuntimeError do
+      @bird.kablam :scatter 
+    end
+    assert_match(/hell/i, err.message) 
+
+    @bird._verify
+  end
+
+  def test_expectation_block_value_is_captured
+    expectation = @bird.expects.kablam(:slug) { |shot|
+      "The shot was #{shot}"
+    }
+
+    assert_not_nil expectation, "Expectation nil"
+    assert_nil expectation.block_value, "Block value should start out nil"
+
+    ret_val = @bird.kablam :slug 
+
+    assert_equal "The shot was slug", expectation.block_value
+    assert_equal "The shot was slug", ret_val, "Block value should also be used for return"
+
+    @bird._verify
+  end
+
+
+  def test_expectation_block_value_is_used_for_return_value
+    @bird.expects.kablam(:scatter) { |shot|
+      "The shot was #{shot}"
+    }
+    val = @bird.kablam :scatter 
+    assert_equal "The shot was scatter", val, "Wrong return value"
+    @bird._verify
+  end
+
+  def test_expectation_is_still_returned_when_using_returns
+    expectation = @bird.expects.kablam(:slug) { |shot|
+      "The shot was #{shot}"
+    }.returns :hosed
+
+    assert_not_nil expectation, "Expectation nil"
+    assert_nil expectation.block_value, "Block value should start out nil"
+
+    ret_val = @bird.kablam :slug 
+
+    assert_equal "The shot was slug", expectation.block_value
+    assert_equal :hosed, ret_val, "Block value should also be used for return"
+
+    @bird._verify
+  end
+
+  def test_expectation_is_still_returned_when_using_raises
+    expectation = @bird.expects.kablam(:slug) { |shot|
+      "The shot was #{shot}"
+    }.raises "aiee!"
+
+    assert_not_nil expectation, "Expectation nil"
+    assert_nil expectation.block_value, "Block value should start out nil"
+
+    err = assert_raise RuntimeError do
+     @bird.kablam :slug 
+    end
+    assert_match(/aiee!/i, err.message)
+    assert_equal "The shot was slug", expectation.block_value
+    @bird._verify
+  end
+
+
+  def test_expect_assignment
+    @bird.expects.size = "large"
+    @bird.size = "large"
+    @bird._verify
+  end
+
+  def test_expect_assignment_with_raise
+    @bird.expects('size=','large').raises "boom"
+
+    err = assert_raise RuntimeError do
+      @bird.size = "large"
+    end
+    assert_match(/boom/i, err.message) 
+  end
+
+end