minitest-distributed 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3898c3d3b163b66922daf90468041da6e76e07c8c102971c8f3cc71ad20e6bd4
-  data.tar.gz: 19c90e644ce560e5d1981dfb6a72d99bfa98daf95997e684954e3cd4d38906ff
+  metadata.gz: '0208858e32026a813e488ae30c72ae1ab9e274574aa55f5eb873f50db170a9d4'
+  data.tar.gz: 2e12cb8be3eb47009eb6aa30a5d58b9e7ef796a4e6851b02754fed3d3e261fdb
 SHA512:
-  metadata.gz: e772261c32992207573b5e76a12ae50eb26120c4d007f013246c6058821c200900a5a914d2bf474d37ffb571b5b03ae95fcc1e95d73a7eaa5e51ccfc15dc08d4
-  data.tar.gz: 905aff0608a7cda2910a920bd9650a9097e9da85104795f3b9ff4c143f4d4ea4dd4608f71d8a103275e821d17b9bf3340c68d33abcc0ef44cc304cda089f79c5
+  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/.rubocop.yml

@@ -36,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

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

@@ -62,7 +62,7 @@ module Minitest
 
           opts.on(
             "--[no-]retry-failures", "Retry failed and errored tests from a previous run attempt " \
-            "with the same run ID (default: enabled)"
+              "with the same run ID (default: enabled)"
           ) do |enabled|
             configuration.retry_failures = enabled
           end

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

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "redis"
+require "set"
 
 module Minitest
   module Distributed
@@ -128,7 +129,6 @@ module Minitest
               argv: [group_name],
             )
             keys_deleted == 0
-
           rescue Redis::CommandError => ce
             if ce.message.include?("BUSYGROUP")
               # If Redis returns a BUSYGROUP error, it means that the consumer group already
@@ -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,9 +199,9 @@ module Minitest
             T.let([], T::Array[Minitest::Runnable])
           end
 
-          redis.pipelined do
+          redis.pipelined do |pipeline|
             tests.each do |test|
-              redis.xadd(stream_key, { class_name: T.must(test.class.name), method_name: test.name })
+              pipeline.xadd(stream_key, { class_name: T.must(test.class.name), method_name: test.name })
             end
           end
         end
@@ -292,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)
 
@@ -383,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
 
@@ -407,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,
@@ -450,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/reporters/distributed_progress_reporter.rb

@@ -29,7 +29,7 @@ module Minitest
           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.
         #

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

@@ -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.4"
+    VERSION = "0.2.5"
   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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-distributed
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Willem van Bergen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-06 00:00:00.000000000 Z
+date: 2022-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -74,6 +74,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop.yml"
@@ -139,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.20
 signing_key: 
 specification_version: 4
 summary: Distributed test executor plugin for Minitest