ci-queue 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d636ab99ab50bd22a5fc67415187e75bac147b8
-  data.tar.gz: 6825eca869948ed64897fb6e2b3ce46fc5e1a918
+  metadata.gz: 97f69595ec09509df32703213fd2d882db14f017
+  data.tar.gz: cae08e13e586bd5c7cc8927057225084b0ee0d74
 SHA512:
-  metadata.gz: 129ec21f70ad9ee2ad108537bfc7ec0032b4bbf9738973da28376a558f37dbc5de884bd4d5e9049ecf94f2ee5c02760f9a678fae67d40a92b7d2c31919f2c123
-  data.tar.gz: 5759824ed9f3b81060b926de0093d523c229f13bd98e5cefb6d4770f97da43acedd480cd97c2af92b4af5c51ecf4474a51a3461007760aa16a5de90529ec8d6c
+  metadata.gz: 742b3d39caf903b480950a86eafb687776e8b4d1a9465d28e1ce29ff37d3242f3127a40d7115e51eddec03b6e22322cef0108ef2a64f6a5744b642b3e1b14ecf
+  data.tar.gz: 8f753085f6408c98e698c0a75c06b77a427e066cbad9aa7c1db102613cdcf4b6d25d27e93145e86928bd5ae956b54adeb44245f36ee2ceee3eb3e9646c45363b

data/README.md

@@ -0,0 +1,48 @@
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ci-queue'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ci-queue
+
+## Usage
+
+### Supported CI providers
+
+`ci-queue` automatically infers most of its configuration if ran on one of the following CI providers:
+
+  - Buildkite
+  - CircleCI
+  - Travis
+
+If you are using another CI system, please refer to the command usage message.
+
+### Minitest
+
+Assuming you use one of the supported CI providers, the command can be as simple as:
+
+```bash
+minitest-queue --queue redis://example.com run -Itest test/**/*_test.rb
+```
+
+Additionally you can configure the requeue settings (see main README) with `--max-requeues` and `--requeue-tolerance`.
+
+
+If you'd like to centralize the error reporting you can do so with:
+
+```
+minitest-queue --queue redis://example.com --timeout 600 report
+```
+
+### RSpec
+
+The RSpec integration is not implemented yet.

data/exe/minitest-queue

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'minitest/queue/runner'
+Minitest::Queue::Runner.invoke(ARGV)

data/lib/ci/queue.rb

@@ -1,3 +1,31 @@
+require 'uri'
+require 'cgi'
+
 require 'ci/queue/version'
+require 'ci/queue/output_helpers'
+require 'ci/queue/index'
+require 'ci/queue/configuration'
 require 'ci/queue/static'
 require 'ci/queue/file'
+
+module CI
+  module Queue
+    extend self
+
+    def from_uri(url, config)
+      uri = URI(url)
+      implementation = case uri.scheme
+      when 'list'
+        Static
+      when 'file', nil
+        File
+      when 'redis'
+        require 'ci/queue/redis'
+        Redis
+      else
+        raise ArgumentError, "Don't know how to handle #{uri.scheme} URLs"
+      end
+      implementation.from_uri(uri, config)
+    end
+  end
+end

data/lib/ci/queue/configuration.rb

@@ -0,0 +1,46 @@
+module CI
+  module Queue
+    class Configuration
+      attr_accessor :timeout, :build_id, :worker_id, :max_requeues, :requeue_tolerance, :namespace, :seed
+
+      class << self
+        def from_env(env)
+          new(
+            build_id: env['CIRCLE_BUILD_URL'] || env['BUILDKITE_BUILD_ID'] || env['TRAVIS_BUILD_ID'],
+            worker_id: env['CIRCLE_NODE_INDEX'] || env['BUILDKITE_PARALLEL_JOB'],
+            seed: env['CIRCLE_SHA1'] || env['BUILDKITE_COMMIT'] || env['TRAVIS_COMMIT'],
+          )
+        end
+      end
+
+      def initialize(
+        timeout: 30, build_id: nil, worker_id: nil, max_requeues: 0, requeue_tolerance: 0,
+        namespace: nil, seed: nil
+      )
+        @namespace = namespace
+        @timeout = timeout
+        @build_id = build_id
+        @worker_id = worker_id
+        @max_requeues = max_requeues
+        @requeue_tolerance = requeue_tolerance
+        @seed = seed
+      end
+
+      def seed
+        @seed || build_id
+      end
+
+      def build_id
+        if namespace
+          "#{namespace}:#{@build_id}"
+        else
+          @build_id
+        end
+      end
+
+      def global_max_requeues(tests_count)
+        (tests_count * Float(requeue_tolerance)).ceil
+      end
+    end
+  end
+end

