rspec-core-parallel 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77f7b9d3542750b2b8a90a8f2ec8c8730205432dbdcd2615516684939343d300
-  data.tar.gz: 7107cf809562b46795cb35f720b709d6892ec758bedfeba55e3df22e9214272f
+  metadata.gz: 959cdd2e6744a83648486825d673ea9164f39f2aa0fbafafd2f4b49eda5163ae
+  data.tar.gz: 8657334668c6e6aaeb8ceca2fabf5c413d1860f19379e34d463a26b01bcdb837
 SHA512:
-  metadata.gz: c5243cfee9b3851588bd9cd041a34e9f0f090568b4519bb08942f6f4f82e3ca891b2e99f851192922f7f623728e667cfd6ffe489487733b71271b01e72008114
-  data.tar.gz: 0672ec4583dacff0e6e8a69e1b394b3bb197bc6ff647ef868c1db2a9ba5d7217a55c32d1c30bf6badbd8fd1bd42517049cab0a59029e35a2058ecd66fa33ab68
+  metadata.gz: d12df7ed1e4abe97795bc1643779d16dd9c348458121952733e974340ae5024abe3e7b18840c308294b8955b5294cb77353506276e0428dc5dfd6775f9080430
+  data.tar.gz: '02925aa2a3aff6acbe74d6c499802d247942cbc83336cba8dce061cba2d41fe73a62d230cac84f26e1b2e70ed73f94414a5c264cd509735fa1226644c6816b2e'

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.4.0
+
+* In Rails apps every worker writes to its own log file (`log/test-1.log`,
+  `log/test-2.log`...) instead of `log/test.log`.
+
+## 0.3.0
+
+* `before(:run)` and `after(:run)` hooks, which run once per run: in the main
+  process around the workers in parallel runs, around the `:suite` hooks in
+  sequential runs.
+* SimpleCov merges the coverage of workers that finished more than its
+  `merge_timeout` (10 minutes by default) before the slowest one.
+
 ## 0.2.1
 
 * No deprecation warning with SimpleCov 1.x, which renamed

data/README.md

@@ -68,6 +68,9 @@ loaded from the schema when needed, like `rails test` does in parallel. Set
 (`maintain_test_schema!` runs before the workers are forked), so on CI create it as usual, e.g. with
 `bin/rails db:create db:schema:load`, rather than with `parallel:create`.
 
+**Logs.** In Rails apps every worker writes to its own log file (`log/test-1.log`, `log/test-2.log`, ...), so that the
+lines of the workers don't mix in `log/test.log`, which keeps the lines of the main process.
+
 **Other resources.** Each worker gets a `TEST_ENV_NUMBER` environment variable (`""`, `"2"`, `"3"`, ...) as with
 parallel_tests, and runs the `parallel_worker_setup` hooks. Workers are forked after the suite is loaded, so anything
 set up while loading, like a constant with a directory or a Redis client, is the same in all of them. This also applies
