archive/ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2025-09-18 01:54:00 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Imported minitest 4.3.2 (r8026)

Browse source 
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37967 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ryan 2012-11-29 03:23:11 +00:00
parent 304885cdff
commit 81eb635f8c
13 changed files with 769 additions and 249 deletions
Download patch file Download diff file Expand all files Collapse all files

120
lib/minitest/README.txt
View file

@ -49,6 +49,17 @@ discovery.
-- Piotr Szotkowski
Comparing to rspec:
rspec is a testing DSL. minitest is ruby.
-- Adam Hawkins, "Bow Before MiniTest"
minitest doesn't reinvent anything that ruby already provides, like:
classes, modules, inheritance, methods. This means you only have to
learn ruby to use minitest and all of your regular OO practices like
extract-method refactorings still apply.
== FEATURES/PROBLEMS:
* minitest/autorun - the easy and explicit way to run all your tests.
@ -93,6 +104,10 @@ Given that you'd like to test the following class:
def test_that_it_will_not_blend
refute_match /^no/i, @meme.will_it_blend?
end
def test_that_will_be_skipped
skip "test this later"
end
end
=== Specs
@ -260,43 +275,74 @@ fixture loading:
== Known Extensions:
minitest-capistrano :: Assertions and expectations for testing Capistrano recipes
minitest-capybara :: Capybara matchers support for minitest unit and spec
minitest-chef-handler :: Run Minitest suites as Chef report handlers
minitest-ci :: CI reporter plugin for MiniTest.
minitest-colorize :: Colorize MiniTest output and show failing tests instantly.
minitest-context :: Defines contexts for code reuse in MiniTest
specs that share common expectations.
minitest-debugger :: Wraps assert so failed assertions drop into
the ruby debugger.
minitest-display :: Patches MiniTest to allow for an easily configurable output.
minitest-emoji :: Print out emoji for your test passes, fails, and skips.
minitest-excludes :: Clean API for excluding certain tests you
don't want to run under certain conditions.
minitest-firemock :: Makes your MiniTest mocks more resilient.
minitest-growl :: Test notifier for minitest via growl.
minitest-instrument :: Instrument ActiveSupport::Notifications when
test method is executed
minitest-instrument-db :: Store information about speed of test
execution provided by minitest-instrument in database
minitest-libnotify :: Test notifier for minitest via libnotify.
minitest-macruby :: Provides extensions to minitest for macruby UI testing.
minitest-matchers :: Adds support for RSpec-style matchers to minitest.
minitest-metadata :: Annotate tests with metadata (key-value).
minitest-mongoid :: Mongoid assertion matchers for MiniTest
minitest-must_not :: Provides must_not as an alias for wont in MiniTest
minitest-predicates :: Adds support for .predicate? methods
minitest-pry :: A minitest plugin to drop into pry on assertion failure.
minitest-rails :: MiniTest integration for Rails 3.1.
minitest-reporters :: Create customizable MiniTest output formats
minitest-rg :: redgreen minitest
minitest-spec-magic :: Minitest::Spec extensions for Rails and beyond
minitest-tags :: add tags for minitest
minitest-wscolor :: Yet another test colorizer.
minitest_owrapper :: Get tests results as a TestResult object.
minitest_should :: Shoulda style syntax for minitest test::unit.
minitest_tu_shim :: minitest_tu_shim bridges between test/unit and minitest.
mongoid-minitest :: MiniTest matchers for Mongoid.
minitest-capistrano :: Assertions and expectations for testing Capistrano recipes
minitest-capybara :: Capybara matchers support for minitest unit and spec
minitest-chef-handler :: Run Minitest suites as Chef report handlers
minitest-ci :: CI reporter plugin for MiniTest.
minitest-colorize :: Colorize MiniTest output and show failing tests instantly.
minitest-context :: Defines contexts for code reuse in MiniTest
specs that share common expectations.
minitest-debugger :: Wraps assert so failed assertions drop into
the ruby debugger.
minitest-display :: Patches MiniTest to allow for an easily configurable output.
minitest-emoji :: Print out emoji for your test passes, fails, and skips.
minitest-excludes :: Clean API for excluding certain tests you
don't want to run under certain conditions.
minitest-firemock :: Makes your MiniTest mocks more resilient.
minitest-growl :: Test notifier for minitest via growl.
minitest-instrument :: Instrument ActiveSupport::Notifications when
test method is executed
minitest-instrument-db :: Store information about speed of test
execution provided by minitest-instrument in database
minitest-libnotify :: Test notifier for minitest via libnotify.
minitest-macruby :: Provides extensions to minitest for macruby UI testing.
minitest-matchers :: Adds support for RSpec-style matchers to minitest.
minitest-metadata :: Annotate tests with metadata (key-value).
minitest-mongoid :: Mongoid assertion matchers for MiniTest
minitest-must_not :: Provides must_not as an alias for wont in MiniTest
minitest-predicates :: Adds support for .predicate? methods
minitest-rails :: MiniTest integration for Rails 3.x
minitest-rails-capybara :: Capybara integration for MiniTest::Rails
minitest-reporters :: Create customizable MiniTest output formats
minitest-rg :: redgreen minitest
minitest-shouldify :: Adding all manner of shoulds to MiniTest (bad idea)
minitest-spec-magic :: Minitest::Spec extensions for Rails and beyond
minitest-tags :: add tags for minitest
minitest-wscolor :: Yet another test colorizer.
minitest_owrapper :: Get tests results as a TestResult object.
minitest_should :: Shoulda style syntax for minitest test::unit.
minitest_tu_shim :: minitest_tu_shim bridges between test/unit and minitest.
mongoid-minitest :: MiniTest matchers for Mongoid.
pry-rescue :: A pry plugin w/ minitest support. See pry-rescue/minitest.rb.
== Unknown Extensions:
Authors... Please send me a pull request with a description of your minitest extension.
* assay-minitest
* capybara_minitest_spec
* detroit-minitest
* em-minitest-spec
* flexmock-minitest
* guard-minitest
* guard-minitest-decisiv
* minitest-activemodel
* minitest-ar-assertions
* minitest-around
* minitest-capybara-unit
* minitest-colorer
* minitest-deluxe
* minitest-extra-assertions
* minitest-nc
* minitest-rails-shoulda
* minitest-spec
* minitest-spec-context
* minitest-spec-rails
* minitest-spec-should
* minitest-sugar
* minitest_should
* mongoid-minitest
* spork-minitest
== REQUIREMENTS:

