turbo_tests2 3.0.0

data/RUBOCOP.md

@@ -0,0 +1,71 @@
+# RuboCop Usage Guide
+
+## Overview
+
+A tale of two RuboCop plugin gems.
+
+### RuboCop Gradual
+
+This project uses `rubocop_gradual` instead of vanilla RuboCop for code style checking. The `rubocop_gradual` tool allows for gradual adoption of RuboCop rules by tracking violations in a lock file.
+
+### RuboCop LTS
+
+This project uses `rubocop-lts` to ensure, on a best-effort basis, compatibility with Ruby >= 1.9.2.
+RuboCop rules are meticulously configured by the `rubocop-lts` family of gems to ensure that a project is compatible with a specific version of Ruby. See: https://rubocop-lts.gitlab.io for more.
+
+## Checking RuboCop Violations
+
+To check for RuboCop violations in this project, always use:
+
+```bash
+bundle exec rake rubocop_gradual:check
+```
+
+**Do not use** the standard RuboCop commands like:
+- `bundle exec rubocop`
+- `rubocop`
+
+## Understanding the Lock File
+
+The `.rubocop_gradual.lock` file tracks all current RuboCop violations in the project. This allows the team to:
+
+1. Prevent new violations while gradually fixing existing ones
+2. Track progress on code style improvements
+3. Ensure CI builds don't fail due to pre-existing violations
+
+## Common Commands
+
+- **Check violations**
+    - `bundle exec rake rubocop_gradual`
+    - `bundle exec rake rubocop_gradual:check`
+- **(Safe) Autocorrect violations, and update lockfile if no new violations**
+  - `bundle exec rake rubocop_gradual:autocorrect`
+- **Force update the lock file (w/o autocorrect) to match violations present in code**
+  - `bundle exec rake rubocop_gradual:force_update`
+
+## Workflow
+
+1. Before submitting a PR, run `bundle exec rake rubocop_gradual:autocorrect`
+   a. or just the default `bundle exec rake`, as autocorrection is a pre-requisite of the default task.
+2. If there are new violations, either:
+   - Fix them in your code
+   - Run `bundle exec rake rubocop_gradual:force_update` to update the lock file (only for violations you can't fix immediately)
+3. Commit the updated `.rubocop_gradual.lock` file along with your changes
+
+## Never add inline RuboCop disables
+
+Do not add inline `rubocop:disable` / `rubocop:enable` comments anywhere in the codebase (including specs, except when following the few existing `rubocop:disable` patterns for a rule already being disabled elsewhere in the code). We handle exceptions in two supported ways:
+
+- Permanent/structural exceptions: prefer adjusting the RuboCop configuration (e.g., in `.rubocop.yml`) to exclude a rule for a path or file pattern when it makes sense project-wide.
+- Temporary exceptions while improving code: record the current violations in `.rubocop_gradual.lock` via the gradual workflow:
+  - `bundle exec rake rubocop_gradual:autocorrect` (preferred; will autocorrect what it can and update the lock only if no new violations were introduced)
+  - If needed, `bundle exec rake rubocop_gradual:force_update` (as a last resort when you cannot fix the newly reported violations immediately)
+
+In general, treat the rules as guidance to follow; fix violations rather than ignore them. For example, RSpec conventions in this project expect `described_class` to be used in specs that target a specific class under test.
+
+## Benefits of rubocop_gradual
+
+- Allows incremental adoption of code style rules
+- Prevents CI failures due to pre-existing violations
+- Provides a clear record of code style debt
+- Enables focused efforts on improving code quality over time

data/SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported Versions
+
+| Version  | Supported |
+|----------|-----------|
+| 1.latest | ✅         |
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+## Additional Support
+
+If you are interested in support for versions older than the latest release,
+please consider sponsoring the project / maintainer @ https://liberapay.com/pboling/donate,
+or find other sponsorship links in the [README].
+
+[README]: README.md

data/certs/pboling.pem

@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEgDCCAuigAwIBAgIBATANBgkqhkiG9w0BAQsFADBDMRUwEwYDVQQDDAxwZXRl
+ci5ib2xpbmcxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkW
+A2NvbTAeFw0yNTA1MDQxNTMzMDlaFw00NTA0MjkxNTMzMDlaMEMxFTATBgNVBAMM
+DHBldGVyLmJvbGluZzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+LGQBGRYDY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAruUoo0WA
+uoNuq6puKWYeRYiZekz/nsDeK5x/0IEirzcCEvaHr3Bmz7rjo1I6On3gGKmiZs61
+LRmQ3oxy77ydmkGTXBjruJB+pQEn7UfLSgQ0xa1/X3kdBZt6RmabFlBxnHkoaGY5
+mZuZ5+Z7walmv6sFD9ajhzj+oIgwWfnEHkXYTR8I6VLN7MRRKGMPoZ/yvOmxb2DN
+coEEHWKO9CvgYpW7asIihl/9GMpKiRkcYPm9dGQzZc6uTwom1COfW0+ZOFrDVBuV
+FMQRPswZcY4Wlq0uEBLPU7hxnCL9nKK6Y9IhdDcz1mY6HZ91WImNslOSI0S8hRpj
+yGOWxQIhBT3fqCBlRIqFQBudrnD9jSNpSGsFvbEijd5ns7Z9ZMehXkXDycpGAUj1
+to/5cuTWWw1JqUWrKJYoifnVhtE1o1DZ+LkPtWxHtz5kjDG/zR3MG0Ula0UOavlD
+qbnbcXPBnwXtTFeZ3C+yrWpE4pGnl3yGkZj9SMTlo9qnTMiPmuWKQDatAgMBAAGj
+fzB9MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQE8uWvNbPVNRXZ
+HlgPbc2PCzC4bjAhBgNVHREEGjAYgRZwZXRlci5ib2xpbmdAZ21haWwuY29tMCEG
+A1UdEgQaMBiBFnBldGVyLmJvbGluZ0BnbWFpbC5jb20wDQYJKoZIhvcNAQELBQAD
+ggGBAJbnUwfJQFPkBgH9cL7hoBfRtmWiCvdqdjeTmi04u8zVNCUox0A4gT982DE9
+wmuN12LpdajxZONqbXuzZvc+nb0StFwmFYZG6iDwaf4BPywm2e/Vmq0YG45vZXGR
+L8yMDSK1cQXjmA+ZBKOHKWavxP6Vp7lWvjAhz8RFwqF9GuNIdhv9NpnCAWcMZtpm
+GUPyIWw/Cw/2wZp74QzZj6Npx+LdXoLTF1HMSJXZ7/pkxLCsB8m4EFVdb/IrW/0k
+kNSfjtAfBHO8nLGuqQZVH9IBD1i9K6aSs7pT6TW8itXUIlkIUI2tg5YzW6OFfPzq
+QekSkX3lZfY+HTSp/o+YvKkqWLUV7PQ7xh1ZYDtocpaHwgxe/j3bBqHE+CUPH2vA
+0V/FwdTRWcwsjVoOJTrYcff8pBZ8r2MvtAc54xfnnhGFzeRHfcltobgFxkAXdE6p
+DVjBtqT23eugOqQ73umLcYDZkc36vnqGxUBSsXrzY9pzV5gGr2I8YUxMqf6ATrZt
+L9nRqA==
+-----END CERTIFICATE-----

data/exe/turbo_tests2

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Alias for `turbo_tests` — turbo_tests2 is a drop-in replacement for turbo_tests.
+require "turbo_tests2"
+
+TurboTests::CLI.new(ARGV).run

data/lib/turbo_tests/cli.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module TurboTests
+  class CLI
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def run
+      handle_shim_command if shim_command?
+
+      requires = []
+      formatters = []
+      tags = []
+      count = nil
+      runtime_log = nil
+      verbose = false
+      fail_fast = nil
+      seed = nil
+      print_failed_group = false
+      create = false
+      nice = false
+
+      OptionParser.new do |opts|
+        opts.banner = <<~BANNER
+          Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('1', '2', '3', ...).
+
+          Reports test results incrementally. Uses methods from `parallel_tests` gem to split files to groups.
+
+          Source code of `turbo_tests2` gem is based on Discourse and RubyGems work in this area (see README file of the source repository).
+
+          Usage: turbo_tests2 [options]
+
+          [optional] Only selected files & folders:
+            turbo_tests2 spec/bar spec/baz/xxx_spec.rb
+
+          Options:
+        BANNER
+
+        opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs") { |n| count = n }
+
+        opts.on("-r", "--require PATH", "Require a file.") do |filename|
+          requires << filename
+        end
+
+        opts.on(
+          "-f",
+          "--format FORMATTER",
+          "Choose a formatter. Available formatters: progress (p), documentation (d). Default: progress",
+        ) do |name|
+          formatters << {
+            name: name,
+            outputs: [],
+          }
+        end
+
+        opts.on("-t", "--tag TAG", "Run examples with the specified tag.") do |tag|
+          tags << tag
+        end
+
+        opts.on("-o", "--out FILE", "Write output to a file instead of $stdout") do |filename|
+          if formatters.empty?
+            formatters << {
+              name: "progress",
+              outputs: [],
+            }
+          end
+          formatters.last[:outputs] << filename
+        end
+
+        opts.on("--runtime-log FILE", "Location of previously recorded test runtimes") do |filename|
+          runtime_log = filename
+        end
+
+        opts.on("-v", "--verbose", "More output") do
+          verbose = true
+        end
+
+        opts.on("--fail-fast=[N]") do |n|
+          n = begin
+            Integer(n)
+          rescue StandardError
+            nil
+          end
+          fail_fast = (n.nil? || n < 1) ? 1 : n
+        end
+
+        opts.on("--seed SEED", "Seed for rspec") do |s|
+          seed = s
+        end
+
+        opts.on("--create", "Create databases") do
+          create = true
+        end
+
+        opts.on("--print_failed_group", "Prints group that had failures in it") do
+          print_failed_group = true
+        end
+
+        opts.on("--nice", "execute test commands with low priority") do
+          nice = true
+        end
+      end.parse!(@argv)
+
+      if create
+        return TurboTests::Runner.create(count)
+      end
+
+      requires.each { |f| require(f) }
+
+      if formatters.empty?
+        formatters << {
+          name: "progress",
+          outputs: [],
+        }
+      end
+
+      formatters.each do |formatter|
+        formatter[:outputs] << "-" if formatter[:outputs].empty?
+      end
+
+      load_rake
+
+      invoke_rake_task("turbo_tests:setup")
+
+      files = @argv.empty? ? ["spec"] : @argv
+      parallel_options = {}
+
+      exitstatus = TurboTests::Runner.run(
+        formatters: formatters,
+        tags: tags,
+        files: files,
+        runtime_log: runtime_log,
+        verbose: verbose,
+        fail_fast: fail_fast,
+        count: count,
+        seed: seed,
+        nice: nice,
+        print_failed_group: print_failed_group,
+        parallel_options: parallel_options,
+      )
+
+      invoke_rake_task("turbo_tests:cleanup")
+
+      # From https://github.com/galtzo-floss/turbo_tests2/pull/20/
+      exit(exitstatus)
+    end
+
+    private
+
+    def shim_command?
+      @argv.first == "shim"
+    end
+
+    def handle_shim_command
+      command = @argv[1]
+      args = @argv.drop(2)
+
+      result =
+        case command
+        when "install"
+          TurboTests::Shim.install(project_root: Dir.pwd, path: parse_shim_path(args, command: command))
+        when "remove"
+          TurboTests::Shim.remove(project_root: Dir.pwd, path: parse_shim_path(args, command: command))
+        else
+          warn(shim_usage(command))
+          exit(1)
+        end
+
+      io = result.exit_code.zero? ? $stdout : $stderr
+      io.puts(result.message)
+      exit(result.exit_code)
+    end
+
+    def parse_shim_path(args, command:)
+      path_override = nil
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: turbo_tests2 shim #{command} [--path PATH]"
+        opts.on("--path PATH", "Use a custom shim path instead of bin/turbo_tests") { |value| path_override = value }
+      end
+
+      remaining = parser.parse(args.dup)
+      if remaining.size > 1 || (remaining.any? && path_override)
+        warn(shim_usage(command))
+        exit(1)
+      end
+
+      remaining.first || path_override
+    rescue OptionParser::ParseError => e
+      warn(e.message)
+      warn(shim_usage(command))
+      exit(1)
+    end
+
+    def shim_usage(command = nil)
+      lines = [
+        "Usage: turbo_tests2 shim install [--path PATH]",
+        "       turbo_tests2 shim remove [--path PATH]",
+      ]
+      lines << "Unknown shim command: #{command}" if command && !%w[install remove].include?(command)
+      lines.join("\n")
+    end
+
+    def load_rake
+      begin
+        require "rake"
+      rescue LoadError
+        # :nocov:
+        return # rake is optional
+        # :nocov:
+      end
+
+      # Pass an empty argv so Rake doesn't parse the current process's ARGV,
+      # which may contain non-Rake arguments (e.g. RSpec's --pattern flag when
+      # tests are run via `rake spec`).
+      Rake.application.init("rake", [])
+      Rake.application.load_rakefile
+    end
+
+    def invoke_rake_task(name)
+      return unless defined?(Rake) && Rake::Task.task_defined?(name)
+
+      Rake::Task[name].invoke
+    end
+  end
+end

data/lib/turbo_tests/json_rows_formatter.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "json"
+require "rspec/core"
+require "rspec/core/formatters"
+require "rspec/core/notifications"
+
+module RSpecExt
+  def handle_interrupt
+    if RSpec.world.wants_to_quit
+      exit!(1)
+    else
+      RSpec.world.wants_to_quit = true
+    end
+  end
+end
+
+RSpec::Core::Runner.singleton_class.prepend(RSpecExt)
+
+module TurboTests
+  # An RSpec formatter used for each subprocess during parallel test execution
+  class JsonRowsFormatter
+    RSpec::Core::Formatters.register(
+      self,
+      :start,
+      :close,
+      :example_failed,
+      :example_passed,
+      :example_pending,
+      :example_group_started,
+      :example_group_finished,
+      :message,
+      :seed,
+    )
+
+    attr_reader :output
+
+    def initialize(output)
+      @output = output
+    end
+
+    def start(notification)
+      output_row(
+        type: :load_summary,
+        summary: load_summary_to_json(notification),
+      )
+    end
+
+    def example_group_started(notification)
+      output_row(
+        type: :group_started,
+        group: group_to_json(notification),
+      )
+    end
+
+    def example_group_finished(notification)
+      output_row(
+        type: :group_finished,
+        group: group_to_json(notification),
+      )
+    end
+
+    def example_passed(notification)
+      output_row(
+        type: :example_passed,
+        example: example_to_json(notification.example),
+      )
+    end
+
+    def example_pending(notification)
+      output_row(
+        type: :example_pending,
+        example: example_to_json(notification.example),
+      )
+    end
+
+    def example_failed(notification)
+      output_row(
+        type: :example_failed,
+        example: example_to_json(notification.example),
+      )
+    end
+
+    def seed(notification)
+      output_row(
+        type: :seed,
+        seed: notification.seed,
+      )
+    end
+
+    def close(_notification)
+      output_row(
+        type: :close,
+      )
+    end
+
+    def message(notification)
+      output_row(
+        type: :message,
+        message: notification.message,
+      )
+    end
+
+    private
+
+    def exception_to_json(exception)
+      return unless exception
+
+      {
+        class_name: exception.class.name.to_s,
+        backtrace: exception.backtrace,
+        message: exception.message,
+        cause: exception_to_json(exception.cause),
+      }
+    end
+
+    def execution_result_to_json(result)
+      {
+        example_skipped?: result.example_skipped?,
+        pending_message: result.pending_message,
+        status: result.status,
+        pending_fixed?: result.pending_fixed?,
+        exception: exception_to_json(result.exception || result.pending_exception),
+      }
+    end
+
+    def stack_frame_to_json(frame)
+      {
+        shared_group_name: frame.shared_group_name,
+        inclusion_location: frame.inclusion_location,
+      }
+    end
+
+    def example_to_json(example)
+      {
+        execution_result: execution_result_to_json(example.execution_result),
+        location: example.location,
+        description: example.description,
+        full_description: example.full_description,
+        metadata: {
+          shared_group_inclusion_backtrace:
+            example
+              .metadata[:shared_group_inclusion_backtrace]
+              .map { |frame| stack_frame_to_json(frame) },
+          extra_failure_lines: example.metadata[:extra_failure_lines],
+        },
+        location_rerun_argument: example.location_rerun_argument,
+      }
+    end
+
+    def load_summary_to_json(notification)
+      {
+        count: notification.count,
+        load_time: notification.load_time,
+      }
+    end
+
+    def group_to_json(notification)
+      {
+        group: {
+          description: notification.group.description,
+        },
+      }
+    end
+
+    def output_row(obj)
+      output.puts ENV["RSPEC_FORMATTER_OUTPUT_ID"] + obj.to_json
+      output.flush
+    end
+  end
+end

data/lib/turbo_tests/reporter.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module TurboTests
+  class Reporter
+    attr_writer :load_time
+    attr_reader :pending_examples, :failed_examples
+
+    class << self
+      def from_config(formatter_config, start_time, seed, seed_used, files, parallel_options)
+        reporter = new(start_time, seed, seed_used, files, parallel_options)
+
+        formatter_config.each do |config|
+          name, outputs = config.values_at(:name, :outputs)
+
+          outputs.map! do |filename|
+            (filename == "-") ? $stdout : File.open(filename, "w")
+          end
+
+          reporter.add(name, outputs)
+        end
+
+        reporter
+      end
+    end
+
+    def initialize(start_time, seed, seed_used, files, parallel_options)
+      @formatters = []
+      @pending_examples = []
+      @failed_examples = []
+      @all_examples = []
+      @messages = []
+      @start_time = start_time
+      @seed = seed
+      @seed_used = seed_used
+      @load_time = 0
+      @errors_outside_of_examples_count = 0
+      @files = files
+      @parallel_options = parallel_options
+    end
+
+    def add(name, outputs)
+      outputs.each do |output|
+        formatter_class =
+          case name
+          when "p", "progress"
+            RSpec::Core::Formatters::ProgressFormatter
+          when "d", "documentation"
+            RSpec::Core::Formatters::DocumentationFormatter
+          else
+            Kernel.const_get(name)
+          end
+
+        @formatters << formatter_class.new(output)
+      end
+    end
+
+    # Borrowed from RSpec::Core::Reporter
+    # https://github.com/rspec/rspec-core/blob/5699fcdc4723087ff6139af55bd155ad9ad61a7b/lib/rspec/core/reporter.rb#L71
+    def report(example_groups)
+      start(example_groups)
+      begin
+        yield self
+      ensure
+        finish
+      end
+    end
+
+    def start(example_groups, time = RSpec::Core::Time.now)
+      @start = time
+      @load_time = (@start - @start_time).to_f
+
+      report_number_of_tests(example_groups)
+      expected_example_count = example_groups.flatten(1).count
+
+      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),
+      )
+    end
+
+    def report_number_of_tests(groups)
+      name = ParallelTests::RSpec::Runner.test_file_name
+
+      num_processes = groups.size
+      num_tests = groups.map(&:size).sum
+      tests_per_process = ((num_processes == 0) ? 0 : num_tests.to_f / num_processes).round
+
+      puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{tests_per_process} #{name}s per process"
+    end
+
+    def group_started(notification)
+      delegate_to_formatters(:example_group_started, notification)
+    end
+
+    def group_finished
+      delegate_to_formatters(:example_group_finished, nil)
+    end
+
+    def example_passed(example)
+      delegate_to_formatters(:example_passed, example.notification)
+
+      @all_examples << example
+    end
+
+    def example_pending(example)
+      delegate_to_formatters(:example_pending, example.notification)
+
+      @all_examples << example
+      @pending_examples << example
+    end
+
+    def example_failed(example)
+      delegate_to_formatters(:example_failed, example.notification)
+
+      @all_examples << example
+      @failed_examples << example
+    end
+
+    def message(message)
+      delegate_to_formatters(:message, RSpec::Core::Notifications::MessageNotification.new(message))
+      @messages << message
+    end
+
+    def error_outside_of_examples(error_message)
+      @errors_outside_of_examples_count += 1
+      message(error_message)
+    end
+
+    def finish
+      end_time = RSpec::Core::Time.now
+
+      @duration = end_time - @start_time
+      delegate_to_formatters(:stop, RSpec::Core::Notifications::ExamplesNotification.new(self))
+
+      delegate_to_formatters(:start_dump, RSpec::Core::Notifications::NullNotification)
+      delegate_to_formatters(
+        :dump_pending,
+        RSpec::Core::Notifications::ExamplesNotification.new(
+          self,
+        ),
+      )
+      delegate_to_formatters(
+        :dump_failures,
+        RSpec::Core::Notifications::ExamplesNotification.new(
+          self,
+        ),
+      )
+      delegate_to_formatters(
+        :dump_summary,
+        RSpec::Core::Notifications::SummaryNotification.new(
+          end_time - @start_time,
+          @all_examples,
+          @failed_examples,
+          @pending_examples,
+          @load_time,
+          @errors_outside_of_examples_count,
+        ),
+      )
+      delegate_to_formatters(
+        :seed,
+        RSpec::Core::Notifications::SeedNotification.new(
+          @seed,
+          @seed_used,
+        ),
+      )
+    ensure
+      delegate_to_formatters(:close, RSpec::Core::Notifications::NullNotification)
+    end
+
+    protected
+
+    def delegate_to_formatters(method, *args)
+      @formatters.each do |formatter|
+        formatter.send(method, *args) if formatter.respond_to?(method)
+      end
+    end
+  end
+end