minitest-distributed 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67081c1e600e34e7dce42e505d453bf376678e3cf13ed4509aedc30283dc3c7b
-  data.tar.gz: 3c9bbf622d0f5924f47871ce4dc7eb4f32542a646a67fdbd79e42a886dcbf5a3
+  metadata.gz: 3898c3d3b163b66922daf90468041da6e76e07c8c102971c8f3cc71ad20e6bd4
+  data.tar.gz: 19c90e644ce560e5d1981dfb6a72d99bfa98daf95997e684954e3cd4d38906ff
 SHA512:
-  metadata.gz: add56064540e75a53e8ab6d22ee82e5d7fac6191a1c68e4649bdf6b086ffa2114c92ce61b21ce9132d54b3c690dc64791081c023bc7d526c029c1d3580cc6f73
-  data.tar.gz: b3d2785c1968a5c5ee78936b7e0c3c257ed6be815f77a3de17403d25934636cd9e4bfdc71ebe15aba9b372434018f7444bde63039a340b3c48827b1482b6b14d
+  metadata.gz: e772261c32992207573b5e76a12ae50eb26120c4d007f013246c6058821c200900a5a914d2bf474d37ffb571b5b03ae95fcc1e95d73a7eaa5e51ccfc15dc08d4
+  data.tar.gz: 905aff0608a7cda2910a920bd9650a9097e9da85104795f3b9ff4c143f4d4ea4dd4608f71d8a103275e821d17b9bf3340c68d33abcc0ef44cc304cda089f79c5

data/.github/workflows/ruby.yml

@@ -10,7 +10,24 @@ name: Ruby
 on: push
 
 jobs:
-  test:
+  test_30:
+    runs-on: ubuntu-latest
+    container: ruby:3.0
+
+    services:
+      redis:
+        image: redis
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: gem install bundler && bundle install
+    - name: Run tests
+      run: bin/rake test
+      env:
+        REDIS_URL: redis://redis:6379
+
+  test_26:
     runs-on: ubuntu-latest
     container: ruby:2.6
 

data/.rubocop.yml

@@ -3,6 +3,8 @@ inherit_gem:
 
 require:
   - rubocop-sorbet
+  - rubocop-rake
+  - rubocop-minitest
 
 AllCops:
   TargetRubyVersion: 2.6

data/Gemfile

@@ -10,3 +10,5 @@ gem "sorbet"
 gem "rubocop"
 gem "rubocop-shopify"
 gem "rubocop-sorbet"
+gem "rubocop-minitest"
+gem "rubocop-rake"

data/lib/minitest/distributed.rb

@@ -1,8 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'minitest'
-require 'sorbet-runtime'
+require "minitest"
+require "sorbet-runtime"
 
 require "minitest/distributed/configuration"
 require "minitest/distributed/test_runner"

data/lib/minitest/distributed/configuration.rb

@@ -1,8 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'uri'
-require 'securerandom'
+require "uri"
+require "securerandom"
 
 module Minitest
   module Distributed
@@ -17,13 +17,13 @@ module Minitest
         sig { params(env: T::Hash[String, T.nilable(String)]).returns(T.attached_class) }
         def from_env(env = ENV.to_h)
           new(
-            coordinator_uri: URI(env['MINITEST_COORDINATOR'] || 'memory:'),
-            run_id: env['MINITEST_RUN_ID'] || SecureRandom.uuid,
-            worker_id: env['MINITEST_WORKER_ID'] || SecureRandom.uuid,
-            test_timeout_seconds: Float(env['MINITEST_TEST_TIMEOUT_SECONDS'] || DEFAULT_TEST_TIMEOUT_SECONDS),
-            test_batch_size: Integer(env['MINITEST_TEST_BATCH_SIZE'] || DEFAULT_BATCH_SIZE),
-            max_attempts: Integer(env['MINITEST_MAX_ATTEMPTS'] || DEFAULT_MAX_ATTEMPTS),
-            max_failures: (max_failures_env = env['MINITEST_MAX_FAILURES']) ? Integer(max_failures_env) : nil,
+            coordinator_uri: URI(env["MINITEST_COORDINATOR"] || "memory:"),
+            run_id: env["MINITEST_RUN_ID"] || SecureRandom.uuid,
+            worker_id: env["MINITEST_WORKER_ID"] || SecureRandom.uuid,
+            test_timeout_seconds: Float(env["MINITEST_TEST_TIMEOUT_SECONDS"] || DEFAULT_TEST_TIMEOUT_SECONDS),
+            test_batch_size: Integer(env["MINITEST_TEST_BATCH_SIZE"] || DEFAULT_BATCH_SIZE),
+            max_attempts: Integer(env["MINITEST_MAX_ATTEMPTS"] || DEFAULT_MAX_ATTEMPTS),
+            max_failures: (max_failures_env = env["MINITEST_MAX_FAILURES"]) ? Integer(max_failures_env) : nil,
           )
         end
 
