Class: Minitest::Mock (Ruby 2.7.5)
Description: Class : Minitest::Mock - Ruby 2.7.5

### Home Classes Methods

### In Files

- minitest-5.13.0/lib/minitest/mock.rb

### Parent

Object

### Methods

- #expect
- #verify

### Files

- History.rdoc
- README.rdoc

### Class/Module Index

Quicksearch

- Kernel
- Minitest::AbstractReporter
- Minitest::Assertion
- Minitest::Assertions
- Minitest::BacktraceFilter
- Minitest::BenchSpec
- Minitest::Benchmark
- Minitest::CompositeReporter
- Minitest::Expectations
- Minitest::Guard
- Minitest::Mock
- Minitest::Parallel
- Minitest::Parallel::Executor
- Minitest::PrideIO
- Minitest::PrideLOL
- Minitest::ProgressReporter
- Minitest::Reportable
- Minitest::Result
- Minitest::Skip
- Minitest::Spec
- Minitest::Spec::DSL
- Minitest::Spec::DSL::InstanceMethods
- Minitest::StatisticsReporter
- Minitest::SummaryReporter
- Minitest::Test
- Minitest::Test::LifecycleHooks
- Minitest::UnexpectedError
- Object
- SubThingySpec
- ThingySpec

No matching classes.

# Minitest::Mock

A simple and clean mock object framework.

All mock objects are an instance of `Mock`

### Public Instance Methods

expect(name, retval, args = [], &blk) click to toggle source

Expect that method `name` is called, optionally with `args` 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"

                   # File minitest-5.13.0/lib/minitest/mock.rb, line 81
    def expect name, retval, args = [], &blk
      name = name.to_sym

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

verify() click to toggle source

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

                   # File minitest-5.13.0/lib/minitest/mock.rb, line 108
    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