Class: FlexMock

Inherits:
Object show all
Extended by:
ArgumentTypes
Includes:
Ordering
Defined in:
lib/flexmock/core.rb,
lib/flexmock/rspec.rb,
lib/flexmock/errors.rb,
lib/flexmock/version.rb,
lib/flexmock/ordering.rb,
lib/flexmock/recorder.rb,
lib/flexmock/composite.rb,
lib/flexmock/undefined.rb,
lib/flexmock/validators.rb,
lib/flexmock/expectation.rb,
lib/flexmock/partial_mock.rb,
lib/flexmock/argument_types.rb,
lib/flexmock/mock_container.rb,
lib/flexmock/spy_describers.rb,
lib/flexmock/explicit_needed.rb,
lib/flexmock/argument_matchers.rb,
lib/flexmock/argument_matching.rb,
lib/flexmock/rspec_spy_matcher.rb,
lib/flexmock/core_class_methods.rb,
lib/flexmock/deprecated_methods.rb,
lib/flexmock/rails/view_mocking.rb,
lib/flexmock/expectation_director.rb,
lib/flexmock/test_unit_integration.rb,
lib/flexmock/default_framework_adapter.rb,
lib/flexmock/test_unit_assert_spy_called.rb

Overview

Deprecated Methods

The following methods are no longer supported in FlexMock. Include this file for legacy applications.

Defined Under Namespace

Modules: ArgumentMatching, ArgumentTypes, MockContainer, Ordering, RSpecMatchers, SpyDescribers, TestCase, TestUnitAssertions, Version Classes: AnyMatcher, AtLeastCountValidator, AtMostCountValidator, CallRecord, CompositeExpectation, CountValidator, DefaultFrameworkAdapter, DuckMatcher, EqualMatcher, ExactCountValidator, Expectation, ExpectationDirector, ExpectationRecorder, ExplicitNeeded, HashMatcher, MockContainerHelper, MockError, OptionalProcMatcher, PartialMockProxy, ProcMatcher, RSpecFrameworkAdapter, Recorder, TestUnitFrameworkAdapter, Undefined, UsageError, UseContainer

Constant Summary collapse

SpecModule = 
Spec
VERSION = 
Version::NUMBERS.join('.')
ContainerHelper = 
MockContainerHelper.new
ANY = 
AnyMatcher.new
OPTIONAL_PROC_MATCHER = 
OptionalProcMatcher.new

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ArgumentTypes

any, ducktype, eq, hsh, on, optional_proc

Methods included from Ordering

#flexmock_allocate_order, #flexmock_current_order, #flexmock_current_order=, #flexmock_groups, #flexmock_validate_order

Constructor Details

#initialize(name = "unknown", container = nil) ⇒ FlexMock

Create a FlexMock object with the given name. The name is used in error messages. If no container is given, create a new, one-off container for this mock.



63
64
65
66
67
68
69
70
71
72
 
# File 'lib/flexmock/core.rb', line 63

def initialize(name="unknown", container=nil)
  @flexmock_name = name
  @expectations = Hash.new
  @ignore_missing = false
  @verified = false
  @calls = []
  @base_class = nil
  container = UseContainer.new if container.nil?
  container.flexmock_remember(self)
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args, &block) ⇒ Object

Handle missing methods by attempting to look up a handler.



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/flexmock/core.rb', line 124

def method_missing(sym, *args, &block)
  enhanced_args = block_given? ? args + [block] : args
  call_record = CallRecord.new(sym, enhanced_args, block_given?)
  @calls << call_record
  flexmock_wrap do
    if handler = @expectations[sym]
      handler.call(enhanced_args, call_record)
    elsif @base_class && @base_class.flexmock_defined?(sym)
      FlexMock.undefined
    elsif @ignore_missing
      FlexMock.undefined
    else
      super(sym, *args, &block)
    end
  end
end

Class Attribute Details

.framework_adapter ⇒ Object (readonly)

Returns the value of attribute framework_adapter.



17
18
19
 
# File 'lib/flexmock/core_class_methods.rb', line 17

def framework_adapter
  @framework_adapter
end

.partials_are_based ⇒ Object

Returns the value of attribute partials_are_based.



56
57
58
 
# File 'lib/flexmock/core.rb', line 56

def partials_are_based
  @partials_are_based
end

Instance Attribute Details

#flexmock_container ⇒ Object

Returns the value of attribute flexmock_container.



53
54
55
 
# File 'lib/flexmock/core.rb', line 53

