minilab 1.1.0-x86-mswin32-60

data/vendor/hardmock-1.3.7/lib/hardmock/mock_control.rb

@@ -0,0 +1,53 @@
+require 'hardmock/utils'
+
+module Hardmock
+  class MockControl #:nodoc:
+    include Utils
+    attr_accessor :name
+
+    def initialize
+      clear_expectations
+    end
+
+    def happy?
+      @expectations.empty?
+    end
+
+    def disappointed?
+      @disappointed
+    end
+
+    def add_expectation(expectation)
+#      puts "MockControl #{self.object_id.to_s(16)} adding expectation: #{expectation}"
+      @expectations << expectation
+    end
+
+    def apply_method_call(mock,mname,args,block)
+      # Are we even expecting any sort of call?
+      if happy?
+        @disappointed = true
+        raise ExpectationError.new("Surprise call to #{format_method_call_string(mock,mname,args)}")
+      end
+
+      begin
+        @expectations.shift.apply_method_call(mock,mname,args,block)
+      rescue Exception => ouch
+        @disappointed = true
+        raise ouch
+      end
+    end
+
+    def verify
+#      puts "MockControl #{self.object_id.to_s(16)} verify: happy? #{happy?}"
+      @disappointed = !happy?
+      raise VerifyError.new("Unmet expectations", @expectations) unless happy?
+    end
+
+    def clear_expectations
+      @expectations = []
+      @disappointed = false
+    end
+
+  end
+
+end

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

@@ -0,0 +1,210 @@
+
+
+# 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-1.3.7/lib/hardmock/trapper.rb

@@ -0,0 +1,31 @@
+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-1.3.7/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-1.3.7/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