data/lib/ci/queue/file.rb

@@ -3,8 +3,14 @@ require 'ci/queue/static'
 module CI
   module Queue
     class File < Static
-      def initialize(path, **args)
-        super(::File.readlines(path).map(&:strip).reject(&:empty?), **args)
+      class << self
+        def from_uri(uri, config)
+          new(uri.path, config)
+        end
+      end
+
+      def initialize(path, *args)
+        super(::File.readlines(path).map(&:strip).reject(&:empty?), *args)
       end
     end
   end

data/lib/ci/queue/index.rb

@@ -0,0 +1,20 @@
+module CI
+  module Queue
+    class Index
+      def initialize(objects, &indexer)
+        @index = objects.map { |o| [indexer.call(o), o] }.to_h
+        @indexer = indexer
+      end
+
+      def fetch(key)
+        @index.fetch(key)
+      end
+
+      def key(value)
+        key = @indexer.call(value)
+        raise KeyError, "value not found: #{value.inspect}" unless @index.key?(key)
+        key
+      end
+    end
+  end
+end

data/lib/ci/queue/output_helpers.rb

@@ -0,0 +1,64 @@
+require 'ansi'
+
+module CI
+  module Queue
+    module OutputHelpers
+      include ANSI::Code
+
+      private
+
+      def step(*args)
+        ci_provider.step(*args)
+      end
+
+      def reopen_previous_step
+        ci_provider.reopen_previous_step
+      end
+
+      def close_previous_step
+        ci_provider.close_previous_step
+      end
+
+      def ci_provider
+        @ci_provider ||= if ENV['BUILDKITE']
+          BuildkiteOutput
+        else
+          DefaultOutput
+        end
+      end
+
+      module DefaultOutput
+        extend self
+
+        def step(title, collapsed: true)
+          puts title
+        end
+
+        def reopen_previous_step
+          # noop
+        end
+
+        def close_previous_step
+          # noop
+        end
+      end
+
+      module BuildkiteOutput
+        extend self
+
+        def step(title, collapsed: true)
+          prefix = collapsed ? '---' : '+++'
+          puts "#{prefix} #{title}"
+        end
+
+        def reopen_previous_step
+          puts '^^^ +++'
+        end
+
+        def close_previous_step
+          puts '^^^ ---'
+        end
+      end
+    end
+  end
+end

data/lib/ci/queue/redis.rb

@@ -10,8 +10,15 @@ module CI
       Error = Class.new(StandardError)
       LostMaster = Class.new(Error)
 
-      def self.new(*args)
-        Worker.new(*args)
+      class << self
+
+        def new(*args)
+          Worker.new(*args)
+        end
+
+        def from_uri(uri, config)
+          new(uri.to_s, config)
+        end
       end
     end
   end

data/lib/ci/queue/redis/base.rb

@@ -2,13 +2,14 @@ module CI
   module Queue
     module Redis
       class Base
-        def initialize(redis:, build_id:)
-          @redis = redis
-          @build_id = build_id
+        def initialize(redis_url, config)
+          @redis_url = redis_url
+          @redis = ::Redis.new(url: redis_url)
+          @config = config
         end
 
-        def empty?
-          size == 0
+        def exhausted?
+          queue_initialized? && size == 0
         end
 
         def size
@@ -22,7 +23,7 @@ module CI
           redis.multi do
             redis.lrange(key('queue'), 0, -1)
             redis.zrange(key('running'), 0, -1)
-          end.flatten.reverse
+          end.flatten.reverse.map { |k| index.fetch(k) }
         end
 
         def progress
