Class: MiniTest::Mock

Inherits:
Object show all
Defined in:
lib/minitest/mock.rb

Overview

All mock objects are an instance of Mock

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Mock

:nodoc:



26
27
28
29
 
# File 'lib/minitest/mock.rb', line 26

def initialize # :nodoc:
  @expected_calls = {}
  @actual_calls = Hash.new {|h,k| h[k] = [] }
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args) ⇒ Object

:nodoc:



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/minitest/mock.rb', line 78

def method_missing(sym, *args) # :nodoc:
  expected = @expected_calls[sym]

  unless expected then
    raise NoMethodError, "unmocked method %p, expected one of %p" %
      [sym, @expected_calls.keys.sort_by(&:to_s)]
  end

  expected_args, retval = expected[:args], expected[:retval]

  unless expected_args.size == args.size
    raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
      [sym, expected[:args].size, args.size]
  end

  @actual_calls[sym] << {
    :retval => retval,
    :args => expected_args.zip(args).map { |mod, a| mod if mod === a }
  }

  retval
end

Instance Method Details

#__respond_to? ⇒ Object 



18
 
# File 'lib/minitest/mock.rb', line 18

alias :__respond_to? :respond_to?

#expect(name, retval, args = []) ⇒ Object

Expect that method name is called, optionally with args, and returns retval.

@mock.expect(:meaning_of_life, 42)
@mock.meaning_of_life # => 42

@mock.expect(:do_something_with, true, [some_obj, true])
@mock.do_something_with(some_obj, true) # => true

args is compared to the expected args using case equality (ie, the ???===??? operator), allowing for less specific expectations.

@mock.expect(:uses_any_string, true, [String])
@mock.uses_any_string("foo") # => true
@mock.verify  # => true

@mock.expect(:uses_one_string, true, ["foo"]
@mock.uses_one_string("bar") # => true
@mock.verify  # => raises MockExpectationError



52
53
54
55
 
# File 'lib/minitest/mock.rb', line 52

def expect(name, retval, args=[])
  @expected_calls[name] = { :retval => retval, :args => args }
  self
end

#respond_to?(sym) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


101
102
103
104
 
# File 'lib/minitest/mock.rb', line 101

def respond_to?(sym) # :nodoc:
  return true if @expected_calls.has_key?(sym)
  return __respond_to?(sym)
end

#verify ⇒ Object

Verify that all methods were called as expected. Raises MockExpectationError if the mock object was not called as expected.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/minitest/mock.rb', line 62

def verify
  @expected_calls.each_key do |name|
    expected = @expected_calls[name]
    msg1 = "expected #{name}, #{expected.inspect}"
    msg2 = "#{msg1}, got #{@actual_calls[name].inspect}"

    raise MockExpectationError, msg2 if
      @actual_calls.has_key? name and
      not @actual_calls[name].include?(expected)

    raise MockExpectationError, msg1 unless
      @actual_calls.has_key? name and @actual_calls[name].include?(expected)
  end
  true
end