@@ -32,50 +32,50 @@ module Minitest
           configuration = from_env
           configuration.progress = options[:io].tty?
 
-          opts.on('--coordinator=URI', "The URI pointing to the coordinator") do |uri|
+          opts.on("--coordinator=URI", "The URI pointing to the coordinator") do |uri|
             configuration.coordinator_uri = URI.parse(uri)
           end
 
-          opts.on('--test-timeout=TIMEOUT', "The maximum run time for a single test in seconds") do |timeout|
+          opts.on("--test-timeout=TIMEOUT", "The maximum run time for a single test in seconds") do |timeout|
             configuration.test_timeout_seconds = Float(timeout)
           end
 
-          opts.on('--max-attempts=ATTEMPTS', "The maximum number of attempts to run a test") do |attempts|
+          opts.on("--max-attempts=ATTEMPTS", "The maximum number of attempts to run a test") do |attempts|
             configuration.max_attempts = Integer(attempts)
           end
 
-          opts.on('--test-batch-size=NUMBER', "The number of tests to process per batch") do |batch_size|
+          opts.on("--test-batch-size=NUMBER", "The number of tests to process per batch") do |batch_size|
             configuration.test_batch_size = Integer(batch_size)
           end
 
-          opts.on('--max-failures=FAILURES', "The maximum allowed failure before aborting a run") do |failures|
+          opts.on("--max-failures=FAILURES", "The maximum allowed failure before aborting a run") do |failures|
             configuration.max_failures = Integer(failures)
           end
 
-          opts.on('--run-id=ID', "The ID for this run shared between coordinated workers") do |id|
+          opts.on("--run-id=ID", "The ID for this run shared between coordinated workers") do |id|
             configuration.run_id = id
           end
 
-          opts.on('--worker-id=ID', "The unique ID for this worker") do |id|
+          opts.on("--worker-id=ID", "The unique ID for this worker") do |id|
             configuration.worker_id = id
           end
 
           opts.on(
-            '--[no-]retry-failures', "Retry failed and errored tests from a previous run attempt " \
+            "--[no-]retry-failures", "Retry failed and errored tests from a previous run attempt " \
             "with the same run ID (default: enabled)"
           ) do |enabled|
             configuration.retry_failures = enabled
           end
 
-          opts.on('--[no-]progress', "Show progress during the test run") do |enabled|
+          opts.on("--[no-]progress", "Show progress during the test run") do |enabled|
             configuration.progress = enabled
           end
 
-          opts.on('--exclude-file=FILE_PATH', "Specify a file of tests to be excluded from running") do |file_path|
+          opts.on("--exclude-file=FILE_PATH", "Specify a file of tests to be excluded from running") do |file_path|
             configuration.exclude_file = file_path
           end
 
-          opts.on('--include-file=FILE_PATH', "Specify a file of tests to be included in the test run") do |file_path|
+          opts.on("--include-file=FILE_PATH", "Specify a file of tests to be included in the test run") do |file_path|
             configuration.include_file = file_path
           end
 
@@ -86,7 +86,7 @@ module Minitest
       extend T::Sig
 
       # standard minitest options don't need to be specified
