Module: RSpec::Unit::Assertions

Included in:
Core::ExampleGroup
Defined in:
lib/rspec/unit/assertions.rb

Overview

Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is included in Test::Unit::TestCase.

To include it in your own code and use its functionality, you simply need to rescue Test::Unit::AssertionFailedError. Additionally you may override add_assertion to get notified whenever an assertion is made.

Notes:

  • The message to each assertion, if given, will be propagated with the failure.

  • It is easy to add your own assertions based on assert_block().

Example Custom Assertion

def deny(boolean, message = nil)
  message = build_message message, '<?> is not false or nil.', boolean
  assert_block message do
    not boolean
  end
end

Defined Under Namespace

Classes: AssertionMessage

Constant Summary

UncaughtThrow =
{ArgumentError => /^uncaught throw :?(.+)$/,
NameError => /^uncaught throw \`(.+)\'$/,
ThreadError => /^uncaught throw \`(.+)\' in thread /}

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.use_pp=(value) ⇒ Object



515
516
517
# File 'lib/rspec/unit/assertions.rb', line 515

def self.use_pp=(value)
  AssertionMessage.use_pp = value
end

Instance Method Details

#assert(boolean, message = nil) ⇒ Object



57
58
59
60
61
62
# File 'lib/rspec/unit/assertions.rb', line 57

def assert(boolean, message=nil)
  _wrap_assertion do
    assert_block("assert should not be called with a block.") { !block_given? }
    assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
  end
end

#assert_block(message = "assert_block failed.") ⇒ Object

:yields:



42
43
44
45
46
47
48
# File 'lib/rspec/unit/assertions.rb', line 42

def assert_block(message="assert_block failed.") # :yields: 
  _wrap_assertion do
    if (! yield)
      raise AssertionFailedError.new(message.to_s)
    end
  end
end

#assert_equal(expected, actual, message = nil) ⇒ Object



75
76
77
78
79
80
81
# File 'lib/rspec/unit/assertions.rb', line 75

def assert_equal(expected, actual, message=nil)
  full_message = build_message(message, <<EOT, expected, actual)
<?> expected but was
<?>.
EOT
  assert_block(full_message) { expected == actual }
end

#assert_in_delta(expected_float, actual_float, delta, message = "") ⇒ Object



437
438
439
440
441
442
443
444
445
446
447
448
449
450
# File 'lib/rspec/unit/assertions.rb', line 437

def assert_in_delta(expected_float, actual_float, delta, message="")
  _wrap_assertion do
    {expected_float => "first float", actual_float => "second float", delta => "delta"}.each do |float, name|
      assert_respond_to(float, :to_f, "The arguments must respond to to_f; the #{name} did not")
    end
    assert_operator(delta, :>=, 0.0, "The delta should not be negative")
    full_message = build_message(message, <<EOT, expected_float, actual_float, delta)
<?> and
<?> expected to be within
<?> of each other.
EOT
    assert_block(full_message) { (expected_float.to_f - actual_float.to_f).abs <= delta.to_f }
  end
end

#assert_instance_of(klass, object, message = "") ⇒ Object



149
150
151
152
153
154
155
156
157
158
159
# File 'lib/rspec/unit/assertions.rb', line 149

def assert_instance_of(klass, object, message="")
  _wrap_assertion do
    assert_equal(Class, klass.class, "assert_instance_of takes a Class as its first argument")
    full_message = build_message(message, <<EOT, object, klass, object.class)
<?> expected to be an instance of
<?> but was
<?>.
EOT
    assert_block(full_message){object.instance_of?(klass)}
  end
end

#assert_kind_of(klass, object, message = "") ⇒ Object



179
180
181
182
183
184
185
# File 'lib/rspec/unit/assertions.rb', line 179

def assert_kind_of(klass, object, message="")
  _wrap_assertion do
    assert(klass.kind_of?(Module), "The first parameter to assert_kind_of should be a kind_of Module.")
    full_message = build_message(message, "<?>\nexpected to be kind_of\\?\n<?> but was\n<?>.", object, klass, object.class)
    assert_block(full_message){object.kind_of?(klass)}
  end
end

#assert_match(pattern, string, message = "") ⇒ Object



217
218
219
220
221
222
223
224
225
226
227
228
# File 'lib/rspec/unit/assertions.rb', line 217

def assert_match(pattern, string, message="")
  _wrap_assertion do
    pattern = case(pattern)
      when String
        Regexp.new(Regexp.escape(pattern))
      else
        pattern
    end
    full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
    assert_block(full_message) { string =~ pattern }
  end
end

#assert_nil(object, message = "") ⇒ Object



168
169
170
# File 'lib/rspec/unit/assertions.rb', line 168

def assert_nil(object, message="")
  assert_equal(nil, object, message)
end

#assert_no_match(regexp, string, message = "") ⇒ Object



361
362
363
364
365
366
367
# File 'lib/rspec/unit/assertions.rb', line 361

def assert_no_match(regexp, string, message="")
  _wrap_assertion do
    assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
    full_message = build_message(message, "<?> expected to not match\n<?>.", regexp, string)
    assert_block(full_message) { regexp !~ string }
  end
end

#assert_not_equal(expected, actual, message = "") ⇒ Object



337
338
339
340
# File 'lib/rspec/unit/assertions.rb', line 337

def assert_not_equal(expected, actual, message="")
  full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
  assert_block(full_message) { expected != actual }
end

#assert_not_nil(object, message = "") ⇒ Object



349
350
351
352
# File 'lib/rspec/unit/assertions.rb', line 349

def assert_not_nil(object, message="")
  full_message = build_message(message, "<?> expected to not be nil.", object)
  assert_block(full_message){!object.nil?}
end

#assert_not_same(expected, actual, message = "") ⇒ Object



320
321
322
323
324
325
326
327
328
# File 'lib/rspec/unit/assertions.rb', line 320

def assert_not_same(expected, actual, message="")
  full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
<?>
with id <?> expected to not be equal\\? to
<?>
with id <?>.
EOT
  assert_block(full_message) { !actual.equal?(expected) }
end

#assert_nothing_raised(*args) ⇒ Object



280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
# File 'lib/rspec/unit/assertions.rb', line 280

def assert_nothing_raised(*args)
  _wrap_assertion do
    if Module === args.last
      message = ""
    else
      message = args.pop
    end
    exceptions, modules = _check_exception_class(args)
    begin
      yield
    rescue Exception => e
      if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
          _expected_exception?(e, exceptions, modules))
        assert_block(build_message(message, "Exception raised:\n?", e)){false}
      else
        raise
      end
    end
    nil
  end
end

#assert_nothing_thrown(message = "", &proc) ⇒ Object



413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
# File 'lib/rspec/unit/assertions.rb', line 413

def assert_nothing_thrown(message="", &proc)
  _wrap_assertion do
    assert(block_given?, "Should have passed a block to assert_nothing_thrown")
    begin
      proc.call
    rescue ArgumentError, NameError, ThreadError => error
      if UncaughtThrow[error.class] !~ error.message
        raise error
      end
      full_message = build_message(message, "<?> was thrown when nothing was expected", $1.to_sym)
      flunk(full_message)
    end
    assert(true, "Expected nothing to be thrown")
  end
end

#assert_operator(object1, operator, object2, message = "") ⇒ Object



258
259
260
261
262
263
264
265
266
267
268
269
# File 'lib/rspec/unit/assertions.rb', line 258

def assert_operator(object1, operator, object2, message="")
  _wrap_assertion do
    full_message = build_message(nil, "<?>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
    assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
    full_message = build_message(message, <<EOT, object1, AssertionMessage.literal(operator), object2)
<?> expected to be
?
<?>.
EOT
    assert_block(full_message) { object1.__send__(operator, object2) }
  end
end

#assert_raise(*args) ⇒ Object



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
# File 'lib/rspec/unit/assertions.rb', line 107

def assert_raise(*args)
  _wrap_assertion do
    if Module === args.last
      message = ""
    else
      message = args.pop
    end
    exceptions, modules = _check_exception_class(args)
    expected = args.size == 1 ? args.first : args
    actual_exception = nil
    full_message = build_message(message, "<?> exception expected but none was thrown.", expected)
    assert_block(full_message) do
      begin
        yield
      rescue Exception => actual_exception
        break
      end
      false
    end
    full_message = build_message(message, "<?> exception expected but was\n?", expected, actual_exception)
    assert_block(full_message) {_expected_exception?(actual_exception, exceptions, modules)}
    actual_exception
  end
end

#assert_raises(*args, &block) ⇒ Object



138
139
140
# File 'lib/rspec/unit/assertions.rb', line 138

def assert_raises(*args, &block)
  assert_raise(*args, &block)
end

#assert_respond_to(object, method, message = "") ⇒ Object



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
# File 'lib/rspec/unit/assertions.rb', line 194

def assert_respond_to(object, method, message="")
  _wrap_assertion do
    full_message = build_message(nil, "<?>\ngiven as the method name argument to #assert_respond_to must be a Symbol or #respond_to\\?(:to_str).", method)

    assert_block(full_message) do
      method.kind_of?(Symbol) || method.respond_to?(:to_str)
    end
    full_message = build_message(message, <<EOT, object, object.class, method)
<?>
of type <?>
expected to respond_to\\?<?>.
EOT
    assert_block(full_message) { object.respond_to?(method) }
  end
end

#assert_same(expected, actual, message = "") ⇒ Object



239
240
241
242
243
244
245
246
247
# File 'lib/rspec/unit/assertions.rb', line 239

def assert_same(expected, actual, message="")
  full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
<?>
with id <?> expected to be equal\\? to
<?>
with id <?>.
EOT
  assert_block(full_message) { actual.equal?(expected) }
end

#assert_send(send_array, message = "") ⇒ Object



464
465
466
467
468
469
470
471
472
473
474
# File 'lib/rspec/unit/assertions.rb', line 464

def assert_send(send_array, message="")
  _wrap_assertion do
    assert_instance_of(Array, send_array, "assert_send requires an array of send information")
    assert(send_array.size >= 2, "assert_send requires at least a receiver and a message name")
    full_message = build_message(message, <<EOT, send_array[0], AssertionMessage.literal(send_array[1].to_s), send_array[2..-1])
<?> expected to respond to
<?(?)> with a true value.
EOT
    assert_block(full_message) { send_array[0].__send__(send_array[1], *send_array[2..-1]) }
  end
end

#assert_throws(expected_symbol, message = "", &proc) ⇒ Object



382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
# File 'lib/rspec/unit/assertions.rb', line 382

def assert_throws(expected_symbol, message="", &proc)
  _wrap_assertion do
    assert_instance_of(Symbol, expected_symbol, "assert_throws expects the symbol that should be thrown for its first argument")
    assert_block("Should have passed a block to assert_throws."){block_given?}
    caught = true
    begin
      catch(expected_symbol) do
        proc.call
        caught = false
      end
      full_message = build_message(message, "<?> should have been thrown.", expected_symbol)
      assert_block(full_message){caught}
    rescue ArgumentError, NameError, ThreadError => error
      if UncaughtThrow[error.class] !~ error.message
        raise error
      end
      full_message = build_message(message, "<?> expected to be thrown but\n<?> was thrown.", expected_symbol, $1.to_sym)
      flunk(full_message)
    end
  end
end

#build_message(head, template = nil, *arguments) ⇒ Object



481
482
483
484
# File 'lib/rspec/unit/assertions.rb', line 481

def build_message(head, template=nil, *arguments)
  template &&= template.chomp
  return AssertionMessage.new(head, template, arguments)
end

#flunk(message = "Flunked") ⇒ Object



309
310
311
# File 'lib/rspec/unit/assertions.rb', line 309

def flunk(message="Flunked")
  assert_block(build_message(message)){false}
end