Methods

Included Modules

Constants

Assertion = Minitest::Assertion

Class Public methods

fixture_paths

Returns the ActiveRecord::FixtureSet collection.

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

πŸ”Ž See on GitHub

fixture_paths=(fixture_paths)

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".

πŸ”Ž See on GitHub

parallel_worker_id()

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

ActiveSupport::TestCase.parallel_worker_id # => 2
πŸ“ Source code
# File activesupport/lib/active_support/test_case.rb, line 34
      def parallel_worker_id
        @@parallel_worker_id
      end
πŸ”Ž See on GitHub

parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases)

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.

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 code
# File activesupport/lib/active_support/test_case.rb, line 107
      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases)
        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)
      end
πŸ”Ž See on GitHub

parallelize_before_fork(&block)

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
    # run this before fork
  end
end
πŸ“ Source code
# File activesupport/lib/active_support/test_case.rb, line 132
      def parallelize_before_fork(&block)
        ActiveSupport::Testing::Parallelization.before_fork_hook(&block)
      end
πŸ”Ž See on GitHub

parallelize_setup(&block)

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
    # create databases
  end
end
πŸ“ Source code
# File activesupport/lib/active_support/test_case.rb, line 149
      def parallelize_setup(&block)
        ActiveSupport::Testing::Parallelization.after_fork_hook(&block)
      end
πŸ”Ž See on GitHub

parallelize_teardown(&block)

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
πŸ“ Source code
# File activesupport/lib/active_support/test_case.rb, line 166
      def parallelize_teardown(&block)
        ActiveSupport::Testing::Parallelization.run_cleanup_hook(&block)
      end
πŸ”Ž See on GitHub

test_order()

Returns the order in which test cases are run.

ActiveSupport::TestCase.test_order # => :random

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

πŸ“ Source code
# File activesupport/lib/active_support/test_case.rb, line 61
      def test_order
        ActiveSupport.test_order ||= :random
      end
πŸ”Ž See on GitHub

test_order=(new_order)

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)

πŸ“ Source code
# File activesupport/lib/active_support/test_case.rb, line 51
      def test_order=(new_order)
        ActiveSupport.test_order = new_order
      end
πŸ”Ž See on GitHub

Instance Public methods

assert_no_match(matcher, obj, msg = nil)

Alias for: refute_match

πŸ”Ž See on GitHub

assert_not_empty(obj, msg = nil)

Alias for: refute_empty

πŸ”Ž See on GitHub

assert_not_equal(exp, act, msg = nil)

Alias for: refute_equal

πŸ”Ž See on GitHub

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

Alias for: refute_in_delta

πŸ”Ž See on GitHub

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

Alias for: refute_in_epsilon

πŸ”Ž See on GitHub

assert_not_includes(collection, obj, msg = nil)

Alias for: refute_includes

πŸ”Ž See on GitHub

assert_not_instance_of(cls, obj, msg = nil)

Alias for: refute_instance_of

πŸ”Ž See on GitHub

assert_not_kind_of(cls, obj, msg = nil)

Alias for: refute_kind_of

πŸ”Ž See on GitHub

assert_not_nil(obj, msg = nil)

Alias for: refute_nil

πŸ”Ž See on GitHub

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

Alias for: refute_operator

πŸ”Ž See on GitHub

assert_not_predicate(o1, op, msg = nil)

Alias for: refute_predicate

πŸ”Ž See on GitHub

assert_not_respond_to(obj, meth, msg = nil)

Alias for: refute_respond_to

πŸ”Ž See on GitHub

assert_not_same(exp, act, msg = nil)

Alias for: refute_same

πŸ”Ž See on GitHub

parallel_worker_id()

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

πŸ“ Source code
# File activesupport/lib/active_support/test_case.rb, line 193
    def parallel_worker_id
      self.class.parallel_worker_id
    end
πŸ”Ž See on GitHub