minitest-distributed 0.1.2 → 0.2.0

data/lib/minitest/distributed/result_aggregate.rb

@@ -6,41 +6,51 @@ module Minitest
     class ResultAggregate < T::Struct
       extend T::Sig
 
+      const :max_failures, T.nilable(Integer)
+
+      # These are maintained between different attempts for the same run ID
       prop :runs, Integer, default: 0
       prop :assertions, Integer, default: 0
       prop :passes, Integer, default: 0
       prop :failures, Integer, default: 0
       prop :errors, Integer, default: 0
       prop :skips, Integer, default: 0
-      prop :reruns, Integer, default: 0
+      prop :requeues, Integer, default: 0
+      prop :discards, Integer, default: 0
+
+      # These are reset between different attempts for the same run ID
       prop :acks, Integer, default: 0
       prop :size, Integer, default: 0
 
-      sig { params(result: Minitest::Result).void }
-      def update_with_result(result)
-        case (result_type = ResultType.of(result))
+      sig { params(runnable_result: EnqueuedRunnable::Result).void }
+      def update_with_result(runnable_result)
+        case (result_type = ResultType.of(runnable_result.committed_result))
         when ResultType::Passed then self.passes += 1
         when ResultType::Failed then self.failures += 1
         when ResultType::Error then self.errors += 1
         when ResultType::Skipped then self.skips += 1
+        when ResultType::Discarded then self.discards += 1
+        when ResultType::Requeued then self.requeues += 1
         else T.absurd(result_type)
         end
 
+        self.acks += 1 if runnable_result.final? && runnable_result.commit.success?
         self.runs += 1
-        self.assertions += result.assertions
+        self.assertions += runnable_result.committed_result.assertions
       end
 
       sig { returns(String) }
       def to_s
         str = +"#{runs} runs, #{assertions} assertions, #{passes} passes, #{failures} failures, #{errors} errors"
         str << ", #{skips} skips" if skips > 0
-        str << ", #{reruns} re-runs" if reruns > 0
+        str << ", #{requeues} re-queued" if requeues > 0
+        str << ", #{discards} discarded" if discards > 0
         str
       end
 
       sig { returns(Integer) }
       def unique_runs
-        runs - reruns
+        runs - requeues - discards
       end
 
       sig { returns(Integer) }
@@ -49,18 +59,37 @@ module Minitest
       end
 
       sig { returns(T::Boolean) }
-      def completed?
+      def complete?
         acks == size
       end
 
+      sig { returns(T::Boolean) }
+      def abort?
+        if (max = max_failures)
+          total_failures >= max
+        else
+          false
+        end
+      end
+
       sig { returns(T::Boolean) }
       def valid?
+        all_runs_reported? && (complete? || abort?)
+      end
+
+      sig { returns(T::Boolean) }
+      def all_runs_reported?
         unique_runs == reported_results
       end
 
+      sig { returns(Integer) }
+      def total_failures
+        failures + errors
+      end
+
       sig { returns(T::Boolean) }
       def passed?
-        completed? && valid? && self.failures == 0 && self.errors == 0
+        total_failures == 0
       end
     end
   end

data/lib/minitest/distributed/result_type.rb

@@ -2,6 +2,74 @@
 # frozen_string_literal: true
 
 module Minitest
+  class Discard < Minitest::Skip
+    extend T::Sig
+
+    sig { returns(Minitest::Result) }
+    attr_reader :original_result
+
+    sig { params(message: String, original_result: Minitest::Result).void }
+    def initialize(message, original_result:)
+      @original_result = original_result
+      super(message)
+    end
+
+    sig { override.returns(String) }
+    def result_label
+      "Discarded"
+    end
+
+    sig { params(result: Minitest::Result, test_timeout_seconds: Float).returns(Minitest::Result) }
+    def self.wrap(result, test_timeout_seconds:)
+      message = +"This test result was discarded, because it could not be committed to the test run coordinator."
+      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.",
+          result.time, test_timeout_seconds, test_timeout_seconds
+        )
+      end
+
+      discard_assertion = Minitest::Discard.new(message, original_result: result)
+      discard_assertion.set_backtrace(caller)
+      discarded_result = result.dup
+      discarded_result.failures = [discard_assertion]
+      discarded_result
+    end
+  end
+
+  class Requeue < Minitest::Skip
+    extend T::Sig
+
+    sig { params(message: String, original_result: Minitest::Result).void }
+    def initialize(message, original_result:)
+      @original_result = original_result
+      super(message)
+    end
+
+    sig { override.returns(String) }
+    def result_label
+      "Requeued"
+    end
+
+    sig { params(result: Minitest::Result, attempt: Integer, max_attempts: Integer).returns(Minitest::Result) }
+    def self.wrap(result, attempt:, max_attempts:)
+      failure = T.must(result.failure)
+
+      message = "#{failure.message}\n\nThe test will be retried (attempt #{attempt} of #{max_attempts})"
+      requeue_assertion = Minitest::Requeue.new(message, original_result: result)
+      requeue_assertion.set_backtrace(failure.backtrace)
+
+      requeued_result = result.dup
+      requeued_result.failures = [requeue_assertion]
+      requeued_result
+    end
+  end
+
+  class AttemptsExhausted < Minitest::Assertion
+  end
+
   module Distributed
     class ResultType < T::Enum
       extend T::Sig
@@ -11,16 +79,22 @@ module Minitest
         Failed = new
         Error = new
         Skipped = new
+        Discarded = new
+        Requeued = new
       end
 
       sig { params(result: Minitest::Result).returns(ResultType) }
       def self.of(result)
         if result.passed?
           Passed
