Class: Test::Unit::TestCase

Inherits:
Object
  • Object
show all
Includes:
Assertions, Attribute, Data, ErrorHandler, ExceptionHandler, FailureHandler, Fixture, Priority, TestCaseNotificationSupport, TestCaseOmissionSupport, TestCasePendingSupport, Util::BacktraceFilter, Util::Output
Defined in:
lib/test/unit/testcase.rb,
lib/test/unit/testcase.rb,
lib/test/unit/testcase.rb,
lib/test/unit/testcase.rb

Overview

Ties everything together. If you subclass and add your own test methods, it takes care of making them into tests and wrapping those tests into a suite. It also does the nitty-gritty of actually running an individual test and collecting its results into a Test::Unit::TestResult object.

You can run two hooks before/after a TestCase run.

Example:

class TestMyClass < Test::Unit::TestCase
  class << self
    def startup
      ...
    end

    def shutdown
      ...
    end
  end

  def setup
    ...
  end

  def cleanup
    ...
  end

  def teardown
    ...
  end

  def test_my_method1
    ...
  end

  def test_my_method2
    ...
  end
end

Here is a call order:

  1. startup
  2. setup
  3. test_my_method1
  4. cleanup
  5. teardown
  6. setup
  7. test_my_method2
  8. cleanup
  9. teardown
  10. shutdown

You can set an attribute to each test.

Example:

class TestMyClass < Test::Unit::TestCase
  attribute :speed, :fast
  def test_my_fast_method
    # You can get the attribute via `self[]`
    self[:speed] # => :fast
    ...
  end

  attribute :speed, :slow
  def test_my_slow_method
    self[:speed] # => :slow
    ...
  end
end

Defined Under Namespace

Classes: InternalData

Constant Summary

STARTED =

:nodoc:

name + "::STARTED"
FINISHED =

:nodoc:

name + "::FINISHED"
STARTED_OBJECT =

:nodoc:

name + "::STARTED::OBJECT"
FINISHED_OBJECT =

:nodoc:

name + "::FINISHED::OBJECT"
DESCENDANTS =

:nodoc:

[]
AVAILABLE_ORDERS =

:nodoc:

[:alphabetic, :random, :defined]
@@added_methods =
{}
@@test_orders =
{}
@@added_method_names =
{}

Constants included from Util::BacktraceFilter

Util::BacktraceFilter::POWERASSERT_PREFIX, Util::BacktraceFilter::TESTUNIT_FILE_SEPARATORS, Util::BacktraceFilter::TESTUNIT_PREFIX, Util::BacktraceFilter::TESTUNIT_RB_FILE

Constants included from ErrorHandler

ErrorHandler::NOT_PASS_THROUGH_EXCEPTIONS, ErrorHandler::NOT_PASS_THROUGH_EXCEPTION_NAMES, ErrorHandler::PASS_THROUGH_EXCEPTIONS, ErrorHandler::PASS_THROUGH_EXCEPTION_NAMES

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Util::Output

#capture_output

Methods included from Util::BacktraceFilter

filter_backtrace

Methods included from Assertions

#assert, #assert_alias_method, #assert_block, #assert_boolean, #assert_compare, #assert_const_defined, #assert_empty, #assert_equal, #assert_fail_assertion, #assert_false, #assert_in_delta, #assert_in_epsilon, #assert_include, #assert_instance_of, #assert_kind_of, #assert_match, #assert_nil, #assert_no_match, #assert_not_const_defined, #assert_not_empty, #assert_not_equal, #assert_not_in_delta, #assert_not_in_epsilon, #assert_not_include, #assert_not_instance_of, #assert_not_kind_of, #assert_not_match, #assert_not_nil, #assert_not_operator, #assert_not_predicate, #assert_not_respond_to, #assert_not_same, #assert_not_send, #assert_nothing_raised, #assert_nothing_thrown, #assert_operator, #assert_path_exist, #assert_path_not_exist, #assert_predicate, #assert_raise, #assert_raise_kind_of, #assert_raise_message, #assert_respond_to, #assert_same, #assert_send, #assert_throw, #assert_true, #build_message, #flunk, #refute, use_pp=

