minitest-distributed 0.2.2 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a8b0499822e88334b7ce7d06210c43d3054485d4dbbc3170f97e485c5d78c3d
-  data.tar.gz: 2e4c720af2bf722152ace13867b0cf66c58aafbf712ac1a5d4b9e308f0c2fd8f
+  metadata.gz: '0208858e32026a813e488ae30c72ae1ab9e274574aa55f5eb873f50db170a9d4'
+  data.tar.gz: 2e12cb8be3eb47009eb6aa30a5d58b9e7ef796a4e6851b02754fed3d3e261fdb
 SHA512:
-  metadata.gz: 8c974a610c8770a9a0ff8c944780182a178fbe1d22737a53a474b9f8f2abcd90765aac1f6a0ee9134cddb1e19dca235bb124b7950585337579b7dba5d4ebf956
-  data.tar.gz: 8337bf3b5c849d386ccbdb13e4cba6d725a274ead9893c60f3d60f9599e5ba7cde0e12ceea035219483ebd9aee0fc06ee9cc9e6a4747c08663f133dab30fd4d0
+  metadata.gz: e18ffe94425ae0726468df99f69d748a4c4d6744960d7f731079bd9dd2a927a924108d6a26e9e6383abe3d91bf311ae7619c666ae563605cacfd7f41c1b7de02
+  data.tar.gz: 83ad27805dd3285a398e9266f7ed9d3a0f7e67468d3a9b8020300c7cc81b89b94222b424aa0ec2e5cb3dd231563d75d1c342f55c9c4918435a490697a326318e

data/.github/dependabot.yml

@@ -0,0 +1,20 @@
+version: 2
+registries:
+  rubygems-server-pkgs-shopify-io:
+    type: rubygems-server
+    url: https://pkgs.shopify.io
+    username: ${{secrets.RUBYGEMS_SERVER_PKGS_SHOPIFY_IO_USERNAME}}
+    password: ${{secrets.RUBYGEMS_SERVER_PKGS_SHOPIFY_IO_PASSWORD}}
+  github-com:
+    type: git
+    url: https://github.com
+    username: ${{secrets.DEPENDENCIES_GITHUB_USER}}
+    password: ${{secrets.DEPENDENCIES_GITHUB_TOKEN}}
+updates:
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: daily
+    open-pull-requests-limit: 100
+    insecure-external-code-execution: allow
+    registries: "*"

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
@@ -34,6 +36,8 @@ Sorbet/FalseSigil:
 
 Sorbet/TrueSigil:
   Enabled: true
+  Exclude:
+    - 'test/fixtures/*'
 
 Sorbet/EnforceSigilOrder:
   Enabled: true

data/Gemfile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in minitest-distributed.gemspec
@@ -10,3 +11,5 @@ gem "sorbet"
 gem "rubocop"
 gem "rubocop-shopify"
 gem "rubocop-sorbet"
+gem "rubocop-minitest"
+gem "rubocop-rake"

data/README.md