@@ -83,7 +86,18 @@ RSpec.configure do |config|
 end
 ```
 
-**Hooks.** `before(:suite)`, `after(:suite)` and `at_exit` hooks run in every worker.
+**Hooks.** `before(:suite)`, `after(:suite)` and `at_exit` hooks run in every worker. For what all the workers share,
+like starting a service or cleaning it up, use `before(:run)` and `after(:run)`: they run once, in the main process,
+before the workers are forked and after they have exited. In sequential runs they run around the `:suite` hooks.
+
+```ruby
+RSpec.configure do |config|
+  config.before(:run) { TestServer.start }
+  config.after(:run) { TestServer.stop }
+end
+```
+
+When a `before(:run)` hook fails, no example runs, but the `after(:run)` hooks still do.
 
 ## Code coverage
 

data/lib/rspec/core/parallel/core_ext.rb

@@ -107,8 +107,74 @@ module RSpec
             Parallel.supported? ? Parallel.default_worker_count : 1
           end
 
+          # `before(:run)` and `after(:run)` hooks run once per run: around the
+          # `:suite` hooks in sequential runs, and in the main process around
+          # the workers in parallel runs, where `:suite` hooks run in every
+          # worker. Use them for what all the workers share, like starting a
+          # service or cleaning it up.
+          def before(scope=nil, *meta, &block)
+            return super unless scope == :run
+
+            run_hooks(:before) << Hooks::BeforeHook.new(block, {})
+          end
+          alias_method :append_before, :before
+
+          def prepend_before(scope=nil, *meta, &block)
+            return super unless scope == :run
+
+            run_hooks(:before).unshift Hooks::BeforeHook.new(block, {})
+          end
+
+          def after(scope=nil, *meta, &block)
+            return super unless scope == :run
+
+            run_hooks(:after).unshift Hooks::AfterHook.new(block, {})
+          end
+          alias_method :prepend_after, :after
+
+          def append_after(scope=nil, *meta, &block)
+            return super unless scope == :run
+
+            run_hooks(:after) << Hooks::AfterHook.new(block, {})
+          end
+
+          def with_suite_hooks
+            return super if parallel_worker_number
+
+            with_run_hooks { super }
+          end
+
+          # @private
+          #
+          # Examples are not run when a `before(:run)` hook fails, but all the
+          # `after(:run)` hooks are, so that everything started is stopped.
+          def with_run_hooks
+            return yield if dry_run?
+
+            begin
+              run_run_hooks('a `before(:run)` hook', run_hooks(:before), :stop_on_failure) ? yield : false
+            ensure
+              run_run_hooks('an `after(:run)` hook', run_hooks(:after))
+            end
+          end
+
         private
 
+          def run_hooks(position)
+            (@run_hooks ||= { :before => [], :after => [] })[position]
+          end
+
+          def run_run_hooks(description, hooks, stop_on_failure=false)
+            context = SuiteHookContext.new(description, reporter)
+            hooks.each do |hook|
+              hook.run(context)
+            rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
+              context.set_exception(e)
+              return false if stop_on_failure
+            end
+            true
+          end
+
           # rspec-core runs the default path (`spec`) when no files are given
           # only when its command is `rspec`.
           def command
@@ -148,7 +214,7 @@ module RSpec
 
             examples_count = @world.example_count(example_groups)
             examples_passed = @configuration.reporter.report(examples_count) do |reporter|
-              Parallel.run(@configuration, @world, parallel_units, reporter)
+              @configuration.with_run_hooks { Parallel.run(@configuration, @world, parallel_units, reporter) }
             end
 
             exit_code(examples_passed)

data/lib/rspec/core/parallel/rails_integration.rb

@@ -11,6 +11,8 @@ module RSpec
       #   `ActiveSupport.parallelize_test_databases` to `false` to opt out.
       #   Workers are numbered from 0 for these hooks, as in Rails. Rails
       #   versions before 8.1 have no hooks to run before forking.
+      # * gives every worker its own log file (`log/test-1.log`, `log/test-2.log`...),
+      #   rather than mixing the lines of all the workers in `log/test.log`.
       # * loads the translations before forking, as Rails does when eager
       #   loading, rather than in every worker.
       #
@@ -22,9 +24,39 @@ module RSpec
         end
 
         def self.after_fork(worker_number)
+          split_log(worker_number)
           hooks(:after_fork_hooks).each { |hook| hook.call(worker_number - 1) }
         end
 
+        # Rails opens the log file itself and hands the open file to its
+        # logger, so the path comes from the file the logger writes to.
+        # Loggers writing elsewhere, like to STDOUT, are left as they are.
+        def self.split_log(worker_number)
+          return unless defined?(::Rails.logger) && ::Rails.logger
+
+          loggers = ::Rails.logger.respond_to?(:broadcasts) ? ::Rails.logger.broadcasts : [::Rails.logger]
+          loggers.each do |logger|
+            device = logger.instance_variable_get(:@logdev)&.dev
+            next unless device.is_a?(::File)
+
+            logger.reopen(open_log_file(worker_log_path(device.path, worker_number)))
+          end
+        end
+
+        def self.worker_log_path(path, worker_number)
+          extension = ::File.extname(path)
+          "#{path.delete_suffix(extension)}-#{worker_number}#{extension}"
+        end
+
+        # As Rails opens its own log file: in binary mode, so that lines in
+        # any encoding can be written, and without buffering.
+        def self.open_log_file(path)
+          file = ::File.open(path, 'a')
+          file.binmode
+          file.sync = true
+          file
+        end
+
         def self.run_cleanup(worker_number)
           hooks(:run_cleanup_hooks).each { |hook| hook.call(worker_number - 1) }
         end

data/lib/rspec/core/parallel/simplecov_integration.rb

@@ -16,6 +16,8 @@ module RSpec
       #   `TEST_ENV_NUMBER`), so workers finishing early checked the coverage
       #   collected so far and printed false "below minimum coverage"
       #   warnings. The main process exits after all the workers.
+      # * extends SimpleCov's `merge_timeout` by the time the workers ran, so
+      #   that the main process merges the results of all of them.
       #
       # @private
       module SimpleCovIntegration
@@ -28,7 +30,10 @@ module RSpec
 
         def self.before_fork
           @command_name = nil
+          @forked_at = nil
           return unless defined?(::SimpleCov) && defined?(::Coverage.running?) && ::Coverage.running?
+
+          @forked_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
           return if ::SimpleCov.enabled_for_subprocesses?
 
           @command_name = ::SimpleCov.command_name
@@ -47,6 +52,15 @@ module RSpec
           ::SimpleCov.command_name "#{@command_name} (worker #{worker_number})" if @command_name
           ::SimpleCov.singleton_class.__send__(:prepend, NotFinalResultProcess)
         end
+
+        # SimpleCov merges only results younger than `merge_timeout`: those of
+        # workers finished long before the slowest one would be left out.
+        def self.after_workers
+          return unless @forked_at && ::SimpleCov.respond_to?(:merge_timeout)
+
+          workers_time = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @forked_at).ceil
+          ::SimpleCov.merge_timeout(::SimpleCov.merge_timeout + workers_time)
+        end
       end
     end
   end

data/lib/rspec/core/parallel/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Core
     module Parallel
-      VERSION = '0.2.1'
+      VERSION = '0.4.0'
     end
   end
 end

data/lib/rspec/core/parallel.rb

@@ -51,6 +51,7 @@ module RSpec
       def self.run(configuration, world, units, reporter)
         worker_count = [configuration.parallel_workers.to_i, units.size].min
         passed = Coordinator.new(configuration, world, worker_count).run(units, reporter)
+        SimpleCovIntegration.after_workers
         persist_run_times(configuration, world)
         passed
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-core-parallel
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Alessandro Rodi