-        elsif result.error?
-          Error
+        elsif result.failure.is_a?(Minitest::Requeue)
+          Requeued
+        elsif result.failure.is_a?(Minitest::Discard)
+          Discarded
         elsif result.skipped?
           Skipped
+        elsif result.error?
+          Error
         else
           Failed
         end

data/lib/minitest/distributed/test_selector.rb

@@ -26,16 +26,14 @@ module Minitest
         @filters << Filters::ExcludeFilter.new(options[:exclude]) if options[:exclude]
       end
 
-      sig { returns(T::Array[EnqueuedRunnable]) }
+      sig { returns(T::Array[Minitest::Runnable]) }
       def discover_tests
         Minitest::Runnable.runnables.flat_map do |runnable|
-          runnable.runnable_methods.map do |method_name|
-            EnqueuedRunnable.new(class_name: runnable.name, method_name: method_name)
-          end
+          runnable.runnable_methods.map { |method_name| runnable.new(method_name) }
         end
       end
 
-      sig { params(tests: T::Array[EnqueuedRunnable]).returns(T::Array[EnqueuedRunnable]) }
+      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|
@@ -45,7 +43,7 @@ module Minitest
         end.compact
       end
 
-      sig { returns(T::Array[EnqueuedRunnable]) }
+      sig { returns(T::Array[Minitest::Runnable]) }
       def tests
         select_tests(discover_tests)
       end

data/lib/minitest/distributed/version.rb

@@ -3,6 +3,6 @@
 
 module Minitest
   module Distributed
-    VERSION = "0.1.2"
+    VERSION = "0.2.0"
   end
 end

data/lib/minitest/distributed_plugin.rb

@@ -12,31 +12,7 @@ module Minitest
         options[:disable_distributed] = true
       end
 
-      options[:distributed] = Minitest::Distributed::Configuration.from_env
-
-      opts.on('--coordinator=URI', "The URI pointing to the coordinator") do |uri|
-        options[:distributed].coordinator_uri = URI.parse(uri)
-      end
-
-      opts.on('--test-timeout=TIMEOUT', "The maximum run time for a single test in seconds") do |timeout|
-        options[:distributed].test_timeout = Float(timeout)
-      end
-
-      opts.on('--max-attempts=ATTEMPTS', "The maximum number of attempts to run a test") do |attempts|
-        options[:distributed].max_attempts = Integer(attempts)
-      end
-
-      opts.on('--test-batch-size=NUMBER', "The number of tests to process per batch") do |batch_size|
-        options[:distributed].test_batch_size = Integer(batch_size)
-      end
-
-      opts.on('--run-id=ID', "The ID for this run shared between coordinated workers") do |id|
-        options[:distributed].run_id = id
-      end
-
-      opts.on('--worker-id=ID', "The unique ID for this worker") do |id|
-        options[:distributed].worker_id = id
-      end
+      options[:distributed] = Minitest::Distributed::Configuration.from_command_line_options(opts)
     end
 
     def plugin_distributed_init(options)

data/sorbet/rbi/minitest.rbi

@@ -12,12 +12,17 @@ module Minitest
     def self.run_one_method(klass, method_name, reporter); end
     def self.runnables; end
 
+    def initialize(method_name); end
+
     def name; end
     def time; end
     def time=(duration); end
     def failures; end
-
-    def initialize(method_name); end
+    def failures=(failures); end
+    def source_location; end
+    def source_location=(value); end
+    def klass; end
+    def klass=(value); end
   end
 
   class Test < Runnable
@@ -61,7 +66,7 @@ module Minitest
     def result_code; end
   end
 
-  class Skip < Exception
+  class Skip < Assertion
   end
 
   class UnexpectedError < Assertion
@@ -190,6 +195,16 @@ module Minitest::Assertions
   end
   def assert_predicate(obj, predicate, msg = nil); end
 
+  sig do
+    params(
+      value: BasicObject,
+      operator: Symbol,
+      comparison: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_operator(value, operator, comparison, msg = nil); end
+
   sig { params(test: T.untyped, msg: T.nilable(String)).returns(TrueClass) }
   def refute(test, msg = nil); end
 

data/sorbet/rbi/redis.rbi

@@ -7,9 +7,17 @@ class Redis
   class CommandError < Error
   end
 
+  class Future
+    sig { returns(T.untyped) }
+    def value; end
+  end
+
   sig { params(options: T::Hash[Symbol, T.untyped]).void }
   def initialize(options); end
 
+  sig { params(block: T.proc.params(arg0: String).void).void }
+  def monitor(&block); end
+
   sig { void }
   def flushdb; end
 
@@ -49,7 +57,7 @@ class Redis
   sig { params(key_value_pairs: T.untyped).returns(T::Boolean) }
   def msetnx(*key_value_pairs); end
 
-  sig { params(key: String).void }
+  sig { params(key: String).returns(Integer) }
   def incr(key); end
 
   sig { params(key: String, value: T.untyped).void }
@@ -58,13 +66,20 @@ class Redis
   sig { params(key: String, start: Integer, stop: Integer).void }
   def lrange(key, start, stop); end
 
-  sig { params(key: String, amount: Integer).void }
+  sig { params(key: String, value: T.untyped).returns(T.untyped) }
+  def sadd(key, value); end
+
+  sig { params(key: String, value: T.untyped).returns(T::Boolean) }
+  def srem(key, value); end
+
+  sig { params(key: String, amount: Integer).returns(Integer) }
   def incrby(key, amount); end
 
-  def xadd(*); end
-  def xack(*); end
+  def xadd(key, value); end
+  def xack(stream_key, group_name, *entry_ids); end
   def xgroup(*); end
   def xpending(*); end
   def xreadgroup(*); end
   def xclaim(*); end
+  def xinfo(*); end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-distributed
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Willem van Bergen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-06-18 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest