123456789_123456789_123456789_123456789_123456789_

Class: Minitest::Mock

Relationships & Source Files
Inherits: Object
Defined in: lib/minitest/mock.rb

Overview

A simple and clean mock object framework.

All mock objects are an instance of Mock

Class Method Summary

Instance Method Summary

Constructor Details

.new(delegator = nil) ⇒ Mock

This method is for internal use only.
[ GitHub ] 

  


# File 'lib/minitest/mock.rb', line 48



def initialize delegator = nil # :nodoc:
  @delegator = delegator
  @expected_calls = Hash.new { |calls, name| calls[name] = [] }
  @actual_calls   = Hash.new { |calls, name| calls[name] = [] }
end


  







Dynamic Method Handling

  

    This class handles dynamic methods through the method_missing method




  

    #method_missing(sym, *args, **kwargs, &block)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/minitest/mock.rb', line 150



def method_missing sym, *args, **kwargs, &block # :nodoc:
  unless @expected_calls.key?(sym) then
    if @delegator && @delegator.respond_to?(sym)
      return @delegator.public_send(sym, *args, **kwargs, &block)
    else
      raise NoMethodError, "unmocked method %p, expected one of %p" %
        [sym, @expected_calls.keys.sort_by(&:to_s)]
    end
  end

  index = @actual_calls[sym].length
  expected_call = @expected_calls[sym][index]

  unless expected_call then
    raise MockExpectationError, "No more expects available for %p: %p %p" %
      [sym, args, kwargs]
  end

  expected_args, expected_kwargs, retval, val_block =
    expected_call.values_at(:args, :kwargs, :retval, :block)

  expected_kwargs = kwargs.map { |ak, av| [ak, Object] }.to_h if
    Hash == expected_kwargs

  if val_block then
    # keep "verify" happy
    @actual_calls[sym] << expected_call

    raise MockExpectationError, "mocked method %p failed block w/ %p %p" %
      [sym, args, kwargs] unless val_block.call(*args, **kwargs, &block)

    return retval
  end

  if expected_args.size != args.size then
    raise ArgumentError, "mocked method %p expects %d arguments, got %p" %
      [sym, expected_args.size, args]
  end

  if expected_kwargs.size != kwargs.size then
    raise ArgumentError, "mocked method %p expects %d keyword arguments, got %p" %
      [sym, expected_kwargs.size, kwargs]
  end

  zipped_args = expected_args.zip(args)
  fully_matched = zipped_args.all? { |mod, a|
    mod === a or mod == a
  }

  unless fully_matched then
    fmt = "mocked method %p called with unexpected arguments %p"
    raise MockExpectationError, fmt % [sym, args]
  end

  unless expected_kwargs.keys.sort == kwargs.keys.sort then
    fmt = "mocked method %p called with unexpected keywords %p vs %p"
    raise MockExpectationError, fmt % [sym, expected_kwargs.keys, kwargs.keys]
  end

  zipped_kwargs = expected_kwargs.map { |ek, ev|
    av = kwargs[ek]
    [ek, [ev, av]]
  }.to_h

  fully_matched = zipped_kwargs.all? { |ek, (ev, av)|
    ev === av or ev == av
  }

  unless fully_matched then
    fmt = "mocked method %p called with unexpected keyword arguments %p vs %p"
    raise MockExpectationError, fmt % [sym, expected_kwargs, kwargs]
  end

  @actual_calls[sym] << {
    :retval => retval,
    :args => zipped_args.map { |e, a| e === a ? e : a },
    :kwargs => zipped_kwargs.map { |k, (e, a)| [k, e === a ? e : a] }.to_h,
  }

  retval
end


  







Instance Method Details



  

    #__call(name, data)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/minitest/mock.rb', line 120



def __call name, data # :nodoc:
  case data
  when Hash then
    args   = data[:args].inspect[1..-2]
    kwargs = data[:kwargs]
    if kwargs && !kwargs.empty? then
      args << ", " unless args.empty?
      args << kwargs.inspect[1..-2]
    end
    "#{name}(#{args}) => #{data[:retval].inspect}"
  else
    data.map { |d| __call name, d }.join ", "
  end
end


  








  

    #__respond_to?  
  

  [ GitHub ]


  

  


# File 'lib/minitest/mock.rb', line 11



alias :__respond_to? :respond_to?


  








  

    #expect(name, retval, args = [], **kwargs, &blk)  
  



  

    

Expect that method name is called, optionally with args (and kwargs or a blk, and returns retval.



@mock.expect(:meaning_of_life, 42)
@mock.meaning_of_life # => 42

@mock.expect(:do_something_with, true, [some_obj, true])
@mock.do_something_with(some_obj, true) # => true

@mock.expect(:do_something_else, true) do |a1, a2|
  a1 == "buggs" && a2 == :bunny
end



args is compared to the expected args using case equality (ie, the ‘===’ operator), allowing for less specific expectations.



@mock.expect(:uses_any_string, true, [String])
@mock.uses_any_string("foo") # => true
@mock.verify  # => true

@mock.expect(:uses_one_string, true, ["foo"])
@mock.uses_one_string("bar") # => raises MockExpectationError



If a method will be called multiple times, specify a new expect for each one. They will be used in the order you define them.



@mock.expect(:ordinal_increment, 'first')
@mock.expect(:ordinal_increment, 'second')

@mock.ordinal_increment # => 'first'
@mock.ordinal_increment # => 'second'
@mock.ordinal_increment # => raises MockExpectationError "No more expects available for :ordinal_increment"


  



  [ GitHub ]


  

  


# File 'lib/minitest/mock.rb', line 91



def expect name, retval, args = [], **kwargs, &blk
  name = name.to_sym

  if block_given?
    raise ArgumentError, "args ignored when block given" unless args.empty?
    raise ArgumentError, "kwargs ignored when block given" unless kwargs.empty?
    @expected_calls[name] << { :retval => retval, :block => blk }
  else
    raise ArgumentError, "args must be an array" unless Array === args

    if ENV["MT_KWARGS_HAC\K"] && (Hash === args.last ||
                                  Hash ==  args.last) then
      if kwargs.empty? then
        kwargs = args.pop
      else
        unless @@KW_WARNED then
          from = caller.first
          warn "Using MT_KWARGS_HAC\K yet passing kwargs. From #{from}"
          @@KW_WARNED = true
        end
      end
    end

    @expected_calls[name] <<
      { :retval => retval, :args => args, :kwargs => kwargs }
  end
  self
end


  








  

    #respond_to?(sym, include_private = false)  ⇒ Boolean 
  

  

    This method is for internal use only.
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/minitest/mock.rb', line 232



def respond_to? sym, include_private = false # :nodoc:
  return true if @expected_calls.key? sym.to_sym
  return true if @delegator && @delegator.respond_to?(sym, include_private)
  __respond_to?(sym, include_private)
end


  








  

    #verify  
  



  

    

Verify that all methods were called as expected. Raises ::MockExpectationError if the mock object was not called as expected.


  



  [ GitHub ]


  

  


# File 'lib/minitest/mock.rb', line 140



def verify
  @expected_calls.each do |name, expected|
    actual = @actual_calls.fetch(name, nil)
    raise MockExpectationError, "expected #{__call name, expected[0]}" unless actual
    raise MockExpectationError, "expected #{__call name, expected[actual.size]}, got [#{__call name, actual}]" if
      actual.size < expected.size
  end
  true
end