Class Spec::Mocks::BaseExpectation

  1. lib/spec/mocks/message_expectation.rb
Parent: Object

Attributes

error_generator [RW]
expected_from [W]
expected_received_count [W]
method_block [W]
sym [R]

Public class methods

new (error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={})
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 11
      def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={})
        @error_generator = error_generator
        @error_generator.opts = opts
        @expected_from = expected_from
        @sym = sym
        @method_block = method_block
        @return_block = nil
        @actual_received_count = 0
        @expected_received_count = expected_received_count
        @args_expectation = ArgumentExpectation.new([ArgumentMatchers::AnyArgsMatcher.new])
        @consecutive = false
        @exception_to_raise = nil
        @symbol_to_throw = nil
        @order_group = expectation_ordering
        @at_least = nil
        @at_most = nil
        @args_to_yield = []
        @failed_fast = nil
        @args_to_yield_were_cloned = false
      end

Public instance methods

and_raise()
and_raise(Exception) #any exception class
and_raise(exception) #any exception object

Warning

When you pass an exception class, the MessageExpectation will raise an instance of it, creating it with new. If the exception class initializer requires any parameters, you must pass in an instance and not the class.

[show source] 
# File lib/spec/mocks/message_expectation.rb, line 74
      def and_raise(exception=Exception)
        @exception_to_raise = exception
      end
and_return (*values, &return_block)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 49
      def and_return(*values, &return_block)
        Kernel::raise AmbiguousReturnError unless @method_block.nil?
        case values.size
          when 0 then value = nil
          when 1 then value = values[0]
        else
          value = values
          @consecutive = true
          @expected_received_count = values.size if !ignoring_args? &&
                                                    @expected_received_count < values.size
        end
        @return_block = block_given? ? return_block : lambda { value }
      end
and_throw (symbol)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 78
      def and_throw(symbol)
        @symbol_to_throw = symbol
      end
and_yield (*args)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 82
      def and_yield(*args)
        if @args_to_yield_were_cloned
          @args_to_yield.clear
          @args_to_yield_were_cloned = false
        end
        
        @args_to_yield << args
        self
      end
build_child (expected_from, method_block, expected_received_count, opts={})
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 32
      def build_child(expected_from, method_block, expected_received_count, opts={})
        child = clone
        child.expected_from = expected_from
        child.method_block = method_block
        child.expected_received_count = expected_received_count
        child.clear_actual_received_count!
        new_gen = error_generator.clone
        new_gen.opts = opts
        child.error_generator = new_gen
        child.clone_args_to_yield @args_to_yield
        child
      end
called_max_times? ()
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 130
      def called_max_times?
        @expected_received_count != :any && @expected_received_count > 0 &&
          @actual_received_count >= @expected_received_count
      end
expected_args ()
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 45
      def expected_args
        @args_expectation.args
      end
invoke (args, block)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 96
      def invoke(args, block)
        if @expected_received_count == 0
          @failed_fast = true
          @actual_received_count += 1
          @error_generator.raise_expectation_error @sym, @expected_received_count, @actual_received_count, *args
        end
        
        @order_group.handle_order_constraint self

        begin
          Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
          Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
          
          
          if !@method_block.nil?
            default_return_val = invoke_method_block(args)
          elsif @args_to_yield.size > 0
            default_return_val = invoke_with_yield(block)
          else
            default_return_val = nil
          end
          
          if @consecutive
            return invoke_consecutive_return_block(args, block)
          elsif @return_block
            return invoke_return_block(args, block)
          else
            return default_return_val
          end
        ensure
          @actual_received_count += 1
        end
      end
matches (sym, args)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 92
      def matches(sym, args)
        @sym == sym and @args_expectation.args_match?(args)
      end

Protected instance methods

clone_args_to_yield (args)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 173
      def clone_args_to_yield(args)
        @args_to_yield = args.clone
        @args_to_yield_were_cloned = true
      end
failed_fast? ()
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 178
      def failed_fast?
        @failed_fast
      end
invoke_consecutive_return_block (args, block)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 159
      def invoke_consecutive_return_block(args, block)
        value = invoke_return_block(args, block)
        index = [@actual_received_count, value.size-1].min
        value[index]
      end
invoke_method_block (args)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 137
      def invoke_method_block(args)
        begin
          @method_block.call(*args)
        rescue => detail
          @error_generator.raise_block_failed_error @sym, detail.message
        end
      end
invoke_return_block (args, block)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 165
      def invoke_return_block(args, block)
        args << block unless block.nil?
        # Ruby 1.9 - when we set @return_block to return values
        # regardless of arguments, any arguments will result in
        # a "wrong number of arguments" error
        @return_block.arity > 0 ? @return_block.call(*args) : @return_block.call()
      end
invoke_with_yield (block)
[show source] 
# File lib/spec/mocks/message_expectation.rb, line 145
      def invoke_with_yield(block)
        if block.nil?
          @error_generator.raise_missing_block_error @args_to_yield
        end
        value = nil
        @args_to_yield.each do |args_to_yield_this_time|
          if block.arity > -1 && args_to_yield_this_time.length != block.arity
            @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity
          end
          value = block.call(*args_to_yield_this_time)
        end
        value
      end