Class: RR::Scenario

Inherits:
Object
  • Object
show all
Defined in:
lib/rr/scenario.rb

Overview

RR::Scenario is the use case for a method call. It has the ArgumentEqualityExpectation, TimesCalledExpectation, and the implementation.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(space, double, definition) ⇒ Scenario

Returns a new instance of Scenario.



21
22
23
24
25
26
27
 
# File 'lib/rr/scenario.rb', line 21

def initialize(space, double, definition)
  @space = space
  @double = double
  @definition = definition
  @times_called = 0
  @times_called_expectation = Expectations::TimesCalledExpectation.new
end

Instance Attribute Details

#definition ⇒ Object (readonly)

Returns the value of attribute definition.



19
20
21
 
# File 'lib/rr/scenario.rb', line 19

def definition
  @definition
end

#double ⇒ Object (readonly)

Returns the value of attribute double.



19
20
21
 
# File 'lib/rr/scenario.rb', line 19

def double
  @double
end

#times_called ⇒ Object (readonly)

Returns the value of attribute times_called.



19
20
21
 
# File 'lib/rr/scenario.rb', line 19

def times_called
  @times_called
end

Class Method Details

.formatted_name(method_name, args) ⇒ Object 



7
8
9
10
 
# File 'lib/rr/scenario.rb', line 7

def formatted_name(method_name, args)
  formatted_errors = args.collect {|arg| arg.inspect}.join(', ')
  "#{method_name}(#{formatted_errors})"
end

.list_message_part(scenarios) ⇒ Object 



12
13
14
15
16
 
# File 'lib/rr/scenario.rb', line 12

def list_message_part(scenarios)
  scenarios.collect do |scenario|
    "- #{formatted_name(scenario.method_name, scenario.expected_arguments)}"
  end.join("\n")
end

Instance Method Details

#after_call(&block) ⇒ Object

Scenario#after_call creates a callback that occurs after call is called. The passed in block receives the return value of the Scenario 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 probes.

probe(User).find('1') {|user| mock(user).valid? {false}}



172
173
174
 
# File 'lib/rr/scenario.rb', line 172

def after_call(&block)
  definition.after_call &block
end

#any_number_of_times(&returns) ⇒ Object

Scenario#any_number_of_times sets an that the Scenario will be called any number of times. This effectively removes the times called expectation from the Scenarion

Passing in a block sets the return value.

mock(subject).method_name.any_number_of_times



118
119
120
 
# File 'lib/rr/scenario.rb', line 118

def any_number_of_times(&returns)
  definition.any_number_of_times(&returns)
end

#argument_expectation ⇒ Object 



325
326
327
 
# File 'lib/rr/scenario.rb', line 325

def argument_expectation
  definition.argument_expectation
end

#at_least(number, &returns) ⇒ Object

Scenario#at_least sets the expectation that the Scenario will be called at least n times. It works by creating a TimesCalledExpectation.

Passing in a block sets the return value.

mock(subject).method_name.at_least(4) {:return_value}



96
97
98
 
# File 'lib/rr/scenario.rb', line 96

def at_least(number, &returns)
  definition.at_least(number, &returns)
end

#at_most(number, &returns) ⇒ Object

Scenario#at_most allows sets the expectation that the Scenario will be called at most n times. It works by creating a TimesCalledExpectation.

Passing in a block sets the return value.

mock(subject).method_name.at_most(4) {:return_value}



107
108
109
 
# File 'lib/rr/scenario.rb', line 107

def at_most(number, &returns)
  definition.at_most(number, &returns)
end

#attempt? ⇒ Boolean

Scenario#attempt? returns true when the TimesCalledExpectation is satisfied.

Returns:

  • (Boolean) 


277
278
279
280
 
# File 'lib/rr/scenario.rb', line 277

def attempt?
  return true unless definition.times_matcher
  times_called_expectation.attempt?
end

#call(double, *args, &block) ⇒ Object

Scenario#call calls the Scenario’s implementation. The return value of the implementation is returned.

A TimesCalledError is raised when the times called exceeds the expected TimesCalledExpectation.



219
220
221
222
223
224
225
226
 
# File 'lib/rr/scenario.rb', line 219

def call(double, *args, &block)
  self.times_called_expectation.attempt! if definition.times_matcher
  @space.verify_ordered_scenario(self) if ordered?
  yields!(block)
  return_value = call_implementation(double, *args, &block)
  return return_value unless definition.after_call_value
  definition.after_call_value.call(return_value)
end

#exact_match?(*arguments) ⇒ Boolean

Scenario#exact_match? returns true when the passed in arguments exactly match the ArgumentEqualityExpectation arguments.

Returns:

  • (Boolean) 


265
266
267
 
# File 'lib/rr/scenario.rb', line 265

def exact_match?(*arguments)
  definition.exact_match?(*arguments)
end

#expected_arguments ⇒ Object

The Arguments that this Scenario expects



302
303
304
305
 
# File 'lib/rr/scenario.rb', line 302

def expected_arguments
  return [] unless argument_expectation
  argument_expectation.expected_arguments
end

#implementation ⇒ Object 



317
318
319
 
# File 'lib/rr/scenario.rb', line 317

def implementation
  definition.implementation
end

#implemented_by(implementation) ⇒ Object

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

obj = Object.new
def obj.foobar
  yield(1)
end
mock(obj).method_name.implemented_by(obj.method(:foobar))



196
197
198
 
# File 'lib/rr/scenario.rb', line 196

def implemented_by(implementation)
  definition.implemented_by implementation
end

#implemented_by_original_method ⇒ Object

Scenario#implemented_by_original_method sets the implementation of the Scenario to be the original method. This is primarily used with probes.

obj = Object.new
def obj.foobar
  yield(1)
end
mock(obj).method_name.implemented_by_original_method
obj.foobar {|arg| puts arg} # puts 1



210
211
212
 
# File 'lib/rr/scenario.rb', line 210

def implemented_by_original_method
  definition.implemented_by_original_method
end

#method_name ⇒ Object

The method name that this Scenario is attatched to



297
298
299
 
# File 'lib/rr/scenario.rb', line 297

def method_name
  double.method_name
end

#never ⇒ Object

Scenario#never sets the expectation that the Scenario will never be called.

This method does not accept a block because it will never be called.

mock(subject).method_name.never



65
66
67
 
# File 'lib/rr/scenario.rb', line 65

def never
  definition.never
end

#once(&returns) ⇒ Object

Scenario#once sets the expectation that the Scenario will be called 1 time.

Passing in a block sets the return value.

mock(subject).method_name.once {:return_value}



75
76
77
 
# File 'lib/rr/scenario.rb', line 75

def once(&returns)
  definition.once(&returns)
end

#ordered(&returns) ⇒ Object

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

Passing in a block sets the return value.

mock(subject).method_name.ordered {return_value}



138
139
140
 
# File 'lib/rr/scenario.rb', line 138

def ordered(&returns)
  definition.ordered(&returns)
end

#ordered? ⇒ Boolean

Scenario#ordered? returns true when the Scenario is ordered.

mock(subject).method_name.ordered?

Returns:

  • (Boolean) 


145
146
147
 
# File 'lib/rr/scenario.rb', line 145

def ordered?
  definition.ordered?
end

#returns(value = nil, &implementation) ⇒ Object

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

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

Passing in an argument causes Scenario to return the argument.



183
184
185
 
# File 'lib/rr/scenario.rb', line 183

def returns(value=nil, &implementation)
  definition.returns(value, &implementation)
end

#terminal? ⇒ Boolean

Returns:

  • (Boolean) 


291
292
293
294
 
# File 'lib/rr/scenario.rb', line 291

def terminal?
  return false unless definition.times_matcher
  times_called_expectation.terminal?
end

#times(number, &returns) ⇒ Object

Scenario#times creates an TimesCalledExpectation of the passed in number.

Passing in a block sets the return value.

mock(subject).method_name.times(4) {:return_value}



128
129
130
 
# File 'lib/rr/scenario.rb', line 128

def times(number, &returns)
  definition.times(number, &returns)
end

#times_called_expectation ⇒ Object 



312
313
314
315
 
# File 'lib/rr/scenario.rb', line 312

def times_called_expectation
  @times_called_expectation.matcher = definition.times_matcher
  @times_called_expectation
end

#times_matcher ⇒ Object

The TimesCalledMatcher for the TimesCalledExpectation



308
309
310
 
# File 'lib/rr/scenario.rb', line 308

def times_matcher
  times_called_expectation.matcher
end

#twice(&returns) ⇒ Object

Scenario#twice sets the expectation that the Scenario will be called 2 times.

Passing in a block sets the return value.

mock(subject).method_name.twice {:return_value}



85
86
87
 
# File 'lib/rr/scenario.rb', line 85

def twice(&returns)
  definition.twice(&returns)
end

#verify ⇒ Object

Scenario#verify verifies the the TimesCalledExpectation is satisfied for this scenario. A TimesCalledError is raised if the TimesCalledExpectation is not met.



285
286
287
288
289
 
# File 'lib/rr/scenario.rb', line 285

def verify
  return true unless definition.times_matcher
  times_called_expectation.verify!
  true
end

#wildcard_match?(*arguments) ⇒ Boolean

Scenario#wildcard_match? returns true when the passed in arguments wildcard match the ArgumentEqualityExpectation arguments.

Returns:

  • (Boolean) 


271
272
273
 
# File 'lib/rr/scenario.rb', line 271

def wildcard_match?(*arguments)
  definition.wildcard_match?(*arguments)
end

#with(*args, &returns) ⇒ Object

Scenario#with sets the expectation that the Scenario will receive the passed in arguments.

Passing in a block sets the return value.

mock(subject).method_name.with(1, 2) {:return_value}



35
36
37
 
# File 'lib/rr/scenario.rb', line 35

def with(*args, &returns)
  definition.with(*args, &returns)
end

#with_any_args(&returns) ⇒ Object

Scenario#with_any_args sets the expectation that the Scenario can receive any arguments.

Passing in a block sets the return value.

mock(subject).method_name.with_any_args {:return_value}



45
46
47
 
# File 'lib/rr/scenario.rb', line 45

def with_any_args(&returns)
  definition.with_any_args(&returns)
end

#with_no_args(&returns) ⇒ Object

Scenario#with_no_args sets the expectation that the Scenario will receive no arguments.

Passing in a block sets the return value.

mock(subject).method_name.with_no_args {:return_value}



55
56
57
 
# File 'lib/rr/scenario.rb', line 55

def with_no_args(&returns)
  definition.with_no_args(&returns)
end

#yields(*args, &returns) ⇒ Object

Scenario#yields sets the Scenario to invoke a passed in block when the Scenario is called. An Expection will be raised if no block is passed in when the Scenario 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|}



158
159
160
 
# File 'lib/rr/scenario.rb', line 158

def yields(*args, &returns)
  definition.yields(*args, &returns)
end