@@ -1,5 +1,12 @@
 # minitest-distributed
 
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE.md)
+
+[About this repo](#about-this-repo) | [Commands](#commands) | [How to use this repo](#how-to-use-this-repo) | [Contribute to this repo](#contribute-to-this-repo) | [License](#license)
+
+## About this repo
+**Introduction:** 
+
 `minitest-distributed` is a plugin for [minitest](https://github.com/seattlerb/minitest)
 for executing tests on a distributed set of unreliable workers.
 
@@ -16,14 +23,14 @@ flakiness. To combat flakiness, minitest-distributed implements resiliency
 patterns, like re-running a test on a different worker on failure, and a
 circuit breaker for misbehaving workers.
 
-## Usage
-
-Add `minitest-distributed` to your `Gemfile`, and run `bundle install`. The
-plugin will be loaded by minitest automatically. The plugin exposes some
-command line arguments that you can use to influence its behavior. They can
-also be set using environment variables.
+|               |                                                                                                                                      |
+|----------------|--------------------------------------------------------------------------------------------------------------------------------------|
+| Current status | Ongoing                                                                                                                              |
+| Owner          | [@Shopify/test-infra](https://github.com/orgs/Shopify/teams/test-infra)                                                              |
+| Help           | [#team-test-infra](https://shopify.slack.com/archives/team-test-infra)                                                               |
 
-### Distributed invocation
+## Commands
+**Distributed invocation**
 
 To actually run tests with multiple workers, you have to point every worker to
 a Redis coordinator, and use the same run identifier.
@@ -52,7 +59,7 @@ Rake::TestTask.new(:test) do |t|
 end
 ```
 
-### Worker retries
+**Worker retries**
 
 Many CI systems offer the options to retry jobs that fail. When jobs are
 retried that were previously part of a worker cluster, all the retried jobs
@@ -61,7 +68,7 @@ during the previous run attempt. This is to make it faster to re-run tests
 that failed due to flakiness, or confirm that it was not flakiness that caused
 them to fail.
 
-### Other optional command line arguments
+**Other optional command line arguments**
 
 - `--test-timeout=SECONDS` or `ENV[MINITEST_TEST_TIMEOUT_SECONDS]` (default: 30s):
   the maximum amount a test is allowed to run before it times out. In a distributed
@@ -87,7 +94,7 @@ them to fail.
   the test run. The file should include test identifiers seperated by 
   newlines.
 
-## Limitations
+**Limitations**
 
 **Parallel tests not supported:** Minitest comes bundled with a parallel test
 executor, which will run tests that are specifically tagged as such in
@@ -96,7 +103,20 @@ in parallel  using separate processes, generally on different VMs. For this
 reason, tests marked as `parallel` will not be treated any differently than
 other tests.
 
-## Development
+## How to use this repo
+Add `minitest-distributed` to your `Gemfile`, and run `bundle install`. The
+plugin will be loaded by minitest automatically. The plugin exposes some
+command line arguments that you can use to influence its behavior. They can
+also be set using environment variables.
+
+## Contribute to this repo
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/Shopify/minitest-distributed. This project is intended to
+be a safe, welcoming space for collaboration, and contributors are expected to
+adhere to the [code of
+conduct](https://github.com/Shopify/minitest-distributed/blob/master/CODE_OF_CONDUCT.md).
+
+**Development**
 
 To bootstrap a local development environment:
 
@@ -109,7 +129,7 @@ To bootstrap a local development environment:
 - You can also run `bin/console` for an interactive prompt that will allow you
   to experiment.
 
-### Releasing a new version
+**Releasing a new version**
 
 - To install this gem onto your local machine, run `bin/rake install`.
 - Only people at Shopify can release a new version to
@@ -117,21 +137,6 @@ To bootstrap a local development environment:
   in `version.rb`, and merge to master. Shipit will take care of building the
   `.gem` bundle, and pushing it to rubygems.org.
 
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at
-https://github.com/Shopify/minitest-distributed. This project is intended to
-be a safe, welcoming space for collaboration, and contributors are expected to
-adhere to the [code of
-conduct](https://github.com/Shopify/minitest-distributed/blob/master/CODE_OF_CONDUCT.md).
-
 ## License
-
 The gem is available as open source under the terms of the [MIT
 License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the `minitest-distributed` project's codebases, issue
-trackers, chat rooms and mailing lists is expected to follow the [code of
-conduct](https://github.com/Shopify/minitest-distributed/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 

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 " \
-            "with the same run ID (default: enabled)"
+            "--[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,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'redis'
+require "redis"
+require "set"
 
 module Minitest
   module Distributed
@@ -65,8 +66,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 +83,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 +125,12 @@ 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.
@@ -165,10 +165,10 @@ module Minitest
               adjust_combined_results(ResultAggregate.new(size: 0))
               T.let([], T::Array[Minitest::Runnable])
             else
-              previous_failures, previous_errors, _deleted = redis.multi do
-                redis.lrange(list_key(ResultType::Failed.serialize), 0, -1)
-                redis.lrange(list_key(ResultType::Error.serialize), 0, -1)
-                redis.del(list_key(ResultType::Failed.serialize), list_key(ResultType::Error.serialize))
+              previous_failures, previous_errors, _deleted = redis.multi do |pipeline|
+                pipeline.lrange(list_key(ResultType::Failed.serialize), 0, -1)
+                pipeline.lrange(list_key(ResultType::Error.serialize), 0, -1)
+                pipeline.del(list_key(ResultType::Failed.serialize), list_key(ResultType::Error.serialize))
               end
 
               # We set the `size` key to the number of tests we are planning to schedule.
@@ -199,8 +199,10 @@ module Minitest
             T.let([], T::Array[Minitest::Runnable])
           end
 
-          redis.pipelined do
-            tests.each { |test| redis.xadd(stream_key, class_name: T.must(test.class.name), method_name: test.name) }
+          redis.pipelined do |pipeline|
+            tests.each do |test|
+              pipeline.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
@@ -290,6 +292,7 @@ module Minitest
         end
         def xclaim_messages(pending_messages, max_idle_time_ms:)
           return [] if pending_messages.empty?
+
           claimed = redis.xclaim(stream_key, group_name, configuration.worker_id,
             max_idle_time_ms, pending_messages.keys)
 
@@ -305,7 +308,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 +330,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
@@ -381,9 +384,9 @@ module Minitest
           # timeout. If the worker crashes between removing an item from the retry setm the test
           # will eventually be picked up by another worker.
           messages_in_retry_set = {}
-          redis.multi do
+          redis.multi do |pipeline|
             active_messages.each do |key, message|
-              messages_in_retry_set[key] = redis.srem(key('retry_set'), message.attempt_id)
+              messages_in_retry_set[key] = pipeline.srem(key("retry_set"), message.attempt_id)
             end
           end
 
@@ -405,17 +408,17 @@ 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)
+          updated = redis.multi do |pipeline|
+            pipeline.incrby(key("runs"), results.runs)
+            pipeline.incrby(key("assertions"), results.assertions)
+            pipeline.incrby(key("passes"), results.passes)
+            pipeline.incrby(key("failures"), results.failures)
+            pipeline.incrby(key("errors"), results.errors)
+            pipeline.incrby(key("skips"), results.skips)
+            pipeline.incrby(key("requeues"), results.requeues)
+            pipeline.incrby(key("discards"), results.discards)
+            pipeline.incrby(key("acks"), results.acks)
+            pipeline.incrby(key("size"), results.size)
           end
 
           @combined_results = ResultAggregate.new(max_failures: configuration.max_failures,
@@ -448,14 +451,14 @@ module Minitest
 
           # Try to commit all the results of this batch to Redis
           runnable_results = []
-          redis.multi do
+          redis.multi do |pipeline|
             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 = pipeline.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)
+                  xack_future = pipeline.xack(stream_key, group_name, enqueued_runnable.entry_id)
                   EnqueuedRunnable::Result::Commit.new { xack_future.value == 1 }
                 end
               end

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,11 +25,11 @@ module Minitest
 
         sig { override.void }
         def start
-          Signal.trap('WINCH') { @window_line_width = nil }
+          Signal.trap("WINCH") { @window_line_width = nil }
           super
         end
 
-        # Note: due to batching and parallel tests, we have no guarantee that `prerecord`
+        # NOTE: due to batching and parallel tests, we have no guarantee that `prerecord`
         # and `record` will be called in succession for the same test without calls to
         # either method being interjected for other tests.
         #
@@ -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/result_type.rb

@@ -25,8 +25,8 @@ module Minitest
       if result.time > test_timeout_seconds
         message << format(
           "\n\nThe test took %0.3fs to run, longer than the test timeout which is configured to be %0.1fs.\n" \
-          "Another worker likely claimed ownership of this test, and will commit the result instead.\n" \
-          "For best results, make sure that all your tests finish within %0.1fs.",
+            "Another worker likely claimed ownership of this test, and will commit the result instead.\n" \
+            "For best results, make sure that all your tests finish within %0.1fs.",
           result.time, test_timeout_seconds, test_timeout_seconds
         )
       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
@@ -44,6 +44,7 @@ module Minitest
       sig { params(tests: T::Array[Minitest::Runnable]).returns(T::Array[Minitest::Runnable]) }
       def select_tests(tests)
         return tests if filters.empty?
+
         tests.flat_map do |runnable_method|
           filters.flat_map do |filter|
             filter.call(runnable_method)

data/lib/minitest/distributed/version.rb

@@ -3,6 +3,6 @@
 
 module Minitest
   module Distributed
-    VERSION = "0.2.2"
+    VERSION = "0.2.5"
   end
 end

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_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

data/sorbet/rbi/redis.rbi

@@ -1,4 +1,5 @@
 # typed: true
+# frozen_string_literal: true
 
 class Redis
   class Error < StandardError
@@ -21,10 +22,10 @@ class Redis
   sig { void }
   def flushdb; end
 
-  sig { params(block: T.proc.void).returns(T::Array[T.untyped]) }
+  sig { params(block: T.proc.params(arg0: Redis::PipelinedConnection).void).returns(T::Array[T.untyped]) }
   def pipelined(&block); end
 
-  sig { params(block: T.proc.void).returns(T::Array[T.untyped]) }
+  sig { params(block: T.proc.params(arg0: Redis::PipelinedConnection).void).returns(T::Array[T.untyped]) }
   def multi(&block); end
 
   sig { params(script: String, keys: T::Array[String], argv: T::Array[String]).returns(T.untyped) }
@@ -83,3 +84,23 @@ class Redis
   def xclaim(*); end
   def xinfo(*); end
 end
+
+class Redis::PipelinedConnection
+  sig { params(key: String, value: T.untyped).returns(T.untyped) }
+  def sadd(key, value); end
+
+  sig { params(key: String, amount: Integer).returns(Integer) }
+  def incrby(key, amount); end
+
+  sig { params(key: String, value: T.untyped).returns(T::Boolean) }
+  def srem(key, value); end
+
+  sig { params(keys: String).void }
+  def del(*keys); end
+
+  sig { params(key: String, start: Integer, stop: Integer).void }
+  def lrange(key, start, stop); end
+
+  def xack(stream_key, group_name, *entry_ids); end
+  def xadd(key, value); end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-distributed
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.5
 platform: ruby
 authors:
 - Willem van Bergen
@@ -74,6 +74,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop.yml"