selective-ruby-minitest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21ed49908ca7c9dde0483d731253012e7bcad60e19136e1972f4283fb5616569
+  data.tar.gz: ac606566b9df73727b87afb88786e6c69263735f57639845139c052586066f69
+SHA512:
+  metadata.gz: 05d25cde4b7fb970d4bca1f7cb464f35402202eac76fb6f47b16a7272337fd9feca28f5cf332529c89674464b407c71a0e93564f14f16e61b8da50e65e7693e6
+  data.tar.gz: 5e5ff5436b4cdd41c9ba7faee1ba558eacdcef2df6e0d33b448e23bbad73dc8dee56d7966e64dd0c0b7f8279a40a8ee5d65bd63b7d477aeb6663313e23ce0289

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Selective
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/lib/selective/ruby/minitest/monkeypatches.rb

@@ -0,0 +1,55 @@
+module Selective
+  module Ruby
+    module Minitest
+      module Monkeypatches
+        module Minitest
+          def autorun
+            # Noop. Rails calls autorun from: lib/active_support/testing/autorun.rb
+            # when rails/test_help is required in test helper (which is normal rails test setup)
+          end
+
+          # This is the first half of Minitest.run
+          def selective_prerun(args = [])
+            load_plugins unless args.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
+
+            options = process_args args
+
+            ::Minitest.seed = options[:seed]
+            srand ::Minitest.seed
+
+            reporter = ::Minitest::CompositeReporter.new
+            reporter << ::Minitest::SummaryReporter.new(options[:io], options)
+            reporter << ::Minitest::ProgressReporter.new(options[:io], options) unless options[:quiet]
+
+            self.reporter = reporter # this makes it available to plugins
+            init_plugins options.merge(report_name: ->(name) { "report-#{name}-#{SecureRandom.uuid}.xml" })
+            self.reporter = nil # runnables shouldn't depend on the reporter, ever
+
+            parallel_executor.start if parallel_executor.respond_to?(:start)
+            reporter.start
+            reporter
+          end
+
+          # This is the second half of ::Minitest.run
+          def selective_postrun(reporter, args = [])
+            options = process_args args
+
+            parallel_executor.shutdown
+
+            # might have been removed/replaced during init_plugins:
+            summary = reporter.reporters.grep(::Minitest::SummaryReporter).first
+
+            reporter.report
+
+            return empty_run! options if summary && summary.count == 0
+            reporter.passed?
+          end
+        end
+
+        def self.apply(config)
+          ::Minitest.singleton_class.prepend(Minitest)
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/minitest/runner_wrapper.rb

