Class: Spec::Mocks::BaseExpectation

Inherits:
Object
  • Object
show all
Defined in:
lib/spec/mocks/message_expectation.rb

Direct Known Subclasses

MessageExpectation, MethodStub

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count = 1, opts = {}) ⇒ BaseExpectation

Returns a new instance of BaseExpectation.



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/spec/mocks/message_expectation.rb', line 7

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 = lambda {}
  @received_count = 0
  @expected_received_count = expected_received_count
  @args_expectation = ArgumentExpectation.new([AnyArgsConstraint.new])
  @consecutive = false
  @exception_to_raise = nil
  @symbol_to_throw = nil
  @order_group = expectation_ordering
  @at_least = nil
  @at_most = nil
  @args_to_yield = nil
end

Instance Attribute Details

#sym ⇒ Object (readonly)

Returns the value of attribute sym.



5
6
7
 
# File 'lib/spec/mocks/message_expectation.rb', line 5

def sym
  @sym
end

Instance Method Details

#and_raise(exception = Exception) ⇒ Object

:call-seq:

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.



56
57
58
 
# File 'lib/spec/mocks/message_expectation.rb', line 56

def and_raise(exception=Exception)
  @exception_to_raise = exception
end

#and_return(*values, &return_block) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/spec/mocks/message_expectation.rb', line 30

def and_return(*values, &return_block)
  Kernel::raise AmbiguousReturnError unless @method_block.nil?
  if values.size == 0
    value = nil
  elsif values.size == 1
    value = values[0]
  else
    value = values
    @consecutive = true
    @expected_received_count = values.size if @expected_received_count != :any &&
                                              @expected_received_count < values.size
  end
  @return_block = block_given? ? return_block : lambda { value }
end

#and_throw(symbol) ⇒ Object 



60
61
62
 
# File 'lib/spec/mocks/message_expectation.rb', line 60

def and_throw(symbol)
  @symbol_to_throw = symbol
end

#and_yield(*args) ⇒ Object 



64
65
66
 
# File 'lib/spec/mocks/message_expectation.rb', line 64

def and_yield(*args)
  @args_to_yield = args
end

#expected_args ⇒ Object 



26
27
28
 
# File 'lib/spec/mocks/message_expectation.rb', line 26

def expected_args
  @args_expectation.args
end

#invoke(args, block) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/spec/mocks/message_expectation.rb', line 72

def invoke(args, block)
  @order_group.handle_order_constraint self

  begin
    if @exception_to_raise.class == Class
      @exception_instance_to_raise = @exception_to_raise.new
    else 
      @exception_instance_to_raise = @exception_to_raise
    end
    Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
    Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?

    if !@method_block.nil?
      return invoke_method_block(args)
    elsif !@args_to_yield.nil?
      return invoke_with_yield(block)
    elsif @consecutive
      return invoke_consecutive_return_block(args, block)
    else
      return invoke_return_block(args, block)
    end
  ensure
    @received_count += 1
  end
end

#matches(sym, args) ⇒ Object 



68
69
70
 
# File 'lib/spec/mocks/message_expectation.rb', line 68

def matches(sym, args)
  @sym == sym and @args_expectation.check_args(args)
end