123456789_123456789_123456789_123456789_123456789_

Class: Minitest::Test

Relationships & Source Files
Namespace Children
Modules:
Extension / Inclusion / Inheritance Descendants
Subclasses:
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Guard, Runnable
Instance Chain:
Inherits: Minitest::Runnable
Defined in: lib/minitest/test.rb,
lib/minitest/hell.rb

Overview

Subclass Test to create your own tests. Typically you’ll want a Test subclass per implementation class.

See Assertions

Constant Summary

Runnable - Inherited

SIGNALS

Assertions - Included

E, UNDEFINED

Reportable - Included

BASE_DIR

Class Attribute Summary

Class Method Summary

Guard - Extended

jruby?

Is this running on jruby?

maglev?

Is this running on maglev?

mri?

Is this running on mri?

osx?

Is this running on macOS?

rubinius?

Is this running on rubinius?

windows?

Is this running on windows?

Runnable - Inherited

.methods_matching

Returns all instance methods matching the pattern re.

.run

Responsible for running all runnable methods in a given class, each in its own instance.

.run_one_method

Runs a single method and has the reporter record the result.

.runnable_methods

Each subclass of Runnable is responsible for overriding this method to return all runnable methods.

.runnables

Returns all subclasses of Runnable.

.test_order

Defines the order to run tests (:random by default).

.inherited, .new, .on_signal, .reset, .with_info_handler

Instance Attribute Summary

Reportable - Included

#error?

Did this run error?

#passed?

Did this run pass?

#skipped?

Was this run skipped?

Assertions - Included

#skipped?

Was this testcase skipped? Meant for #teardown.

Runnable - Inherited

#assertions

Number of assertions executed in this run.

#failures

An assertion raised during the run, if any.

#metadata

Metadata you attach to the test results that get sent to the reporter.

#metadata=

Sets metadata, mainly used for Result.from.

#metadata?

Returns true if metadata exists.

#name

Name of the run.

#name=

Set the name of the run.

#passed?

Did this run pass?

#skipped?

Was this run skipped? See #passed? for more information.

#time

The time it took to run.

Instance Method Summary

Guard - Included

#jruby?

Is this running on jruby?

#maglev?

Is this running on maglev?

#mri?

Is this running on mri?

#osx?

Is this running on macOS?

#rubinius?

Is this running on rubinius?

#windows?

Is this running on windows?

LifecycleHooks - Included

#after_setup

Runs before every test, after setup.

#after_teardown

Runs after every test, after teardown.

#before_setup

Runs before every test, before setup.

#before_teardown

Runs after every test, before teardown.

#setup

Runs before every test.

#teardown

Runs after every test.

Reportable - Included

#location

The location identifier of this test.

#result_code

Returns “.”, “F”, or “E” based on the result of the run.

#class_name

Assertions - Included

#assert

Fails unless test is truthy.

#assert_empty

Fails unless obj is empty.

#assert_equal

Fails unless exp == act printing the difference between the two, if possible.

#assert_in_delta

For comparing Floats.

#assert_in_epsilon

For comparing Floats.

#assert_includes

Fails unless collection includes obj.

#assert_instance_of

Fails unless obj is an instance of cls.

#assert_kind_of

Fails unless obj is a kind of cls.

#assert_match

Fails unless matcher =~ obj.

#assert_mock

Assert that the mock verifies correctly.

#assert_nil

Fails unless obj is nil.

#assert_operator

For testing with binary operators.

#assert_output

Fails if stdout or stderr do not output the expected results.

#assert_path_exists

Fails unless path exists.

#assert_pattern

For testing with pattern matching (only supported with Ruby 3.0 and later).

#assert_predicate

For testing with predicates.

#assert_raises

Fails unless the block raises one of exp.

#assert_respond_to

Fails unless obj responds to meth.

#assert_same

Fails unless exp and act are #equal?

#assert_send

send_ary is a receiver, message and arguments.

#assert_silent

Fails if the block outputs anything to stderr or stdout.

#assert_throws

Fails unless the block throws sym

#capture_io

Captures $stdout and $stderr into strings:

#capture_subprocess_io

Captures $stdout and $stderr into strings, using Tempfile to ensure that subprocess IO is captured as well.

#diff

Returns a diff between exp and act.

#exception_details

Returns details for exception e.

#fail_after

Fails after a given date (in the local time zone).

#flunk

Fails with msg.

#message

Returns a proc that will output msg along with the default message.

#mu_pp

This returns a human-readable version of obj.

#mu_pp_for_diff

This returns a diff-able more human-readable version of obj.

#pass

used for counting assertions.

#refute

Fails if test is truthy.

#refute_empty

Fails if obj is empty.

#refute_equal

Fails if exp == act.

#refute_in_delta

For comparing Floats.

#refute_in_epsilon

For comparing Floats.

#refute_includes

Fails if collection includes obj.

#refute_instance_of

Fails if obj is an instance of cls.

#refute_kind_of

Fails if obj is a kind of cls.

#refute_match

Fails if matcher =~ obj.

#refute_nil

