turbo_tests2 3.0.0 → 3.1.1

data/lib/turbo_tests/json_rows_formatter.rb

@@ -20,6 +20,12 @@ RSpec::Core::Runner.singleton_class.prepend(RSpecExt)
 module TurboTests
   # An RSpec formatter used for each subprocess during parallel test execution
   class JsonRowsFormatter
+    INTERNAL_BACKTRACE_PATTERNS = [
+      %r{/bin/turbo_tests2\b},
+      %r{/exe/turbo_tests2\b},
+      %r{/lib/turbo_tests(?:\.rb|/)}
+    ].freeze
+
     RSpec::Core::Formatters.register(
       self,
       :start,
@@ -31,6 +37,8 @@ module TurboTests
       :example_group_finished,
       :message,
       :seed,
+      :deprecation,
+      :dump_profile
     )
 
     attr_reader :output
@@ -42,78 +50,115 @@ module TurboTests
     def start(notification)
       output_row(
         type: :load_summary,
-        summary: load_summary_to_json(notification),
+        summary: load_summary_to_json(notification)
       )
     end
 
     def example_group_started(notification)
       output_row(
         type: :group_started,
-        group: group_to_json(notification),
+        group: group_to_json(notification)
       )
     end
 
     def example_group_finished(notification)
       output_row(
         type: :group_finished,
-        group: group_to_json(notification),
+        group: group_to_json(notification)
       )
     end
 
     def example_passed(notification)
       output_row(
         type: :example_passed,
-        example: example_to_json(notification.example),
+        example: example_to_json(notification.example)
       )
     end
 
     def example_pending(notification)
       output_row(
         type: :example_pending,
-        example: example_to_json(notification.example),
+        example: example_to_json(notification.example)
       )
     end
 
     def example_failed(notification)
       output_row(
         type: :example_failed,
-        example: example_to_json(notification.example),
+        example: example_to_json(notification.example)
       )
     end
 
     def seed(notification)
       output_row(
         type: :seed,
-        seed: notification.seed,
+        seed: notification.seed
       )
     end
 
     def close(_notification)
       output_row(
-        type: :close,
+        type: :close
       )
     end
 
     def message(notification)
       output_row(
         type: :message,
-        message: notification.message,
+        message: notification.message
+      )
+    end
+
+    def deprecation(notification)
+      output_row(
+        type: :deprecation,
+        deprecation: deprecation_to_json(notification)
+      )
+    end
+
+    def dump_profile(notification)
+      output_row(
+        type: :profile,
+        profile: profile_to_json(notification)
       )
     end
 
     private
 
+    def profile_to_json(notification)
+      {
+        duration: notification.duration,
+        number_of_examples: notification.number_of_examples,
+        examples: notification.examples.map { |example| example_to_json(example) }
+      }
+    end
+
+    def deprecation_to_json(notification)
+      {
+        deprecated: notification.deprecated,
+        message: notification.message,
+        replacement: notification.replacement,
+        call_site: notification.call_site
+      }
+    end
+
     def exception_to_json(exception)
       return unless exception
 
       {
         class_name: exception.class.name.to_s,
-        backtrace: exception.backtrace,
+        backtrace: filtered_backtrace(exception.backtrace),
         message: exception.message,
-        cause: exception_to_json(exception.cause),
+        cause: exception_to_json(exception.cause)
       }
     end
 
+    def filtered_backtrace(backtrace)
+      Array(backtrace).reject do |line|
+        INTERNAL_BACKTRACE_PATTERNS.any? { |pattern| line.match?(pattern) }
+      end
+    end
+
     def execution_result_to_json(result)
       {
         example_skipped?: result.example_skipped?,
@@ -121,13 +166,14 @@ module TurboTests
         status: result.status,
         pending_fixed?: result.pending_fixed?,
         exception: exception_to_json(result.exception || result.pending_exception),
+        run_time: result.respond_to?(:run_time) ? result.run_time : nil
       }
     end
 
     def stack_frame_to_json(frame)
       {
         shared_group_name: frame.shared_group_name,
-        inclusion_location: frame.inclusion_location,
+        inclusion_location: frame.inclusion_location
       }
     end
 
@@ -142,29 +188,29 @@ module TurboTests
             example
               .metadata[:shared_group_inclusion_backtrace]
               .map { |frame| stack_frame_to_json(frame) },
