ceedling 0.12.2 → 0.13.0.rc1

data/vendor/hardmock/lib/hardmock/mock.rb

@@ -0,0 +1,180 @@
+
+module Hardmock
+  # Mock is used to set expectations in your test.  Most of the time you'll use
+  # <tt>#expects</tt> to create expectations.
+  #
+  # Aside from the scant few control methods (like +expects+, +trap+ and +_verify+) 
+  # all calls made on a Mock instance will be immediately applied to the internal
+  # expectation mechanism.
+  #
+  # * If the method call was expected and all the parameters match properly, execution continues
+  # * If the expectation was configured with an expectation block, the block is invoked
+  # * If the expectation was set up to raise an error, the error is raised now
+  # * If the expectation was set up to return a value, it is returned
+  # * If the method call was _not_ expected, or the parameter values are wrong, an ExpectationError is raised.
+  class Mock
+    include Hardmock::MethodCleanout
+
+    # Create a new Mock instance with a name and a MockControl to support it.
+    # If not given, a MockControl is made implicitly for this Mock alone; this means
+    # expectations for this mock are not tied to other expectations in your test.
+    #
+    # It's not recommended to use a Mock directly; see Hardmock and
+    # Hardmock#create_mocks for the more wholistic approach.
+    def initialize(name, mock_control=nil)
+      @name = name
+      @control = mock_control || MockControl.new
+      @expectation_builder = ExpectationBuilder.new
+    end
+
+    def inspect
+      "<Mock #{@name}>"
+    end
+
+    # Begin declaring an expectation for this Mock.
+    #
+    # == Simple Examples
+    # Expect the +customer+ to be queried for +account+, and return <tt>"The
+    # Account"</tt>: 
+    #   @customer.expects.account.returns "The Account"
+    #
+    # Expect the +withdraw+ method to be called, and raise an exception when it
+    # is (see Expectation#raises for more info):
+    #   @cash_machine.expects.withdraw(20,:dollars).raises("not enough money")
+    #
+    # Expect +customer+ to have its +user_name+ set
+    #   @customer.expects.user_name = 'Big Boss'
+    #   
+    # Expect +customer+ to have its +user_name+ set, and raise a RuntimeException when
+    # that happens:
+    #   @customer.expects('user_name=', "Big Boss").raises "lost connection"
+    #
+    # Expect +evaluate+ to be passed a block, and when that happens, pass a value
+    # to the block (see Expectation#yields for more info):
+    #   @cruncher.expects.evaluate.yields("some data").returns("some results")
+    #
+    #
+    # == Expectation Blocks
+    # To do special handling of expected method calls when they occur, you
+    # may pass a block to your expectation, like:
+    #   @page_scraper.expects.handle_content do |address,request,status|
+    #     assert_not_nil address, "Can't abide nil addresses"
+    #     assert_equal "http-get", request.method, "Can only handle GET"
+    #     assert status > 200 and status < 300, status, "Failed status"
+    #     "Simulated results #{request.content.downcase}"
+    #   end
+    # In this example, when <tt>page_scraper.handle_content</tt> is called, its
+    # three arguments are passed to the <i>expectation block</i> and evaluated
+    # using the above assertions.  The last value in the block will be used 
+    # as the return value for +handle_content+
+    #
+    # You may specify arguments to the expected method call, just like any normal
+    # expectation, and those arguments will be pre-validated before being passed
+    # to the expectation block.  This is useful when you know all of the
+    # expected values but still need to do something programmatic.
+    #
+    # If the method being invoked on the mock accepts a block, that block will be
+    # passed to your expectation block as the last (or only) argument.  Eg, the 
+    # convenience method +yields+ can be replaced with the more explicit:
+    #   @cruncher.expects.evaluate do |block|
+    #     block.call "some data"
+    #     "some results"
+    #   end
+    #
+    # The result value of the expectation block becomes the return value for the
+    # expected method call. This can be overidden by using the +returns+ method:
+    #   @cruncher.expects.evaluate do |block|
+    #     block.call "some data"
+    #     "some results"
+    #   end.returns("the actual value")
+    # 
+    # <b>Additionally</b>, the resulting value of the expectation block is stored
+    # in the +block_value+ field on the expectation.  If you've saved a reference 
+    # to your expectation, you may retrieve the block value once the expectation
+    # has been met.
+    #
+    #   evaluation_event = @cruncher.expects.evaluate do |block|
+    #     block.call "some data"
+    #     "some results"
+    #   end.returns("the actual value")
+    #
+    #   result = @cruncher.evaluate do |input|
+    #     puts input  # => 'some data'
+    #   end
+    #   # result is 'the actual value'
+    #   
+    #   evaluation_event.block_value # => 'some results'
+    #
+    def expects(*args, &block)
+      expector = Expector.new(self,@control,@expectation_builder)
+      # If there are no args, we return the Expector
+      return expector if args.empty?
+      # If there ARE args, we set up the expectation right here and return it
+      expector.send(args.shift.to_sym, *args, &block)
+    end
+    alias_method :expect, :expects
+    alias_method :should_receive, :expects
+
+    # Special-case convenience: #trap sets up an expectation for a method
+    # that will take a block.  That block, when sent to the expected method, will
+    # be trapped and stored in the expectation's +block_value+ field.
+    # The Expectation#trigger method may then be used to invoke that block.
+    #
+    # Like +expects+, the +trap+ mechanism can be followed by +raises+ or +returns+.
+    #
+    # _Unlike_ +expects+, you may not use an expectation block with +trap+.  If 
+    # the expected method takes arguments in addition to the block, they must
+    # be specified in the arguments to the +trap+ call itself.
+    #
+    # == Example
+    # 
+    #   create_mocks :address_book, :editor_form
+    #
+    #   # Expect a subscription on the :person_added event for @address_book:
+    #   person_event = @address_book.trap.subscribe(:person_added)
+    #
+    #   # The runtime code would look like:
+    #   @address_book.subscribe :person_added do |person_name|
+    #     @editor_form.name = person_name
+    #   end
+    #
+    #   # At this point, the expectation for 'subscribe' is met and the 
+    #   # block has been captured.  But we're not done:
+    #   @editor_form.expects.name = "David"
+    #
+    #   # Now invoke the block we trapped earlier:
+    #    person_event.trigger "David"
+    #
+    #   verify_mocks
+    def trap(*args)
+      Trapper.new(self,@control,ExpectationBuilder.new)
+    end
+
+    def method_missing(mname,*args) #:nodoc:
+      block = nil
+      block = Proc.new if block_given?
+      @control.apply_method_call(self,mname,args,block)
+    end
+
+
+    def _control #:nodoc:
+      @control
+    end
+
+    def _name #:nodoc:
+      @name
+    end
+
+    # Verify that all expectations are fulfilled.  NOTE: this method triggers
+    # validation on the _control_ for this mock, so all Mocks that share the
+    # MockControl with this instance will be included in the verification.
+    #
+    # <b>Only use this method if you are managing your own Mocks and their controls.</b>
+    #
+    # Normal usage of Hardmock doesn't require you to call this; let
+    # Hardmock#verify_mocks do it for you.
+    def _verify
+      @control.verify
+    end
+  end
+end

data/vendor/hardmock/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/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/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