-      prop :coordinator_uri, URI::Generic, default: URI('memory:')
+      prop :coordinator_uri, URI::Generic, default: URI("memory:")
       prop :run_id, String, factory: -> { SecureRandom.uuid }
       prop :worker_id, String, factory: -> { SecureRandom.uuid }
       prop :test_timeout_seconds, Float, default: DEFAULT_TEST_TIMEOUT_SECONDS
@@ -102,9 +102,9 @@ module Minitest
       def coordinator
         @coordinator = T.let(@coordinator, T.nilable(Coordinators::CoordinatorInterface))
         @coordinator ||= case coordinator_uri.scheme
-        when 'redis'
+        when "redis"
           Coordinators::RedisCoordinator.new(configuration: self)
-        when 'memory'
+        when "memory"
           Coordinators::MemoryCoordinator.new(configuration: self)
         else
           raise NotImplementedError, "Unknown coordinator implementation: #{coordinator_uri.scheme}"

data/lib/minitest/distributed/coordinators/redis_coordinator.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'redis'
+require "redis"
 
 module Minitest
   module Distributed
@@ -65,8 +65,8 @@ module Minitest
           @configuration = configuration
 
           @redis = T.let(nil, T.nilable(Redis))
-          @stream_key = T.let(key('queue'), String)
-          @group_name = T.let('minitest-distributed', String)
+          @stream_key = T.let(key("queue"), String)
+          @group_name = T.let("minitest-distributed", String)
           @local_results = T.let(ResultAggregate.new, ResultAggregate)
           @combined_results = T.let(nil, T.nilable(ResultAggregate))
           @reclaimed_timeout_tests = T.let(Set.new, T::Set[EnqueuedRunnable])
@@ -82,9 +82,9 @@ module Minitest
         sig { override.returns(ResultAggregate) }
         def combined_results
           @combined_results ||= begin
