Class: ActiveSupport::TestCase

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

Constant Summary collapse

Assertion = 
Minitest::Assertion
@@parallel_worker_id =

Class variable to store the parallel worker ID

nil

Constants included from ActiveSupport::Testing::Assertions

ActiveSupport::Testing::Assertions::UNTRACKED

Class Method Summary collapse

Instance 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, #prepend_features, #prepended

Methods included from ActiveSupport::Testing::TimeHelpers

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

Methods included from ActiveSupport::Testing::ConstantStubbing

#stub_const

Methods included from ActiveSupport::Testing::Deprecation

#assert_deprecated, #assert_not_deprecated, #collect_deprecations

Methods included from ActiveSupport::Testing::NotificationAssertions

#assert_no_notifications, #assert_notification, #assert_notifications_count, #capture_notifications

Methods included from ActiveSupport::Testing::EventReporterAssertions

#assert_event_reported, #assert_events_reported, #assert_no_event_reported, #with_debug_event_reporting

Methods included from ActiveSupport::Testing::ErrorReporterAssertions

#assert_error_reported, #assert_no_error_reported, #capture_error_reports

Methods included from ActiveSupport::Testing::Assertions

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

Methods included from ActiveSupport::Testing::TaggedLogging

#before_setup

Methods included from ActiveSupport::Testing::SetupAndTeardown

#after_teardown, #before_setup, prepended

Methods included from ActiveSupport::Testing::TestsWithoutAssertions

#after_teardown

Class Method Details

.parallel_worker_id ⇒ Object

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

ActiveSupport::TestCase.parallel_worker_id # => 2



34
35
36
 
# File 'lib/active_support/test_case.rb', line 34

def parallel_worker_id
  @@parallel_worker_id
end

.parallel_worker_id=(value) ⇒ Object

:nodoc:



38
39
40
 
# File 'lib/active_support/test_case.rb', line 38

def parallel_worker_id=(value) # :nodoc:
  @@parallel_worker_id = value
end

.parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases) ⇒ 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 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.



107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File '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

.parallelize_before_fork(&block) ⇒ Object

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



132
133
134
 
# File 'lib/active_support/test_case.rb', line 132

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

.parallelize_setup(&block) ⇒ Object

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



149
150
151
 
# File 'lib/active_support/test_case.rb', line 149

def parallelize_setup(&block)
  ActiveSupport::Testing::Parallelization.after_fork_hook(&block)
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



166
167
168
 
# File 'lib/active_support/test_case.rb', line 166

def parallelize_teardown(&block)
  ActiveSupport::Testing::Parallelization.run_cleanup_hook(&block)
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.



61
62
63
 
# File 'lib/active_support/test_case.rb', line 61

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)



51
52
53
 
# File 'lib/active_support/test_case.rb', line 51

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

Instance Method Details

#inspect ⇒ Object

:nodoc:



355
356
357
 
# File 'lib/active_support/test_case.rb', line 355

def inspect # :nodoc:
  Object.instance_method(:to_s).bind_call(self)
end

#parallel_worker_id ⇒ Object

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



193
194
195
 
# File 'lib/active_support/test_case.rb', line 193

def parallel_worker_id
  self.class.parallel_worker_id
end