Fails if obj is nil.

#refute_operator

Fails if o1 is not op o2.

#refute_path_exists

Fails if path exists.

#refute_pattern

For testing with pattern matching (only supported with Ruby 3.0 and later).

#refute_predicate

For testing with predicates.

#refute_respond_to

Fails if obj responds to the message meth.

#refute_same

Fails if exp is the same (by object identity) as act.

#skip

Skips the current run.

#skip_until

Skips the current run until a given date (in the local time zone).

#things_to_diff

Returns things to diff [expect, butwas], or [nil, nil] if nothing to diff.

#_synchronize, #_where

Runnable - Inherited

#result_code

Returns a single character string to print based on the result of the run.

#run

Runs a single method.

#failure, #marshal_dump, #marshal_load, #time_it

Constructor Details

This class inherits a constructor from Minitest::Runnable

Class Attribute Details

.io_lock (rw)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/minitest/test.rb', line 26

class << self; attr_accessor :io_lock; end

Class Method Details

.i_suck_and_my_tests_are_order_dependent!

Call this at the top of your tests when you absolutely positively need to have ordered tests. In doing so, you’re admitting that you suck and your tests are weak.

[ GitHub ]

  
# File 'lib/minitest/test.rb', line 35

def self.i_suck_and_my_tests_are_order_dependent!
  class << self
    undef_method :test_order if method_defined? :test_order
    define_method :test_order do :alpha end
  end
end

.make_my_diffs_pretty!

Make diffs for this Test use #pretty_inspect so that diff in assert_equal can have more details. NOTE: this is much slower than the regular inspect but much more usable for complex objects.

[ GitHub ]

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

def self.make_my_diffs_pretty!
  require "pp"

  define_method :mu_pp, &:pretty_inspect
end

.parallelize_me!

Call this at the top of your tests (inside the Test subclass or describe block) when you want to run your tests in parallel. In doing so, you’re admitting that you rule and your tests are awesome.

[ GitHub ]

  
# File 'lib/minitest/test.rb', line 60

def self.parallelize_me!
  include Minitest::Parallel::Test
  extend Minitest::Parallel::Test::ClassMethods
end

.runnable_methods

Returns all instance methods starting with “test_”. Based on #test_order, the methods are either sorted, randomized (default), or run in parallel.

[ GitHub ]

  
# File 'lib/minitest/test.rb', line 70

def self.runnable_methods
  methods = methods_matching(/^test_/)

  case self.test_order
  when :random, :parallel then
    srand Minitest.seed
    methods.sort.shuffle
  when :alpha, :sorted then
    methods.sort
  else
    raise "Unknown test_order: #{self.test_order.inspect}"
  end
end

Instance Method Details

#capture_exceptions

This method is for internal use only.
[ GitHub ]

  
# File 'lib/minitest/test.rb', line 191

def capture_exceptions # :nodoc:
  yield
rescue *PASSTHROUGH_EXCEPTIONS
  raise
rescue Assertion => e
  self.failures << e
rescue Exception => e
  self.failures << UnexpectedError.new(sanitize_exception e)
end

#class_name

This method is for internal use only.
[ GitHub ]

  
# File 'lib/minitest/test.rb', line 15

def class_name # :nodoc:
  self.class.name # for Minitest::Reportable
end

#neuter_exception(e)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/minitest/test.rb', line 208

def neuter_exception e # :nodoc:
  bt = e.backtrace
  msg = e.message.dup

  new_exception e.class, msg, bt            # e.class can be a problem...
rescue
  msg.prepend "Neutered Exception #{e.class}: "

  new_exception RuntimeError, msg, bt, true # but if this raises, we die
end

#new_exception(klass, msg, bt, kill = false)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/minitest/test.rb', line 219

def new_exception klass, msg, bt, kill = false # :nodoc:
  ne = klass.new msg
  ne.set_backtrace bt

  if kill then
    ne.instance_variables.each do |v|
      ne.remove_instance_variable v
    end
  end

  Marshal.dump ne                           # can raise TypeError
  ne
end

#run

Runs a single test with setup/teardown hooks.

[ GitHub ]

  
# File 'lib/minitest/test.rb', line 87

def run
  with_info_handler do
    time_it do
      capture_exceptions do
        SETUP_METHODS.each do |hook|
          self.send hook
        end

        self.send self.name
      end

      TEARDOWN_METHODS.each do |hook|
        capture_exceptions do
          self.send hook
        end
      end
    end
  end

  Result.from self # per contract
end

#sanitize_exception(e)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/minitest/test.rb', line 201

def sanitize_exception e # :nodoc:
  Marshal.dump e
  e                                         # good: use as-is
rescue
  neuter_exception e
end

#with_info_handler(&block)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/minitest/test.rb', line 233

def with_info_handler &block # :nodoc:
  t0 = Minitest.clock_time

  handler = lambda do
    warn "\nCurrent: %s#%s %.2fs" % [self.class, self.name, Minitest.clock_time - t0]
  end

  self.class.on_signal ::Minitest.info_signal, handler, &block
end