@@ -0,0 +1,233 @@
+require "tempfile"
+require 'digest'
+require "json"
+
+module Selective
+  module Ruby
+    module Minitest
+      class RunnerWrapper
+        class TestManifestError < StandardError; end
+
+        attr_reader :test_case_callback, :reporter, :test_ids, :targeted_test_ids, :minitest_args, :test_map
+        attr_accessor :connection_lost
+
+        FRAMEWORK = "minitest"
+        DEFAULT_TEST_DIR = "test"
+
+        def initialize(args, test_case_callback)
+          @test_case_callback = test_case_callback
+
+          @targeted_test_ids, @minitest_args, wrapper_config_hash = parse_args(args)
+          Selective::Ruby::Minitest::Monkeypatches.apply(wrapper_config_hash)
+
+          configure
+        end
+
+        def manifest
+          raise_test_manifest_error("No test cases found") if test_ids.empty?
+
+          ids = @targeted_test_ids.any? ? @targeted_test_ids : test_ids
+          {
+            "test_cases" => ids.map do |test_id|
+              test = test_map[test_id]
+              {
+                id: test_id,
+                file_path: test[:file_path],
+                run_time: 0.0
+              }
+            end
+          }
+        end
+
+        def run_test_cases(test_case_ids)
+          test_case_ids.map do |test_id|
+            klass, method_name = get_test_from_map(test_id)
+            real_time = time { klass.run_one_method(klass, method_name, reporter) }
+            foo = format_test_case(test_id, klass, method_name, real_time)
+            test_case_callback.call(foo)
+          end
+        end
+
+        def remove_test_case_result(test_case_id)
+          file_path, method_name = test_case_id.split(":")
+
+          result = summary_reporter.results.detect do |r|
+            r.source_location.first.gsub(root_path, "") == file_path &&
+              r.name == method_name
+          end
+
+          result.failures = []
+
+          summary_reporter.results.delete(result)
+        end
+
+        def base_test_path
+          "./#{default_test_glob.split("/").first}"
+        end
+
+        def exit_status
+          failures.length.zero? ? 0 : 1
+        end
+
+        def finish
+          ::Minitest.selective_postrun(reporter, minitest_args)
+
+          # This usually happens in at_exit defined in autorun.
+          ::Minitest.class_variable_get(:@@after_run).reverse_each(&:call)
+        end
+
+        def framework
+          RunnerWrapper::FRAMEWORK
+        end
+
+        def framework_version
+          ::Minitest::VERSION
+        end
+
+        def wrapper_version
+          ::Minitest::VERSION
+        end
+
+        private
+
+        def time(&block)
+          Benchmark.measure(&block).real
+        end
+
+        def get_test_from_map(test_id)
+          t = test_map[test_id]
+
+          [t[:klass], t[:method_name]]
+
+        rescue
+          puts "Test not found in map: #{test_id}"
+        end
+
+        def summary_reporter
+          reporter.reporters.grep(::Minitest::SummaryReporter).first || # Minitest with no 3rd party reporter gems
+            reporter.reporters.first.send(:all_reporters)&.grep(::Minitest::Reporters::DefaultReporter)&.first # Minitest with minitest-reporters gem
+        end
+
+        def failures
+          summary_reporter.results
+        end
+
+        def failure_for(klass, method_name)
+          failures.last.then do |last_failure|
+            return if last_failure.nil?
+            return unless klass.to_s == last_failure.klass
+            return unless last_failure.name == method_name
+
+            last_failure
+          end
+        end
+
+        def format_test_case(test_id, klass, method_name, time)
+          failure = failure_for(klass, method_name)
+          test = test_map[test_id]
+
+          status = if failure.nil?
+            "passed"
+          else
+            failure.skipped? ? "pending" : "failed"
+          end
+
+          result = {
+            id: test_id,
+            description: method_name,
+            full_description: method_name,
+            status: status,
+            file_path: test[:file_path],
+            line_number: test[:line_number].to_i,
+            run_time: time
+          }
+
+          failure && result.merge!(
+            failure_message_lines: failure.to_s.split("\n"),
+            failure_formatted_backtrace: failure.failures&.first&.backtrace || []
+          )
+
+          result
+        end
+
+        def default_test_glob
+          ENV["DEFAULT_TEST"] || "#{DEFAULT_TEST_DIR}/**/*_test.rb"
+        end
+
+        def list_tests(patterns)
+          Rake::FileList[patterns.any? ? patterns : default_test_glob].then do |files|
+            include_pattern = ENV["INCLUDE_PATTERN"]
+            exclude_pattern = ENV["EXCLUDE_PATTERN"]
+
+            files = files.select { |file| file.match?(include_pattern) } if include_pattern
+            files = files.reject { |file| file.match?(exclude_pattern) } if exclude_pattern
+
+            files
+          end
+        end
+
+        def parse_args(args)
+          flag_args, test_ids = args.partition do |arg|
+            arg.start_with?("-")
+          end
+
+          supported_wrapper_args = %w[]
+          wrapper_args, minitest_args = flag_args.partition do |arg|
+            supported_wrapper_args.any? do |p|
+              arg.start_with?(p)
+            end
+          end
+
+          wrapper_config_hash = wrapper_args.each_with_object({}) do |arg, hash|
+            key = arg.sub("--", "").tr("-", "_").to_sym
+            hash[key] = true
+          end
+
+          [test_ids, minitest_args, wrapper_config_hash]
+        end
+
+        def normalize_path(path)
+          Pathname.new(path).relative_path_from("./")
+        end
+
+        def raise_test_manifest_error(output)
+          raise TestManifestError.new("Selective could not generate a test manifest. The output was:\n#{output}")
+        end
+
+        def root_path
+          "#{Dir.pwd}/"
+        end
+
+        def configure
+          targeted_test_paths = targeted_test_ids.map { |test_id| test_id.split(":").first }.uniq
+          tests = targeted_test_paths.any? ? targeted_test_paths : list_tests([])
+          $LOAD_PATH.unshift "./#{DEFAULT_TEST_DIR}"
+          tests.to_a.each { |path| require File.expand_path(path) }
+
+          @reporter = ::Minitest.selective_prerun(minitest_args)
+          suites = ::Minitest::Runnable.runnables.shuffle
+
+          @test_ids, @test_map, duplicate_test_ids = suites.each_with_object([[], {}, []]) do |klass, (test_ids, test_map, duplicate_test_ids)|
+            klass.runnable_methods.map do |method_name|
+              file_path, line_number = klass.instance_method(method_name).source_location
+              file_path = file_path.gsub(root_path, "")
+              digest = Digest::MD5.hexdigest("#{klass.name}##{method_name}")
+              test_id = "#{file_path}:#{digest}"
+
+              if test_map[test_id]
+                duplicate_test_ids << "#{file_path}:#{line_number}"
+              else
+                test_ids << test_id
+                test_map[test_id] = {klass: klass, method_name: method_name, file_path: file_path, line_number: line_number}
+              end
+            end
+          end
+
+          if duplicate_test_ids.any?
+            puts("\e[33mDuplicate test ids found. Please ensure unique test class/method names are used to ensure all tests are run. \n#{duplicate_test_ids.join("\n")}\e[0m")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/minitest/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Selective
+  module Ruby
+    module Minitest
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/selective-ruby-minitest.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "minitest"
+require "rake/file_list"
+require "benchmark"
+require "#{__dir__}/selective/ruby/minitest/version"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.inflector.inflect("minitest" => "Minitest")
+loader.ignore("#{__dir__}/selective-ruby-minitest.rb")
+loader.ignore("#{__dir__}/selective/ruby/minitest/version.rb")
+loader.setup
+
+require "selective-ruby-core"
+
+module Selective
+  module Ruby
+    module Minitest
+      class Error < StandardError; end
+
+      def self.register
+        Selective::Ruby::Core.register_runner(
+          "minitest", Selective::Ruby::Minitest::RunnerWrapper
+        )
+      end
+    end
+  end
+end
+
+Selective::Ruby::Minitest.register

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: selective-ruby-minitest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Benjamin Wood
+- Nate Vick
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.12
+- !ruby/object:Gem::Dependency
+  name: selective-ruby-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Selective is an intelligent test runner for your current CI provider.
+  Get real-time test results, intelligent ordering based on code changes, shorter
+  run times, automatic flake detection, the ability to re-enqueue failed tests, and
+  more.
+email:
+- ben@hint.io
+- nate@hint.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- lib/selective-ruby-minitest.rb
+- lib/selective/ruby/minitest/monkeypatches.rb
+- lib/selective/ruby/minitest/runner_wrapper.rb
+- lib/selective/ruby/minitest/version.rb
+homepage: https://www.selective.ci
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.selective.ci
+  source_code_uri: http://github.com/selectiveci/selective-ruby-minitest
+  changelog_uri: https://github.com/selectiveci/selective-ruby-minitest/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key: 
+specification_version: 4
+summary: Selective Ruby Minitest Client
+test_files: []