Methods included from Priority

available_values, default, default=, disable, enable, enabled?, #priority_setup, #priority_teardown

Methods included from TestCaseNotificationSupport

#notify

Methods included from TestCaseOmissionSupport

#omit, #omit_if, #omit_unless

Methods included from TestCasePendingSupport

#pend

Methods included from FailureHandler

#add_failure

Methods included from ExceptionHandler

exception_handlers

Methods included from Attribute

#[], #attributes

Constructor Details

#initialize(test_method_name) ⇒ TestCase

Creates a new instance of the fixture for running the test represented by test_method_name.



401
402
403
404
# File 'lib/test/unit/testcase.rb', line 401

def initialize(test_method_name)
  @method_name = test_method_name
  @internal_data = InternalData.new
end

Instance Attribute Details

#method_nameObject (readonly)

Returns the value of attribute method_name



397
398
399
# File 'lib/test/unit/testcase.rb', line 397

def method_name
  @method_name
end

Class Method Details

.added_method_namesObject

:nodoc:



135
136
137
# File 'lib/test/unit/testcase.rb', line 135

def added_method_names # :nodoc:
  (@@added_method_names[self] ||= {}).keys
end

.added_methodsObject

:nodoc:



136
137
138
# File 'lib/test/unit/testcase.rb', line 136

def added_methods # :nodoc:
  @@added_methods[self] ||= []
end

.description(value, target = nil) ⇒ Object

Describes a test.

The following example associates “register a normal user” description with “test_register” test.

description “register a normal user” def test_register … end



298
299
300
301
# File 'lib/test/unit/testcase.rb', line 298

def description(value, target=nil)
  targets = [target].compact
  attribute(:description, value, {}, *targets)
end

.find_locations(query) ⇒ Object



378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
# File 'lib/test/unit/testcase.rb', line 378

def find_locations(query)
  query_path = query[:path]
  query_line = query[:line]
  query_method_name = query[:method_name]

  available_locations = target_method_locations(query_path)
  if query_line
    available_locations = available_locations.sort_by do |location|
      -location[:line]
    end
    available_location = available_locations.find do |location|
      query_line >= location[:line]
    end
    return [] if available_location.nil?
    return [] if available_location[:test_case] != self
    available_locations = [available_location]
  end
  if query_method_name
    available_location = available_locations.find do |location|
      query_method_name == location[:method_name]
    end
    return [] if available_location.nil?
    available_locations = [available_location]
  end

  available_locations
end

.inherited(sub_class) ⇒ Object

:nodoc:



106
107
108
109
110
# File 'lib/test/unit/testcase.rb', line 106

def inherited(sub_class) # :nodoc:
  require "test/unit"
  DESCENDANTS << sub_class
  super
end

.method_added(name) ⇒ Object

:nodoc:



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
# File 'lib/test/unit/testcase.rb', line 113

def method_added(name) # :nodoc:
  super
  _added_methods = added_methods
  stringified_name = name.to_s
  if _added_methods.include?(stringified_name)
    attribute(:redefined, {:backtrace => caller}, {}, stringified_name)
  end
  _attributes = attributes_table[stringified_name] || {}
  source_location = _attributes[:source_location]
  if source_location
    path, line = source_location
  else
    path, line, = caller[0].split(/:(\d+)/,2)
    line = line.to_i if line
  end
  method_locations << {
    :method_name => stringified_name,
    :path => path,
    :line => line,
  }
  _added_methods << stringified_name
end

.shutdownObject

Called after every test case runs. Can be used to tear down fixture information used in test case scope.

Here is an example test case: class TestMyClass < Test::Unit::TestCase class « self def shutdown … end end

def teardown
  ...
end

def test_my_class1
  ...
end

def test_my_class2
  ...
end   end

Here is a call order: * test_my_class1 (or test_my_class2) * teardown * test_my_class2 (or test_my_class1) * teardown * shutdown

Note that you should not assume test order. Tests should be worked in any order.



218
219
# File 'lib/test/unit/testcase.rb', line 218