-          extra_failure_lines: example.metadata[:extra_failure_lines],
+          extra_failure_lines: example.metadata[:extra_failure_lines]
         },
-        location_rerun_argument: example.location_rerun_argument,
+        location_rerun_argument: example.location_rerun_argument
       }
     end
 
     def load_summary_to_json(notification)
       {
         count: notification.count,
-        load_time: notification.load_time,
+        load_time: notification.load_time
       }
     end
 
     def group_to_json(notification)
       {
         group: {
-          description: notification.group.description,
-        },
+          description: notification.group.description
+        }
       }
     end
 
     def output_row(obj)
-      output.puts ENV["RSPEC_FORMATTER_OUTPUT_ID"] + obj.to_json
+      output.puts "#{ENV.fetch("RSPEC_FORMATTER_OUTPUT_ID", "")}#{obj.to_json}"
       output.flush
     end
   end

data/lib/turbo_tests/reporter.rb

@@ -75,7 +75,7 @@ module TurboTests
       delegate_to_formatters(:seed, RSpec::Core::Notifications::SeedNotification.new(@seed, @seed_used))
       delegate_to_formatters(
         :start,
-        RSpec::Core::Notifications::StartNotification.new(expected_example_count, @load_time),
+        RSpec::Core::Notifications::StartNotification.new(expected_example_count, @load_time)
       )
     end
 
@@ -127,6 +127,27 @@ module TurboTests
       message(error_message)
     end
 
+    def deprecation(deprecation)
+      notification = RSpec::Core::Notifications::DeprecationNotification.from_hash(
+        deprecated: deprecation[:deprecated],
+        message: deprecation[:message],
+        replacement: deprecation[:replacement],
+        call_site: deprecation[:call_site]
+      )
+      delegate_to_formatters(:deprecation, notification)
+    end
+
+    def profile(profile)
+      examples = profile[:examples].map { |example| FakeExample.from_obj(example) }
+      notification = RSpec::Core::Notifications::ProfileNotification.new(
+        profile[:duration],
+        examples,
+        profile[:number_of_examples],
+        {}
+      )
+      delegate_to_formatters(:dump_profile, notification)
+    end
+
     def finish
       end_time = RSpec::Core::Time.now
 
@@ -137,14 +158,14 @@ module TurboTests
       delegate_to_formatters(
         :dump_pending,
         RSpec::Core::Notifications::ExamplesNotification.new(
-          self,
-        ),
+          self
+        )
       )
       delegate_to_formatters(
         :dump_failures,
         RSpec::Core::Notifications::ExamplesNotification.new(
-          self,
-        ),
+          self
+        )
       )
       delegate_to_formatters(
         :dump_summary,
@@ -154,15 +175,15 @@ module TurboTests
           @failed_examples,
           @pending_examples,
           @load_time,
-          @errors_outside_of_examples_count,
-        ),
+          @errors_outside_of_examples_count
+        )
       )
       delegate_to_formatters(
         :seed,
         RSpec::Core::Notifications::SeedNotification.new(
           @seed,
-          @seed_used,
-        ),
+          @seed_used
+        )
       )
     ensure
       delegate_to_formatters(:close, RSpec::Core::Notifications::NullNotification)

data/lib/turbo_tests/runner.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "parallel_tests/rspec/runner"
+require "tempfile"
 
 require_relative "../utils/hash_extension"
 
@@ -29,6 +30,7 @@ module TurboTests
 
         start_time = opts.fetch(:start_time) { RSpec::Core::Time.now }
         runtime_log = opts.fetch(:runtime_log, nil)
+        example_status_log = opts.fetch(:example_status_log, nil)
         verbose = opts.fetch(:verbose, false)
         fail_fast = opts.fetch(:fail_fast, nil)
         count = opts.fetch(:count, nil)
@@ -39,7 +41,10 @@ module TurboTests
 
         use_runtime_info = files == ["spec"]
 
-        if use_runtime_info
+        if example_status_log
+          runtime_log = runtime_log_from_example_status(example_status_log)
+          parallel_options[:runtime_log] = runtime_log
+        elsif use_runtime_info
           parallel_options[:runtime_log] = runtime_log
         else
           parallel_options[:group_by] = :filesize