-            stats_as_string = redis.mget(key('runs'), key('assertions'), key('passes'),
-              key('failures'), key('errors'), key('skips'), key('requeues'), key('discards'),
-              key('acks'), key('size'))
+            stats_as_string = redis.mget(key("runs"), key("assertions"), key("passes"),
+              key("failures"), key("errors"), key("skips"), key("requeues"), key("discards"),
+              key("acks"), key("size"))
 
             ResultAggregate.new(
               max_failures: configuration.max_failures,
@@ -124,13 +124,13 @@ module Minitest
             # fails, and the DEL never gets executed for followers.
             keys_deleted = redis.evalsha(
               register_consumergroup_script,
-              keys: [stream_key, key('size'), key('acks')],
+              keys: [stream_key, key("size"), key("acks")],
               argv: [group_name],
             )
             keys_deleted == 0
 
           rescue Redis::CommandError => ce
-            if ce.message.include?('BUSYGROUP')
+            if ce.message.include?("BUSYGROUP")
               # If Redis returns a BUSYGROUP error, it means that the consumer group already
               # exists. In our case, it means that another worker managed to successfully
               # run the XGROUP command, and will act as leader and publish the tests.
@@ -200,7 +200,9 @@ module Minitest
           end
 
           redis.pipelined do
-            tests.each { |test| redis.xadd(stream_key, class_name: T.must(test.class.name), method_name: test.name) }
+            tests.each do |test|
+              redis.xadd(stream_key, { class_name: T.must(test.class.name), method_name: test.name })
+            end
           end
         end
 
@@ -238,7 +240,7 @@ module Minitest
 
           cleanup
         rescue Redis::CommandError => ce
-          if ce.message.start_with?('NOGROUP')
+          if ce.message.start_with?("NOGROUP")
             # When a redis conumer group commands fails with a NOGROUP error, we assume the
             # consumer group was deleted by the first worker that detected the run is complete.
             # So this worker can exit its loop as well.
@@ -277,7 +279,7 @@ module Minitest
 
         sig { params(block: Integer).returns(T::Array[EnqueuedRunnable]) }
         def claim_fresh_runnables(block:)
-          result = redis.xreadgroup(group_name, configuration.worker_id, stream_key, '>',
+          result = redis.xreadgroup(group_name, configuration.worker_id, stream_key, ">",
             block: block, count: configuration.test_batch_size)
           EnqueuedRunnable.from_redis_stream_claim(result.fetch(stream_key, []), configuration: configuration)
         end
@@ -305,7 +307,7 @@ module Minitest
           max_idle_time_ms_with_jitter = max_idle_time_ms * rand(1.0...1.2)
 
           # Find all the pending messages to see if we want to attenpt to claim some.
-          pending = redis.xpending(stream_key, group_name, '-', '+', configuration.test_batch_size)
+          pending = redis.xpending(stream_key, group_name, "-", "+", configuration.test_batch_size)
           return [] if pending.empty?
 
           active_consumers = Set[configuration.worker_id]
@@ -327,9 +329,9 @@ module Minitest
           # We can skip this if we already know that there is more than one active one.
           if active_consumers.size == 1
             begin
-              redis.xinfo('consumers', stream_key, group_name).each do |consumer|
-                if consumer.fetch('idle') < max_idle_time_ms
-                  active_consumers << consumer.fetch('name')
+              redis.xinfo("consumers", stream_key, group_name).each do |consumer|
+                if consumer.fetch("idle") < max_idle_time_ms
+                  active_consumers << consumer.fetch("name")
                 end
               end
             rescue Redis::CommandError
@@ -383,7 +385,7 @@ module Minitest
           messages_in_retry_set = {}
           redis.multi do
             active_messages.each do |key, message|
-              messages_in_retry_set[key] = redis.srem(key('retry_set'), message.attempt_id)
+              messages_in_retry_set[key] = redis.srem(key("retry_set"), message.attempt_id)
             end
           end
 
@@ -406,16 +408,16 @@ module Minitest
         sig { params(results: ResultAggregate).void }
         def adjust_combined_results(results)
           updated = redis.multi do
-            redis.incrby(key('runs'), results.runs)
-            redis.incrby(key('assertions'), results.assertions)
-            redis.incrby(key('passes'), results.passes)
-            redis.incrby(key('failures'), results.failures)
-            redis.incrby(key('errors'), results.errors)
-            redis.incrby(key('skips'), results.skips)
-            redis.incrby(key('requeues'), results.requeues)
-            redis.incrby(key('discards'), results.discards)
-            redis.incrby(key('acks'), results.acks)
-            redis.incrby(key('size'), results.size)
+            redis.incrby(key("runs"), results.runs)
+            redis.incrby(key("assertions"), results.assertions)
+            redis.incrby(key("passes"), results.passes)
+            redis.incrby(key("failures"), results.failures)
+            redis.incrby(key("errors"), results.errors)
+            redis.incrby(key("skips"), results.skips)
+            redis.incrby(key("requeues"), results.requeues)
+            redis.incrby(key("discards"), results.discards)
+            redis.incrby(key("acks"), results.acks)
+            redis.incrby(key("size"), results.size)
           end
 
           @combined_results = ResultAggregate.new(max_failures: configuration.max_failures,
@@ -452,7 +454,7 @@ module Minitest
             results.each do |enqueued_runnable, initial_result|
               runnable_results << enqueued_runnable.commit_result(initial_result) do |result_to_commit|
                 if ResultType.of(result_to_commit) == ResultType::Requeued
-                  sadd_future = redis.sadd(key('retry_set'), enqueued_runnable.attempt_id)
+                  sadd_future = redis.sadd(key("retry_set"), enqueued_runnable.attempt_id)
                   EnqueuedRunnable::Result::Commit.new { sadd_future.value }
                 else
                   xack_future = redis.xack(stream_key, group_name, enqueued_runnable.entry_id)

data/lib/minitest/distributed/enqueued_runnable.rb

@@ -19,10 +19,10 @@ module Minitest
       sig { params(xpending_result: T::Hash[String, T.untyped]).returns(T.attached_class) }
       def self.from_xpending(xpending_result)
         new(
-          worker_id: xpending_result.fetch('consumer'),
-          entry_id: xpending_result.fetch('entry_id'),
-          elapsed_time_ms: xpending_result.fetch('elapsed'),
-          attempt: xpending_result.fetch('count'),
+          worker_id: xpending_result.fetch("consumer"),
+          entry_id: xpending_result.fetch("entry_id"),
+          elapsed_time_ms: xpending_result.fetch("elapsed"),
+          attempt: xpending_result.fetch("count"),
         )
       end
     end
@@ -33,7 +33,7 @@ module Minitest
 
       sig { params(name: String).returns(T.class_of(Minitest::Runnable)) }
       def self.find_class(name)
-        name.split('::')
+        name.split("::")
           .reduce(Object) { |ns, const| ns.const_get(const) } # rubocop:disable Sorbet/ConstantsFromStrings
       end
 
@@ -44,7 +44,7 @@ module Minitest
 
       sig { params(identifier: String).returns(Minitest::Runnable) }
       def self.from_identifier(identifier)
-        class_name, method_name = identifier.split('#', 2)
+        class_name, method_name = identifier.split("#", 2)
         find_class(T.must(class_name)).new(T.must(method_name))
       end
     end
@@ -133,8 +133,8 @@ module Minitest
             attempt = pending_messages.key?(entry_id) ? pending_messages.fetch(entry_id).attempt + 1 : 1
 
             new(
-              class_name: runnable_method_info.fetch('class_name'),
-              method_name: runnable_method_info.fetch('method_name'),
+              class_name: runnable_method_info.fetch("class_name"),
+              method_name: runnable_method_info.fetch("method_name"),
               entry_id: entry_id,
               attempt: attempt,
               max_attempts: configuration.max_attempts,

data/lib/minitest/distributed/reporters/distributed_progress_reporter.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'io/console'
+require "io/console"
 
 module Minitest
   module Distributed
@@ -25,7 +25,7 @@ module Minitest
 
         sig { override.void }
         def start
-          Signal.trap('WINCH') { @window_line_width = nil }
+          Signal.trap("WINCH") { @window_line_width = nil }
           super
         end
 
@@ -74,7 +74,7 @@ module Minitest
 
         sig { void }
         def clear_current_line
-          io.print("\r" + (' ' * window_line_width) + "\r")
+          io.print("\r" + (" " * window_line_width) + "\r")
         end
 
         sig { returns(Integer) }

data/lib/minitest/distributed/reporters/junitxml_reporter.rb

@@ -1,8 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'rexml/document'
-require 'fileutils'
+require "rexml/document"
+require "fileutils"
 
 module Minitest
   module Distributed
@@ -27,7 +27,7 @@ module Minitest
 
         sig { params(io: IO, options: T::Hash[Symbol, T.untyped]).void }
         def initialize(io, options)
-          @io = io
+          super
           @report_path = T.let(options.fetch(:junitxml), String)
           @results = T.let(Hash.new { |hash, key| hash[key] = [] }, T::Hash[String, T::Array[Minitest::Result]])
         end
@@ -48,7 +48,7 @@ module Minitest
         sig { override.void }
         def report
           FileUtils.mkdir_p(File.dirname(@report_path))
-          File.open(@report_path, 'w+') do |file|
+          File.open(@report_path, "w+") do |file|
             format_document(generate_document, file)
           end
         end
@@ -56,9 +56,9 @@ module Minitest
         sig { returns(REXML::Document) }
         def generate_document
           doc = REXML::Document.new(nil, prologue_quote: :quote, attribute_quote: :quote)
-          doc << REXML::XMLDecl.new('1.1', 'utf-8')
+          doc << REXML::XMLDecl.new("1.1", "utf-8")
 
-          testsuites = doc.add_element('testsuites')
+          testsuites = doc.add_element("testsuites")
           results.each do |suite, tests|
             add_tests_to(testsuites, suite, tests)
           end
@@ -81,21 +81,21 @@ module Minitest
           lineno = T.must(results.first).source_location.last
 
           testsuite = testsuites.add_element(
-            'testsuite',
-            { 'name' => suite, 'filepath' => relative_path }.merge(aggregate_suite_results(results))
+            "testsuite",
+            { "name" => suite, "filepath" => relative_path }.merge(aggregate_suite_results(results))
           )
 
           results.each do |test|
             attributes = {
-              'name' => test.name,
-              'classname' => suite,
-              'assertions' => test.assertions,
-              'time' => test.time,
+              "name" => test.name,
+              "classname" => suite,
+              "assertions" => test.assertions,
+              "time" => test.time,
               # 'run-command' => ... # TODO
             }
-            attributes['lineno'] = lineno if lineno != -1
+            attributes["lineno"] = lineno if lineno != -1
 
-            testcase_tag = testsuite.add_element('testcase', attributes)
+            testcase_tag = testsuite.add_element("testcase", attributes)
             add_failure_tag_if_needed(testcase_tag, test)
           end
         end
@@ -107,9 +107,9 @@ module Minitest
             # noop
           when ResultType::Error, ResultType::Failed
             failure = T.must(result.failure)
-            failure_tag = testcase.add_element('failure',
-              'type' => result_type.serialize,
-              'message' => truncate_message(failure.message))
+            failure_tag = testcase.add_element("failure",
+              "type" => result_type.serialize,
+              "message" => truncate_message(failure.message))
             failure_tag.add_text(REXML::CData.new(result.to_s))
           else
             T.absurd(result_type)
@@ -118,17 +118,17 @@ module Minitest
 
         sig { params(message: String).returns(String) }
         def truncate_message(message)
-          T.must(message.lines.first).chomp.gsub(/\e\[[^m]+m/, '')
+          T.must(message.lines.first).chomp.gsub(/\e\[[^m]+m/, "")
         end
 
         sig { params(results: T::Array[Minitest::Result]).returns(T::Hash[String, Numeric]) }
         def aggregate_suite_results(results)
           aggregate = Hash.new(0)
           results.each do |result|
-            aggregate['assertions'] += result.assertions
-            aggregate['failures'] += 1 if failure?(ResultType.of(result))
-            aggregate['tests'] += 1
-            aggregate['time'] += result.time
+            aggregate["assertions"] += result.assertions
+            aggregate["failures"] += 1 if failure?(ResultType.of(result))
+            aggregate["tests"] += 1
+            aggregate["time"] += result.time
           end
           aggregate
         end

data/lib/minitest/distributed/test_selector.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'pathname'
+require "pathname"
 
 module Minitest
   module Distributed

data/lib/minitest/distributed/version.rb

@@ -3,6 +3,6 @@
 
 module Minitest
   module Distributed
-    VERSION = "0.2.3"
+    VERSION = "0.2.4"
   end
 end

data/lib/minitest/distributed_plugin.rb

@@ -1,14 +1,14 @@
 # typed: true
 # frozen_string_literal: true
 
-require_relative './distributed'
+require_relative "./distributed"
 
 module Minitest
   class << self
     extend T::Sig
 
     def plugin_distributed_options(opts, options)
-      opts.on('--disable-distributed', "Disable the distributed plugin") do
+      opts.on("--disable-distributed", "Disable the distributed plugin") do
         options[:disable_distributed] = true
       end
 

data/lib/minitest/junitxml_plugin.rb

@@ -4,9 +4,9 @@
 module Minitest
   class << self
     def plugin_junitxml_options(opts, options)
-      options[:junitxml] = ENV['MINITEST_JUNITXML']
+      options[:junitxml] = ENV["MINITEST_JUNITXML"]
 
-      opts.on('--junitxml=PATH', "Generate a JUnitXML report at the specified path") do |path|
+      opts.on("--junitxml=PATH", "Generate a JUnitXML report at the specified path") do |path|
         options[:junitxml] = path
       end
     end
@@ -14,7 +14,7 @@ module Minitest
     def plugin_junitxml_init(options)
       return if options[:junitxml].nil?
 
-      require 'minitest/distributed/reporters/junitxml_reporter'
+      require "minitest/distributed/reporters/junitxml_reporter"
       reporter << Minitest::Distributed::Reporters::JUnitXMLReporter.new(options[:io], options)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-distributed
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Willem van Bergen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-06 00:00:00.000000000 Z
+date: 2021-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest