Module: RR::Adapters::RRMethods

Included in:
RR, Rspec, TestUnit
Defined in:
lib/rr/adapters/rr_methods.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.register_strategy_class(strategy_class, method_name) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/rr/adapters/rr_methods.rb', line 5

def register_strategy_class(strategy_class, method_name)
  class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
  def #{method_name}(subject=DoubleDefinitions::DoubleDefinitionCreator::NO_SUBJECT, method_name=nil, &definition_eval_block)
    creator = DoubleDefinitions::DoubleDefinitionCreator.new
    creator.#{method_name}(subject, method_name, &definition_eval_block)
  end
  CLASS

  class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
  def #{method_name}!(method_name=nil, &definition_eval_block)
    creator = DoubleDefinitions::DoubleDefinitionCreator.new
    creator.#{method_name}!(method_name, &definition_eval_block)
  end
  CLASS
end

Instance Method Details

#any_times ⇒ Object

Returns a AnyTimesMatcher. This is meant to be passed in as an argument to Double#times.

mock(object).method_name(anything).times(any_times) {return_value}



37
38
39
 
# File 'lib/rr/adapters/rr_methods.rb', line 37

def any_times
  TimesCalledMatchers::AnyTimesMatcher.new
end

#anything ⇒ Object

Sets up an Anything wildcard ArgumentEqualityExpectation that succeeds when passed any argument.

mock(object).method_name(anything) {return_value}
object.method_name("an arbitrary value") # passes



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

def anything
  RR::WildcardMatchers::Anything.new
end

#boolean ⇒ Object

Sets up an Boolean wildcard ArgumentEqualityExpectation that succeeds when passed an argument that is a ::Boolean.

mock(object).method_name(boolean) {return_value}
object.method_name(false) # passes



69
70
71
 
# File 'lib/rr/adapters/rr_methods.rb', line 69

def boolean
  RR::WildcardMatchers::Boolean.new
end

#duck_type(*args) ⇒ Object

Sets up a DuckType wildcard ArgumentEqualityExpectation that succeeds when the passed argument implements the methods.

arg = Object.new
def arg.foo; end
def arg.bar; end
mock(object).method_name(duck_type(:foo, :bar)) {return_value}
object.method_name(arg) # passes



80
81
82
 
# File 'lib/rr/adapters/rr_methods.rb', line 80

def duck_type(*args)
  RR::WildcardMatchers::DuckType.new(*args)
end

#hash_including(expected_hash) ⇒ Object

Sets up a HashIncluding wildcard ArgumentEqualityExpectation that succeeds when the passed argument contains at least those keys and values of the expectation.

mock(object).method_name(hash_including(:foo => 1)) {return_value}
object.method_name({:foo => 1, :bar => 2) # passes



89
90
91
 
# File 'lib/rr/adapters/rr_methods.rb', line 89

def hash_including(expected_hash)
  RR::WildcardMatchers::HashIncluding.new(expected_hash)
end

#is_a(klass) ⇒ Object

Sets up an IsA wildcard ArgumentEqualityExpectation that succeeds when passed an argument of a certain type.

mock(object).method_name(is_a(String)) {return_value}
object.method_name("A String") # passes



53
54
55
 
# File 'lib/rr/adapters/rr_methods.rb', line 53

def is_a(klass)
  RR::WildcardMatchers::IsA.new(klass)
end

#numeric ⇒ Object

Sets up an Numeric wildcard ArgumentEqualityExpectation that succeeds when passed an argument that is ::Numeric.

mock(object).method_name(numeric) {return_value}
object.method_name(99) # passes



61
62
63
 
# File 'lib/rr/adapters/rr_methods.rb', line 61

def numeric
  RR::WildcardMatchers::Numeric.new
end

#received(subject) ⇒ Object 



110
111
112
 
# File 'lib/rr/adapters/rr_methods.rb', line 110

def received(subject)
  RR::SpyVerificationProxy.new(subject)
end

#reset ⇒ Object

Resets the registered Doubles and ordered Doubles



29
30
31
 
# File 'lib/rr/adapters/rr_methods.rb', line 29

def reset
  RR::Space.instance.reset
end

#satisfy(expectation_proc = nil, &block) ⇒ Object

Sets up a Satisfy wildcard ArgumentEqualityExpectation that succeeds when the passed argument causes the expectation’s proc to return true.

mock(object).method_name(satisfy {|arg| arg == :foo}) {return_value}
object.method_name(:foo) # passes



98
99
100
101
 
# File 'lib/rr/adapters/rr_methods.rb', line 98

def satisfy(expectation_proc=nil, &block)
  expectation_proc ||= block
  RR::WildcardMatchers::Satisfy.new(expectation_proc)
end

#spy(subject) ⇒ Object 



103
104
105
106
107
108
 
# File 'lib/rr/adapters/rr_methods.rb', line 103

def spy(subject)
  methods_to_stub = subject.public_methods - ["methods", "==", "__send__", "__id__"]
  methods_to_stub.each do |method|
    stub.proxy(subject, method)
  end
end

#verify ⇒ Object

Verifies all the DoubleInjection objects have met their TimesCalledExpectations.



24
25
26
 
# File 'lib/rr/adapters/rr_methods.rb', line 24

def verify
  RR::Space.instance.verify_doubles
end