Module: RR::DoubleDefinitions::DoubleDefinition::DefinitionConstructionMethods

Included in:
RR::DoubleDefinitions::DoubleDefinition
Defined in:
lib/rr/double_definitions/double_definition.rb

Instance Method Summary collapse

Instance Method Details

#after_call(&after_call_proc) ⇒ Object

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}}

Raises:

  • (ArgumentError) 


224
225
226
227
228
 
# File 'lib/rr/double_definitions/double_definition.rb', line 224

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) ⇒ Object

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))



273
274
275
276
 
# File 'lib/rr/double_definitions/double_definition.rb', line 273

def implemented_by(implementation)
  @implementation = implementation
  self
end

#implemented_by_original_method ⇒ Object 



259
260
261
262
 
# File 'lib/rr/double_definitions/double_definition.rb', line 259

def implemented_by_original_method
  implemented_by ORIGINAL_METHOD
  self
end

#ordered(&return_value_block) ⇒ Object Also known as: then

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}

Raises:



185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/rr/double_definitions/double_definition.rb', line 185

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
  DoubleDefinitionCreatorProxy.new(double_definition_creator)
end

#returns(*args, &implementation) ⇒ Object

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.



246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/rr/double_definitions/double_definition.rb', line 246

def returns(*args, &implementation)
  value = args.first
  if !args.empty? && implementation
    raise ArgumentError, "returns cannot accept both an argument and a block"
  end
  if implementation
    implemented_by implementation
  else
    implemented_by lambda {value}
  end
  self
end

#verbose(&after_call_proc) ⇒ Object

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

Passing in a block sets the return value



233
234
235
236
237
 
# File 'lib/rr/double_definitions/double_definition.rb', line 233

def verbose(&after_call_proc)
  @verbose = true
  @after_call_proc = after_call_proc
  self
end

#verify_method_signature ⇒ Object Also known as: strong 



278
279
280
281
 
# File 'lib/rr/double_definitions/double_definition.rb', line 278

def verify_method_signature
  @verify_method_signature = true
  self
end

#yields(*args, &return_value_block) ⇒ Object

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|}



208
209
210
211
212
 
# File 'lib/rr/double_definitions/double_definition.rb', line 208

def yields(*args, &return_value_block)
  @yields_value = args
  install_method_callback return_value_block
  self
end