ceedling 0.12.2 → 0.13.0.rc1

data/vendor/hardmock/lib/hardmock/utils.rb

@@ -0,0 +1,9 @@
+
+module Hardmock
+  module Utils #:nodoc:
+    def format_method_call_string(mock,mname,args)
+      arg_string = args.map { |a| a.inspect }.join(', ')
+      call_text = "#{mock._name}.#{mname}(#{arg_string})"
+    end
+  end
+end

data/vendor/hardmock/lib/test_unit_before_after.rb

@@ -0,0 +1,169 @@
+require 'test/unit'
+require 'test/unit/testcase'
+require 'test/unit/assertions'
+
+module Test #:nodoc:#
+  module Unit #:nodoc:#
+    
+    # == TestCase Modifications
+    #
+    # Monkey-patch to provide a formal mechanism for appending actions to be executed after teardown.
+    # Use after_teardown to define one or more actions to be executed after teardown for ALL tests.
+    #
+    # COMING SOON?
+    # * (maybe?) Hooks for before_teardown, after_setup, on_error
+    # * (maybe?) Options for positional control, eg, after_teardown :before_other_actions
+    # * (maybe?) Provide tagging/filtering so action execution can be controlled specifically?
+    #
+    # == Usage
+    #
+    # Invoke TestCase.after_teardown with optional parameter, which will be invoked with a reference
+    # to the test instance that has just been torn down.
+    #
+    # Example:
+    # 
+    #   Test::Unit::TestCase.after_teardown do |test|
+    #     test.verify_mocks
+    #   end
+    #   
+    # == Justification
+    #
+    # There are a number of tools and libraries that play fast-n-loose with setup and teardown by 
+    # wrapping them, and by overriding method_added as a means of upholding special setup/teardown 
+    # behavior, usually by re-wrapping newly defined user-level setup/teardown methods.
+    # mocha and active_record/fixtures (and previously, hardmock) will fight for this
+    # territory with often unpredictable results.
+    #
+    # We wouldn't have to battle if Test::Unit provided a formal pre- and post- hook mechanism.
+    #
+    class TestCase
+
+      class << self
+        
+        # Define an action to be run after teardown. Subsequent calls result in 
+        # multiple actions.  The block will be given a reference to the test
+        # being executed.
+        #
+        # Example:
+        # 
+        #   Test::Unit::TestCase.after_teardown do |test|
+        #     test.verify_mocks
+        #   end
+        def after_teardown(&block)
+          post_teardown_actions << block
+        end
+
+        # Used internally. Access the list of post teardown actions for to be
+        # used by all tests.
+        def post_teardown_actions
+          @@post_teardown_actions ||= []
+        end
+
+        # Define an action to be run before setup. Subsequent calls result in 
+        # multiple actions, EACH BEING PREPENDED TO THE PREVIOUS.  
+        # The block will be given a reference to the test being executed.
+        #
+        # Example:
+        # 
+        #   Test::Unit::TestCase.before_setup do |test|
+        #     test.prepare_hardmock_control
+        #   end
+        def before_setup(&block)
+          pre_setup_actions.unshift block
+        end
+
+        # Used internally. Access the list of post teardown actions for to be
+        # used by all tests.
+        def pre_setup_actions
+          @@pre_setup_actions ||= []
+        end
+      end
+
+      # OVERRIDE: This is a reimplementation of the default "run", updated to
+      # execute actions after teardown.
+      def run(result)
+        yield(STARTED, name)
+        @_result = result
+        begin
+          execute_pre_setup_actions(self)
+          setup
+          __send__(@method_name)
+        rescue Test::Unit::AssertionFailedError => e
+          add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+        rescue Exception
+          raise if should_passthru_exception($!) # See implementation; this is for pre-1.8.6 compat
+          add_error($!)
+        ensure
+          begin
+            teardown
+          rescue Test::Unit::AssertionFailedError => e
+            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+          rescue Exception
+            raise if should_passthru_exception($!) # See implementation; this is for pre-1.8.6 compat
+            add_error($!)
+          ensure
+            execute_post_teardown_actions(self)
+          end
+        end
+        result.add_run
+        yield(FINISHED, name)
+      end
+
+      private
+
+      # Run through the after_teardown actions, treating failures and errors
+      # in the same way that "run" does: they are reported, and the remaining
+      # actions are executed.
+      def execute_post_teardown_actions(test_instance)
+        self.class.post_teardown_actions.each do |action|
+          begin
+            action.call test_instance
+          rescue Test::Unit::AssertionFailedError => e
+            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+          rescue Exception
+            raise if should_passthru_exception($!)
+            add_error($!)
+          end
+        end
+      end
+      
+      # Run through the before_setup actions.
+      # Failures or errors cause execution to stop.
+      def execute_pre_setup_actions(test_instance)
+        self.class.pre_setup_actions.each do |action|
+#          begin
+            action.call test_instance
+#          rescue Test::Unit::AssertionFailedError => e
+#            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+#          rescue Exception
+#            raise if should_passthru_exception($!)
+#            add_error($!)
+#          end
+        end
+      end
+
+      # Make sure that this extension doesn't show up in failure backtraces
+      def auxiliary_backtrace_filter(trace)
+        trace.reject { |x| x =~ /test_unit_before_after/ }
+      end
+
+      # Is the given error of the type that we allow to fly out (rather than catching it)?
+      def should_passthru_exception(ex)
+        return passthrough_exception_types.include?($!.class)
+      end
+
+      # Provide a list of exception types that are to be allowed to explode out.
+      # Pre-ruby-1.8.6 doesn't use this functionality, so the PASSTHROUGH_EXCEPTIONS
+      # constant won't be defined.  This methods defends against that and returns
+      # an empty list instead.
+      def passthrough_exception_types
+        begin 
+          return PASSTHROUGH_EXCEPTIONS
+        rescue NameError
+          # older versions of test/unit do not have PASSTHROUGH_EXCEPTIONS constant
+          return []
+        end
+      end
+    end
+  end
+end

