module RR::DoubleDefinitions::DoubleDefinition::DefinitionConstructionMethods

Public Instance Methods

after_call(&after_call_proc) click to toggle source

Double#after_call creates a callback that occurs after call is called. The passed in block receives the return value of the Double being called. An Expection will be raised if no block is passed in.

mock(subject).method_name {return_value}.after_call {|return_value|}
subject.method_name # return_value

This feature is built into proxies.

mock.proxy(User).find('1') {|user| mock(user).valid? {false}}
# File lib/rr/double_definitions/double_definition.rb, line 213
def after_call(&after_call_proc)
  raise ArgumentError, "after_call expects a block" unless after_call_proc
  @after_call_proc = after_call_proc
  self
end
implemented_by(implementation) click to toggle source

Double#implemented_by sets the implementation of the Double. This method takes a Proc or a Method. Passing in a Method allows the Double to accept blocks.

obj = Object.new
def obj.foobar
  yield(1)
end
mock(obj).method_name.implemented_by(obj.method(:foobar))
# File lib/rr/double_definitions/double_definition.rb, line 263
def implemented_by(implementation)
  @implementation = implementation
  self
end
implemented_by_original_method() click to toggle source
# File lib/rr/double_definitions/double_definition.rb, line 249
def implemented_by_original_method
  implemented_by ORIGINAL_METHOD
  self
end
ordered(&return_value_block) click to toggle source

Double#ordered sets the Double to have an ordered expectation.

Passing in a block sets the return value.

mock(subject).method_name.ordered {return_value}
# File lib/rr/double_definitions/double_definition.rb, line 174
def ordered(&return_value_block)
  raise(
    Errors::DoubleDefinitionError,
    "Double Definitions must have a dedicated Double to be ordered. " <<
    "For example, using instance_of does not allow ordered to be used. " <<
    "proxy the class's #new method instead."
  ) unless @double
  @ordered = true
  space.register_ordered_double(@double)
  install_method_callback return_value_block
  DoubleDefinitionCreateBlankSlate.new(double_definition_create)
end
Also aliased as: then
returns(*args, &implementation) click to toggle source

Double#returns accepts an argument value or a block. It will raise an ArgumentError if both are passed in.

Passing in a block causes Double to return the return value of the passed in block.

Passing in an argument causes Double to return the argument.

# File lib/rr/double_definitions/double_definition.rb, line 235
def returns(*args, &implementation)
  if !args.empty? && implementation
    raise ArgumentError, "returns cannot accept both an argument and a block"
  end
  if implementation
    install_method_callback implementation
  else
    install_method_callback(lambda do |*lambda_args|
      args.first
    end)
  end
  self
end
strong()
then(&return_value_block)
Alias for: ordered
verbose(&after_call_proc) click to toggle source

Double#verbose sets the Double to print out each method call it receives.

Passing in a block sets the return value

# File lib/rr/double_definitions/double_definition.rb, line 222
def verbose(&after_call_proc)
  @verbose = true
  @after_call_proc = after_call_proc
  self
end
verify_method_signature() click to toggle source
# File lib/rr/double_definitions/double_definition.rb, line 268
def verify_method_signature
  @verify_method_signature = true
  self
end
Also aliased as: strong
yields(*args, &return_value_block) click to toggle source

Double#yields sets the Double to invoke a passed in block when the Double is called. An Expection will be raised if no block is passed in when the Double is called.

Passing in a block sets the return value.

mock(subject).method_name.yields(yield_arg1, yield_arg2) {return_value}
subject.method_name {|yield_arg1, yield_arg2|}
# File lib/rr/double_definitions/double_definition.rb, line 197
def yields(*args, &return_value_block)
  @yields_value = args
  install_method_callback return_value_block
  self
end

Protected Instance Methods

install_method_callback(block) click to toggle source
# File lib/rr/double_definitions/double_definition.rb, line 275
def install_method_callback(block)
  if block
    if implementation_is_original_method?
      after_call(&block)
    else
      implemented_by block
    end
  end
end