@@ -56,6 +61,7 @@ module TurboTests
           files: files,
           tags: tags,
           runtime_log: runtime_log,
+          example_status_log: example_status_log,
           verbose: verbose,
           fail_fast: fail_fast,
           count: count,
@@ -64,9 +70,24 @@ module TurboTests
           print_failed_group: print_failed_group,
           use_runtime_info: use_runtime_info,
           parallel_options: parallel_options,
-          nice: nice,
+          nice: nice
         ).run
       end
+
+      def runtime_log_from_example_status(example_status_log)
+        statuses = RSpec::Core::ExampleStatusPersister.load_from(example_status_log)
+        runtimes = statuses.each_with_object(Hash.new(0.0)) do |status, sums|
+          next unless status.fetch(:status).match?(/pass/i)
+
+          file_name = RSpec::Core::Example.parse_id(status.fetch(:example_id)).first
+          sums[file_name] += status.fetch(:run_time).to_s[/\d+(\.\d+)?/].to_f
+        end
+
+        path = File.join("tmp", "turbo_tests2_example_status_runtime.log")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, runtimes.sort.map { |file, runtime| "#{file}:#{runtime}" }.join("\n"))
+        path
+      end
     end
 
     def initialize(**opts)
@@ -97,6 +118,7 @@ module TurboTests
       @messages = Thread::Queue.new
       @threads = []
       @wait_threads = []
+      @exited_process_ids = []
       @error = false
       @print_failed_group = opts[:print_failed_group]
     end
@@ -104,41 +126,44 @@ module TurboTests
     def run
       @num_processes = [
         ParallelTests.determine_number_of_processes(@count),
-        ParallelTests::RSpec::Runner.tests_with_size(@files, {}).size,
+        ParallelTests::RSpec::Runner.tests_with_size(@files, {}).size
       ].min
 
       tests_in_groups =
         ParallelTests::RSpec::Runner.tests_in_groups(
           @files,
           @num_processes,
-          **@parallel_options,
+          **@parallel_options
         )
+      @tests_in_groups = tests_in_groups
 
       subprocess_opts = {
-        record_runtime: @record_runtime,
+        record_runtime: @record_runtime
       }
 
-      @reporter.report(tests_in_groups) do |_reporter|
-        old_signal = Signal.trap(:INT) { handle_interrupt }
+      ParallelTests.with_pid_file do
+        @reporter.report(tests_in_groups) do |_reporter|
+          old_signal = Signal.trap(:INT) { handle_interrupt }
 
-        @wait_threads = tests_in_groups.map.with_index do |tests, process_id|
-          start_regular_subprocess(tests, process_id + 1, **subprocess_opts)
-        end.compact
-        @interrupt_handled = false
+          @wait_threads = tests_in_groups.map.with_index do |tests, process_id|
+            start_regular_subprocess(tests, process_id + 1, **subprocess_opts)
+          end.compact
+          @interrupt_handled = false
 
-        handle_messages
+          handle_messages
 
-        @threads.each(&:join)
+          @threads.each(&:join)
 
-        report_failed_group(tests_in_groups) if @print_failed_group
+          report_failed_group(tests_in_groups) if @print_failed_group
 
-        Signal.trap(:INT, old_signal)
+          Signal.trap(:INT, old_signal)
 
-        if @reporter.failed_examples.empty? && @wait_threads.map(&:value).all?(&:success?)
-          0
-        else
-          # From https://github.com/galtzo-floss/turbo_tests2/pull/20/
-          @wait_threads.map { |thread| thread.value.exitstatus }.max
+          if @reporter.failed_examples.empty? && @wait_threads.map(&:value).all?(&:success?)
+            0
+          else
+            # From https://github.com/galtzo-floss/turbo_tests2/pull/20/
+            @wait_threads.map { |thread| thread.value.exitstatus }.max
+          end
         end
       end
     end
@@ -150,6 +175,7 @@ module TurboTests
         Kernel.exit
       else
         puts "\nShutting down subprocesses..."
+        report_unfinished_groups("Groups not finished")
         @wait_threads.each do |wait_thr|
           begin
             child_pid = wait_thr.pid
