Adds an expectation that a method identified by method_name Symbol/String must be called exactly once with any parameters. Returns the new expectation which can be further modified by methods on Expectation.

  object = mock()
  object.expects(:method1)
  object.method1
  # no error raised

  object = mock()
  object.expects(:method1)
  # error raised, because method1 not called exactly once

If method_names_vs_return_values is a Hash, an expectation will be set up for each entry using the key as method_name and value as return_value.

  object = mock()
  object.expects(:method1 => :result1, :method2 => :result2)

  # exactly equivalent to

  object = mock()
  object.expects(:method1).returns(:result1)
  object.expects(:method2).returns(:result2)

Aliased by __expects__

[Source]

    # File lib/mocha/mock.rb, line 42
42:     def expects(method_name_or_hash, backtrace = nil)
43:       iterator = ArgumentIterator.new(method_name_or_hash)
44:       iterator.each { |*args|
45:         method_name = args.shift
46:         ensure_method_not_already_defined(method_name)
47:         expectation = Expectation.new(self, method_name, backtrace)
48:         expectation.returns(args.shift) if args.length > 0
49:         @expectations.add(expectation)
50:       }
51:     end

Constrains the mock so that it can only expect or stub methods to which responder responds. The constraint is only applied at method invocation time.

A NoMethodError will be raised if the responder does not respond_to? a method invocation (even if the method has been expected or stubbed).

The mock will delegate its respond_to? method to the responder.

  class Sheep
    def chew(grass); end
    def self.number_of_legs; end
  end

  sheep = mock('sheep')
  sheep.expects(:chew)
  sheep.expects(:foo)
  sheep.respond_to?(:chew) # => true
  sheep.respond_to?(:foo) # => true
  sheep.chew
  sheep.foo
  # no error raised

  sheep = mock('sheep')
  sheep.responds_like(Sheep.new)
  sheep.expects(:chew)
  sheep.expects(:foo)
  sheep.respond_to?(:chew) # => true
  sheep.respond_to?(:foo) # => false
  sheep.chew
  sheep.foo # => raises NoMethodError exception

  sheep_class = mock('sheep_class')
  sheep_class.responds_like(Sheep)
  sheep_class.stubs(:number_of_legs).returns(4)
  sheep_class.expects(:foo)
  sheep_class.respond_to?(:number_of_legs) # => true
  sheep_class.respond_to?(:foo) # => false
  assert_equal 4, sheep_class.number_of_legs
  sheep_class.foo # => raises NoMethodError exception

Aliased by quacks_like

[Source]

     # File lib/mocha/mock.rb, line 126
126:     def responds_like(object)
127:       @responder = object
128:       self
129:     end

Adds an expectation that a method identified by method_name Symbol/String may be called any number of times with any parameters. Returns the new expectation which can be further modified by methods on Expectation.

  object = mock()
  object.stubs(:method1)
  object.method1
  object.method1
  # no error raised

If method_names_vs_return_values is a Hash, an expectation will be set up for each entry using the key as method_name and value as return_value.

  object = mock()
  object.stubs(:method1 => :result1, :method2 => :result2)

  # exactly equivalent to

  object = mock()
  object.stubs(:method1).returns(:result1)
  object.stubs(:method2).returns(:result2)

Aliased by __stubs__

[Source]

    # File lib/mocha/mock.rb, line 74
74:     def stubs(method_name_or_hash, backtrace = nil)
75:       iterator = ArgumentIterator.new(method_name_or_hash)
76:       iterator.each { |*args|
77:         method_name = args.shift
78:         ensure_method_not_already_defined(method_name)
79:         expectation = Expectation.new(self, method_name, backtrace)
80:         expectation.at_least(0)
81:         expectation.returns(args.shift) if args.length > 0
82:         @expectations.add(expectation)
83:       }
84:     end