@@ -32,8 +33,7 @@ module CI
         def wait_for_master(timeout: 10)
           return true if master?
           (timeout * 10 + 1).to_i.times do
-            case master_status
-            when 'ready', 'finished'
+            if queue_initialized?
               return true
             else
               sleep 0.1
@@ -46,14 +46,25 @@ module CI
           redis.scard(key('workers'))
         end
 
+        def queue_initialized?
+          @queue_initialized ||= begin
+            status = master_status
+            status == 'ready' || status == 'finished'
+          end
+        end
+
         private
 
-        attr_reader :redis, :build_id
+        attr_reader :redis, :config, :redis_url
 
         def key(*args)
           ['build', build_id, *args].join(':')
         end
 
+        def build_id
+          config.build_id
+        end
+
         def master_status
           redis.get(key('master-status'))
         end

data/lib/ci/queue/redis/retry.rb

@@ -2,27 +2,27 @@ module CI
   module Queue
     module Redis
       class Retry < Static
-        def initialize(tests, redis:, build_id:, worker_id:, **args)
+        def initialize(tests, config, redis:)
           @redis = redis
-          @build_id = build_id
-          @worker_id = worker_id
-          super(tests, **args)
+          super(tests, config)
         end
 
         def minitest_reporters
+          require 'minitest/reporters/queue_reporter'
           require 'minitest/reporters/redis_reporter'
           @minitest_reporters ||= [
+            Minitest::Reporters::QueueReporter.new,
             Minitest::Reporters::RedisReporter::Worker.new(
               redis: redis,
-              build_id: build_id,
-              worker_id: worker_id,
+              build_id: config.build_id,
+              worker_id: config.worker_id,
             )
           ]
         end
 
         private
 
-        attr_reader :redis, :build_id, :worker_id
+        attr_reader :redis
       end
     end
   end

data/lib/ci/queue/redis/supervisor.rb

@@ -6,11 +6,27 @@ module CI
           false
         end
 
+        def minitest_reporters
+          require 'minitest/reporters/redis_reporter'
+          @reporters ||= [
+            Minitest::Reporters::RedisReporter::Summary.new(
+              build_id: build_id,
+              redis: redis,
+            )
+          ]
+        end
+
         def wait_for_workers
-          return false unless wait_for_master
+          return false unless wait_for_master(timeout: config.timeout)
 
-          sleep 0.1 until empty?
-          true
+          time_left = config.timeout
+          until exhausted? || time_left <= 0
+            sleep 0.1
+            time_left -= 0.1
+          end
+          exhausted?
+        rescue CI::Queue::Redis::LostMaster
+          false
         end
       end
     end

data/lib/ci/queue/redis/worker.rb

@@ -13,15 +13,20 @@ module CI
       class Worker < Base
         attr_reader :total
 
-        def initialize(tests, redis:, build_id:, worker_id:, timeout:, max_requeues: 0, requeue_tolerance: 0.0)
+        def initialize(redis, config)
           @reserved_test = nil
-          @max_requeues = max_requeues
-          @global_max_requeues = (tests.size * requeue_tolerance).ceil
           @shutdown_required = false
-          super(redis: redis, build_id: build_id)
-          @worker_id = worker_id.to_s
-          @timeout = timeout
-          push(tests)
+          super(redis, config)
+        end
+
+        def populate(tests, &indexer)
+          @index = Index.new(tests, &indexer)
+          push(tests.map { |t| index.key(t) })
+          self
+        end
+
+        def populated?
+          !!defined?(@index)
         end
 
         def shutdown!
@@ -38,9 +43,9 @@ module CI
 
         def poll
           wait_for_master
-          until shutdown_required? || empty?
+          until shutdown_required? || exhausted?
             if test = reserve
-              yield test
+              yield index.fetch(test)
             else
               sleep 0.05
             end
@@ -48,19 +53,20 @@ module CI
         rescue ::Redis::BaseConnectionError
         end
 
