class Minitest::Runnable

Represents anything “runnable”, like Test, Spec, Benchmark, or whatever you can dream up.

Subclasses of this are automatically registered and available in Runnable.runnables.

Attributes

assertions [RW]

Number of assertions executed in this run.

failures [RW]

An assertion raised during the run, if any.

metadata [W]

Sets metadata, mainly used for Result.from.

time [RW]

The time it took to run.

Public Class Methods

filter_runnable_methods (options={})

Returns an array of filtered runnable_methods. Uses options (–include arguments) and options (–exclude arguments) values to filter.

# File lib/minitest.rb, line 433
def self.filter_runnable_methods options={}
  pos = options[:include]
  neg = options[:exclude]

  pos = Regexp.new $1 if pos.kind_of?(String) && pos =~ %r%/(.*)/%
  neg = Regexp.new $1 if neg.kind_of?(String) && neg =~ %r%/(.*)/%

  # at most 1-2% slower than a 1-pass version, stop optimizing this
  self.runnable_methods
    .select { |m| !pos ||  pos === m || pos === "#{self}##{m}"  }
    .reject { |m|  neg && (neg === m || neg === "#{self}##{m}") }
end

methods_matching (re)

Returns all instance methods matching the pattern re.

# File lib/minitest.rb, line 418
def self.methods_matching re
  public_instance_methods(true).grep(re).map(&:to_s)
end

run (klass, method_name, reporter)

Runs a single method and has the reporter record the result. This was considered internal API but is factored out of run so that subclasses can specialize the running of an individual test. See Minitest::ParallelTest::ClassMethods for an example.

# File lib/minitest.rb, line 483
def Runnable.run klass, method_name, reporter
  reporter.prerecord klass, method_name
  reporter.record klass.new(method_name).run
end

run_order ()

Defines the order to run tests (:random by default). Override this or use a convenience method to change it for your tests.

# File lib/minitest.rb, line 492
def self.run_order
  :random
end

run_suite (reporter, options = {})

Responsible for running all runnable methods in a given class, each in its own instance. Each instance is passed to the reporter to record.

# File lib/minitest.rb, line 451
def Runnable.run_suite reporter, options = {}
  filtered_methods = filter_runnable_methods options

  return if filtered_methods.empty?

  t0 = name = nil

  @_info_handler = lambda do
    unless reporter.passed? then
      warn "Current results:"
      warn reporter.reporters.grep(SummaryReporter).first
    end

    warn "Current: %s#%s %.2fs" % [self, name, Minitest.clock_time - t0]
  end

  with_info_handler do
    filtered_methods.each do |method_name|
      name = method_name
      t0 = Minitest.clock_time

      run self, method_name, reporter
    end
  end
end

runnable_methods ()

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

# File lib/minitest.rb, line 519
def self.runnable_methods
  raise NotImplementedError, "subclass responsibility"
end

runnables ()

Returns all subclasses of Runnable.

# File lib/minitest.rb, line 526
def self.runnables
  @@runnables
end

Public Instance Methods

metadata ()

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

Lazily initializes to a hash, to keep memory down.

NOTE: this data must be plain (read: marshal-able) data! Hashes! Arrays! Strings!

# File lib/minitest.rb, line 549
def metadata
  @metadata ||= {}
end

metadata? ()

Returns true if metadata exists.

# File lib/minitest.rb, line 561
def metadata?
  defined? @metadata
end

name ()

Name of the run.

# File lib/minitest.rb, line 404
def name
  @NAME
end

name= (o)

Set the name of the run.

# File lib/minitest.rb, line 411
def name= o
  @NAME = o
end

passed? ()

Did this run pass?

Note: skipped runs are not considered passing, but they don’t cause the process to exit non-zero.

# File lib/minitest.rb, line 578
def passed?
  raise NotImplementedError, "subclass responsibility"
end

result_code ()

Returns a single character string to print based on the result of the run. One of ".", "F", "E" or "S".

# File lib/minitest.rb, line 587
def result_code
  raise NotImplementedError, "subclass responsibility"
end

run ()

Runs a single method. Needs to return self.

# File lib/minitest.rb, line 568
def run
  raise NotImplementedError, "subclass responsibility"
end

skipped? ()

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

# File lib/minitest.rb, line 594
def skipped?
  raise NotImplementedError, "subclass responsibility"
end