turbo_tests2 3.0.0

data/lib/turbo_tests/runner.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+require "json"
+require "parallel_tests/rspec/runner"
+
+require_relative "../utils/hash_extension"
+
+module TurboTests
+  class Runner
+    using CoreExtensions
+
+    class << self
+      def create(count)
+        # We are unable to load parallel tests' tasks in the normal way (top of file)
+        # because it requires that the Rails.application instance already be configured
+        require "parallel_tests/tasks"
+
+        ENV["PARALLEL_TEST_FIRST_IS_1"] = "true"
+        command = ["bundle", "exec", "rake", "db:create", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"]
+        args = {count: count.to_s}
+        ParallelTests::Tasks.run_in_parallel(command, args)
+      end
+
+      def run(opts = {})
+        files = opts[:files]
+        formatters = opts[:formatters]
+        tags = opts[:tags]
+        parallel_options = opts[:parallel_options] || {}
+
+        start_time = opts.fetch(:start_time) { RSpec::Core::Time.now }
+        runtime_log = opts.fetch(:runtime_log, nil)
+        verbose = opts.fetch(:verbose, false)
+        fail_fast = opts.fetch(:fail_fast, nil)
+        count = opts.fetch(:count, nil)
+        seed = opts.fetch(:seed, nil)
+        seed_used = !seed.nil?
+        print_failed_group = opts.fetch(:print_failed_group, false)
+        nice = opts.fetch(:nice, false)
+
+        use_runtime_info = files == ["spec"]
+
+        if use_runtime_info
+          parallel_options[:runtime_log] = runtime_log
+        else
+          parallel_options[:group_by] = :filesize
+        end
+
+        warn("VERBOSE") if verbose
+
+        reporter = Reporter.from_config(formatters, start_time, seed, seed_used, files, parallel_options)
+
+        new(
+          reporter: reporter,
+          formatters: formatters,
+          start_time: start_time,
+          files: files,
+          tags: tags,
+          runtime_log: runtime_log,
+          verbose: verbose,
+          fail_fast: fail_fast,
+          count: count,
+          seed: seed,
+          seed_used: seed_used,
+          print_failed_group: print_failed_group,
+          use_runtime_info: use_runtime_info,
+          parallel_options: parallel_options,
+          nice: nice,
+        ).run
+      end
+    end
+
+    def initialize(**opts)
+      @formatters = opts[:formatters]
+      @reporter = opts[:reporter]
+      @files = opts[:files]
+      @tags = opts[:tags]
+      @verbose = opts[:verbose]
+      @fail_fast = opts[:fail_fast]
+      @start_time = opts[:start_time]
+      @count = opts[:count]
+      @seed = opts[:seed]
+      @seed_used = opts[:seed_used]
+      @nice = opts[:nice]
+      @use_runtime_info = opts[:use_runtime_info]
+
+      @load_time = 0
+      @load_count = 0
+      @failure_count = 0
+
+      # Supports runtime_log as a top level option,
+      #   but also nested inside parallel_options
+      @runtime_log = opts[:runtime_log] || "tmp/turbo_rspec_runtime.log"
+      @parallel_options = opts.fetch(:parallel_options, {})
+      @parallel_options[:runtime_log] ||= @runtime_log
+      @record_runtime = @parallel_options[:group_by] == :runtime
+
+      @messages = Thread::Queue.new
+      @threads = []
+      @wait_threads = []
+      @error = false
+      @print_failed_group = opts[:print_failed_group]
+    end
+
+    def run
+      @num_processes = [
+        ParallelTests.determine_number_of_processes(@count),
+        ParallelTests::RSpec::Runner.tests_with_size(@files, {}).size,
+      ].min
+
+      tests_in_groups =
+        ParallelTests::RSpec::Runner.tests_in_groups(
+          @files,
+          @num_processes,
+          **@parallel_options,
+        )
+
+      subprocess_opts = {
+        record_runtime: @record_runtime,
+      }
+
+      @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
+
+        handle_messages
+
+        @threads.each(&:join)
+
+        report_failed_group(tests_in_groups) if @print_failed_group
+
+        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
+        end
+      end
+    end
+
+    private
+
+    def handle_interrupt
+      if @interrupt_handled
+        Kernel.exit
+      else
+        puts "\nShutting down subprocesses..."
+        @wait_threads.each do |wait_thr|
+          begin
+            child_pid = wait_thr.pid
+            pgid = Process.respond_to?(:getpgid) ? Process.getpgid(child_pid) : 0
+            Process.kill(:INT, child_pid) if Process.pid != pgid
+          rescue Errno::ESRCH, Errno::ENOENT
+            # process already gone — ignore
+          end
+        end
+        @interrupt_handled = true
+      end
+    end
+
+    def start_regular_subprocess(tests, process_id, **opts)
+      start_subprocess(
+        {"TEST_ENV_NUMBER" => process_id.to_s},
+        @tags.map { |tag| "--tag=#{tag}" },
+        tests,
+        process_id,
+        **opts,
+      )
+    end
+
+    def start_subprocess(env, extra_args, tests, process_id, record_runtime:)
+      if tests.empty?
+        @messages << {
+          type: "exit",
+          process_id: process_id,
+        }
+
+        nil
+      else
+        env["RSPEC_FORMATTER_OUTPUT_ID"] = SecureRandom.uuid
+        env["RUBYOPT"] = ["-I#{File.expand_path("..", __dir__)}", ENV["RUBYOPT"]].compact.join(" ")
+        env["RSPEC_SILENCE_FILTER_ANNOUNCEMENTS"] = "1"
+
+        command_name =
+          if ENV["RSPEC_EXECUTABLE"]
+            ENV["RSPEC_EXECUTABLE"].split
+          elsif ENV["BUNDLE_BIN_PATH"]
+            [ENV["BUNDLE_BIN_PATH"], "exec", "rspec"]
+          else
+            "rspec"
+          end
+
+        record_runtime_options =
+          if record_runtime
+            [
+              "--format",
+              "ParallelTests::RSpec::RuntimeLogger",
+              "--out",
+              @runtime_log,
+            ]
+          else
+            []
+          end
+
+        seed_option = if @seed_used
+          [
+            "--seed", @seed,
+          ]
+        else
+          []
+        end
+
+        spec_opts = ParallelTests::RSpec::Runner.send(:spec_opts)
+
+        command = [
+          *command_name,
+          *extra_args,
+          *seed_option,
+          "--format",
+          "TurboTests::JsonRowsFormatter",
+          *record_runtime_options,
+          *spec_opts,
+          *tests,
+        ]
+        command.unshift("nice") if @nice
+
+        if @verbose
+          command_str = [
+            env.map { |k, v| "#{k}=#{v}" }.join(" "),
+            command.join(" "),
+          ].select { |x| x.size > 0 }.join(" ")
+
+          warn("Process #{process_id}: #{command_str}")
+        end
+
+        stdin, stdout, stderr, wait_thr = Open3.popen3(env, *command)
+        stdin.close
+
+        # rubocop:disable ThreadSafety/NewThread
+        @threads <<
+          Thread.new do
+            stdout.each_line do |line|
+              result = line.split(env["RSPEC_FORMATTER_OUTPUT_ID"])
+
+              initial = result.shift
+              print(initial) unless initial.empty?
+
+              message = result.shift
+              next unless message
+
+              message = JSON.parse(message, symbolize_names: true)
+
+              message[:process_id] = process_id
+              @messages << message
+            end
+
+            @messages << {type: "exit", process_id: process_id}
+          end
+        # rubocop:enable ThreadSafety/NewThread
+
+        @threads << start_copy_thread(stderr, $stderr)
+
+        # rubocop:disable ThreadSafety/NewThread
+        @threads << Thread.new do
+          @messages << {type: "error"} unless wait_thr.value.success?
+        end
+        # rubocop:enable ThreadSafety/NewThread
+
+        wait_thr
+      end
+    end
+
+    def start_copy_thread(src, dst)
+      # rubocop:disable ThreadSafety/NewThread
+      Thread.new do
+        # rubocop:enable ThreadSafety/NewThread
+        loop do
+          begin
+            msg = src.readpartial(4096)
+          rescue EOFError
+            src.close
+            break
+          else
+            dst.write(msg)
+          end
+        end
+      end
+    end
+
+    def handle_messages
+      exited = 0
+
+      loop do
+        message = @messages.pop
+        case message[:type]
+        when "example_passed"
+          example = FakeExample.from_obj(message[:example])
+          @reporter.example_passed(example)
+        when "group_started"
+          @reporter.group_started(message[:group].to_struct)
+        when "group_finished"
+          @reporter.group_finished
+        when "example_pending"
+          example = FakeExample.from_obj(message[:example])
+          @reporter.example_pending(example)
+        when "load_summary"
+          message = message[:summary]
+          # NOTE: notifications order and content is not guaranteed hence the fetch
+          #       and count increment tracking to get the latest accumulated load time
+          @reporter.load_time = message[:load_time] if message.fetch(:count, 0) > @load_count
+        when "example_failed"
+          example = FakeExample.from_obj(message[:example])
+          @reporter.example_failed(example)
+          @failure_count += 1
+          if fail_fast_met
+            @threads.each(&:kill)
+            break
+          end
+        when "message"
+          if message[:message].include?("An error occurred") || message[:message].include?("occurred outside of examples")
+            @reporter.error_outside_of_examples(message[:message])
+            @error = true
+          else
+            @reporter.message(message[:message])
+          end
+        when "seed"
+        when "close"
+        when "error"
+          # Do nothing
+          nil
+        when "exit"
+          exited += 1
+          break if exited == @num_processes
+        else
+          warn("Unhandled message in main process: #{message}")
+        end
+
+        $stdout.flush
+      end
+    rescue Interrupt
+    end
+
+    def fail_fast_met
+      !@fail_fast.nil? && @failure_count >= @fail_fast
+    end
+
+    def report_failed_group(tests_in_groups)
+      @wait_threads.map(&:value).each_with_index do |value, index|
+        next if value.success?
+
+        failing_group = tests_in_groups[index].join(" ")
+        puts "Group that failed: #{failing_group}"
+      end
+    end
+  end
+end

data/lib/turbo_tests/shim.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module TurboTests
+  class Shim
+    Result = Struct.new(:status, :path, :message, :exit_code, keyword_init: true)
+
+    DEFAULT_RELATIVE_PATH = File.join("bin", "turbo_tests")
+    MANAGED_MARKER = "Generated by turbo_tests2 shim install"
+
+    class << self
+      def install(project_root: Dir.pwd, path: nil)
+        new(project_root: project_root, path: path).install
+      end
+
+      def remove(project_root: Dir.pwd, path: nil)
+        new(project_root: project_root, path: path).remove
+      end
+    end
+
+    attr_reader :project_root, :path
+
+    def initialize(project_root: Dir.pwd, path: nil)
+      @project_root = File.expand_path(project_root)
+      @path = File.expand_path(path || DEFAULT_RELATIVE_PATH, @project_root)
+    end
+
+    def install
+      existing_managed = false
+      if File.exist?(path)
+        existing = File.read(path)
+        return result(:unchanged, "Shim already installed at #{display_path}.", 0) if existing == rendered_content
+        return result(:conflict, "Refusing to overwrite unmanaged file at #{display_path}.", 1) unless managed_content?(existing)
+        existing_managed = true
+      end
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, rendered_content)
+      FileUtils.chmod(0o755, path)
+
+      result(existing_managed ? :updated : :installed, "Installed turbo_tests shim at #{display_path}.", 0)
+    end
+
+    def remove
+      return result(:missing, "No shim found at #{display_path}.", 0) unless File.exist?(path)
+
+      content = File.read(path)
+      return result(:conflict, "Refusing to remove unmanaged file at #{display_path}.", 1) unless managed_content?(content)
+
+      File.delete(path)
+      result(:removed, "Removed turbo_tests shim at #{display_path}.", 0)
+    end
+
+    private
+
+    def display_path
+      path.sub(%r{\A#{Regexp.escape(project_root)}/?}, "")
+    end
+
+    def managed_content?(content)
+      content.include?(MANAGED_MARKER)
+    end
+
+    def rendered_content
+      <<~SH
+        #!/usr/bin/env sh
+        # #{MANAGED_MARKER}
+        exec bundle exec turbo_tests2 "$@"
+      SH
+    end
+
+    def result(status, message, exit_code)
+      Result.new(status: status, path: path, message: message, exit_code: exit_code)
+    end
+  end
+end

data/lib/turbo_tests/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module TurboTests
+  module Version
+    VERSION = "3.0.0"
+  end
+  VERSION = Version::VERSION # Traditional Constant Location
+end

data/lib/turbo_tests.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "version_gem"
+require_relative "turbo_tests/version"
+
+TurboTests::Version.class_eval do
+  extend VersionGem::Basic
+end
+require "securerandom"
+require "open3"
+require "fileutils"
+require "json"
+
+require "rspec"
+
+require "parallel_tests"
+require "parallel_tests/rspec/runner"
+
+require "turbo_tests/reporter"
+require "turbo_tests/runner"
+require "turbo_tests/json_rows_formatter"
+
+module TurboTests
+  autoload :CLI, "turbo_tests/cli"
+  autoload :Shim, "turbo_tests/shim"
+  FakeException = Struct.new(:backtrace, :message, :cause)
+  class FakeException
+    class << self
+      def from_obj(obj)
+        return unless obj
+
+        klass =
+          Class.new(FakeException) do
+            define_singleton_method(:name) do
+              obj[:class_name]
+            end
+          end
+
+        klass.new(
+          obj[:backtrace],
+          obj[:message],
+          FakeException.from_obj(obj[:cause]),
+        )
+      end
+    end
+  end
+
+  FakeExecutionResult = Struct.new(
+    :example_skipped?,
+    :pending_message,
+    :status,
+    :pending_fixed?,
+    :exception,
+    :pending_exception,
+  )
+  class FakeExecutionResult
+    class << self
+      def from_obj(obj)
+        new(
+          obj[:example_skipped?],
+          obj[:pending_message],
+          obj[:status].to_sym,
+          obj[:pending_fixed?],
+          FakeException.from_obj(obj[:exception]),
+          FakeException.from_obj(obj[:exception]),
+        )
+      end
+    end
+  end
+
+  FakeExample = Struct.new(
+    :execution_result,
+    :location,
+    :description,
+    :full_description,
+    :metadata,
+    :location_rerun_argument,
+  )
+  class FakeExample
+    class << self
+      def from_obj(obj)
+        metadata = obj[:metadata]
+
+        metadata[:shared_group_inclusion_backtrace].map! do |frame|
+          RSpec::Core::SharedExampleGroupInclusionStackFrame.new(
+            frame[:shared_group_name],
+            frame[:inclusion_location],
+          )
+        end
+
+        metadata[:shared_group_inclusion_backtrace] = metadata.delete(:shared_group_inclusion_backtrace)
+
+        new(
+          FakeExecutionResult.from_obj(obj[:execution_result]),
+          obj[:location],
+          obj[:description],
+          obj[:full_description],
+          metadata,
+          obj[:location_rerun_argument],
+        )
+      end
+    end
+
+    def notification
+      RSpec::Core::Notifications::ExampleNotification.for(
+        self,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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)
+  end
+
+  around do |example|
+    original_rubyopt = ENV.fetch("RUBYOPT", 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["RUBYOPT"] = ["-r#{spawn_path}", original_rubyopt].compact.join(" ").strip
+      end
+
+      example.run
+    ensure
+      ENV["RUBYOPT"] = original_rubyopt
+    end
+  end
+end

data/lib/turbo_tests2.rb

@@ -0,0 +1,6 @@
+# For technical reasons, if we move to Zeitwerk, this cannot be require_relative.
+#   See: https://github.com/fxn/zeitwerk#for_gem_extension
+# But we will use require_relative to avoid the risk of it loading the old turbo_tests gem.
+# Bottom-line: Do not use Zeitwerk in this gem.
+# Hook for other libraries to load this library (e.g. via bundler)
+require_relative "turbo_tests"

data/lib/utils/hash_extension.rb

@@ -0,0 +1,7 @@
+module CoreExtensions
+  refine Hash do
+    def to_struct
+      Struct.new(*keys).new(*values.map { |value| value.is_a?(Hash) ? value.to_struct : value })
+    end
+  end
+end

data/sig/turbo_tests/version.rbs

@@ -0,0 +1,7 @@
+module TurboTests
+  module Version
+    VERSION: String
+  end
+  VERSION: String
+end
+

data.tar.gz.sig

@@ -0,0 +1 @@
+
Yv)� w?Z�Ď_G�]��z�J�����