-        def retry_queue(**args)
-          Retry.new(
-            redis.lrange(key('worker', worker_id, 'queue'), 0, -1).reverse.uniq,
-            redis: redis,
-            build_id: build_id,
-            worker_id: worker_id,
-            **args
-          )
+        def retry_queue
+          log = redis.lrange(key('worker', worker_id, 'queue'), 0, -1).reverse.uniq
+          Retry.new(log, config, redis: redis)
+        end
+
+        def supervisor
+          Supervisor.new(redis_url, config)
         end
 
         def minitest_reporters
+          require 'minitest/reporters/queue_reporter'
           require 'minitest/reporters/redis_reporter'
           @minitest_reporters ||= [
+            Minitest::Reporters::QueueReporter.new,
             Minitest::Reporters::RedisReporter::Worker.new(
               redis: redis,
               build_id: build_id,
@@ -70,30 +76,40 @@ module CI
         end
 
         def acknowledge(test)
-          raise_on_mismatching_test(test)
+          test_key = index.key(test)
+          raise_on_mismatching_test(test_key)
           eval_script(
             :acknowledge,
             keys: [key('running'), key('processed')],
-            argv: [test],
+            argv: [test_key],
           ) == 1
         end
 
         def requeue(test, offset: Redis.requeue_offset)
-          raise_on_mismatching_test(test)
+          test_key = index.key(test)
+          raise_on_mismatching_test(test_key)
 
           requeued = eval_script(
             :requeue,
             keys: [key('processed'), key('requeues-count'), key('queue'), key('running')],
-            argv: [max_requeues, global_max_requeues, test, offset],
+            argv: [config.max_requeues, config.global_max_requeues(total), test_key, offset],
           ) == 1
 
-          @reserved_test = test unless requeued
+          @reserved_test = test_key unless requeued
           requeued
         end
 
         private
 
-        attr_reader :worker_id, :timeout, :max_requeues, :global_max_requeues
+        attr_reader :index
+
+        def worker_id
+          config.worker_id
+        end
+
+        def timeout
+          config.timeout
+        end
 
         def raise_on_mismatching_test(test)
           if @reserved_test == test
@@ -112,9 +128,6 @@ module CI
           @reserved_test = (try_to_reserve_lost_test || try_to_reserve_test)
         end
 
-        RESERVE_TEST = %{
-        }
-
         def try_to_reserve_test
           eval_script(
             :reserve,
@@ -133,6 +146,7 @@ module CI
 
         def push(tests)
           @total = tests.size
+
           if @master = redis.setnx(key('master-status'), 'setup')
             redis.multi do
               redis.lpush(key('queue'), tests)

data/lib/ci/queue/static.rb

@@ -1,18 +1,48 @@
 module CI
   module Queue
     class Static
+      class << self
+        def from_uri(uri, config)
+          tests = uri.opaque.split(':').map { |t| CGI.unescape(t) }
+          new(tests, config)
+        end
+      end
+
       attr_reader :progress, :total
 
-      def initialize(tests, max_requeues: 0, requeue_tolerance: 0.0)
+      def initialize(tests, config)
         @queue = tests
+        @config = config
         @progress = 0
         @total = tests.size
-        @max_requeues = max_requeues
-        @global_max_requeues = (tests.size * requeue_tolerance).ceil
+      end
+
+      def minitest_reporters
+        require 'minitest/reporters/queue_reporter'
+        @minitest_reporters ||= [
+          Minitest::Reporters::QueueReporter.new,
+        ]
+      end
+
+      def supervisor
+        raise NotImplementedError, "This type of queue can't be supervised"
+      end
+
+      def retry_queue
+        self
+      end
+
+      def populate(tests, &indexer)
+        @index = Index.new(tests, &indexer)
+        self
+      end
+
+      def populated?
+        !!defined?(@index)
       end
 
       def to_a
-        @queue.dup
+        @queue.map { |i| index.fetch(i) }
       end
 
       def size
@@ -21,12 +51,12 @@ module CI
 
       def poll
         while test = @queue.shift
-          yield test
+          yield index.fetch(test)
           @progress += 1
         end
       end
 
-      def empty?
+      def exhausted?
         @queue.empty?
       end
 
@@ -35,18 +65,19 @@ module CI
       end
 
       def requeue(test)
-        return false unless should_requeue?(test)
-        requeues[test] += 1
-        @queue.unshift(test)
+        key = index.key(test)
+        return false unless should_requeue?(key)
+        requeues[key] += 1
+        @queue.unshift(index.key(test))
         true
       end
 
       private
 
-      attr_reader :max_requeues, :global_max_requeues
+      attr_reader :index, :config
 
-      def should_requeue?(test)
-        requeues[test] < max_requeues && requeues.values.inject(0, :+) < global_max_requeues
+      def should_requeue?(key)
+        requeues[key] < config.max_requeues && requeues.values.inject(0, :+) < config.global_max_requeues(total)
       end
 
       def requeues

data/lib/ci/queue/version.rb

@@ -1,6 +1,6 @@
 module CI
   module Queue
-    VERSION = '0.6.0'
+    VERSION = '0.7.0'
     DEV_SCRIPTS_ROOT = ::File.expand_path('../../../../../redis', __FILE__)
     RELEASE_SCRIPTS_ROOT = ::File.expand_path('../redis', __FILE__)
   end

data/lib/minitest/queue.rb

@@ -65,7 +65,7 @@ module Minitest
     SuiteNotFound = Class.new(StandardError)
 
     def loaded_tests
-      MiniTest::Test.runnables.flat_map do |suite|
+      Minitest::Test.runnables.flat_map do |suite|
         suite.runnable_methods.map do |method|
           "#{suite}##{method}"
         end

data/lib/minitest/queue/runner.rb

@@ -0,0 +1,243 @@
+require 'optparse'
+require 'minitest/queue'
+require 'ci/queue'
+require 'digest/md5'
+
+module Minitest
+  module Queue
+    class Runner
+      include ::CI::Queue::OutputHelpers
+
+      Error = Class.new(StandardError)
+      MissingParameter = Class.new(Error)
+
+      def self.invoke(argv)
+        new(argv).run!
+      end
+
+      def initialize(argv)
+        @queue_config = CI::Queue::Configuration.from_env(ENV)
+        @command, @argv = parse(argv)
+      end
+
+      def run!
+        invalid_usage!("No command given") if command.nil?
+        invalid_usage!('Missing queue URL') unless queue_url
+
+        @queue = CI::Queue.from_uri(queue_url, queue_config)
+
+        method = "#{command}_command"
+        if respond_to?(method)
+          public_send(method)
+        else
+          invalid_usage!("Unknown command: #{command}")
+        end
+      end
+
+      def retry_command
+        self.queue = queue.retry_queue
+        run_command
+      end
+
+      def run_command
+        set_load_path
+        Minitest.queue = queue
+        trap('TERM') { Minitest.queue.shutdown! }
+        trap('INT') { Minitest.queue.shutdown! }
+        load_tests
+        populate_queue
+        # Let minitest's at_exit hook trigger
+      end
+
+      def report_command
+        supervisor = begin
+          queue.supervisor
+        rescue NotImplementedError => error
+          abort! error.message
+        end
+
+        step("Waiting for workers to complete")
+
+        unless supervisor.wait_for_workers
+          unless supervisor.queue_initialized?
+            abort! "No master was elected. Did all workers crash?"
+          end
+
+          unless supervisor.exhausted?
+            abort! "#{supervisor.size} tests weren't run."
+          end
+        end
+
+        success = supervisor.minitest_reporters.all?(&:success?)
+        supervisor.minitest_reporters.each do |reporter|
+          reporter.report
+        end
+
+        STDOUT.flush
+        exit! success ? 0 : 1
+      end
+
+      private
+
+      attr_reader :queue_config, :options, :command, :argv
+      attr_accessor :queue, :queue_url, :load_paths
+
+      def populate_queue
+        Minitest.queue.populate(shuffle(Minitest.loaded_tests), &:to_s) # TODO: stop serializing
+      end
+
+      def set_load_path
+        if paths = load_paths
+          paths.split(':').reverse.each do |path|
+            $LOAD_PATH.unshift(File.expand_path(path))
+          end
+        end
+      end
+
+      def load_tests
+        argv.sort.each do |f|
+          require File.expand_path(f)
+        end
+      end
+
+      def parse(argv)
+        parser.parse!(argv)
+        command = argv.shift
+        return command, argv
+      end
+
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: minitest-queue [options] COMMAND [ARGS]"
+
+          opts.separator ""
+          opts.separator "Example: minitest-queue -Itest --queue redis://example.com run test/**/*_test.rb"
+
+          opts.separator ""
+          opts.separator "GLOBAL OPTIONS"
+
+
+          help = split_heredoc(<<-EOS)
+            URL of the queue, e.g. redis://example.com.
+            Defaults to $CI_QUEUE_URL if set.
+          EOS
+          opts.separator ""
+          opts.on('--queue URL', *help) do |url|
+            self.queue_url = url
+          end
+
+          help = split_heredoc(<<-EOS)
+            Unique identifier for the workload. All workers working on the same suite of tests must have the same build identifier.
+            If the build is tried again, or another revision is built, this value must be different.
+            It's automatically inferred on Buildkite, CircleCI and Travis.
+          EOS
+          opts.separator ""
+          opts.on('--build BUILD_ID', *help) do |build_id|
+            queue_config.build_id = build_id
+          end
+
+          help = split_heredoc(<<-EOS)
+            Optional. Sets a prefix for the build id in case a single CI build runs multiple independent test suites.
+              Example: --namespace integration
+          EOS
+          opts.separator ""
+          opts.on('--namespace NAMESPACE', *help) do |namespace|
+            queue_config.namespace = namespace
+          end
+
+          opts.separator ""
+          opts.separator "COMMANDS"
+          opts.separator ""
+          opts.separator "    run [TEST_FILES...]: Participate in leader election, and then work off the test queue."
+
+          help = split_heredoc(<<-EOS)
+            Specify a timeout after which if a test haven't completed, it will be picked up by another worker.
+            It is very important to set this vlaue higher than the slowest test in the suite, otherwise performance will be impacted.
+            Defaults to 30 seconds.
+          EOS
+          opts.separator ""
+          opts.on('--timeout TIMEOUT', *help) do |timeout|
+            queue_config.timeout = Float(timeout)
+          end
+
+          help = split_heredoc(<<-EOS)
+            Specify $LOAD_PATH directory, similar to Ruby's -I
+          EOS
+          opts.separator ""
+          opts.on('-IPATHS', *help) do |paths|
+            self.load_paths = paths
+          end
+
+          help = split_heredoc(<<-EOS)
+            Sepcify a seed used to shuffle the test suite.
+            On Buildkite, CircleCI and Travis, the commit revision will be used by default.
+          EOS
+          opts.separator ""
+          opts.on('--seed SEED', *help) do |seed|
+            queue_config.seed = seed
+          end
+
+          help = split_heredoc(<<-EOS)
+            A unique identifier for this worker, It must be consistent to allow retries.
+            If not specified, retries won't be available.
+            It's automatically inferred on Buildkite and CircleCI.
+          EOS
+          opts.separator ""
+          opts.on('--worker WORKER_ID', *help) do |worker_id|
+            queue_config.worker_id = worker_id
+          end
+
+          help = split_heredoc(<<-EOS)
+            Defines how many time a single test can be requeued.
+            Defaults to 0.
+          EOS
+          opts.separator ""
+          opts.on('--max-requeues MAX') do |max|
+            queue_config.max_requeues = Integer(max)
+          end
+
+          help = split_heredoc(<<-EOS)
+            Defines how many requeues can happen overall, based on the test suite size. e.g 0.05 for 5%.
+            Defaults to 0.
+          EOS
+          opts.separator ""
+          opts.on('--requeue-tolerance RATIO', *help) do |ratio|
+            queue_config.requeue_tolerance = Float(ratio)
+          end
+
+          opts.separator ""
+          opts.separator "    retry: Replays a previous run in the same order."
+
+          opts.separator ""
+          opts.separator "    report: Wait for all workers to complete and summarize the test failures."
+        end
+      end
+
+      def split_heredoc(string)
+        string.lines.map(&:strip)
+      end
+
+      def shuffle(tests)
+        random = Random.new(Digest::MD5.hexdigest(queue_config.seed).to_i(16))
+        tests.shuffle(random: random)
+      end
+
+      def queue_url
+        @queue_url || ENV['CI_QUEUE_URL']
+      end
+
+      def invalid_usage!(message)
+        reopen_previous_step
+        puts red(message)
+        puts parser
+        exit! 1 # exit! is required to avoid minitest at_exit callback
+      end
+
+      def abort!(message)
+        reopen_previous_step
+        puts red(message)
+        exit! 1 # exit! is required to avoid minitest at_exit callback
+      end
+    end
+  end
+end

data/lib/minitest/reporters/failure_formatter.rb

@@ -1,4 +1,3 @@
-require 'ansi'
 require 'delegate'
 
 module Minitest

data/lib/minitest/reporters/queue_reporter.rb

@@ -1,9 +1,10 @@
+require 'ci/queue/output_helpers'
 require 'minitest/reporters'
 
 module Minitest
   module Reporters
     class QueueReporter < BaseReporter
-      include ANSI::Code
+      include ::CI::Queue::OutputHelpers
       attr_accessor :requeues
 
       def initialize(*)
@@ -20,9 +21,10 @@ module Minitest
       private
 
       def print_report
+        reopen_previous_step if failures > 0 || errors > 0
         success = failures.zero? && errors.zero?
         failures_count = "#{failures} failures, #{errors} errors,"
-        puts [
+        step [
           'Ran %d tests, %d assertions,' % [count, assertions],
           success ? green(failures_count) : red(failures_count),
           yellow("#{skips} skips, #{requeues} requeues"),

data/lib/minitest/reporters/redis_reporter.rb

@@ -89,16 +89,20 @@ module Minitest
       end
 
       class Summary < Base
-        include ANSI::Code
+        include ::CI::Queue::OutputHelpers
 
-        def report(io: STDOUT)
-          io.puts aggregates
+        def report
+          puts aggregates
           errors = error_reports
-          io.puts errors
+          puts errors
 
           errors.empty?
         end
 
+        def success?
+          errors == 0 && failures == 0
+        end
+
         def record(*)
           raise NotImplementedError
         end
@@ -133,12 +137,12 @@ module Minitest
           success = failures.zero? && errors.zero?
           failures_count = "#{failures} failures, #{errors} errors,"
 
-          [
+          step([
             'Ran %d tests, %d assertions,' % [processed, assertions],
             success ? green(failures_count) : red(failures_count),
             yellow("#{skips} skips, #{requeues} requeues"),
             'in %.2fs (aggregated)' % total_time,
-          ].join(' ')
+          ].join(' '), collapsed: success)
         end
 
         def fetch_summary

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ci-queue
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-30 00:00:00.000000000 Z
+date: 2017-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,12 +97,14 @@ dependencies:
 description: To parallelize your CI without having to balance your tests
 email:
 - jean.boussier@shopify.com
-executables: []
+executables:
+- minitest-queue
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
+- README.md
 - Rakefile
 - bin/bundler
 - bin/console
@@ -110,8 +112,12 @@ files:
 - bin/setup
 - ci-queue.gemspec
 - dev.yml
+- exe/minitest-queue
 - lib/ci/queue.rb
+- lib/ci/queue/configuration.rb
 - lib/ci/queue/file.rb
+- lib/ci/queue/index.rb
+- lib/ci/queue/output_helpers.rb
 - lib/ci/queue/redis.rb
 - lib/ci/queue/redis/acknowledge.lua
 - lib/ci/queue/redis/base.rb
@@ -124,6 +130,7 @@ files:
 - lib/ci/queue/static.rb
 - lib/ci/queue/version.rb
 - lib/minitest/queue.rb
+- lib/minitest/queue/runner.rb
 - lib/minitest/reporters/failure_formatter.rb
 - lib/minitest/reporters/order_reporter.rb
 - lib/minitest/reporters/queue_reporter.rb
@@ -148,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Distribute tests over many workers using a queue