ActiveSupport::TestCase (original) (raw)

Methods

A

F

P

T

Included Modules

Constants

Assertion = Minitest::Assertion

Class Public methods

Sets the given path to the fixture set.

Can also append multiple paths.

ActiveSupport::TestCase.fixture_paths << "component1/test/fixtures"

In your test_helper.rb you must have require "rails/test_help".

Returns the current parallel worker ID if tests are running in parallel, nil otherwise.

ActiveSupport::TestCase.parallel_worker_id

Source: show | on GitHub

def parallel_worker_id @@parallel_worker_id end

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 databases and will not work with system tests.

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

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

Because parallelization presents an overhead, it is only enabled when the number of tests to run is above the threshold param. The default value is 50, and it’s configurable via config.active_support.test_parallelization_threshold.

Parallelization shuffles tests and distributes them to workers in round-robin order, so given the same seed value and worker count, the same sequence of tests will run on each worker. This makes flaky tests caused by parallel test interdependence somewhat easier to reproduce, though it is not a guarantee of deterministic test execution.

This can make test runtime slower and spikier when one worker gets most of the slow tests. Enable work_stealing to allow idle workers to steal tests from busy workers, smoothing out runtime at the cost of less reproducible flaky-test failures:

parallelize(workers: :number_of_processors, work_stealing: true)

If you want to skip Rails default creation of one database per process in favor of writing your own implementation, you can set parallelize_databases, or configure it via config.active_support.parallelize_test_databases.

parallelize(workers: :number_of_processors, parallelize_databases: false)

Note that your test suite may deadlock if you attempt to use only one database with multiple processes.

Source: show | on GitHub

def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases, work_stealing: false) case when ENV["PARALLEL_WORKERS"] workers = ENV["PARALLEL_WORKERS"].to_i when workers == :number_of_processors workers = (Concurrent.available_processor_count || Concurrent.processor_count).floor end

if with == :processes ActiveSupport.parallelize_test_databases = parallelize_databases end

Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold, work_stealing: work_stealing) end

Before fork hook for parallel testing. This can be used to run anything before the processes are forked.

In your test_helper.rb add the following:

class ActiveSupport::TestCase parallelize_before_fork do

end end

Source: show | on GitHub

def parallelize_before_fork(&block) ActiveSupport::Testing::Parallelization.before_fork_hook(&block) end

Setup 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

end end

Source: show | on GitHub

def parallelize_setup(&block) ActiveSupport::Testing::Parallelization.after_fork_hook(&block) end

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

end end

Source: show | on GitHub

def parallelize_teardown(&block) ActiveSupport::Testing::Parallelization.run_cleanup_hook(&block) end

Returns the order in which test cases are run.

ActiveSupport::TestCase.test_order

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

Source: show | on GitHub

def test_order ActiveSupport.test_order ||= :random end

Sets the order in which test cases are run.

ActiveSupport::TestCase.test_order = :random

Valid values are:

Source: show | on GitHub

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

Instance Public methods

assert_no_match(matcher, obj, msg = nil) Link

assert_not_empty(obj, msg = nil) Link

assert_not_equal(exp, act, msg = nil) Link

assert_not_in_delta(exp, act, delta = 0.001, msg = nil) Link

assert_not_in_epsilon(a, b, epsilon = 0.001, msg = nil) Link

assert_not_includes(collection, obj, msg = nil) Link

assert_not_instance_of(cls, obj, msg = nil) Link

assert_not_kind_of(cls, obj, msg = nil) Link

assert_not_nil(obj, msg = nil) Link

assert_not_operator(o1, op, o2 = UNDEFINED, msg = nil) Link

assert_not_predicate(o1, op, msg = nil) Link

assert_not_respond_to(obj, meth, msg = nil) Link

assert_not_same(exp, act, msg = nil) Link

Returns the current parallel worker ID if tests are running in parallel

Source: show | on GitHub

def parallel_worker_id self.class.parallel_worker_id end