def shutdown
end

.startupObject

Called before every test case runs. Can be used to set up fixture information used in test case scope.

Here is an example test case: class TestMyClass < Test::Unit::TestCase class « self def startup … end end

def setup
  ...
end

def test_my_class1
  ...
end

def test_my_class2
  ...
end   end

Here is a call order: * startup * setup * test_my_class1 (or test_my_class2) * setup * test_my_class2 (or test_my_class1)

Note that you should not assume test order. Tests should be worked in any order.



182
183
# File 'lib/test/unit/testcase.rb', line 182

def startup
end

.sub_test_case(name) { ... } ⇒ Test::Unit::TestCase

Defines a sub test case.

This is a syntax sugar. The both of the following codes are the same in meaning:

Standard: class TestParent < Test::Unit::TestCase class TestChild < self def test_in_child end end end

Syntax sugar: class TestParent < Test::Unit::TestCase sub_test_case(“TestChild”) do def test_in_child end end end

The difference of them are the following:

  • Test case created by sub_test_case is an anonymous class. So you can’t refer the test case by name.
  • The class name of class style must follow constant naming rule in Ruby. But the name of test case created by sub_test_case doesn’t need to follow the rule. For example, you can use a space in name such as “child test”.

Parameters:

  • name (String)

    The name of newly created sub test case.

Yields:

  • The block is evaluated under the newly created sub test case class context.

Returns:



338
339
340
341
342
343
344
345
346
347
348
# File 'lib/test/unit/testcase.rb', line 338

def sub_test_case(name, &block)
  parent_test_case = self
  sub_test_case = Class.new(self) do
    singleton_class = class << self; self; end
    singleton_class.send(:define_method, :name) do
      [parent_test_case.name, name].compact.join("::")
    end
  end
  sub_test_case.class_eval(&block)
  sub_test_case
end

.suiteObject

Rolls up all of the test* methods in the fixture into one suite, creating a new instance of the fixture for each method.



143
144
145
146
# File 'lib/test/unit/testcase.rb', line 143

def suite
  suite_creator = TestSuiteCreator.new(self)
  suite_creator.create
end

.test(*test_description_or_targets, &block) ⇒ Object

Defines a test in declarative syntax or marks following method as a test method.

In declarative syntax usage, the following two test definitions are the almost same:

description “register user” def test_register_user … end

test “register user” do … end

In test method mark usage, the “my_test_method” is treated as a test method:

test def my_test_method assert_equal(“call me”, …) end



264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
# File 'lib/test/unit/testcase.rb', line 264

def test(*test_description_or_targets, &block)
  if block_given?
    test_description = test_description_or_targets.first
    if test_description.nil?
      raise ArgumentError, "test description is missing"
    end
    n_arguments = test_description_or_targets.size
    if n_arguments > 1
      message = "wrong number of arguments (#{n_arguments} for 1)"
      raise ArgumentError, message
    end
    method_name = "test: #{test_description}"
    description(test_description, method_name)
    attribute(:test, true, {}, method_name)
    if block.respond_to?(:source_location)
      attribute(:source_location, block.source_location, {}, method_name)
    end
    define_method(method_name, &block)
  else
    targets = test_description_or_targets
    attribute(:test, true, {}, *targets)
  end
end

.test_defined?(query) ⇒ Boolean

Checks whether a test that is matched the query is defined.

Parameters:

  • query (Hash)

    a customizable set of options

Options Hash (query):

  • :path (String) — default: nil

    the path where a test is defined in.

  • :line (Numeric) — default: nil

    the line number where a test is defined at.

  • :method_name (String) — default: nil

    the method name for a test.

Returns:

  • (Boolean)


359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
# File 'lib/test/unit/testcase.rb', line 359

def test_defined?(query)
  query_path = query[:path]
  query_line = query[:line]
  query_method_name = query[:method_name]

  available_locations = method_locations
  if query_path
    available_locations = available_locations.find_all do |location|
      location[:path].end_with?(query_path)
    end
  end
  if query_line
    available_location = available_locations.reverse.find do |location|
      query_line >= location[:line]
    end
    return false if available_location.nil?
    available_locations = [available_location]
  end
  if query_method_name
    available_location = available_locations.find do |location|
      query_method_name == location[:method_name]
    end
    return false if available_location.nil?
    available_locations = [available_location]
  end

  not available_locations.empty?
