rspec-core-parallel 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b57c9af852c507ef4696411ab9de26231b9c04d9400fb8cdb48beb99edf4a89
-  data.tar.gz: ef94f289bf3f6128f124c7bf3c0300a11d435cf0e8a40c2405beaae4b3c274d3
+  metadata.gz: 1e45d853c91a7618f7d3e2610761a0a7271ade685db327199de1b3a045ed9609
+  data.tar.gz: f652d5b00ce96ef27afbab7d064caaf8ed9cc5541c5fa739708bdd24cf08c5ef
 SHA512:
-  metadata.gz: c57a12dc5500fc4578a6ac51bfaa27b68b4f98da09e4297e2857993328ed2b6a9923851caffd14db0cc9a88fd9aecaa30dbdccb9fe44fcc721b48b4885329baa
-  data.tar.gz: d5b61024b3bc242e08c1c35a0b65feb8877083542f85f33d970a4250e30fcdc0a2f473f097cb0fad9c816e1e393ad54406637d39deef1ed55c1e8ed456273a3a
+  metadata.gz: ce28c54e6b455f78bed2682ce55ddc7c79b53ee3913a9ea3c5e91ed13f2b0507baa56130a494feb1bd913a3c05ea30819eb29608ee2aa82b9b314ab5335b6a1b
+  data.tar.gz: 2db7c74933f5f617e44027b3687b473395d2c4d93e8277ac13b172e558b6c3304a572ef5f5c81c77acbf26c85e4802b3d1aa3ea9b811b2c67b1c6b20c7cadd4e

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 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
+  `enable_for_subprocesses` to `merge_subprocesses`.
+
 ## 0.2.0
 
 * SimpleCov collects the coverage of the workers without any configuration.

data/README.md

@@ -83,7 +83,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/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,11 +30,19 @@ 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
-          ::SimpleCov.enable_for_subprocesses true
+          # SimpleCov 1.x renamed `enable_for_subprocesses`, deprecating it.
+          if ::SimpleCov.respond_to?(:merge_subprocesses)
+            ::SimpleCov.merge_subprocesses true
+          else
+            ::SimpleCov.enable_for_subprocesses true
+          end
           require 'simplecov/process'
         end
 
@@ -42,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.0'
+      VERSION = '0.3.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.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Alessandro Rodi