data/vendor/hardmock/rake_tasks/rdoc.rake

@@ -0,0 +1,19 @@
+require 'rake/rdoctask'
+require File.expand_path(File.dirname(__FILE__) + "/rdoc_options.rb")
+
+namespace :doc do
+
+  desc "Generate RDoc documentation"
+  Rake::RDocTask.new { |rdoc|
+    rdoc.rdoc_dir = 'doc'
+    rdoc.title    = "Hardmock: Strict expectation-based mock object library " 
+    add_rdoc_options(rdoc.options)
+    rdoc.rdoc_files.include('lib/**/*.rb', 'README','CHANGES','LICENSE')
+  }
+
+  task :show => [ 'doc:rerdoc' ] do
+    sh "open doc/index.html"
+  end
+
+end
+

data/vendor/hardmock/rake_tasks/rdoc_options.rb

@@ -0,0 +1,4 @@
+
+def add_rdoc_options(options)
+  options << '--line-numbers' << '--inline-source' << '--main' << 'README' << '--title' << 'Hardmock'
+end

data/vendor/hardmock/rake_tasks/test.rake

@@ -0,0 +1,22 @@
+require 'rake/testtask'
+
+namespace :test do
+
+  desc "Run unit tests"
+  Rake::TestTask.new("units") { |t|
+    t.libs << "test"
+    t.pattern = 'test/unit/*_test.rb'
+    t.verbose = true
+  }
+
+  desc "Run functional tests"
+  Rake::TestTask.new("functional") { |t|
+    t.libs << "test"
+    t.pattern = 'test/functional/*_test.rb'
+    t.verbose = true
+  }
+
+  desc "Run all the tests"
+  task :all => [ 'test:units', 'test:functional' ]
+
+end

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

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'assert_error'
+
+class AssertErrorTest < Test::Unit::TestCase
+
+  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
+
+  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")
+      end
+    end
+    assert_match(/not good/i, err.message) 
+    assert_match(/too funky/i, err.message) 
+  end
+
+  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")
+      end
+    end
+    assert_match(/StandardError/i, err.message) 
+    assert_match(/RuntimeError/i, err.message) 
+  end
+
+  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
+
+  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")
+      end
+    end
+    assert_match(/way/i, err.message) 
+  end
+
+  it "can operate without any message specification" do
+    assert_error StandardError do 
+      raise StandardError.new("ooof")
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+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
+
+  #
+  # TESTS
+  #
+
+  it "auto-verifies all mocks in teardown" do
+    write_and_execute_test 
+  end
+
+  it "auto-verifies even if user defines own teardown" do
+    @teardown_code =<<-EOM 
+      def teardown
+        # just in the way
+      end
+    EOM
+    write_and_execute_test 
+  end
+
+  should "not obscure normal failures when verification fails" do
+    @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
+
+  should "not skip user-defined teardown when verification fails" do
+    @teardown_code =<<-EOM 
+      def teardown
+        puts "User teardown"
+      end
+    EOM
+    write_and_execute_test 
+    assert_output_contains(/User teardown/)
+  end
+
+  it "is quiet when verification is ok" do
+    @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
+
+  should "auto-verify even if user teardown explodes" do
+    @teardown_code =<<-EOM 
+      def teardown
+        raise "self destruct"
+      end
+    EOM
+    @expect_errors = 2
+    write_and_execute_test
+    assert_output_contains(/self destruct/)
+  end
+
+  it "plays nice with inherited teardown methods" do
+    @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
+
+  #
+  # 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`
+  end
+
+  def formatted_test_output
+    if @test_output
+      @test_output.split(/\n/).map { |line| "> #{line}" }.join("\n")
+    else
+      "(NO TEST OUTPUT!)"
+    end
+  end
+
+  def remove_temp_test_file
+    FileUtils::rm_f temp_test_file
+  end
+
+  def assert_results(h)
+    if @test_output !~ /#{h[:tests]} tests, [0-9]+ assertions, #{h[:failures]} failures, #{h[:errors]} errors/
+      flunk "Test results didn't match #{h.inspect}:\n#{formatted_test_output}"
+    end
+  end
+
+  def assert_output_contains(*patterns)
+    patterns.each do |pattern|
+      if @test_output !~ pattern
+        flunk "Test output didn't match #{pattern.inspect}:\n#{formatted_test_output}"
+      end
+    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
+  
+end