@@ -165,11 +191,15 @@ module TurboTests
 
     def start_regular_subprocess(tests, process_id, **opts)
       start_subprocess(
-        {"TEST_ENV_NUMBER" => process_id.to_s},
+        {
+          "TEST_ENV_NUMBER" => process_id.to_s,
+          "PARALLEL_TEST_GROUPS" => @num_processes.to_s,
+          "PARALLEL_PID_FILE" => parallel_pid_file_path
+        },
         @tags.map { |tag| "--tag=#{tag}" },
         tests,
         process_id,
-        **opts,
+        **opts
       )
     end
 
@@ -177,7 +207,7 @@ module TurboTests
       if tests.empty?
         @messages << {
           type: "exit",
-          process_id: process_id,
+          process_id: process_id
         }
 
         nil
@@ -201,7 +231,7 @@ module TurboTests
               "--format",
               "ParallelTests::RSpec::RuntimeLogger",
               "--out",
-              @runtime_log,
+              @runtime_log
             ]
           else
             []
@@ -209,7 +239,7 @@ module TurboTests
 
         seed_option = if @seed_used
           [
-            "--seed", @seed,
+            "--seed", @seed
           ]
         else
           []
@@ -225,20 +255,22 @@ module TurboTests
           "TurboTests::JsonRowsFormatter",
           *record_runtime_options,
           *spec_opts,
-          *tests,
+          *tests
         ]
         command.unshift("nice") if @nice
 
         if @verbose
           command_str = [
             env.map { |k, v| "#{k}=#{v}" }.join(" "),
-            command.join(" "),
+            command.join(" ")
           ].select { |x| x.size > 0 }.join(" ")
 
           warn("Process #{process_id}: #{command_str}")
         end
 
+        pid_file_path = env["PARALLEL_PID_FILE"] || parallel_pid_file_path
         stdin, stdout, stderr, wait_thr = Open3.popen3(env, *command)
+        track_parallel_pid(wait_thr.pid, pid_file_path)
         stdin.close
 
         # rubocop:disable ThreadSafety/NewThread
@@ -267,7 +299,12 @@ module TurboTests
 
         # rubocop:disable ThreadSafety/NewThread
         @threads << Thread.new do
-          @messages << {type: "error"} unless wait_thr.value.success?
+          begin
+            status = wait_thr.value
+            @messages << {type: "error"} unless status.success?
+          ensure
+            untrack_parallel_pid(wait_thr.pid, pid_file_path)
+          end
         end
         # rubocop:enable ThreadSafety/NewThread
 
@@ -275,6 +312,18 @@ module TurboTests
       end
     end
 
+    def parallel_pid_file_path
+      ENV["PARALLEL_PID_FILE"]
+    end
+
+    def track_parallel_pid(pid, pid_file_path = parallel_pid_file_path)
+      ParallelTests::Pids.new(pid_file_path).add(pid) if pid && pid_file_path
+    end
+
+    def untrack_parallel_pid(pid, pid_file_path = parallel_pid_file_path)
+      ParallelTests::Pids.new(pid_file_path).delete(pid) if pid && pid_file_path
+    end
+
     def start_copy_thread(src, dst)
       # rubocop:disable ThreadSafety/NewThread
       Thread.new do
@@ -318,6 +367,7 @@ module TurboTests
           @reporter.example_failed(example)
           @failure_count += 1
           if fail_fast_met
+            report_unfinished_groups("Groups stopped by fail-fast")
             @threads.each(&:kill)
             break
           end
@@ -328,13 +378,16 @@ module TurboTests
           else
             @reporter.message(message[:message])
           end
-        when "seed"
-        when "close"
-        when "error"
+        when "deprecation"
+          @reporter.deprecation(message[:deprecation])
+        when "profile"
+          @reporter.profile(message[:profile])
+        when "seed", "close", "error"
           # Do nothing
           nil
         when "exit"
           exited += 1
+          @exited_process_ids << message[:process_id]
           break if exited == @num_processes
         else
           warn("Unhandled message in main process: #{message}")
@@ -357,5 +410,20 @@ module TurboTests
         puts "Group that failed: #{failing_group}"
       end
     end
+
+    def report_unfinished_groups(label)
+      groups = Array(@tests_in_groups)
+      unfinished_groups = groups.each_with_index.with_object([]) do |(tests, index), unfinished|
+        process_id = index + 1
+        unfinished << tests unless @exited_process_ids.include?(process_id)
+      end
+
+      return if unfinished_groups.empty?
+
+      puts "#{label}:"
+      unfinished_groups.each_with_index do |tests, index|
+        puts "  #{index + 1}) #{tests.join(" ")}"
+      end
+    end
   end
 end

