Class: ActiveSupport::TestCase

Inherits:
Minitest::Test
  • Object
show all
Extended by:
ActiveSupport::Testing::Declarative
Includes:
ActiveSupport::Testing::Assertions, ActiveSupport::Testing::Deprecation, ActiveSupport::Testing::FileFixtures, ActiveSupport::Testing::SetupAndTeardown, ActiveSupport::Testing::TaggedLogging, ActiveSupport::Testing::TimeHelpers
Defined in:
lib/active_support/test_case.rb

Constant Summary collapse

Assertion = 
Minitest::Assertion

Constants included from ActiveSupport::Testing::Assertions

ActiveSupport::Testing::Assertions::UNTRACKED

Class Method Summary collapse

Methods included from ActiveSupport::Testing::Declarative

test

Methods included from ActiveSupport::Testing::FileFixtures

#file_fixture

Methods included from Concern

#append_features, #class_methods, extended, #included

Methods included from ActiveSupport::Testing::TimeHelpers

#after_teardown, #freeze_time, #travel, #travel_back, #travel_to

Methods included from ActiveSupport::Testing::Deprecation

#assert_deprecated, #assert_not_deprecated, #collect_deprecations

Methods included from ActiveSupport::Testing::Assertions

#assert_changes, #assert_difference, #assert_no_changes, #assert_no_difference, #assert_not, #assert_nothing_raised

Methods included from ActiveSupport::Testing::TaggedLogging

#before_setup

Methods included from ActiveSupport::Testing::SetupAndTeardown

#after_teardown, #before_setup, prepended

Class Method Details

.parallelize(workers: :number_of_processors, with: :processes) ⇒ Object

Parallelizes the test suite.

Takes a workers argument that controls how many times the process is forked. For each process a new database will be created suffixed with the worker number.

test-database-0
test-database-1

If ENV["PARALLEL_WORKERS"] is set the workers argument will be ignored and the environment variable will be used instead. This is useful for CI environments, or other environments where you may need more workers than you do for local testing.

If the number of workers is set to 1 or fewer, the tests will not be parallelized.

If workers is set to :number_of_processors, the number of workers will be set to the actual core count on the machine you are on.

The default parallelization method is to fork processes. If you’d like to use threads instead you can pass with: :threads to the parallelize method. Note the threaded parallelization does not create multiple database and will not work with system tests at this time.

parallelize(workers: :number_of_processors, with: :threads)

The threaded parallelization uses minitest’s parallel executor directly. The processes parallelization uses a Ruby DRb server.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/active_support/test_case.rb', line 74

def parallelize(workers: :number_of_processors, with: :processes)
  workers = Concurrent.physical_processor_count if workers == :number_of_processors
  workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]

  return if workers <= 1

  executor = case with
             when :processes
               Testing::Parallelization.new(workers)
             when :threads
               Minitest::Parallel::Executor.new(workers)
             else
               raise ArgumentError, "#{with} is not a supported parallelization executor."
  end

  self.lock_threads = false if defined?(self.lock_threads) && with == :threads

  Minitest.parallel_executor = executor

  parallelize_me!
end

.parallelize_setup(&block) ⇒ Object

Set up hook for parallel testing. This can be used if you have multiple databases or any behavior that needs to be run after the process is forked but before the tests run.

Note: this feature is not available with the threaded parallelization.

In your test_helper.rb add the following:

class ActiveSupport::TestCase
  parallelize_setup do
    # create databases
  end
end



109
110
111
112
113
 
# File 'lib/active_support/test_case.rb', line 109

def parallelize_setup(&block)
  ActiveSupport::Testing::Parallelization.after_fork_hook do |worker|
    yield worker
  end
end

.parallelize_teardown(&block) ⇒ Object

Clean up hook for parallel testing. This can be used to drop databases if your app uses multiple write/read databases or other clean up before the tests finish. This runs before the forked process is closed.

Note: this feature is not available with the threaded parallelization.

In your test_helper.rb add the following:

class ActiveSupport::TestCase
  parallelize_teardown do
    # drop databases
  end
end



128
129
130
131
132
 
# File 'lib/active_support/test_case.rb', line 128

def parallelize_teardown(&block)
  ActiveSupport::Testing::Parallelization.run_cleanup_hook do |worker|
    yield worker
  end
end

.test_order ⇒ Object

Returns the order in which test cases are run.

ActiveSupport::TestCase.test_order # => :random

Possible values are :random, :parallel, :alpha, :sorted. Defaults to :random.



41
42
43
 
# File 'lib/active_support/test_case.rb', line 41

def test_order
  ActiveSupport.test_order ||= :random
end

.test_order=(new_order) ⇒ Object

Sets the order in which test cases are run.

ActiveSupport::TestCase.test_order = :random # => :random

Valid values are:

  • :random (to run tests in random order)

  • :parallel (to run tests in parallel)

  • :sorted (to run tests alphabetically by method name)

  • :alpha (equivalent to :sorted)



31
32
33
 
# File 'lib/active_support/test_case.rb', line 31

def test_order=(new_order)
  ActiveSupport.test_order = new_order
end