end

.test_orderObject

Returns the current test order. This returns +:alphabetic+ by default.



225
226
227
# File 'lib/test/unit/testcase.rb', line 225

def test_order
  @@test_orders[self] || AVAILABLE_ORDERS.first
end

.test_order=(order) ⇒ Object

Sets the current test order.

Here are the available order: [:alphabetic] Default. Tests are sorted in alphabetic order. [:random] Tests are sorted in random order. [:defined] Tests are sorted in defined order.



238
239
240
# File 'lib/test/unit/testcase.rb', line 238

def test_order=(order)
  @@test_orders[self] = order
end

Instance Method Details

#==(other) ⇒ Object

It’s handy to be able to compare TestCase instances.



631
632
633
634
635
636
# File 'lib/test/unit/testcase.rb', line 631

def ==(other)
  return false unless other.kind_of?(self.class)
  return false unless @method_name == other.method_name
  return false unless data_label == other.data_label
  self.class == other.class
end

#add_passvoid

This method returns an undefined value.

Notify that the test is passed. Normally, it is not needed because #run calls it automatically. If you want to override #run, it is not a good idea. Please contact test-unit developers. We will help you without your custom #run. For example, we may add a new hook in #run.

This is a public API for developers who extend test-unit.



680
681
682
# File 'lib/test/unit/testcase.rb', line 680

def add_pass
  current_result.add_pass
end

#assign_test_data(label, data) ⇒ Object

Assigns test data to the test. It is used in internal.



407
408
409
# File 'lib/test/unit/testcase.rb', line 407

def assign_test_data(label, data) # :nodoc:
  @internal_data.assign_test_data(label, data)
end

#cleanupObject

Called after every test method runs but the test method isn’t marked as ‘passed’. Can be used to clean up and/or verify tested condition. e.g. Can be used to verify mock.

You can add additional cleanup tasks by the following code: class TestMyClass < Test::Unit::TestCase def cleanup … end

cleanup
def my_cleanup1
  ...
end

cleanup do
  ... # cleanup callback1
end

cleanup
def my_cleanup2
  ...
end

cleanup do
  ... # cleanup callback2
end

def test_my_class
  ...
end   end

Here is a call order: * test_my_class * cleanup callback2 * my_cleanup2 * cleanup callback1 * my_cleanup1 * cleanup



545
546
# File 'lib/test/unit/testcase.rb', line 545

def cleanup
end

#data_labelObject

Returns a label of test data for the test. If the test isn’t associated with any test data, it returns +nil+.



602
603
604
# File 'lib/test/unit/testcase.rb', line 602

def data_label
  @internal_data.test_data_label
end

#default_testObject



591
592
593
# File 'lib/test/unit/testcase.rb', line 591

def default_test
  flunk("No tests were specified")
end

#descriptionObject

Returns a description for the test. A description will be associated by Test::Unit::TestCase.test or Test::Unit::TestCase.description.

Returns a name for the test for no description test.



621
622
623
# File 'lib/test/unit/testcase.rb', line 621

def description
  self[:description] || name
end

#elapsed_timeObject

Returns elapsed time for the test was ran.



644
645
646
# File 'lib/test/unit/testcase.rb', line 644

def elapsed_time
  @internal_data.elapsed_time
end

#interrupted?Boolean

Returns whether the test is interrupted.

Returns:

  • (Boolean)


649
650
651
# File 'lib/test/unit/testcase.rb', line 649

def interrupted?
  @internal_data.interrupted?
end

#local_nameObject

Returns a human-readable name for the specific test that this instance of TestCase represents.

#local_name doesn’t include class name. #name includes class name.



672
673
674
675
676
677
678
# File 'lib/test/unit/testcase.rb', line 672

def local_name
  if @internal_data.have_test_data?
    "#{@method_name}[#{data_label}]"
  else
    @method_name.to_s
  end
