mirror of https://github.com/docusealco/docuseal
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1233 lines
29 KiB
1233 lines
29 KiB
require "optparse"
|
|
require "stringio"
|
|
require "etc"
|
|
|
|
require_relative "minitest/parallel"
|
|
require_relative "minitest/compress"
|
|
|
|
##
|
|
# The top-level namespace for Minitest. Also the location of the main
|
|
# runtime. See +Minitest.run+ for more information.
|
|
|
|
module Minitest
|
|
VERSION = "6.0.3" # :nodoc:
|
|
|
|
@@installed_at_exit ||= false
|
|
@@after_run = []
|
|
@extensions = []
|
|
|
|
def self.cattr_accessor name # :nodoc:
|
|
(class << self; self; end).attr_accessor name
|
|
end
|
|
|
|
##
|
|
# The random seed used for this run. This is used to srand at the
|
|
# start of the run and between each +Runnable.run+.
|
|
#
|
|
# Set via Minitest.run after processing args.
|
|
|
|
cattr_accessor :seed
|
|
|
|
##
|
|
# Parallel test executor
|
|
|
|
cattr_accessor :parallel_executor
|
|
|
|
n_threads = (ENV["MT_CPU"] || Etc.nprocessors).to_i
|
|
|
|
self.parallel_executor = Parallel::Executor.new n_threads if n_threads > 1
|
|
|
|
##
|
|
# Filter object for backtraces.
|
|
|
|
cattr_accessor :backtrace_filter
|
|
|
|
##
|
|
# Reporter object to be used for all runs.
|
|
#
|
|
# NOTE: This accessor is only available during setup, not during runs.
|
|
|
|
cattr_accessor :reporter
|
|
|
|
##
|
|
# Names of known extension plugins.
|
|
|
|
cattr_accessor :extensions
|
|
|
|
##
|
|
# The signal to use for dumping information to STDERR. Defaults to "INFO".
|
|
|
|
cattr_accessor :info_signal
|
|
self.info_signal = "INFO"
|
|
|
|
cattr_accessor :allow_fork
|
|
self.allow_fork = false
|
|
|
|
##
|
|
# Registers Minitest to run at process exit
|
|
|
|
def self.autorun
|
|
Warning[:deprecated] = true
|
|
|
|
at_exit {
|
|
next if $! and not ($!.kind_of? SystemExit and $!.success?)
|
|
|
|
exit_code = nil
|
|
|
|
pid = Process.pid
|
|
at_exit {
|
|
next if !Minitest.allow_fork && Process.pid != pid
|
|
@@after_run.reverse_each(&:call)
|
|
exit exit_code || false
|
|
}
|
|
|
|
exit_code = Minitest.run ARGV
|
|
} unless @@installed_at_exit
|
|
@@installed_at_exit = true
|
|
end
|
|
|
|
##
|
|
# A simple hook allowing you to run a block of code after everything
|
|
# is done running. Eg:
|
|
#
|
|
# Minitest.after_run { p $debugging_info }
|
|
|
|
def self.after_run &block
|
|
@@after_run << block
|
|
end
|
|
|
|
##
|
|
# Manually load plugins by name.
|
|
|
|
def self.load *names
|
|
names.each do |name|
|
|
require "minitest/#{name}_plugin"
|
|
|
|
self.extensions << name.to_s
|
|
end
|
|
end
|
|
|
|
##
|
|
# Register a plugin to be used. Does NOT require / load it.
|
|
|
|
def self.register_plugin name_or_mod
|
|
self.extensions << name_or_mod
|
|
nil
|
|
end
|
|
|
|
def self.load_plugins # :nodoc:
|
|
return unless defined? Gem
|
|
|
|
seen = {}
|
|
|
|
Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
|
|
name = File.basename plugin_path, "_plugin.rb"
|
|
|
|
next if seen[name]
|
|
seen[name] = true
|
|
|
|
require plugin_path
|
|
self.extensions << name
|
|
end
|
|
end
|
|
|
|
def self.init_plugins options # :nodoc:
|
|
self.extensions.each do |mod_or_meth|
|
|
case mod_or_meth
|
|
when Symbol, String then
|
|
name = mod_or_meth
|
|
msg = "plugin_#{name}_init"
|
|
next unless self.respond_to? msg
|
|
send msg, options
|
|
when Module then
|
|
recv = mod_or_meth
|
|
next unless recv.respond_to? :minitest_plugin_init
|
|
recv.minitest_plugin_init options
|
|
else
|
|
raise ArgumentError, "plugin is %p, but it must be a symbol, string or module" % [mod_or_meth]
|
|
end
|
|
end
|
|
end
|
|
|
|
def self.process_args args = [] # :nodoc:
|
|
options = {
|
|
:io => $stdout,
|
|
}
|
|
orig_args = args.dup
|
|
|
|
warn "--no-plugins is a no-op" if args.delete "--no-plugins" # TODO: remove me! when?
|
|
|
|
OptionParser.new do |opts|
|
|
opts.program_name = "minitest"
|
|
opts.version = Minitest::VERSION
|
|
|
|
opts.banner = [
|
|
"Usage: minitest [paths] [options]",
|
|
"ruby path/to/test.rb [options]",
|
|
"rake test [A=options] (see Minitest::TestTask for more options)\n\n",
|
|
].join "\n or: "
|
|
|
|
opts.on "-h", "--help", "Display this help." do
|
|
puts opts
|
|
exit! true
|
|
end
|
|
|
|
opts.on "-V", "--version", "Display the version." do
|
|
puts "#{opts.program_name} #{Minitest::VERSION}"
|
|
exit! true
|
|
end
|
|
|
|
desc = "Sets random seed. Also via env, eg: SEED=42"
|
|
opts.on "-s", "--seed SEED", Integer, desc do |m|
|
|
options[:seed] = m
|
|
end
|
|
|
|
opts.on "-v", "--verbose", "Verbose. Print each name as they run." do
|
|
options[:verbose] = true
|
|
end
|
|
|
|
opts.on "-q", "--quiet", "Quiet. Show no dots while processing files." do
|
|
options[:quiet] = true
|
|
end
|
|
|
|
opts.on "--show-skips", "Show skipped at the end of run." do
|
|
options[:show_skips] = true
|
|
end
|
|
|
|
opts.on "-b", "--bisect", "Run minitest in bisect-mode to isolate flaky tests." if
|
|
File.basename($0).match?(/minitest/)
|
|
|
|
opts.on "-i", "--include PATTERN", "Include /regexp/ or string for run." do |a|
|
|
options[:include] = a
|
|
end
|
|
|
|
opts.on "-e", "--exclude PATTERN", "Exclude /regexp/ or string from run." do |a|
|
|
options[:exclude] = a
|
|
end
|
|
|
|
# part of my unofficial embedded gem "makeoptparseworkwell"
|
|
def opts.topdict(name) = (name.length > 1 ? top.long : top.short)
|
|
def opts.alias(from, to) = (dict = topdict(from) ; dict[to] = dict[from])
|
|
|
|
# these will work but won't show up in --help output:
|
|
opts.alias "include", "name"
|
|
opts.alias "i", "n"
|
|
opts.alias "e", "x"
|
|
|
|
opts.on "-S", "--skip CODES", String, "Skip reporting of certain types of results (eg E)." do |s|
|
|
options[:skip] = s.chars.to_a
|
|
end
|
|
|
|
opts.on "-W[error]", String, "Turn Ruby warnings into errors" do |s|
|
|
options[:Werror] = true
|
|
case s
|
|
when "error", "all", nil then
|
|
require_relative "minitest/error_on_warning"
|
|
$VERBOSE = true
|
|
::Warning[:deprecated] = true
|
|
else
|
|
::Warning[s.to_sym] = true # check validity of category
|
|
end
|
|
end
|
|
|
|
unless extensions.empty?
|
|
opts.separator ""
|
|
opts.separator "Known extensions: #{extensions.join ", "}"
|
|
|
|
extensions.each do |mod_or_meth|
|
|
case mod_or_meth
|
|
when Symbol, String then
|
|
meth = mod_or_meth
|
|
msg = "plugin_#{meth}_options"
|
|
send msg, opts, options if respond_to? msg
|
|
when Module
|
|
recv = mod_or_meth
|
|
next unless recv.respond_to? :minitest_plugin_options
|
|
recv.minitest_plugin_options opts, options
|
|
else
|
|
raise ArgumentError, "plugin is %p, but it must be a symbol, string or module" % [mod_or_meth]
|
|
end
|
|
end
|
|
end
|
|
|
|
begin
|
|
opts.parse! args
|
|
rescue OptionParser::InvalidOption => e
|
|
puts
|
|
puts e
|
|
puts
|
|
puts opts
|
|
exit 1
|
|
end
|
|
|
|
orig_args -= args
|
|
end
|
|
|
|
unless options[:seed] then
|
|
srand
|
|
options[:seed] = (ENV["SEED"] || srand).to_i % 0xFFFF
|
|
orig_args << "--seed" << options[:seed].to_s
|
|
end
|
|
|
|
options[:args] = orig_args.map { |s|
|
|
s.match?(/[\s|&<>$()]/) ? s.inspect : s
|
|
}.join " "
|
|
|
|
options
|
|
end
|
|
|
|
##
|
|
# This is the top-level run method. Everything starts from here. It
|
|
# tells each Runnable sub-class to run, and each of those are
|
|
# responsible for doing whatever they do.
|
|
#
|
|
# The overall structure of a run looks like this:
|
|
#
|
|
# [Minitest.load_plugins] optional, called by user, or require what you want
|
|
# Minitest.autorun
|
|
# Minitest.run(args)
|
|
# Minitest.process_args
|
|
# Minitest.init_plugins
|
|
# Minitest.run_all_suites(reporter, options)
|
|
# Runnable.runnables.each |runnable_klass|
|
|
# runnable_klass.run_suite(reporter, options)
|
|
# filtered_methods = runnable_klass.filter_runnable_methods options
|
|
# filtered_methods.each |runnable_method|
|
|
# runnable_klass.run(self, runnable_method, reporter)
|
|
# runnable_klass.new(runnable_method).run
|
|
|
|
def self.run args = []
|
|
options = process_args args
|
|
|
|
Minitest.seed = options[:seed]
|
|
srand Minitest.seed
|
|
|
|
reporter = CompositeReporter.new
|
|
reporter << SummaryReporter.new(options[:io], options)
|
|
reporter << ProgressReporter.new(options[:io], options) unless options[:quiet]
|
|
|
|
self.reporter = reporter # this makes it available to plugins
|
|
self.init_plugins options
|
|
self.reporter = nil # runnables shouldn't depend on the reporter, ever
|
|
|
|
self.parallel_executor.start if parallel_executor.respond_to? :start
|
|
reporter.start
|
|
begin
|
|
run_all_suites reporter, options
|
|
finished = true
|
|
rescue Interrupt
|
|
warn "Interrupted. Exiting..."
|
|
end
|
|
self.parallel_executor.shutdown if parallel_executor.respond_to? :shutdown
|
|
|
|
# might have been removed/replaced during init_plugins:
|
|
summary = reporter.reporters.grep(SummaryReporter).first
|
|
|
|
reporter.report
|
|
|
|
return empty_run! options if finished && summary && summary.count == 0
|
|
finished and reporter.passed?
|
|
end
|
|
|
|
def self.empty_run! options # :nodoc:
|
|
filter = options[:include]
|
|
return true unless filter # no filter, but nothing ran == success
|
|
|
|
warn "Nothing ran for filter: %s" % [filter]
|
|
|
|
require "did_you_mean" # soft dependency, punt if it doesn't load
|
|
|
|
ms = Runnable.runnables.flat_map(&:runnable_methods)
|
|
cs = DidYouMean::SpellChecker.new(dictionary: ms).correct filter
|
|
|
|
warn DidYouMean::Formatter.message_for cs unless cs.empty?
|
|
rescue LoadError
|
|
# do nothing
|
|
end
|
|
|
|
##
|
|
# Internal run method. Responsible for telling all Runnable
|
|
# sub-classes to run.
|
|
|
|
def self.run_all_suites reporter, options
|
|
suites = Runnable.runnables.shuffle
|
|
parallel, serial = suites.partition { |s| s.run_order == :parallel }
|
|
|
|
# If we run the parallel tests before the serial tests, the parallel tests
|
|
# could run in parallel with the serial tests. This would be bad because
|
|
# the serial tests won't lock around Reporter#record. Run the serial tests
|
|
# first, so that after they complete, the parallel tests will lock when
|
|
# recording results.
|
|
serial.map { |suite| suite.run_suite reporter, options } +
|
|
parallel.map { |suite| suite.run_suite reporter, options }
|
|
end
|
|
|
|
def self.filter_backtrace bt # :nodoc:
|
|
result = backtrace_filter.filter bt
|
|
result = bt.dup if result.empty?
|
|
result
|
|
end
|
|
|
|
##
|
|
# Represents anything "runnable", like Test, Spec, Benchmark, or
|
|
# whatever you can dream up.
|
|
#
|
|
# Subclasses of this are automatically registered and available in
|
|
# Runnable.runnables.
|
|
|
|
class Runnable
|
|
##
|
|
# Number of assertions executed in this run.
|
|
|
|
attr_accessor :assertions
|
|
|
|
##
|
|
# An assertion raised during the run, if any.
|
|
|
|
attr_accessor :failures
|
|
|
|
##
|
|
# The time it took to run.
|
|
|
|
attr_accessor :time
|
|
|
|
def time_it # :nodoc:
|
|
t0 = Minitest.clock_time
|
|
|
|
yield
|
|
ensure
|
|
self.time = Minitest.clock_time - t0
|
|
end
|
|
|
|
##
|
|
# Name of the run.
|
|
|
|
def name
|
|
@NAME
|
|
end
|
|
|
|
##
|
|
# Set the name of the run.
|
|
|
|
def name= o
|
|
@NAME = o
|
|
end
|
|
|
|
##
|
|
# Returns all instance methods matching the pattern +re+.
|
|
|
|
def self.methods_matching re
|
|
public_instance_methods(true).grep(re).map(&:to_s)
|
|
end
|
|
|
|
def self.reset # :nodoc:
|
|
@@runnables = []
|
|
end
|
|
|
|
reset
|
|
|
|
##
|
|
# Returns an array of filtered +runnable_methods+. Uses
|
|
# options[:include] (--include arguments) and options[:exclude]
|
|
# (--exclude arguments) values to filter.
|
|
|
|
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
|
|
|
|
##
|
|
# Responsible for running all runnable methods in a given class,
|
|
# each in its own instance. Each instance is passed to the
|
|
# reporter to record.
|
|
|
|
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
|
|
|
|
##
|
|
# 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.
|
|
|
|
def Runnable.run klass, method_name, reporter
|
|
reporter.prerecord klass, method_name
|
|
reporter.record klass.new(method_name).run
|
|
end
|
|
|
|
##
|
|
# Defines the order to run tests (:random by default). Override
|
|
# this or use a convenience method to change it for your tests.
|
|
|
|
def self.run_order
|
|
:random
|
|
end
|
|
|
|
def self.with_info_handler _reporter=nil, &block # :nodoc:
|
|
on_signal ::Minitest.info_signal, @_info_handler, &block
|
|
end
|
|
|
|
SIGNALS = Signal.list # :nodoc:
|
|
|
|
def self.on_signal name, action # :nodoc:
|
|
supported = SIGNALS[name]
|
|
|
|
old_trap = trap name do
|
|
old_trap.call if old_trap.respond_to? :call
|
|
action.call
|
|
end if supported
|
|
|
|
yield
|
|
ensure
|
|
trap name, old_trap if supported
|
|
end
|
|
|
|
##
|
|
# Each subclass of Runnable is responsible for overriding this
|
|
# method to return all runnable methods. See #methods_matching.
|
|
|
|
def self.runnable_methods
|
|
raise NotImplementedError, "subclass responsibility"
|
|
end
|
|
|
|
##
|
|
# Returns all subclasses of Runnable.
|
|
|
|
def self.runnables
|
|
@@runnables
|
|
end
|
|
|
|
def failure # :nodoc:
|
|
self.failures.first
|
|
end
|
|
|
|
def initialize name # :nodoc:
|
|
self.name = name
|
|
self.failures = []
|
|
self.assertions = 0
|
|
# lazy initializer for metadata
|
|
end
|
|
|
|
##
|
|
# 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!
|
|
|
|
def metadata
|
|
@metadata ||= {}
|
|
end
|
|
|
|
##
|
|
# Sets metadata, mainly used for +Result.from+.
|
|
|
|
attr_writer :metadata
|
|
|
|
##
|
|
# Returns true if metadata exists.
|
|
|
|
def metadata?
|
|
defined? @metadata
|
|
end
|
|
|
|
##
|
|
# Runs a single method. Needs to return self.
|
|
|
|
def run
|
|
raise NotImplementedError, "subclass responsibility"
|
|
end
|
|
|
|
##
|
|
# Did this run pass?
|
|
#
|
|
# Note: skipped runs are not considered passing, but they don't
|
|
# cause the process to exit non-zero.
|
|
|
|
def passed?
|
|
raise NotImplementedError, "subclass responsibility"
|
|
end
|
|
|
|
##
|
|
# Returns a single character string to print based on the result
|
|
# of the run. One of <tt>"."</tt>, <tt>"F"</tt>,
|
|
# <tt>"E"</tt> or <tt>"S"</tt>.
|
|
|
|
def result_code
|
|
raise NotImplementedError, "subclass responsibility"
|
|
end
|
|
|
|
##
|
|
# Was this run skipped? See #passed? for more information.
|
|
|
|
def skipped?
|
|
raise NotImplementedError, "subclass responsibility"
|
|
end
|
|
end # Runnable
|
|
|
|
##
|
|
# Shared code for anything that can get passed to a Reporter. See
|
|
# Minitest::Test & Minitest::Result.
|
|
|
|
module Reportable
|
|
##
|
|
# Did this run pass?
|
|
#
|
|
# Note: skipped runs are not considered passing, but they don't
|
|
# cause the process to exit non-zero.
|
|
|
|
def passed?
|
|
not self.failure
|
|
end
|
|
|
|
BASE_DIR = "#{Dir.pwd}/" # :nodoc:
|
|
|
|
##
|
|
# The location identifier of this test. Depends on a method
|
|
# existing called class_name.
|
|
|
|
def location
|
|
loc = " [#{self.failure.location.delete_prefix BASE_DIR}]" unless passed? or error?
|
|
"#{self.class_name}##{self.name}#{loc}"
|
|
end
|
|
|
|
def class_name # :nodoc:
|
|
raise NotImplementedError, "subclass responsibility"
|
|
end
|
|
|
|
##
|
|
# Returns ".", "F", or "E" based on the result of the run.
|
|
|
|
def result_code
|
|
self.failure and self.failure.result_code or "."
|
|
end
|
|
|
|
##
|
|
# Was this run skipped?
|
|
|
|
def skipped?
|
|
self.failure and Skip === self.failure
|
|
end
|
|
|
|
##
|
|
# Did this run error?
|
|
|
|
def error?
|
|
self.failures.any? UnexpectedError
|
|
end
|
|
end # Reportable
|
|
|
|
##
|
|
# This represents a test result in a clean way that can be
|
|
# marshalled over a wire. Tests can do anything they want to the
|
|
# test instance and can create conditions that cause Marshal.dump to
|
|
# blow up. By using Result.from(a_test) you can be reasonably sure
|
|
# that the test result can be marshalled.
|
|
|
|
class Result < Runnable
|
|
include Minitest::Reportable
|
|
|
|
##
|
|
# The class name of the test result.
|
|
|
|
attr_accessor :klass
|
|
|
|
##
|
|
# The location of the test method.
|
|
|
|
attr_accessor :source_location
|
|
|
|
##
|
|
# Create a new test result from a Runnable instance.
|
|
|
|
def self.from runnable
|
|
o = runnable
|
|
|
|
r = self.new o.name
|
|
r.klass = o.class.name
|
|
r.assertions = o.assertions
|
|
r.failures = o.failures.dup
|
|
r.time = o.time
|
|
r.metadata = o.metadata if o.metadata?
|
|
|
|
r.source_location = o.method(o.name).source_location rescue ["unknown", -1]
|
|
|
|
r
|
|
end
|
|
|
|
def class_name # :nodoc:
|
|
self.klass # for Minitest::Reportable
|
|
end
|
|
|
|
def to_s # :nodoc:
|
|
return location if passed? and not skipped?
|
|
|
|
failures.map { |failure|
|
|
"#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
|
|
}.join "\n"
|
|
end
|
|
end # Result
|
|
|
|
##
|
|
# Defines the API for Reporters. Subclass this and override whatever
|
|
# you want. Go nuts.
|
|
|
|
class AbstractReporter
|
|
|
|
def initialize # :nodoc:
|
|
@mutex = Mutex.new
|
|
end
|
|
|
|
##
|
|
# Starts reporting on the run.
|
|
|
|
def start
|
|
end
|
|
|
|
##
|
|
# About to start running a test. This allows a reporter to show
|
|
# that it is starting or that we are in the middle of a test run.
|
|
|
|
def prerecord klass, name
|
|
end
|
|
|
|
##
|
|
# Output and record the result of the test. Call
|
|
# {result#result_code}[rdoc-ref:Runnable#result_code] to get the
|
|
# result character string. Stores the result of the run if the run
|
|
# did not pass.
|
|
|
|
def record result
|
|
end
|
|
|
|
##
|
|
# Outputs the summary of the run.
|
|
|
|
def report
|
|
end
|
|
|
|
##
|
|
# Did this run pass?
|
|
|
|
def passed?
|
|
true
|
|
end
|
|
|
|
def synchronize &block # :nodoc:
|
|
@mutex.synchronize(&block)
|
|
end
|
|
end # AbstractReportera
|
|
|
|
class Reporter < AbstractReporter # :nodoc:
|
|
##
|
|
# The IO used to report.
|
|
|
|
attr_accessor :io
|
|
|
|
##
|
|
# Command-line options for this run.
|
|
|
|
attr_accessor :options
|
|
|
|
def initialize io = $stdout, options = {} # :nodoc:
|
|
super()
|
|
self.io = io
|
|
self.options = options
|
|
end
|
|
end
|
|
|
|
##
|
|
# A very simple reporter that prints the "dots" during the run.
|
|
#
|
|
# This is added to the top-level CompositeReporter at the start of
|
|
# the run. If you want to change the output of minitest via a
|
|
# plugin, pull this out of the composite and replace it with your
|
|
# own.
|
|
|
|
class ProgressReporter < Reporter
|
|
def prerecord klass, name # :nodoc:
|
|
return unless options[:verbose]
|
|
|
|
io.print "%s#%s = " % [klass.name, name]
|
|
io.flush
|
|
end
|
|
|
|
def record result # :nodoc:
|
|
io.print "%.2f s = " % [result.time] if options[:verbose]
|
|
io.print result.result_code
|
|
io.puts if options[:verbose]
|
|
end
|
|
end
|
|
|
|
##
|
|
# A reporter that gathers statistics about a test run. Does not do
|
|
# any IO because meant to be used as a parent class for a reporter
|
|
# that does.
|
|
#
|
|
# If you want to create an entirely different type of output (eg,
|
|
# CI, HTML, etc), this is the place to start.
|
|
#
|
|
# Example:
|
|
#
|
|
# class JenkinsCIReporter < StatisticsReporter
|
|
# def report
|
|
# super # Needed to calculate some statistics
|
|
#
|
|
# print "<testsuite "
|
|
# print "tests='#{count}' "
|
|
# print "failures='#{failures}' "
|
|
# # Remaining XML...
|
|
# end
|
|
# end
|
|
|
|
class StatisticsReporter < Reporter
|
|
##
|
|
# Total number of assertions.
|
|
|
|
attr_accessor :assertions
|
|
|
|
##
|
|
# Total number of test cases.
|
|
|
|
attr_accessor :count
|
|
|
|
##
|
|
# An +Array+ of test cases that failed or were skipped.
|
|
|
|
attr_accessor :results
|
|
|
|
##
|
|
# Time the test run started. If available, the monotonic clock is
|
|
# used and this is a +Float+, otherwise it's an instance of
|
|
# +Time+.
|
|
|
|
attr_accessor :start_time
|
|
|
|
##
|
|
# Test run time. If available, the monotonic clock is used and
|
|
# this is a +Float+, otherwise it's an instance of +Time+.
|
|
|
|
attr_accessor :total_time
|
|
|
|
##
|
|
# Total number of tests that failed.
|
|
|
|
attr_accessor :failures
|
|
|
|
##
|
|
# Total number of tests that erred.
|
|
|
|
attr_accessor :errors
|
|
|
|
##
|
|
# Total number of tests that warned.
|
|
|
|
attr_accessor :warnings
|
|
|
|
##
|
|
# Total number of tests that where skipped.
|
|
|
|
attr_accessor :skips
|
|
|
|
def initialize io = $stdout, options = {} # :nodoc:
|
|
super
|
|
|
|
self.assertions = 0
|
|
self.count = 0
|
|
self.results = []
|
|
self.start_time = nil
|
|
self.total_time = nil
|
|
self.failures = nil
|
|
self.errors = nil
|
|
self.warnings = nil
|
|
self.skips = nil
|
|
end
|
|
|
|
def passed? # :nodoc:
|
|
results.all?(&:skipped?)
|
|
end
|
|
|
|
def start # :nodoc:
|
|
self.start_time = Minitest.clock_time
|
|
end
|
|
|
|
def record result # :nodoc:
|
|
self.count += 1
|
|
self.assertions += result.assertions
|
|
|
|
results << result if not result.passed? or result.skipped?
|
|
end
|
|
|
|
##
|
|
# Report on the tracked statistics.
|
|
|
|
def report
|
|
aggregate = results.group_by { |r| r.failure.class }
|
|
aggregate.default = [] # dumb. group_by should provide this
|
|
|
|
self.total_time = Minitest.clock_time - start_time
|
|
self.failures = aggregate[Assertion].size
|
|
self.errors = aggregate[UnexpectedError].size
|
|
self.warnings = aggregate[UnexpectedWarning].size
|
|
self.skips = aggregate[Skip].size
|
|
end
|
|
end # StatisticsReporter
|
|
|
|
##
|
|
# A reporter that prints the header, summary, and failure details at
|
|
# the end of the run.
|
|
#
|
|
# This is added to the top-level CompositeReporter at the start of
|
|
# the run. If you want to change the output of minitest via a
|
|
# plugin, pull this out of the composite and replace it with your
|
|
# own.
|
|
|
|
class SummaryReporter < StatisticsReporter
|
|
attr_accessor :sync # :nodoc:
|
|
attr_accessor :old_sync # :nodoc:
|
|
|
|
def start # :nodoc:
|
|
super
|
|
|
|
io.puts "Run options: #{options[:args]}"
|
|
io.puts
|
|
io.puts "# Running:"
|
|
io.puts
|
|
|
|
self.sync = io.respond_to? :"sync="
|
|
self.old_sync, io.sync = io.sync, true if self.sync
|
|
end
|
|
|
|
def report # :nodoc:
|
|
super
|
|
|
|
io.sync = self.old_sync
|
|
|
|
io.puts unless options[:verbose] # finish the dots
|
|
io.puts
|
|
io.puts statistics
|
|
aggregated_results io
|
|
io.puts summary
|
|
end
|
|
|
|
def statistics # :nodoc:
|
|
"Finished in %.6fs, %.4f runs/s, %.4f assertions/s." %
|
|
[total_time, count / total_time, assertions / total_time]
|
|
end
|
|
|
|
def aggregated_results io # :nodoc:
|
|
filtered_results = results.dup
|
|
filtered_results.reject!(&:skipped?) unless
|
|
options[:verbose] or options[:show_skips]
|
|
|
|
skip = options[:skip] || []
|
|
|
|
filtered_results.each_with_index { |result, i|
|
|
next if skip.include? result.result_code
|
|
|
|
io.puts "\n%3d) %s" % [i+1, result]
|
|
}
|
|
io.puts
|
|
io
|
|
end
|
|
|
|
def to_s # :nodoc:
|
|
aggregated_results(StringIO.new("".b)).string
|
|
end
|
|
|
|
def summary # :nodoc:
|
|
extra = []
|
|
|
|
extra << ", %d warnings" % [warnings] if options[:Werror]
|
|
|
|
extra << "\n\nYou have skipped tests. Run with --verbose for details." if
|
|
results.any?(&:skipped?) unless
|
|
options[:verbose] or
|
|
options[:show_skips] or
|
|
ENV["MT_NO_SKIP_MSG"]
|
|
|
|
"%d runs, %d assertions, %d failures, %d errors, %d skips%s" %
|
|
[count, assertions, failures, errors, skips, extra.join]
|
|
end
|
|
end # SummaryReporter
|
|
|
|
##
|
|
# Dispatch to multiple reporters as one.
|
|
|
|
class CompositeReporter < AbstractReporter
|
|
##
|
|
# The list of reporters to dispatch to.
|
|
|
|
attr_accessor :reporters
|
|
|
|
def initialize *reporters # :nodoc:
|
|
super()
|
|
self.reporters = reporters
|
|
end
|
|
|
|
def io # :nodoc:
|
|
reporters.first.io
|
|
end
|
|
|
|
##
|
|
# Add another reporter to the mix.
|
|
|
|
def << reporter
|
|
self.reporters << reporter
|
|
end
|
|
|
|
def passed? # :nodoc:
|
|
self.reporters.all?(&:passed?)
|
|
end
|
|
|
|
def start # :nodoc:
|
|
self.reporters.each(&:start)
|
|
end
|
|
|
|
def prerecord klass, name # :nodoc:
|
|
self.reporters.each do |reporter|
|
|
reporter.prerecord klass, name
|
|
end
|
|
end
|
|
|
|
def record result # :nodoc:
|
|
self.reporters.each do |reporter|
|
|
reporter.record result
|
|
end
|
|
end
|
|
|
|
def report # :nodoc:
|
|
self.reporters.each(&:report)
|
|
end
|
|
end # CompositeReporter
|
|
|
|
##
|
|
# Represents run failures.
|
|
|
|
class Assertion < Exception
|
|
RE = /in [`'](?:[^']+[#.])?(?:assert|refute|flunk|pass|fail|raise|must|wont)/ # :nodoc:
|
|
|
|
def error # :nodoc:
|
|
self
|
|
end
|
|
|
|
##
|
|
# Where was this run before an assertion was raised?
|
|
|
|
def location
|
|
bt = Minitest.filter_backtrace self.backtrace
|
|
idx = bt.rindex { |s| s.match? RE } || -1 # fall back to first item
|
|
loc = bt[idx+1] || bt.last || "unknown:-1"
|
|
|
|
loc.sub(/:in .*$/, "")
|
|
end
|
|
|
|
def result_code # :nodoc:
|
|
result_label[0, 1]
|
|
end
|
|
|
|
def result_label # :nodoc:
|
|
"Failure"
|
|
end
|
|
end
|
|
|
|
##
|
|
# Assertion raised when skipping a run.
|
|
|
|
class Skip < Assertion
|
|
def result_label # :nodoc:
|
|
"Skipped"
|
|
end
|
|
end
|
|
|
|
##
|
|
# Assertion wrapping an unexpected error that was raised during a run.
|
|
|
|
class UnexpectedError < Assertion
|
|
include Minitest::Compress
|
|
|
|
# TODO: figure out how to use `cause` instead
|
|
attr_accessor :error # :nodoc:
|
|
|
|
def initialize error # :nodoc:
|
|
super "Unexpected exception"
|
|
|
|
if SystemStackError === error then
|
|
bt = error.backtrace
|
|
new_bt = compress bt
|
|
error = error.exception "#{bt.size} -> #{new_bt.size}"
|
|
error.set_backtrace new_bt
|
|
end
|
|
|
|
self.error = error
|
|
end
|
|
|
|
def backtrace # :nodoc:
|
|
self.error.backtrace
|
|
end
|
|
|
|
BASE_RE = %r%#{Regexp.escape Dir.pwd}/% # :nodoc:
|
|
|
|
def message # :nodoc:
|
|
bt = Minitest.filter_backtrace(self.backtrace).join("\n ")
|
|
.gsub(BASE_RE, "")
|
|
"#{self.error.class}: #{self.error.message}\n #{bt}"
|
|
end
|
|
|
|
def result_label # :nodoc:
|
|
"Error"
|
|
end
|
|
end
|
|
|
|
##
|
|
# Assertion raised on warning when running in -Werror mode.
|
|
|
|
class UnexpectedWarning < Assertion
|
|
def result_label # :nodoc:
|
|
"Warning"
|
|
end
|
|
end
|
|
|
|
##
|
|
# Provides a simple set of guards that you can use in your tests
|
|
# to skip execution if it is not applicable. These methods are
|
|
# mixed into Test as both instance and class methods so you
|
|
# can use them inside or outside of the test methods.
|
|
#
|
|
# def test_something_for_mri
|
|
# skip "bug 1234" if jruby?
|
|
# # ...
|
|
# end
|
|
#
|
|
# if windows? then
|
|
# # ... lots of test methods ...
|
|
# end
|
|
|
|
module Guard
|
|
|
|
##
|
|
# Is this running on jruby?
|
|
|
|
def jruby? platform = RUBY_PLATFORM
|
|
"java" == platform
|
|
end
|
|
|
|
##
|
|
# Is this running on mri?
|
|
|
|
def mri? platform = RUBY_DESCRIPTION
|
|
platform.start_with? "ruby"
|
|
end
|
|
|
|
##
|
|
# Is this running on macOS?
|
|
|
|
def osx? platform = RUBY_PLATFORM
|
|
platform.include? "darwin"
|
|
end
|
|
|
|
##
|
|
# Is this running on windows?
|
|
|
|
def windows? platform = RUBY_PLATFORM
|
|
/mswin|mingw/.match? platform
|
|
end
|
|
end
|
|
|
|
##
|
|
# The standard backtrace filter for minitest.
|
|
#
|
|
# See Minitest.backtrace_filter=.
|
|
|
|
class BacktraceFilter
|
|
|
|
MT_RE = %r%lib/minitest|internal:warning% # :nodoc:
|
|
|
|
##
|
|
# The regular expression to use to filter backtraces. Defaults to +MT_RE+.
|
|
|
|
attr_accessor :regexp
|
|
|
|
def initialize regexp = MT_RE # :nodoc:
|
|
self.regexp = regexp
|
|
end
|
|
|
|
##
|
|
# Filter +bt+ to something useful. Returns the whole thing if
|
|
# $DEBUG (ruby) or $MT_DEBUG (env).
|
|
|
|
def filter bt
|
|
return ["No backtrace"] unless bt
|
|
|
|
return bt.dup if $DEBUG || ENV["MT_DEBUG"]
|
|
|
|
new_bt = bt.take_while { |line| !regexp.match? line.to_s }
|
|
new_bt = bt.select { |line| !regexp.match? line.to_s } if new_bt.empty?
|
|
new_bt = bt.dup if new_bt.empty?
|
|
|
|
new_bt
|
|
end
|
|
end
|
|
|
|
self.backtrace_filter = BacktraceFilter.new
|
|
|
|
# :stopdoc:
|
|
|
|
if defined? Process::CLOCK_MONOTONIC # :nodoc:
|
|
def self.clock_time
|
|
Process.clock_gettime Process::CLOCK_MONOTONIC
|
|
end
|
|
else
|
|
def self.clock_time
|
|
Time.now
|
|
end
|
|
end
|
|
|
|
class Runnable # re-open
|
|
def self.inherited klass # :nodoc:
|
|
self.runnables << klass
|
|
super
|
|
end
|
|
end
|
|
|
|
# :startdoc:
|
|
end
|
|
|
|
require_relative "minitest/test"
|
|
if ENV["MINITEST_SERVER"] then
|
|
require_relative "minitest/server_plugin"
|
|
Minitest.register_plugin :server
|
|
end
|