Module: AE::Legacy::Assertions
- Included in:
- World
- Defined in:
- lib/ae/legacy.rb
Overview
Test::Unit Legacy Assertions
This module provides a compatibility layer for Test::Unit. This is an optional module and is intended for providing an easier transition from Test::Unit to AE assertions.
Note that two methods are not provided, #assert_nothing_raised
, and #assert_nothing_thrown
.
Instance Method Summary collapse
-
#assert(test = nil, msg = nil) ⇒ Object
The assertion upon which all other assertions are based.
-
#assert_block(msg = nil) ⇒ Object
Passes if the block yields true.
-
#assert_equal(exp, act, msg = nil) ⇒ Object
Passes if expected == +actual.
-
#assert_in_delta(exp, act, delta, msg = nil) ⇒ Object
Passes if expected_float and actual_float are equal within delta tolerance.
-
#assert_instance_of(cls, obj, msg = nil) ⇒ Object
Passes if object .instance_of? klass.
-
#assert_kind_of(cls, obj, msg = nil) ⇒ Object
Passes if object .kind_of? klass.
-
#assert_match(exp, act, msg = nil) ⇒ Object
Passes if string =~ pattern.
-
#assert_nil(obj, msg = nil) ⇒ Object
Passes if object is nil.
-
#assert_no_match(exp, act, msg = nil) ⇒ Object
Passes if regexp !~ string.
-
#assert_not_equal(exp, act, msg = nil) ⇒ Object
Passes if expected != actual.
-
#assert_not_nil(obj, msg = nil) ⇒ Object
Passes if ! object .nil?.
-
#assert_not_same(exp, act, msg = nil) ⇒ Object
Passes if ! actual .equal? expected.
-
#assert_operator(o1, op, o2, msg = "") ⇒ Object
Compares the
object1
withobject2
using operator. -
#assert_raises(*args) ⇒ Object
(also: #assert_raise)
Passes if the block raises one of the given exceptions.
-
#assert_respond_to(obj, meth, msg = nil) ⇒ Object
Passes if
object
respond_to?method
. -
#assert_same(exp, act, msg = nil) ⇒ Object
Passes if
actual
.equal?expected
(i.e. they are the same instance). -
#assert_send(send_array, msg = nil) ⇒ Object
Passes if the method send returns a true value.
-
#assert_throws(sym, msg = nil) ⇒ Object
Passes if the block throws expected_symbol.
-
#flunk(msg = nil) ⇒ Object
Flunk always fails.
Instance Method Details
#assert(test = nil, msg = nil) ⇒ Object
The assertion upon which all other assertions are based.
assert [1, 2].include?(5)
30 31 32 33 34 35 36 37 |
# File 'lib/ae/legacy.rb', line 30 def assert(test=nil, msg=nil) if test msg = "failed assertion (no message given)" unless msg raise Assertion.new(msg, caller) unless test else Assertor.new(self, :backtrace=>caller) # TODO: Probably remove this! end end |
#assert_block(msg = nil) ⇒ Object
Passes if the block yields true.
assert_block “Couldn’t do the thing” do
do_the_thing
end
45 46 47 48 49 |
# File 'lib/ae/legacy.rb', line 45 def assert_block(msg=nil) # :yields: test = ! yield msg = "assertion failed" unless msg __assert__(test, msg) end |
#assert_equal(exp, act, msg = nil) ⇒ Object
Passes if expected == +actual.
Note that the ordering of arguments is important, since a helpful error message is generated when this one fails that tells you the values of expected and actual.
assert_equal 'MY STRING', 'my string'.upcase
59 60 61 62 63 |
# File 'lib/ae/legacy.rb', line 59 def assert_equal(exp, act, msg=nil) test = (exp == act) msg = "Expected #{act.inspect} to be equal to #{exp.inspect}" unless msg __assert__(test, msg) end |
#assert_in_delta(exp, act, delta, msg = nil) ⇒ Object
Passes if expected_float and actual_float are equal within delta tolerance.
assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
69 70 71 72 73 |
# File 'lib/ae/legacy.rb', line 69 def assert_in_delta(exp, act, delta, msg=nil) test = (exp.to_f - act.to_f).abs <= delta.to_f msg = "Expected #{exp} to be within #{delta} of #{act}" unless msg __assert__(test, msg) end |
#assert_instance_of(cls, obj, msg = nil) ⇒ Object
Passes if object .instance_of? klass
assert_instance_of String, 'foo'
79 80 81 82 83 |
# File 'lib/ae/legacy.rb', line 79 def assert_instance_of(cls, obj, msg=nil) test = (cls === obj) msg = "Expected #{obj} to be a #{cls}" unless msg __assert__(test, msg) end |
#assert_kind_of(cls, obj, msg = nil) ⇒ Object
Passes if object .kind_of? klass
assert_kind_of Object, 'foo'
89 90 91 92 93 |
# File 'lib/ae/legacy.rb', line 89 def assert_kind_of(cls, obj, msg=nil) test = obj.kind_of?(cls) msg = "Expected #{obj.inspect} to be a kind of #{cls}" unless msg __assert__(test, msg) end |
#assert_match(exp, act, msg = nil) ⇒ Object
Passes if string =~ pattern.
assert_match(/\d+/, 'five, 6, seven')
99 100 101 102 103 |
# File 'lib/ae/legacy.rb', line 99 def assert_match(exp, act, msg=nil) test = (act =~ exp) msg = "Expected #{act.inspect} to match #{exp.inspect}" unless msg __assert__(test, msg) end |
#assert_nil(obj, msg = nil) ⇒ Object
Passes if object is nil.
assert_nil [1, 2].uniq!
109 110 111 112 113 |
# File 'lib/ae/legacy.rb', line 109 def assert_nil(obj, msg=nil) test = obj.nil? msg = "Expected #{obj.inspect} to be nil" unless msg __assert__(test, msg) end |
#assert_no_match(exp, act, msg = nil) ⇒ Object
Passes if regexp !~ string
assert_no_match(/two/, 'one 2 three')
119 120 121 122 123 |
# File 'lib/ae/legacy.rb', line 119 def assert_no_match(exp, act, msg=nil) test = (act !~ exp) msg = "Expected #{act.inspect} to match #{exp.inspect}" unless msg __assert__(test, msg) end |
#assert_not_equal(exp, act, msg = nil) ⇒ Object
Passes if expected != actual
assert_not_equal 'some string', 5
129 130 131 132 133 |
# File 'lib/ae/legacy.rb', line 129 def assert_not_equal(exp, act, msg=nil) test = (exp != act) msg = "Expected #{act.inspect} to not be equal to #{exp.inspect}" unless msg __assert__(test, msg) end |
#assert_not_nil(obj, msg = nil) ⇒ Object
Passes if ! object .nil?
assert_not_nil '1 two 3'.sub!(/two/, '2')
139 140 141 142 143 |
# File 'lib/ae/legacy.rb', line 139 def assert_not_nil(obj, msg=nil) test = ! obj.nil? msg = "Expected #{obj.inspect} to not be nil" unless msg __assert__(test, msg) end |
#assert_not_same(exp, act, msg = nil) ⇒ Object
149 150 151 152 153 |
# File 'lib/ae/legacy.rb', line 149 def assert_not_same(exp, act, msg=nil) test = ! exp.equal?(act) msg = "Expected #{act.inspect} to not be the same as #{exp.inspect}" unless msg __assert__(test, msg) end |
#assert_operator(o1, op, o2, msg = "") ⇒ Object
Compares the object1
with object2
using operator.
Passes if object1.send(operator, object2) is true.
assert_operator 5, :>=, 4
161 162 163 164 165 |
# File 'lib/ae/legacy.rb', line 161 def assert_operator(o1, op, o2, msg="") test = o1.__send__(op, o2) msg = "Expected #{o1}.#{op}(#{o2}) to be true" unless msg __assert__(test, msg) end |
#assert_raises(*args) ⇒ Object Also known as: assert_raise
Passes if the block raises one of the given exceptions.
assert_raise RuntimeError, LoadError do
raise 'Boom!!!'
end
173 174 175 176 177 178 179 180 181 182 183 184 185 |
# File 'lib/ae/legacy.rb', line 173 def assert_raises(*args) msg = (Module === args.last ? nil : args.pop) begin yield msg = "Expected #{exp} to be raised" unless msg __assert__(false, msg) rescue Exception => e test = (exp === e) msg = "Expected #{exp} to be raised, but got #{e.class}" unless msg __assert__(test, msg) return e end end |
#assert_respond_to(obj, meth, msg = nil) ⇒ Object
Passes if object
respond_to? method
.
assert_respond_to 'bugbear', :slice
207 208 209 210 211 212 213 |
# File 'lib/ae/legacy.rb', line 207 def assert_respond_to(obj, meth, msg=nil) msg = "Expected #{obj} (#{obj.class}) to respond to ##{meth}" unless msg #flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs #obj, meth = meth, obj if flip test = obj.respond_to?(meth) __assert__(test, msg) end |
#assert_same(exp, act, msg = nil) ⇒ Object
Passes if actual
.equal? expected
(i.e. they are the same instance).
o = Object.new
assert_same(o, o)
220 221 222 223 224 |
# File 'lib/ae/legacy.rb', line 220 def assert_same(exp, act, msg=nil) msg = "Expected #{act.inspect} to be the same as #{exp.inspect}" unless msg test = exp.equal?(act) __assert__(test, msg) end |
#assert_send(send_array, msg = nil) ⇒ Object
Passes if the method send returns a true value. The parameter send_array
is composed of:
-
A receiver
-
A method
-
Arguments to the method
Example:
assert_send [[1, 2], :include?, 4]
237 238 239 240 241 242 |
# File 'lib/ae/legacy.rb', line 237 def assert_send(send_array, msg=nil) r, m, *args = *send_array test = r.__send__(m, *args) msg = "Expected #{r}.#{m}(*#{args.inspect}) to return true" unless msg __assert__(test, msg) end |
#assert_throws(sym, msg = nil) ⇒ Object
Passes if the block throws expected_symbol
assert_throws :done do
throw :done
end
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 |
# File 'lib/ae/legacy.rb', line 250 def assert_throws(sym, msg=nil) msg = "Expected #{sym} to have been thrown" unless msg test = true catch(sym) do begin yield rescue ArgumentError => e # 1.9 exception default += ", not #{e..split(/ /).last}" rescue NameError => e # 1.8 exception default += ", not #{e.name.inspect}" end test = false end __assert__(test, msg) end |
#flunk(msg = nil) ⇒ Object
Flunk always fails.
flunk 'Not done testing yet.'
270 271 272 |
# File 'lib/ae/legacy.rb', line 270 def flunk(msg=nil) __assert__(false, msg) end |