def flexmock_container
  @flexmock_container
end

#flexmock_name ⇒ Object (readonly)

Returns the value of attribute flexmock_name.



52
53
54
 
# File 'lib/flexmock/core.rb', line 52

def flexmock_name
  @flexmock_name
end

Class Method Details

.check(msg, &block) ⇒ Object

Check will assert the block returns true. If it doesn’t, an assertion failure is triggered with the given message.



69
70
71
 
# File 'lib/flexmock/core_class_methods.rb', line 69

def check(msg, &block)  # :nodoc:
  FlexMock.framework_adapter.make_assertion(msg, &block)
end

.format_args(args) ⇒ Object

Class method to format a list of args (the part between the parenthesis).



59
60
61
62
63
64
65
 
# File 'lib/flexmock/core_class_methods.rb', line 59

def format_args(args)
  if args
    args.collect { |a| a.inspect }.join(', ')
  else
    "*args"
  end
end

.format_call(sym, args) ⇒ Object

Class method to format a method name and argument list as a nice looking string.



53
54
55
 
# File 'lib/flexmock/core_class_methods.rb', line 53

def format_call(sym, args)  # :nodoc:
  "#{sym}(#{format_args(args)})"
end

.undefined ⇒ Object

Undefined is normally available as FlexMock.undefined



47
48
49
 
# File 'lib/flexmock/undefined.rb', line 47

def self.undefined
  @undefined
end

.use(*names) ⇒ Object

Class method to make sure that verify is called at the end of a test. One mock object will be created for each name given to the use method. The mocks will be passed to the block as arguments. If no names are given, then a single anonymous mock object will be created.

At the end of the use block, each mock object will be verified to make sure the proper number of calls have been made.

Usage:

FlexMock.use("name") do |mock|    # Creates a mock named "name"
  mock.should_receive(:meth).
    returns(0).once
end                               # mock is verified here

NOTE: If you include FlexMock::TestCase into your test case file, you can create mocks that will be automatically verified in the test teardown by using the flexmock method.



39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/flexmock/core_class_methods.rb', line 39

def use(*names)
  names = ["unknown"] if names.empty?
  container = UseContainer.new
  mocks = names.collect { |n| container.flexmock(n) }
  yield(*mocks)
rescue Exception => _
  container.got_exception = true
  raise
ensure
  container.flexmock_teardown
end

Instance Method Details

#by_default ⇒ Object 



102
103
104
105
 
# File 'lib/flexmock/core.rb', line 102

def by_default
  @last_expectation.by_default
  self
end

#flexmock_based_on(base_class) ⇒ Object 



160
161
162
163
 
# File 'lib/flexmock/core.rb', line 160

def flexmock_based_on(base_class)
  @base_class = base_class
  should_receive(:class => base_class)
end

#flexmock_calls ⇒ Object

Return the list of calls made on this mock. Used in formatting error messages.



188
189
190
 
# File 'lib/flexmock/core.rb', line 188

def flexmock_calls
  @calls
end

#flexmock_define_expectation(location, *args) ⇒ Object 



233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/flexmock/core.rb', line 233

def flexmock_define_expectation(location, *args)
  @last_expectation = ContainerHelper.parse_should_args(self, args) do |sym|
    @expectations[sym] ||= ExpectationDirector.new(sym)
    result = Expectation.new(self, sym, location)
    @expectations[sym] << result
    override_existing_method(sym) if flexmock_respond_to?(sym)
    result = ExplicitNeeded.new(result, sym, @base_class) if
      @base_class && ! @base_class.flexmock_defined?(sym)
    result
  end
end

#flexmock_expectations_for(method_name) ⇒ Object

Return the expectation director for a method name.



156
157
158
 
# File 'lib/flexmock/core.rb', line 156

def flexmock_expectations_for(method_name) # :nodoc:
  @expectations[method_name]
end

#flexmock_find_expectation(method_name, *args) ⇒ Object

Find the mock expectation for method sym and arguments.



150
151
152
153
 
# File 'lib/flexmock/core.rb', line 150

def flexmock_find_expectation(method_name, *args) # :nodoc:
  exp = @expectations[method_name]
  exp ? exp.find_expectation(*args) : nil
end

#flexmock_invoke_original(sym, args) ⇒ Object

Invocke the original non-mocked functionality for the given symbol.



194
195
196
 
# File 'lib/flexmock/core.rb', line 194

def flexmock_invoke_original(sym, args)
  return FlexMock.undefined