data/lib/turbo_tests/shim.rb

@@ -2,7 +2,16 @@
 
 module TurboTests
   class Shim
-    Result = Struct.new(:status, :path, :message, :exit_code, keyword_init: true)
+    class Result
+      attr_reader :status, :path, :message, :exit_code
+
+      def initialize(status:, path:, message:, exit_code:)
+        @status = status
+        @path = path
+        @message = message
+        @exit_code = exit_code
+      end
+    end
 
     DEFAULT_RELATIVE_PATH = File.join("bin", "turbo_tests")
     MANAGED_MARKER = "Generated by turbo_tests2 shim install"

data/lib/turbo_tests/version.rb

@@ -2,7 +2,7 @@
 
 module TurboTests
   module Version
-    VERSION = "3.0.0"
+    VERSION = "3.1.1"
   end
   VERSION = Version::VERSION # Traditional Constant Location
 end

data/lib/turbo_tests.rb

@@ -39,7 +39,7 @@ module TurboTests
         klass.new(
           obj[:backtrace],
           obj[:message],
-          FakeException.from_obj(obj[:cause]),
+          FakeException.from_obj(obj[:cause])
         )
       end
     end
@@ -52,6 +52,7 @@ module TurboTests
     :pending_fixed?,
     :exception,
     :pending_exception,
+    :run_time
   )
   class FakeExecutionResult
     class << self
@@ -63,6 +64,7 @@ module TurboTests
           obj[:pending_fixed?],
           FakeException.from_obj(obj[:exception]),
           FakeException.from_obj(obj[:exception]),
+          obj[:run_time]
         )
       end
     end
@@ -74,7 +76,7 @@ module TurboTests
     :description,
     :full_description,
     :metadata,
-    :location_rerun_argument,
+    :location_rerun_argument
   )
   class FakeExample
     class << self
@@ -84,7 +86,7 @@ module TurboTests
         metadata[:shared_group_inclusion_backtrace].map! do |frame|
           RSpec::Core::SharedExampleGroupInclusionStackFrame.new(
             frame[:shared_group_name],
-            frame[:inclusion_location],
+            frame[:inclusion_location]
           )
         end
 
@@ -96,14 +98,14 @@ module TurboTests
           obj[:description],
           obj[:full_description],
           metadata,
-          obj[:location_rerun_argument],
+          obj[:location_rerun_argument]
         )
       end
     end
 
     def notification
       RSpec::Core::Notifications::ExampleNotification.for(
-        self,
+        self
       )
     end
   end

data/lib/turbo_tests2/rspec/shared_contexts/simplecov_spawn.rb

@@ -1,26 +1,30 @@
 # frozen_string_literal: true
 
-require "bundler"
 require "rspec/core"
 
 RSpec.shared_context("with simplecov spawn coverage") do
   let(:simplecov_spawn_path) do
-    File.expand_path(".simplecov_spawn.rb", Bundler.root.to_s)
+    [Dir.pwd, File.expand_path("..", Dir.pwd)]
+      .map { |dir| File.expand_path(".simplecov_spawn.rb", dir) }
+      .find { |path| File.file?(path) }
   end
 
   around do |example|
     original_rubyopt = ENV.fetch("RUBYOPT", nil)
+    original_cov_min_hard = ENV.fetch("K_SOUP_COV_MIN_HARD", nil)
     begin
       if defined?(SimpleCov) && SimpleCov.running
         spawn_path = simplecov_spawn_path
         raise ArgumentError, "Expected SimpleCov spawn shim at #{spawn_path}" unless File.file?(spawn_path)
 
+        ENV["K_SOUP_COV_MIN_HARD"] = "false"
         ENV["RUBYOPT"] = ["-r#{spawn_path}", original_rubyopt].compact.join(" ").strip
       end
 
       example.run
     ensure
       ENV["RUBYOPT"] = original_rubyopt
+      ENV["K_SOUP_COV_MIN_HARD"] = original_cov_min_hard
     end
   end
 end

data/sig/turbo_tests/version.rbs

@@ -4,4 +4,3 @@ module TurboTests
   end
   VERSION: String
 end
-