ceedling 0.0.2 → 0.0.3

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

@@ -1,180 +0,0 @@
-
-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/new_project_template/vendor/ceedling/vendor/hardmock/lib/hardmock/mock_control.rb

@@ -1,53 +0,0 @@
-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/new_project_template/vendor/ceedling/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/new_project_template/vendor/ceedling/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