end

#nameObject

Returns a human-readable name for the specific test that this instance of TestCase represents.



608
609
610
611
612
613
614
# File 'lib/test/unit/testcase.rb', line 608

def name
  if @internal_data.have_test_data?
    "#{@method_name}[#{data_label}](#{self.class.name})"
  else
    "#{@method_name}(#{self.class.name})"
  end
end

#passed?Boolean

Returns whether this individual test passed or not. Primarily for use in teardown so that artifacts can be left behind if the test fails.

Returns:

  • (Boolean)


656
657
658
# File 'lib/test/unit/testcase.rb', line 656

def passed?
  @internal_data.passed?
end

#problem_occurredvoid

This method returns an undefined value.

Notify that a problem is occurred in the test. It means that the test is a failed test. If any failed tests exist in test suites, the test process exits with failure exit status.

This is a public API for developers who extend test-unit.



667
668
669
# File 'lib/test/unit/testcase.rb', line 667

def problem_occurred
  @internal_data.problem_occurred
end

#run(result) ⇒ Object

Runs the individual test method represented by this instance of the fixture, collecting statistics, failures and errors in result.



430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
# File 'lib/test/unit/testcase.rb', line 430

def run(result)
  begin
    @_result = result
    @internal_data.test_started
    yield(STARTED, name)
    yield(STARTED_OBJECT, self)
    begin
      run_setup
      run_test
      run_cleanup
      add_pass
    rescue Exception
      @internal_data.interrupted
      raise unless handle_exception($!)
    ensure
      begin
        run_teardown
      rescue Exception
        raise unless handle_exception($!)
      end
    end
    @internal_data.test_finished
    result.add_run
    yield(FINISHED, name)
    yield(FINISHED_OBJECT, self)
  ensure
    # @_result = nil # For test-spec's after_all :<
  end
end

#setupObject

Called before every test method runs. Can be used to set up fixture information.

You can add additional setup tasks by the following code: class TestMyClass < Test::Unit::TestCase def setup … end

setup
def my_setup1
  ...
end

setup do
  ... # setup callback1
end

setup
def my_setup2
  ...
end

setup do
  ... # setup callback2
end

def test_my_class
  ...
end   end

Here is a call order: * setup * my_setup1 * setup callback1 * my_setup2 * setup callback2 * test_my_class



500
501
# File 'lib/test/unit/testcase.rb', line 500

def setup
end

#sizeObject



595
596
597
# File 'lib/test/unit/testcase.rb', line 595

def size
  1
end

#start_timeObject

Returns a Time at the test was started.



639
640
641
# File 'lib/test/unit/testcase.rb', line 639

def start_time
  @internal_data.start_time
end

#teardownObject

Called after every test method runs. Can be used to tear down fixture information.

You can add additional teardown tasks by the following code: class TestMyClass < Test::Unit::TestCase def teardown … end

teardown
def my_teardown1
  ...
end

teardown do
  ... # teardown callback1
end

teardown
def my_teardown2
  ...
end

teardown do
  ... # teardown callback2
end

def test_my_class
  ...
end   end

Here is a call order: * test_my_class * teardown callback2 * my_teardown2 * teardown callback1 * my_teardown1 * teardown



588
589
# File 'lib/test/unit/testcase.rb', line 588

def teardown
end

#to_sObject

Overridden to return #name.



626
627
628
# File 'lib/test/unit/testcase.rb', line 626

def to_s
  name
end

#valid?Boolean

Returns the test is valid test. It is used in internal.

Returns:

  • (Boolean)


412
413
414
415
416
417
418
419
420
421
422
423
424
425
# File 'lib/test/unit/testcase.rb', line 412

def valid? # :nodoc:
  return false unless respond_to?(@method_name)
  test_method = method(@method_name)
  if @internal_data.have_test_data?
    return false unless test_method.arity == 1
  else
    return false unless test_method.arity <= 0
  end
  owner = Util::MethodOwnerFinder.find(self, @method_name)
  if owner.class != Module and self.class != owner
    return false
  end
  true
end