16
lib/minitest/hell.rb Normal file
View file

@ -0,0 +1,16 @@
# encoding: utf-8
######################################################################
# This file is imported from the minitest project.
# DO NOT make modifications in this repo. They _will_ be reverted!
# File a patch instead and assign it to Ryan Davis.
######################################################################
class Minitest::Unit::TestCase
class << self
alias :old_test_order :test_order
def test_order # :nodoc:
:parallel
end
end
end

43
lib/minitest/mock.rb
View file

@ -31,8 +31,8 @@ module MiniTest
end
##
# Expect that method +name+ is called, optionally with +args+, and returns
# +retval+.
# 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
@ -40,6 +40,10 @@ module MiniTest
# @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.
#
@ -51,9 +55,14 @@ module MiniTest
# @mock.uses_one_string("bar") # => true
# @mock.verify # => raises MockExpectationError
def expect(name, retval, args=[])
raise ArgumentError, "args must be an array" unless Array === args
@expected_calls[name] << { :retval => retval, :args => args }
def expect(name, retval, args=[], &blk)
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
@ -103,7 +112,17 @@ module MiniTest
[sym, args]
end
expected_args, retval = expected_call[:args], expected_call[:retval]
expected_args, retval, val_block =
expected_call.values_at(:args, :retval, :block)
if val_block then
raise MockExpectationError, "mocked method %p failed block w/ %p" %
[sym, args] unless val_block.call(args)
# keep "verify" happy
@actual_calls[sym] << expected_call
return retval
end
if expected_args.size != args.size then
raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
@ -127,9 +146,9 @@ module MiniTest
retval
end
def respond_to?(sym) # :nodoc:
def respond_to?(sym, include_private = false) # :nodoc:
return true if @expected_calls.has_key?(sym.to_sym)
return __respond_to?(sym)
return __respond_to?(sym, include_private)
end
end
end
@ -155,7 +174,15 @@ class Object # :nodoc:
new_name = "__minitest_stub__#{name}"
metaclass = class << self; self; end
if respond_to? name and not methods.map(&:to_s).include? name.to_s then
metaclass.send :define_method, name do |*args|
super(*args)
end
end
metaclass.send :alias_method, new_name, name
metaclass.send :define_method, name do |*args|
if val_or_callable.respond_to? :call then
val_or_callable.call(*args)

36
lib/minitest/parallel_each.rb Normal file
View file

@ -0,0 +1,36 @@
# encoding: utf-8
######################################################################
# This file is imported from the minitest project.
# DO NOT make modifications in this repo. They _will_ be reverted!
# File a patch instead and assign it to Ryan Davis.
######################################################################
class ParallelEach
require 'thread'
include Enumerable
N = (ENV['N'] || 2).to_i
def initialize list
@queue = Queue.new # *sigh*... the Queue api sucks sooo much...
list.each { |i| @queue << i }
N.times { @queue << nil }
end
def grep pattern
self.class.new super
end
def each
threads = N.times.map {
Thread.new do
Thread.current.abort_on_exception = true
while job = @queue.pop
yield job
end
end
}
threads.map(&:join)
end
end

2
lib/minitest/pride.rb
View file

@ -47,7 +47,7 @@ class PrideIO
def puts(*o) # :nodoc:
o.map! { |s|
s.sub(/Finished tests/) {
s.to_s.sub(/Finished tests/) {
@index = 0
'Fabulous tests'.split(//).map { |c|
pride(c)

2
lib/minitest/spec.rb
View file

@ -537,5 +537,5 @@ module MiniTest::Expectations
end
class Object # :nodoc:
include MiniTest::Expectations
include MiniTest::Expectations unless ENV["MT_NO_EXPECTATIONS"]
end

287
lib/minitest/unit.rb
View file

@ -7,6 +7,8 @@
require 'optparse'
require 'rbconfig'
require 'thread' # required for 1.8
require 'minitest/parallel_each'
##
# Minimal (mostly drop-in) replacement for test-unit.
@ -37,24 +39,36 @@ module MiniTest
class Skip < Assertion; end
def self.filter_backtrace bt # :nodoc:
return ["No backtrace"] unless bt
class << self
attr_accessor :backtrace_filter
end
new_bt = []
class BacktraceFilter # :nodoc:
def filter bt
return ["No backtrace"] unless bt
unless $DEBUG then
bt.each do |line|
break if line =~ /lib\/minitest/
new_bt << line
new_bt = []
unless $DEBUG then
bt.each do |line|
break if line =~ /lib\/minitest/
new_bt << line
end
new_bt = bt.reject { |line| line =~ /lib\/minitest/ } if new_bt.empty?
new_bt = bt.dup if new_bt.empty?
else
new_bt = bt.dup
end
new_bt = bt.reject { |line| line =~ /lib\/minitest/ } if new_bt.empty?
new_bt = bt.dup if new_bt.empty?
else
new_bt = bt.dup
new_bt
end
end
new_bt
self.backtrace_filter = BacktraceFilter.new
def self.filter_backtrace bt # :nodoc:
backtrace_filter.filter bt
end
##
@ -68,14 +82,12 @@ module MiniTest
"UNDEFINED" # again with the rdoc bugs... :(
end
WINDOZE = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ # :nodoc:
##
# Returns the diff command to use in #diff. Tries to intelligently
# figure out what diff to use.
def self.diff
@diff = if WINDOZE
@diff = if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ then
"diff.exe -u"
else
if system("gdiff", __FILE__, __FILE__)
@ -136,10 +148,11 @@ module MiniTest
if result.empty? then
klass = exp.class
result = [
"No visible difference.",
"You should look at your implementation of #{klass}#==.",
expect
].join "\n"
"No visible difference in the #{klass}#inspect output.\n",
"You should look at the implementation of #== on ",
"#{klass} or its members.\n",
expect,
].join
end
end
end
@ -314,6 +327,8 @@ module MiniTest
# "" if you require it to be silent. Pass in a regexp if you want
# to pattern match.
#
# NOTE: this uses #capture_io, not #capture_subprocess_io.
#
# See also: #assert_silent
def assert_output stdout = nil, stderr = nil
@ -351,30 +366,30 @@ module MiniTest
def assert_raises *exp
msg = "#{exp.pop}.\n" if String === exp.last
should_raise = false
begin
yield
should_raise = true
rescue MiniTest::Skip => e
details = "#{msg}#{mu_pp(exp)} exception expected, not"
if exp.include? MiniTest::Skip then
return e
else
raise e
end
return e if exp.include? MiniTest::Skip
raise e
rescue Exception => e
details = "#{msg}#{mu_pp(exp)} exception expected, not"
assert(exp.any? { |ex|
ex.instance_of?(Module) ? e.kind_of?(ex) : ex == e.class
}, exception_details(e, details))
expected = exp.any? { |ex|
if ex.instance_of? Module then
e.kind_of? ex
else
e.instance_of? ex
end
}
assert expected, proc {
exception_details(e, "#{msg}#{mu_pp(exp)} exception expected, not")
}
return e
end
exp = exp.first if exp.size == 1
flunk "#{msg}#{mu_pp(exp)} expected but nothing was raised." if
should_raise
flunk "#{msg}#{mu_pp(exp)} expected but nothing was raised."
end
##
@ -431,6 +446,8 @@ module MiniTest
catch(sym) do
begin
yield
rescue ThreadError => e # wtf?!? 1.8 + threads == suck
default += ", not \:#{e.message[/uncaught throw \`(\w+?)\'/, 1]}"
rescue ArgumentError => e # 1.9 exception
default += ", not #{e.message.split(/ /).last}"
rescue NameError => e # 1.8 exception
@ -446,24 +463,76 @@ module MiniTest
# Captures $stdout and $stderr into strings:
#
# out, err = capture_io do
# puts "Some info"
# warn "You did a bad thing"
# end
#
# assert_match %r%info%, out
# assert_match %r%bad%, err
#
# NOTE: For efficiency, this method uses StringIO and does not
# capture IO for subprocesses. Use #capture_subprocess_io for
# that.
def capture_io
require 'stringio'
orig_stdout, orig_stderr = $stdout, $stderr
captured_stdout, captured_stderr = StringIO.new, StringIO.new
$stdout, $stderr = captured_stdout, captured_stderr
yield
synchronize do
orig_stdout, orig_stderr = $stdout, $stderr
$stdout, $stderr = captured_stdout, captured_stderr
begin
yield
ensure
$stdout = orig_stdout
$stderr = orig_stderr
end
end
return captured_stdout.string, captured_stderr.string
ensure
$stdout = orig_stdout
$stderr = orig_stderr
end
##
# Captures $stdout and $stderr into strings, using Tempfile to
# ensure that subprocess IO is captured as well.
#
# out, err = capture_subprocess_io do
# system "echo Some info"
# system "echo You did a bad thing 1>&2"
# end
#
# assert_match %r%info%, out
# assert_match %r%bad%, err
#
# NOTE: This method is approximately 10x slower than #capture_io so
# only use it when you need to test the output of a subprocess.
def capture_subprocess_io
require 'tempfile'
captured_stdout, captured_stderr = Tempfile.new("out"), Tempfile.new("err")
synchronize do
orig_stdout, orig_stderr = $stdout.dup, $stderr.dup
$stdout.reopen captured_stdout
$stderr.reopen captured_stderr
begin
yield
$stdout.rewind
$stderr.rewind
[captured_stdout.read, captured_stderr.read]
ensure
captured_stdout.unlink
captured_stderr.unlink
$stdout.reopen orig_stdout
$stderr.reopen orig_stderr
end
end
end
##
@ -656,10 +725,19 @@ module MiniTest
msg ||= "Skipped, no message given"
raise MiniTest::Skip, msg, bt
end
##
# Takes a block and wraps it with the runner's shared mutex.
def synchronize
Minitest::Unit.runner.synchronize do
yield
end
end
end
class Unit # :nodoc:
VERSION = "3.4.0" # :nodoc:
VERSION = "4.3.2" # :nodoc:
attr_accessor :report, :failures, :errors, :skips # :nodoc:
attr_accessor :test_count, :assertion_count # :nodoc:
@ -667,7 +745,6 @@ module MiniTest
attr_accessor :help # :nodoc:
attr_accessor :verbose # :nodoc:
attr_writer :options # :nodoc:
attr_accessor :last_error # :nodoc:
##
# Lazy accessor for options.
@ -695,7 +772,8 @@ module MiniTest
def self.autorun
at_exit {
next if $! # don't run if there was an exception
# don't run if there was a non-exit exception
next if $! and not $!.kind_of? SystemExit
# the order here is important. The at_exit handler must be
# installed before anyone else gets a chance to install their
@ -810,10 +888,15 @@ module MiniTest
end
##
# Runs all the +suites+ for a given +type+.
# Runs all the +suites+ for a given +type+. Runs suites declaring
# a test_order of +:parallel+ in parallel, and everything else
# serial.
def _run_suites suites, type
suites.map { |suite| _run_suite suite, type }
parallel, serial = suites.partition { |s| s.test_order == :parallel }
ParallelEach.new(parallel).map { |suite| _run_suite suite, type } +
serial.map { |suite| _run_suite suite, type }
end
##
@ -832,14 +915,10 @@ module MiniTest
print "#{suite}##{method} = " if @verbose
@start_time = Time.now
self.last_error = nil
start_time = Time.now if @verbose
result = inst.run self
time = Time.now - @start_time
record suite, method, inst._assertions, time, last_error
print "%.2f s = " % time if @verbose
print "%.2f s = " % (Time.now - start_time) if @verbose
print result
puts if @verbose
@ -878,7 +957,6 @@ module MiniTest
# exception +e+
def puke klass, meth, e
self.last_error = e
e = case e
when MiniTest::Skip then
@skips += 1
@ -900,7 +978,11 @@ module MiniTest
@report = []
@errors = @failures = @skips = 0
@verbose = false
self.last_error = nil
@mutex = Mutex.new
end
def synchronize # :nodoc:
@mutex.synchronize { yield }
end
def process_args args = [] # :nodoc:
@ -1103,31 +1185,10 @@ module MiniTest
module Deprecated # :nodoc:
##
# This entire module is deprecated and slated for removal on 2013-01-01.
##
# This entire module is deprecated and slated for removal on 2013-01-01.
module Hooks
##
# Adds a block of code that will be executed before every
# TestCase is run.
#
# NOTE: This method is deprecated, use before/after_setup. It
# will be removed on 2013-01-01.
def self.add_setup_hook arg=nil, &block
warn "NOTE: MiniTest::Unit::TestCase.add_setup_hook is deprecated, use before/after_setup via a module (and call super!). It will be removed on 2013-01-01. Called from #{caller.first}"
hook = arg || block
@setup_hooks << hook
end
def self.setup_hooks # :nodoc:
if superclass.respond_to? :setup_hooks then
superclass.setup_hooks
else
[]
end + @setup_hooks
end
def run_setup_hooks # :nodoc:
_run_hooks self.class.setup_hooks
end
@ -1142,6 +1203,36 @@ module MiniTest
end
end
def run_teardown_hooks # :nodoc:
_run_hooks self.class.teardown_hooks.reverse
end
end
##
# This entire module is deprecated and slated for removal on 2013-01-01.
module HooksCM
##
# Adds a block of code that will be executed before every
# TestCase is run.
#
# NOTE: This method is deprecated, use before/after_setup. It
# will be removed on 2013-01-01.
def add_setup_hook arg=nil, &block
warn "NOTE: MiniTest::Unit::TestCase.add_setup_hook is deprecated, use before/after_setup via a module (and call super!). It will be removed on 2013-01-01. Called from #{caller.first}"
hook = arg || block
@setup_hooks << hook
end
def setup_hooks # :nodoc:
if superclass.respond_to? :setup_hooks then
superclass.setup_hooks
else
[]
end + @setup_hooks
end
##
# Adds a block of code that will be executed after every
# TestCase is run.
@ -1149,23 +1240,19 @@ module MiniTest
# NOTE: This method is deprecated, use before/after_teardown. It
# will be removed on 2013-01-01.
def self.add_teardown_hook arg=nil, &block
def add_teardown_hook arg=nil, &block
warn "NOTE: MiniTest::Unit::TestCase#add_teardown_hook is deprecated, use before/after_teardown. It will be removed on 2013-01-01. Called from #{caller.first}"
hook = arg || block
@teardown_hooks << hook
end
def self.teardown_hooks # :nodoc:
def teardown_hooks # :nodoc:
if superclass.respond_to? :teardown_hooks then
superclass.teardown_hooks
else
[]
end + @teardown_hooks
end
def run_teardown_hooks # :nodoc:
_run_hooks self.class.teardown_hooks.reverse
end
end
end
@ -1178,6 +1265,7 @@ module MiniTest
class TestCase
include LifecycleHooks
include Deprecated::Hooks
extend Deprecated::HooksCM # UGH... I can't wait 'til 2013!
include Guard
extend Guard
@ -1202,6 +1290,8 @@ module MiniTest
runner.status $stderr
end if SUPPORTS_INFO_SIGNAL
start_time = Time.now
result = ""
begin
@passed = nil
@ -1210,11 +1300,15 @@ module MiniTest
self.after_setup
self.run_test self.__name__
result = "." unless io?
time = Time.now - start_time
runner.record self.class, self.__name__, self._assertions, time, nil
@passed = true
rescue *PASSTHROUGH_EXCEPTIONS
raise
rescue Exception => e
@passed = false
time = Time.now - start_time
runner.record self.class, self.__name__, self._assertions, time, e
result = runner.puke self.class, self.__name__, e
ensure
%w{ before_teardown teardown after_teardown }.each do |hook|
@ -1278,6 +1372,32 @@ module MiniTest
end
end
##
# Make diffs for this TestCase use #pretty_inspect so that diff
# in assert_equal can be more details. NOTE: this is much slower
# than the regular inspect but much more usable for complex
# objects.
def self.make_my_diffs_pretty!
require 'pp'
define_method :mu_pp do |o|
o.pretty_inspect
end
end
##
# Call this at the top of your tests when you want to run your
# tests in parallel. In doing so, you're admitting that you rule
# and your tests are awesome.
def self.parallelize_me!
class << self
undef_method :test_order if method_defined? :test_order
define_method :test_order do :parallel end
end
end
def self.inherited klass # :nodoc:
@@test_suites[klass] = true
klass.reset_setup_teardown_hooks
@ -1296,6 +1416,9 @@ module MiniTest
methods = public_instance_methods(true).grep(/^test/).map { |m| m.to_s }
case self.test_order
when :parallel
max = methods.size
ParallelEach.new methods.sort.sort_by { rand max }
when :random then
max = methods.size
methods.sort.sort_by { rand max }