end

#flexmock_received?(sym, args, options = {}) ⇒ Boolean

True if the mock received the given method and arguments.

Returns:

  • (Boolean) 


166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/flexmock/core.rb', line 166

def flexmock_received?(sym, args, options={})
  count = 0
  additional = options[:and] || []
  additional = [additional] if additional.is_a?(Proc)
  @calls.each { |call_record|
    if call_record.matches?(sym, args, options)
      count += 1
      if options[:on_count].nil? || count == options[:on_count]
        additional.each do |add| add.call(*call_record.args) end
      end
    end
  }
  if options[:times]
    result = count == options[:times]
  else
    result = count > 0
  end
  result
end

#flexmock_respond_to? ⇒ Object

Save the original definition of respond_to? for use a bit later.



142
 
# File 'lib/flexmock/core.rb', line 142

alias flexmock_respond_to? respond_to?

#flexmock_teardown ⇒ Object

Teardown and infrastructure setup for this mock.



92
93
 
# File 'lib/flexmock/core.rb', line 92

def flexmock_teardown
end

#flexmock_verify ⇒ Object

Verify that each method that had an explicit expected count was actually called that many times.



81
82
83
84
85
86
87
88
89
 
# File 'lib/flexmock/core.rb', line 81

def flexmock_verify
  return if @verified
  @verified = true
  flexmock_wrap do
    @expectations.each do |sym, handler|
      handler.flexmock_verify
    end
  end
end

#inspect ⇒ Object

Return the inspection string for a mock.



75
76
77
 
# File 'lib/flexmock/core.rb', line 75

def inspect
  "<FlexMock:#{flexmock_name}>"
end

#method(sym) ⇒ Object

Override the built-in method to include the mocked methods.



199
200
201
202
203
204
205
206
207
 
# File 'lib/flexmock/core.rb', line 199

def method(sym)
  @expectations[sym] || super
rescue NameError => ex
  if @ignore_missing
    proc { FlexMock.undefined }
  else
    raise ex
  end
end

#mock_handle(sym, expected_count = nil, &block) ⇒ Object

Handle all messages denoted by sym by calling the given block and passing any parameters to the block. If we know exactly how many calls are to be made to a particular method, we may check that by passing in the number of expected calls as a second paramter.



40
41
42
43
 
# File 'lib/flexmock/deprecated_methods.rb', line 40

def mock_handle(sym, expected_count=nil, &block) # :nodoc:
  $stderr.puts "mock_handle is deprecated, use the new should_receive interface instead."
  self.should_receive(sym).times(expected_count).returns(&block)
end

#respond_to?(sym, *args) ⇒ Boolean

Override the built-in respond_to? to include the mocked methods.

Returns:

  • (Boolean) 


145
146
147
 
# File 'lib/flexmock/core.rb', line 145

def respond_to?(sym, *args)
  super || (@expectations[sym] ? true : @ignore_missing)
end

#should_expect {|Recorder.new(self)| ... } ⇒ Object

Declare that the mock object should expect methods by providing a recorder for the methods and having the user invoke the expected methods in a block. Further expectations may be applied the result of the recording call.

Example Usage:

mock.should_expect do |record|
  record.add(Integer, 4) { |a, b|
    a + b
  }.at_least.once

Yields:



257
258
259
 
# File 'lib/flexmock/core.rb', line 257

def should_expect
  yield Recorder.new(self)
end

#should_ignore_missing ⇒ Object Also known as: mock_ignore_missing

Ignore all undefined (missing) method calls.



96
97
98
99
 
# File 'lib/flexmock/core.rb', line 96

def should_ignore_missing
  @ignore_missing = true
  self
end

#should_receive(*args) ⇒ Object

:call-seq:

mock.should_receive(:method_name)
mock.should_receive(:method1, method2, ...)
mock.should_receive(:meth1 => result1, :meth2 => result2, ...)

Declare that the mock object should receive a message with the given name.

If more than one method name is given, then the mock object should expect to receive all the listed melthods. If a hash of method name/value pairs is given, then the each method will return the associated result. Any expectations applied to the result of should_receive will be applied to all the methods defined in the argument list.

An expectation object for the method name is returned as the result of this method. Further expectation constraints can be added by chaining to the result.

See Expectation for a list of declarators that can be used.



228
229
230
231
 
# File 'lib/flexmock/core.rb', line 228

def should_receive(*args)
  location = caller.first
  flexmock_define_expectation(location, *args)
end