ceedling 0.31.1 → 1.0.1

data/vendor/hardmock/lib/hardmock/stubbing.rb

@@ -1,210 +0,0 @@
-
-
-# Stubbing support
-#
-# Stubs methods on classes and instances
-#
-
-# Why's "metaid.rb" stuff crunched down:
-class Object #:nodoc:#
-	def hm_metaclass #:nodoc:#
-    class << self
-      self
-    end
-  end
-	
-	def hm_meta_eval(&blk) #:nodoc:#
-    hm_metaclass.instance_eval(&blk)
-  end
-
-	def hm_meta_def(name, &blk) #:nodoc:#
-		hm_meta_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 ReplacedMethod #:nodoc:#
-    attr_reader :target, :method_name
-
-    def initialize(target, method_name)
-      @target = target
-      @method_name = method_name
-
-      Hardmock.track_replaced_method self
-    end
-  end
-
-  class StubbedMethod < ReplacedMethod #:nodoc:#
-    def invoke(args)
-      raise @raises if @raises
-      @return_value
-    end
-
-    def returns(stubbed_return)
-      @return_value = stubbed_return
-    end
-
-    def raises(err)
-      err = RuntimeError.new(err) unless err.kind_of?(Exception)
-      @raises = err
-    end
-  end
-
-  class ::Object
-    def stubs!(method_name)
-      method_name = method_name.to_s
-      already_stubbed = Hardmock.has_replaced_method?(self, method_name)
-
-      stubbed_method = Hardmock::StubbedMethod.new(self, method_name)
-
-
-      unless _is_mock? or already_stubbed
-        if methods.include?(method_name.to_s)
-          hm_meta_eval do 
-            alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
-          end
-        end
-      end
-
-      hm_meta_def method_name do |*args|
-        stubbed_method.invoke(args)
-      end
-
-      stubbed_method
-    end
-
-    def expects!(method_name, *args, &block)
-      if self._is_mock?
-        raise Hardmock::StubbingError, "Cannot use 'expects!(:#{method_name})' on a Mock object; try 'expects' instead"
-      end
-
-      method_name = method_name.to_s
-
-      @_my_mock = Mock.new(_my_name, $main_mock_control) if @_my_mock.nil?
-
-      unless Hardmock.has_replaced_method?(self, method_name)
-        # Track the method as replaced
-        Hardmock::ReplacedMethod.new(self, method_name)
-
-        # Preserver original implementation of the method by aliasing it away
-        if methods.include?(method_name)
-          hm_meta_eval do 
-            alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
-          end
-        end
-
-        # Re-define the method to utilize our patron mock instance.
-        # (This global-temp-var thing is hokey but I was having difficulty generating 
-        # code for the meta class.)
-        begin
-          $method_text_temp = %{
-            def #{method_name}(*args,&block)
-              @_my_mock.__send__(:#{method_name}, *args, &block)
-            end
-          }
-          class << self
-            eval $method_text_temp
-          end
-        ensure
-          $method_text_temp = nil
-        end
-      end
-
-      return @_my_mock.expects(method_name, *args, &block)
-    end
-      
-    def _is_mock?
-      self.kind_of?(Mock)
-    end
-
-    def _my_name
-      self.kind_of?(Class) ? self.name : self.class.name
-    end
-
-    def _clear_mock
-      @_my_mock = nil
-    end
-
-  end
-
-  class ::NilClass
-    # Use this only if you really mean it
-    alias_method :intentionally_stubs!, :stubs!
-    
-    # Use this only if you really mean it
-    alias_method :intentionally_expects!, :expects!
-
-    # Overridden to protect against accidental nil reference self delusion 
-    def stubs!(mname)
-      raise StubbingError, "Cannot stub #{mname} method on nil.  (If you really mean to, try 'intentionally_stubs!')"
-    end
-
-    # Overridden to protect against accidental nil reference self delusion 
-    def expects!(mname, *args)
-      raise StubbingError, "Cannot mock #{mname} method on nil.  (If you really mean to, try 'intentionally_expects!')"
-    end
-  end
-
-  class << self
-    def track_replaced_method(replaced_method)
-      all_replaced_methods << replaced_method
-    end
-
-    def all_replaced_methods
-      $all_replaced_methods ||= []
-    end
-
-    def has_replaced_method?(obj, method_name)
-      hits = all_replaced_methods.select do |replaced|
-        (replaced.target.object_id == obj.object_id) and (replaced.method_name.to_s == method_name.to_s)
-      end
-      return !hits.empty?
-    end
-
-    def restore_all_replaced_methods
-      all_replaced_methods.each do |replaced|
-        unless replaced.target._is_mock?
-          backed_up = "_hardmock_original_#{replaced.method_name}"
-          if replaced.target.methods.include?(backed_up)
-            replaced.target.hm_meta_eval do
-              alias_method replaced.method_name.to_sym, backed_up.to_sym 
-            end
-          end
-          replaced.target._clear_mock
-        end
-      end
-      all_replaced_methods.clear
-    end
-  end
-
-end
-

data/vendor/hardmock/lib/hardmock/trapper.rb

@@ -1,31 +0,0 @@
-require 'test/unit/assertions'
-require 'hardmock/errors'
-
-module Hardmock
-  class Trapper #:nodoc:
-    include Hardmock::MethodCleanout
-
-    def initialize(mock,mock_control,expectation_builder)
-      @mock = mock
-      @mock_control = mock_control
-      @expectation_builder = expectation_builder
-    end
-
-    def method_missing(mname, *args)
-      if block_given?
-        raise ExpectationError.new("Don't pass blocks when using 'trap' (setting exepectations for '#{mname}')")
-      end
-      
-      the_block = lambda { |target_block| target_block }
-      expectation = @expectation_builder.build_expectation(
-        :mock => @mock, 
-        :method => mname, 
-        :arguments => args, 
-        :suppress_arguments_to_block => true,
-        :block => the_block)
-
-      @mock_control.add_expectation expectation
-      expectation
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-
-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/hardmock.rb

@@ -1,86 +0,0 @@
-require 'hardmock/method_cleanout'
-require 'hardmock/mock'
-require 'hardmock/mock_control'
-require 'hardmock/utils'
-require 'hardmock/errors'
-require 'hardmock/trapper'
-require 'hardmock/expector'
-require 'hardmock/expectation'
-require 'hardmock/expectation_builder'
-require 'hardmock/stubbing'
-
-module Hardmock
-
-  # Create one or more new Mock instances in your test suite. 
-  # Once created, the Mocks are accessible as instance variables in your test.
-  # Newly built Mocks are added to the full set of Mocks for this test, which will
-  # be verified when you call verify_mocks.
-  #
-  #   create_mocks :donkey, :cat # Your test now has @donkey and @cat
-  #   create_mock  :dog          # Test now has @donkey, @cat and @dog
-  #   
-  # The first call returned a hash { :donkey => @donkey, :cat => @cat }
-  # and the second call returned { :dog => @dog }
-  #
-  # For more info on how to use your mocks, see Mock and Expectation
-  #
-  def create_mocks(*mock_names)
-    prepare_hardmock_control unless @main_mock_control
-
-    mocks = {}
-    mock_names.each do |mock_name|
-      raise ArgumentError, "'nil' is not a valid name for a mock" if mock_name.nil?
-      mock_name = mock_name.to_s
-      mock_object = Mock.new(mock_name, @main_mock_control)
-      mocks[mock_name.to_sym] = mock_object
-      self.instance_variable_set "@#{mock_name}", mock_object
-    end
-    @all_mocks ||= {}
-    @all_mocks.merge! mocks
-
-    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
-  # raised.
-  #
-  # <b>You normally won't need to call this yourself.</b> Within Test::Unit::TestCase, this will be done automatically at teardown time.
-  #
-  # * +force+ -- if +false+, and a VerifyError or ExpectationError has already occurred, this method will not raise.  This is to help you suppress repeated errors when if you're calling #verify_mocks in the teardown method of your test suite.  BE WARNED - only use this if you're sure you aren't obscuring useful information.  Eg, if your code handles exceptions internally, and an ExpectationError gets gobbled up by your +rescue+ block, the cause of failure for your test may be hidden from you.  For this reason, #verify_mocks defaults to force=true as of Hardmock 1.0.1
-  def verify_mocks(force=true)
-    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
-    $main_mock_control = nil
-    reset_stubs
-  end
-  
-  alias :verify_hardmocks :verify_mocks
-
-  # 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
-    reset_stubs
-    $main_mock_control = nil
-  end
-
-  def reset_stubs
-    Hardmock.restore_all_replaced_methods
-  end
-
-end
-
-require 'extend_test_unit'

data/vendor/hardmock/lib/test_unit_before_after.rb

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

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

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

data/vendor/hardmock/rake_tasks/test.rake

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

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