Minitest Assertions. All assertion methods accept a msg
which is printed if the assertion fails.
Protocol: Nearly everything here boils up to assert
, which expects to be able to increment an instance accessor named assertions
. This is not provided by Assertions and must be provided by the thing including Assertions. See Minitest::Runnable for an example.
# File lib/minitest/assertions.rb, line 29 def self.diff @diff = if (RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ && system("diff.exe", __FILE__, __FILE__)) then "diff.exe -u" elsif Minitest::Test.maglev? then "diff -u" elsif system("gdiff", __FILE__, __FILE__) "gdiff -u" # solaris and kin suck elsif system("diff", __FILE__, __FILE__) "diff -u" else nil end unless defined? @diff @diff end
Returns the diff command to use in diff. Tries to intelligently figure out what diff to use.
Set the diff command to use in diff.
# File lib/minitest/assertions.rb, line 172 def assert_equal exp, act, msg = nil msg = message(msg, E) { diff exp, act } result = assert exp == act, msg if nil == exp then if Minitest::VERSION =~ /^6/ then refute_nil exp, "Use assert_nil if expecting nil." else where = Minitest.filter_backtrace(caller).first where = where.split(/:in /, 2).first # clean up noise warn "DEPRECATED: Use assert_nil if expecting nil from #{where}. This will fail in Minitest 6." end end result end
Fails unless exp == act
printing the difference between the two, if possible.
If there is no visible difference but the assertion fails, you should suspect that your #== is buggy, or your inspect output is missing crucial details. For nicer structural diffing, set Minitest::Test.make_my_diffs_pretty!
For floats use assert_in_delta.
See also: ::diff
# File lib/minitest/assertions.rb, line 196 def assert_in_delta exp, act, delta = 0.001, msg = nil n = (exp - act).abs msg = message(msg) { "Expected |#{exp} - #{act}| (#{n}) to be <= #{delta}" } assert delta >= n, msg end
For comparing Floats. Fails unless exp
and act
are within delta
of each other.
assert_in_delta Math::PI, (22.0 / 7.0), 0.01
# File lib/minitest/assertions.rb, line 247 def assert_match matcher, obj, msg = nil msg = message(msg) { "Expected #{mu_pp matcher} to match #{mu_pp obj}" } assert_respond_to matcher, :"=~" matcher = Regexp.new Regexp.escape matcher if String === matcher assert matcher =~ obj, msg end
Fails unless matcher
=~
obj
.
# File lib/minitest/assertions.rb, line 267 def assert_operator o1, op, o2 = UNDEFINED, msg = nil return assert_predicate o1, op, msg if UNDEFINED == o2 msg = message(msg) { "Expected #{mu_pp(o1)} to be #{op} #{mu_pp(o2)}" } assert o1.__send__(op, o2), msg end
For testing with binary operators. Eg:
assert_operator 5, :<=, 4
# File lib/minitest/assertions.rb, line 285 def assert_output stdout = nil, stderr = nil out, err = capture_io do yield end err_msg = Regexp === stderr ? :assert_match : :assert_equal if stderr out_msg = Regexp === stdout ? :assert_match : :assert_equal if stdout y = send err_msg, stderr, err, "In stderr" if err_msg x = send out_msg, stdout, out, "In stdout" if out_msg (!stdout || x) && (!stderr || y) end
Fails if stdout or stderr do not output the expected results. Pass in nil if you don't care about that streams output. Pass in “” if you require it to be silent. Pass in a regexp if you want to pattern match.
assert_output(/hey/) { method_with_output }
NOTE: this uses capture_io, not capture_subprocess_io.
See also: assert_silent
# File lib/minitest/assertions.rb, line 308 def assert_predicate o1, op, msg = nil msg = message(msg) { "Expected #{mu_pp(o1)} to be #{op}" } assert o1.__send__(op), msg end
For testing with predicates. Eg:
assert_predicate str, :empty?
This is really meant for specs and is front-ended by #assert_operator:
str.must_be :empty?
# File lib/minitest/assertions.rb, line 321 def assert_raises *exp msg = "#{exp.pop}.\n" if String === exp.last exp << StandardError if exp.empty? begin yield rescue *exp => e pass # count assertion return e rescue Minitest::Skip, Minitest::Assertion # don't count assertion raise rescue SignalException, SystemExit raise rescue Exception => e flunk proc { exception_details(e, "#{msg}#{mu_pp(exp)} exception expected, not") } end exp = exp.first if exp.size == 1 flunk "#{msg}#{mu_pp(exp)} expected but nothing was raised." end
Fails unless the block raises one of exp
. Returns the exception matched so you can check the message, attributes, etc.
exp
takes an optional message on the end to help explain failures and defaults to StandardError if no exception class is passed.
# File lib/minitest/assertions.rb, line 372 def assert_send send_ary, m = nil where = Minitest.filter_backtrace(caller).first where = where.split(/:in /, 2).first # clean up noise warn "DEPRECATED: assert_send. From #{where}" recv, msg, *args = send_ary m = message(m) { "Expected #{mu_pp(recv)}.#{msg}(*#{mu_pp(args)}) to return true" } assert recv.__send__(msg, *args), m end
send_ary
is a receiver, message and arguments.
Fails unless the call returns a true value
Fails if the block outputs anything to stderr or stdout.
See also: assert_output
# File lib/minitest/assertions.rb, line 397 def assert_throws sym, msg = nil default = "Expected #{mu_pp(sym)} to have been thrown" caught = true 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 raise e unless e.message.include?("uncaught throw") default += ", not #{e.message.split(/ /).last}" rescue NameError => e # 1.8 exception raise e unless e.name == sym default += ", not #{e.name.inspect}" end caught = false end assert caught, message(msg) { default } end
Fails unless the block throws sym
# File lib/minitest/assertions.rb, line 433 def capture_io _synchronize do begin captured_stdout, captured_stderr = StringIO.new, StringIO.new orig_stdout, orig_stderr = $stdout, $stderr $stdout, $stderr = captured_stdout, captured_stderr yield return captured_stdout.string, captured_stderr.string ensure $stdout = orig_stdout $stderr = orig_stderr end end end
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.
# File lib/minitest/assertions.rb, line 466 def capture_subprocess_io _synchronize do begin require "tempfile" captured_stdout, captured_stderr = Tempfile.new("out"), Tempfile.new("err") orig_stdout, orig_stderr = $stdout.dup, $stderr.dup $stdout.reopen captured_stdout $stderr.reopen captured_stderr yield $stdout.rewind $stderr.rewind return captured_stdout.read, captured_stderr.read ensure captured_stdout.unlink captured_stderr.unlink $stdout.reopen orig_stdout $stderr.reopen orig_stderr end end 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.
# File lib/minitest/assertions.rb, line 59 def diff exp, act expect = mu_pp_for_diff exp butwas = mu_pp_for_diff act result = nil need_to_diff = (expect.include?("\n") || butwas.include?("\n") || expect.size > 30 || butwas.size > 30 || expect == butwas) && Minitest::Assertions.diff return "Expected: #{mu_pp exp}\n Actual: #{mu_pp act}" unless need_to_diff Tempfile.open("expect") do |a| a.puts expect a.flush Tempfile.open("butwas") do |b| b.puts butwas b.flush result = `#{Minitest::Assertions.diff} #{a.path} #{b.path}` result.sub!(/^\-\-\- .+/, "--- expected") result.sub!(/^\+\+\+ .+/, "+++ actual") if result.empty? then klass = exp.class result = [ "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 result end
Returns a diff between exp
and act
. If there is no known diff command or if it doesn't make sense to diff the output (single line, short output), then it simply returns a basic comparison between the two.
# File lib/minitest/assertions.rb, line 517 def message msg = nil, ending = nil, &default proc { msg = msg.call.chomp(".") if Proc === msg custom_message = "#{msg}.\n" unless msg.nil? or msg.to_s.empty? "#{custom_message}#{default.call}#{ending || "."}" } end
Returns a proc that will output msg
along with the default message.
# File lib/minitest/assertions.rb, line 107 def mu_pp obj s = obj.inspect if defined? Encoding then s = s.encode Encoding.default_external if String === obj && obj.encoding != Encoding.default_external then s = "# encoding: #{obj.encoding}\n#{s}" end end s end
This returns a human-readable version of obj
. By default inspect is called. You can override this to use pretty_print if you want.
# File lib/minitest/assertions.rb, line 127 def mu_pp_for_diff obj mu_pp(obj).gsub(/\\n/, "\n").gsub(/:0x[a-fA-F0-9]{4,}/m, ":0xXXXXXX") end
This returns a diff-able human-readable version of obj
. This differs from the regular #mu_pp because it expands escaped newlines and makes hex-values generic (like object_ids). This uses #mu_pp to do the first pass and then cleans it up.
# File lib/minitest/assertions.rb, line 566 def refute_in_delta exp, act, delta = 0.001, msg = nil n = (exp - act).abs msg = message(msg) { "Expected |#{exp} - #{act}| (#{n}) to not be <= #{delta}" } refute delta >= n, msg end
For comparing Floats. Fails if exp
is within delta
of act
.
refute_in_delta Math::PI, (22.0 / 7.0)
# File lib/minitest/assertions.rb, line 614 def refute_match matcher, obj, msg = nil msg = message(msg) { "Expected #{mu_pp matcher} to not match #{mu_pp obj}" } assert_respond_to matcher, :"=~" matcher = Regexp.new Regexp.escape matcher if String === matcher refute matcher =~ obj, msg end
Fails if matcher
=~
obj
.
# File lib/minitest/assertions.rb, line 635 def refute_operator o1, op, o2 = UNDEFINED, msg = nil return refute_predicate o1, op, msg if UNDEFINED == o2 msg = message(msg) { "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}" } refute o1.__send__(op, o2), msg end
Fails if o1
is not op
o2
. Eg:
refute_operator 1, :>, 2 #=> pass refute_operator 1, :<, 2 #=> fail
# File lib/minitest/assertions.rb, line 650 def refute_predicate o1, op, msg = nil msg = message(msg) { "Expected #{mu_pp(o1)} to not be #{op}" } refute o1.__send__(op), msg end
For testing with predicates.
refute_predicate str, :empty?
This is really meant for specs and is front-ended by #refute_operator:
str.wont_be :empty?
# File lib/minitest/assertions.rb, line 667 def refute_same exp, act, msg = nil msg = message(msg) { data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id] "Expected %s (oid=%d) to not be the same as %s (oid=%d)" % data } refute exp.equal?(act), msg end
Fails if exp
is the same (by object identity) as act
.
© Ryan Davis, seattle.rb
Licensed under the MIT License.