knapsack_pro 7.1.0 → 7.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 832322e0370ece75c8c2e53870b526e6bc4cd3f43214d4ee893a48cef6b209af
-  data.tar.gz: a3847464969d15278d84d00d9638c9e6e2cecea0190be5f773c70da0117c0d44
+  metadata.gz: 965d1d9b1d138cf0db8abe0fb44fc1672d5992d9f40f014c0f1f72c370d82585
+  data.tar.gz: 9570a9c2ffd20d1324451106f7a6144a298b6efb02981eabdc1f354d5c289940
 SHA512:
-  metadata.gz: d3648e3a7f77b8acfac104dc32a6f99cca7d86456cadd2127ff3b8e6d0a874df452398b5a266a887d54c9c239bf28727501a524cc3351adbb676b8887e272014
-  data.tar.gz: c7212ef6b958a7bb7aec2add6e6dc9d02e753936401f8d7705b4799c4ef1bb2b20c3456d1ad165b9e8ece86873b7393ee7afe1aa260c798b8644e6ace039fb17
+  metadata.gz: e7b335edb2e4107b44b0bf69b7cffdf0af110e316ad3d1f07190d919e23fe7172cae3081c5f97450174f1e0597f9d71387dafd8a0861aca604531a9cb1b1c26c
+  data.tar.gz: 269bc36e25e5a2048f2105f973523bc00dfba73b38ebf7eac482b121a8cd22a129f72c671579bd230830bcb3aa600428d2f7a5a3410ce1515c7ee4353fc36dde

data/.circleci/config.yml

@@ -152,6 +152,12 @@ jobs:
           command: |
             export KNAPSACK_PRO_BRANCH="$CIRCLE_BRANCH--$CIRCLE_BUILD_NUM--regular"
             bundle exec rake knapsack_pro:rspec
+      - run:
+          working_directory: ~/rails-app-with-knapsack_pro
+          command: |
+            # retry the same split ||
+            export KNAPSACK_PRO_BRANCH="$CIRCLE_BRANCH--$CIRCLE_BUILD_NUM--regular"
+            bundle exec rake knapsack_pro:rspec
       - run:
           working_directory: ~/rails-app-with-knapsack_pro
           command: |
@@ -285,6 +291,7 @@ jobs:
           RACK_ENV: test
           KNAPSACK_PRO_ENDPOINT: https://api-staging.knapsackpro.com
           KNAPSACK_PRO_TEST_SUITE_TOKEN_MINITEST: $KNAPSACK_PRO_TEST_SUITE_TOKEN_MINITEST
+          KNAPSACK_PRO_RSPEC_DISABLED: true
           EXTRA_TEST_FILES_DELAY: 10
       - image: cimg/postgres:14.7
         environment:
@@ -308,6 +315,12 @@ jobs:
           command: |
             export KNAPSACK_PRO_BRANCH="$CIRCLE_BRANCH--$CIRCLE_BUILD_NUM--regular"
             bundle exec rake knapsack_pro:minitest[--verbose]
+      - run:
+          working_directory: ~/rails-app-with-knapsack_pro
+          command: |
+            # retry the same split ||
+            export KNAPSACK_PRO_BRANCH="$CIRCLE_BRANCH--$CIRCLE_BUILD_NUM--regular"
+            bundle exec rake knapsack_pro:minitest[--verbose]
 
   e2e-queue-minitest:
     parameters:
@@ -325,6 +338,7 @@ jobs:
           RACK_ENV: test
           KNAPSACK_PRO_ENDPOINT: https://api-staging.knapsackpro.com
           KNAPSACK_PRO_TEST_SUITE_TOKEN_MINITEST: $KNAPSACK_PRO_TEST_SUITE_TOKEN_MINITEST
+          KNAPSACK_PRO_RSPEC_DISABLED: true
           EXTRA_TEST_FILES_DELAY: 10
       - image: cimg/postgres:14.7
         environment:

data/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+### 7.4.0
+* Warn when `KNAPSACK_PRO_*` environment variables are set manually if their values could be automatically determined from supported CI environments.
+
+  https://github.com/KnapsackPro/knapsack_pro-ruby/pull/254
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v7.3.0...v7.4.0
+
+### 7.3.0
+
+* [Queue Mode][RSpec] Pass each batch of tests to the queue hooks: `KnapsackPro::Hooks::Queue.before_subset_queue` and `KnapsackPro::Hooks::Queue.after_subset_queue`
+
+  The `KnapsackPro::Hooks::Queue.before_subset_queue` and `KnapsackPro::Hooks::Queue.after_subset_queue` hooks get a 3rd variable - the `queue`.
+
+  The `queue` variable stores an enumerable collection with each batch of tests fetched from the Queue API. The batch has:
+
+  * a list of test file paths (`KnapsackPro::Batch#test_file_paths` returns an array like `['a_spec.rb', 'b_spec.rb']`)
+  * a status of the given set of tests in the batch (`KnapsackPro::Batch#status` returns `:not_executed`, `:passed` or `:failed`)
+
+  Example usage:
+
+  ```ruby
+  # spec_helper.rb
+
+  KnapsackPro::Hooks::Queue.before_subset_queue do |queue_id, subset_queue_id, queue|
+    print "Tests from all batches fetched from the Queue API so far:  "
+    puts queue.map(&:test_file_paths).inspect
+
+    queue.each(&:test_file_paths) # you can use each as well
+
+    print "Current batch tests: "
+    puts queue.current_batch.test_file_paths.inspect
+
+    print "Current batch status: "
+    puts queue.current_batch.status # returns :not_executed in the `before_subset_queue` hook
+  end
+
+  KnapsackPro::Hooks::Queue.after_subset_queue do |queue_id, subset_queue_id, queue|
+    print "Tests from all batches fetched from the Queue API so far: "
+    puts queue.map(&:test_file_paths).inspect
+
+    print "Current batch tests: "
+    puts queue.current_batch.test_file_paths.inspect
+
+    print "Current batch status: "
+    puts queue.current_batch.status # returns :passed or :failed in the `after_subset_queue` hook
+  end
+  ```
+
+  https://github.com/KnapsackPro/knapsack_pro-ruby/pull/253
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v7.2.0...v7.3.0
+
+### 7.2.0
+
+* Always use the original `Net::HTTP` client, even when WebMock replaces it with its own
+    * No action is required on your side, but you can delete the following code that you may have used to configure Knapsack Pro with WebMock or VCR:
+    ```diff
+      WebMock.disable_net_connect!(
+        allow_localhost: true,
+    -   allow: ['api.knapsackpro.com']
+      )
+
+      # VCR
+    - config.ignore_hosts('localhost', '127.0.0.1', '0.0.0.0', 'api.knapsackpro.com')
+    + config.ignore_localhost = true
+    ```
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/251
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v7.1.0...v7.2.0
+
 ### 7.1.0
 
 * [RSpec] [Queue Mode] Log error message and backtrace when unexpected failure is raised
@@ -28,6 +99,25 @@ https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v7.0.0...v7.0.1
     __After:__<br>
     The `before(:suite)` and `after(:suite)` hooks are executed only once: `before(:suite)` is executed before starting tests, `after(:suite)` is executed after all tests are completed. (It is what you would expect from RSpec).
 
+  * It is recommended that you define your `before(:suite)` hooks in `spec_helper.rb` or `rails_helper.rb`. These files should be loaded before any test files so that the hook is registered by RSpec.
+
+    The `before(:suite)` hook is executed first. After that, test files are dynamically loaded in multiple batches from the Knapsack Pro Queue API. __The `before(:suite)` hooks defined in test files won't be executed because it is too late!__
+
+    If you need to have something that is similar to `before(:suite)` and you want to define it in a test file, then you can use this:
+
+    ```ruby
+    RSpec.configure do |config|
+      config.before(:context) do
+        unless ENV['MY_HOOK_NAME']
+          # your code to run in the hook
+        end
+        ENV['MY_HOOK_NAME'] = 'hook_called'
+      end
+    end
+    ```
+
+    Alternatively, if you need to [load code only once for a specific type of specs you can check this](https://docs.knapsackpro.com/ruby/rspec/#load-code-only-once-for-a-specific-type-of-specs).
+
   * The `KnapsackPro::Hooks::Queue.after_queue` hook change:
 
     __Before:__<br>
@@ -36,6 +126,25 @@ https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v7.0.0...v7.0.1
     __After:__<br>
     The `KnapsackPro::Hooks::Queue.after_queue` hook is executed __inside__ of the `after(:suite)` hook.
 
+  * The RSpec `filter_run_excluding` option is not supported in Queue Mode.
+
+    __Before:__ The following option won't run tests tagged with `:manual`.<br>
+
+    ```ruby
+    # spec_helper.rb
+    RSpec.configure do |config|
+      config.filter_run_excluding :manual
+    end
+    ```
+
+    __After:__ The RSpec `filter_run_excluding` option is ignored in Queue Mode. You must manually pass the `--tag ~manual` option to the Knapsack Pro command to skip tests tagged with `:manual`.
+
+    ```
+    bundle exec rake "knapsack_pro:queue:rspec[--tag ~manual]"
+    ```
+
+  * Please [update the datadog-ci gem to the latest version](https://github.com/DataDog/datadog-ci-rb/issues/147#issuecomment-2099997045) if you use DataDog. This allows DataDog to collect RSpec data correctly in Knapsack Pro Queue Mode.
+
 * Recommended RSpec changes in your project:
   * Remove the following code if you use Queue Mode and the `rspec_junit_formatter` gem to generate JUnit XML or JSON reports:
 

data/lib/knapsack_pro/batch.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module KnapsackPro
+  class Batch
+    attr_reader :test_file_paths, :status
+
+    def initialize(test_file_paths)
+      @test_file_paths = test_file_paths
+      @status = :not_executed
+    end
+
+    def _passed
+      @status = :passed
+    end
+
+    def _failed
+      @status = :failed
+    end
+  end
+end

data/lib/knapsack_pro/client/connection.rb

@@ -141,13 +141,21 @@ module KnapsackPro
       end
 
       def build_http(uri)
-        http = Net::HTTP.new(uri.host, uri.port)
+        http = net_http.new(uri.host, uri.port)
         http.use_ssl = (uri.scheme == 'https')
         http.open_timeout = TIMEOUT
         http.read_timeout = TIMEOUT
         http
       end
 
+      def net_http
+        if defined?(WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP)
+          WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP
+        else
+          Net::HTTP
+        end
+      end
+
       def post
         uri = URI.parse(endpoint_url)
         http = build_http(uri)

data/lib/knapsack_pro/config/env.rb

@@ -13,30 +13,21 @@ module KnapsackPro
 
       class << self
         def ci_node_total
-          (ENV['KNAPSACK_PRO_CI_NODE_TOTAL'] ||
-            ci_env_for(:node_total) ||
-            1).to_i
+          (env_for('KNAPSACK_PRO_CI_NODE_TOTAL', :node_total) || 1).to_i
         end
 
         def ci_node_index
-          (ENV['KNAPSACK_PRO_CI_NODE_INDEX'] ||
-            ci_env_for(:node_index) ||
-            0).to_i
+          (env_for('KNAPSACK_PRO_CI_NODE_INDEX', :node_index) || 0).to_i
         end
 
         def ci_node_build_id
           env_name = 'KNAPSACK_PRO_CI_NODE_BUILD_ID'
-          ENV[env_name] ||
-            ci_env_for(:node_build_id) ||
+          env_for(env_name, :node_build_id) ||
             raise("Missing environment variable #{env_name}. Read more at #{KnapsackPro::Urls::KNAPSACK_PRO_CI_NODE_BUILD_ID}")
         end
 
         def ci_node_retry_count
-          (
-            ENV['KNAPSACK_PRO_CI_NODE_RETRY_COUNT'] ||
-            ci_env_for(:node_retry_count) ||
-            0
-          ).to_i
+          (env_for('KNAPSACK_PRO_CI_NODE_RETRY_COUNT', :node_retry_count) || 0).to_i
         end
 
         def max_request_retries
@@ -47,23 +38,19 @@ module KnapsackPro
         end
 
         def commit_hash
-          ENV['KNAPSACK_PRO_COMMIT_HASH'] ||
-            ci_env_for(:commit_hash)
+          env_for('KNAPSACK_PRO_COMMIT_HASH', :commit_hash)
         end
 
         def branch
-          ENV['KNAPSACK_PRO_BRANCH'] ||
-            ci_env_for(:branch)
+          env_for('KNAPSACK_PRO_BRANCH', :branch)
         end
 
         def project_dir
-          ENV['KNAPSACK_PRO_PROJECT_DIR'] ||
-            ci_env_for(:project_dir)
+          env_for('KNAPSACK_PRO_PROJECT_DIR', :project_dir)
         end
 
         def user_seat
-          ENV['KNAPSACK_PRO_USER_SEAT'] ||
-            ci_env_for(:user_seat)
+          env_for('KNAPSACK_PRO_USER_SEAT', :user_seat)
         end
 
         def masked_user_seat
@@ -183,7 +170,7 @@ module KnapsackPro
         def fixed_queue_split
           @fixed_queue_split ||= begin
             env_name = 'KNAPSACK_PRO_FIXED_QUEUE_SPLIT'
-            computed = ENV.fetch(env_name, ci_env_for(:fixed_queue_split)).to_s
+            computed = env_for(env_name, :fixed_queue_split).to_s
 
             if !ENV.key?(env_name)
               KnapsackPro.logger.info("#{env_name} is not set. Using default value: #{computed}. Learn more at #{KnapsackPro::Urls::FIXED_QUEUE_SPLIT}")
@@ -249,10 +236,6 @@ module KnapsackPro
           end
         end
 
-        def ci_env_for(env_name)
-          detected_ci.new.send(env_name)
-        end
-
         def detected_ci
           detected = KnapsackPro::Config::CI.constants.map do |constant|
             Object.const_get("KnapsackPro::Config::CI::#{constant}").new.detected
@@ -293,6 +276,21 @@ module KnapsackPro
         def required_env(env_name)
           ENV[env_name] || raise("Missing environment variable #{env_name}")
         end
+
+        def env_for(knapsack_env_name, ci_env_method)
+          knapsack_env_value = ENV[knapsack_env_name]
+          ci_env_value = ci_env_for(ci_env_method)
+
+          if !knapsack_env_value.nil? && !ci_env_value.nil? && knapsack_env_value != ci_env_value.to_s
+            KnapsackPro.logger.info("You have set the environment variable #{knapsack_env_name} to #{knapsack_env_value} which could be automatically determined from the CI environment as #{ci_env_value}.")
+          end
+
+          knapsack_env_value != nil ? knapsack_env_value : ci_env_value
+        end
+
+        def ci_env_for(env_name)
+          detected_ci.new.send(env_name)
+        end
       end
     end
   end

data/lib/knapsack_pro/extensions/rspec_extension.rb

@@ -90,7 +90,7 @@ module KnapsackPro
 
           configuration.reporter.report(_expected_example_count = 0) do |reporter|
             configuration.with_suite_hooks do
-              queue_runner.with_batch do |test_file_paths|
+              queue_runner.with_batch do |test_file_paths, queue|
                 knapsack__load_spec_files_batch(test_file_paths)
 
                 examples_passed = ordering_strategy.order(world.example_groups).map do |example_group|
@@ -98,7 +98,12 @@ module KnapsackPro
                   example_group.run(reporter)
                 end.all?
 
-                node_examples_passed = false unless examples_passed
+                if examples_passed
+                  queue.mark_batch_passed
+                else
+                  queue.mark_batch_failed
+                  node_examples_passed = false
+                end
 
                 knapsack__persist_example_statuses
 

data/lib/knapsack_pro/hooks/queue.rb

@@ -54,22 +54,25 @@ module KnapsackPro
           end
         end
 
-        def call_before_subset_queue
+        # `queue` is always present for RSpec
+        def call_before_subset_queue(queue = nil)
           return unless before_subset_queue_store
           before_subset_queue_store.each do |block|
             block.call(
               KnapsackPro::Config::Env.queue_id,
-              KnapsackPro::Config::Env.subset_queue_id
+              KnapsackPro::Config::Env.subset_queue_id,
+              queue
             )
           end
         end
 
-        def call_after_subset_queue
+        def call_after_subset_queue(queue = nil)
           return unless after_subset_queue_store
           after_subset_queue_store.each do |block|
             block.call(
               KnapsackPro::Config::Env.queue_id,
-              KnapsackPro::Config::Env.subset_queue_id
+              KnapsackPro::Config::Env.subset_queue_id,
+              queue
             )
           end
         end

data/lib/knapsack_pro/queue.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module KnapsackPro
+  class Queue
+    include Enumerable
+
+    def initialize
+      @batches = []
+    end
+
+    def each(&block)
+      @batches.each(&block)
+    end
+
+    def add_batch_for(test_file_paths)
+      return if test_file_paths.empty?
+      @batches << KnapsackPro::Batch.new(test_file_paths)
+    end
+
+    def mark_batch_passed
+      current_batch._passed
+    end
+
+    def mark_batch_failed
+      current_batch._failed
+    end
+
+    def current_batch
+      @batches.last
+    end
+
+    def size
+      @batches.size
+    end
+
+    def [](index)
+      @batches[index]
+    end
+  end
+end

data/lib/knapsack_pro/runners/queue/rspec_runner.rb

@@ -33,6 +33,7 @@ module KnapsackPro
           @stream_out = stream_out
           @node_test_file_paths = []
           @rspec_runner = nil # RSpec::Core::Runner is lazy initialized
+          @queue = KnapsackPro::Queue.new
         end
 
         # Based on:
@@ -82,11 +83,13 @@ module KnapsackPro
             subset_queue_id = KnapsackPro::Config::EnvGenerator.set_subset_queue_id
             ENV['KNAPSACK_PRO_SUBSET_QUEUE_ID'] = subset_queue_id
 
-            KnapsackPro::Hooks::Queue.call_before_subset_queue
+            @queue.add_batch_for(test_file_paths)
 
-            yield test_file_paths
+            KnapsackPro::Hooks::Queue.call_before_subset_queue(@queue)
 
-            KnapsackPro::Hooks::Queue.call_after_subset_queue
+            yield test_file_paths, @queue
+
+            KnapsackPro::Hooks::Queue.call_after_subset_queue(@queue)
 
             if @rspec_runner.knapsack__wants_to_quit?
               KnapsackPro.logger.warn('RSpec wants to quit.')

data/lib/knapsack_pro/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KnapsackPro
-  VERSION = '7.1.0'
+  VERSION = '7.4.0'
 end

data/lib/knapsack_pro.rb

@@ -67,6 +67,8 @@ require_relative 'knapsack_pro/test_files_with_test_cases_composer'
 require_relative 'knapsack_pro/base_allocator_builder'
 require_relative 'knapsack_pro/allocator_builder'
 require_relative 'knapsack_pro/queue_allocator_builder'
+require_relative 'knapsack_pro/batch'
+require_relative 'knapsack_pro/queue'
 require_relative 'knapsack_pro/runners/base_runner'
 require_relative 'knapsack_pro/runners/rspec_runner'
 require_relative 'knapsack_pro/runners/cucumber_runner'

data/spec/integration/runners/queue/rspec_runner_spec.rb

@@ -739,6 +739,139 @@ describe "#{KnapsackPro::Runners::Queue::RSpecRunner} - Integration tests", :cle
 
       expect(actual.exit_code).to eq 0
     end
+
+    it 'gives access to batch of tests in queue hooks' do
+      rspec_options = ''
+
+      spec_helper = <<~SPEC
+      require 'knapsack_pro'
+      KnapsackPro::Adapters::RSpecAdapter.bind
+
+      KnapsackPro::Hooks::Queue.before_subset_queue do |queue_id, subset_queue_id, queue|
+        print "Tests in batches in before_subset_queue: "
+        puts queue.map(&:test_file_paths).inspect
+
+        print "Batches' statuses in before_subset_queue: "
+        puts queue.map(&:status).inspect
+      end
+
+      KnapsackPro::Hooks::Queue.after_subset_queue do |queue_id, subset_queue_id, queue|
+        print "Tests in batches in after_subset_queue: "
+        puts queue.map(&:test_file_paths).inspect
+        print "Batches' statuses in after_subset_queue: "
+        puts queue.map(&:status).inspect
+
+        # call public API methods that must be backward compatible
+        print "Current batch tests: "
+        puts queue.current_batch.test_file_paths.inspect
+        print "Current batch status: "
+        puts queue.current_batch.status
+      end
+      SPEC
+
+      spec_a = Spec.new('a_spec.rb', <<~SPEC)
+        describe 'A_describe' do
+          it 'A1 test example' do
+            expect(1).to eq 1
+          end
+        end
+      SPEC
+
+      spec_b = Spec.new('b_spec.rb', <<~SPEC)
+        describe 'B_describe' do
+          it 'B1 test example' do
+            expect(1).to eq 1
+          end
+        end
+      SPEC
+
+      spec_c = Spec.new('c_spec.rb', <<~SPEC)
+        describe 'C_describe' do
+          it 'C1 test example' do
+            expect(1).to eq 1
+          end
+        end
+      SPEC
+
+      failing_spec_d = Spec.new('d_spec.rb', <<~SPEC)
+        describe 'D_describe' do
+          it 'D1 test example' do
+            expect(1).to eq 0
+          end
+        end
+      SPEC
+
+      spec_e = Spec.new('e_spec.rb', <<~SPEC)
+        describe 'E_describe' do
+          it 'E1 test example' do
+            expect(1).to eq 1
+          end
+        end
+      SPEC
+
+      spec_f = Spec.new('f_spec.rb', <<~SPEC)
+        describe 'F_describe' do
+          it 'F1 test example' do
+            expect(1).to eq 1
+          end
+        end
+      SPEC
+
+      failing_spec_g = Spec.new('g_spec.rb', <<~SPEC)
+        describe 'G_describe' do
+          it 'G1 test example' do
+            expect(1).to eq 0
+          end
+        end
+      SPEC
+
+      spec_h = Spec.new('h_spec.rb', <<~SPEC)
+        describe 'h_describe' do
+          it 'H1 test example' do
+            expect(1).to eq 1
+          end
+        end
+      SPEC
+
+      generate_specs(spec_helper, rspec_options, [
+        [spec_a, spec_b],
+        [spec_c, failing_spec_d],
+        [spec_e, spec_f],
+        [failing_spec_g, spec_h],
+      ])
+
+      actual = subject
+
+      expect(actual.stdout).to include('Tests in batches in before_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"]]')
+      expect(actual.stdout).to include('Tests in batches in before_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"], ["spec_integration/c_spec.rb", "spec_integration/d_spec.rb"]]')
+      expect(actual.stdout).to include('Tests in batches in before_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"], ["spec_integration/c_spec.rb", "spec_integration/d_spec.rb"], ["spec_integration/e_spec.rb", "spec_integration/f_spec.rb"]]')
+      expect(actual.stdout).to include('Tests in batches in before_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"], ["spec_integration/c_spec.rb", "spec_integration/d_spec.rb"], ["spec_integration/e_spec.rb", "spec_integration/f_spec.rb"], ["spec_integration/g_spec.rb", "spec_integration/h_spec.rb"]]')
+
+      expect(actual.stdout).to include('Tests in batches in after_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"]]')
+      expect(actual.stdout).to include('Tests in batches in after_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"], ["spec_integration/c_spec.rb", "spec_integration/d_spec.rb"]]')
+      expect(actual.stdout).to include('Tests in batches in after_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"], ["spec_integration/c_spec.rb", "spec_integration/d_spec.rb"], ["spec_integration/e_spec.rb", "spec_integration/f_spec.rb"]]')
+      expect(actual.stdout).to include('Tests in batches in after_subset_queue: [["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"], ["spec_integration/c_spec.rb", "spec_integration/d_spec.rb"], ["spec_integration/e_spec.rb", "spec_integration/f_spec.rb"], ["spec_integration/g_spec.rb", "spec_integration/h_spec.rb"]]')
+
+
+      expect(actual.stdout).to include("Batches' statuses in before_subset_queue: [:not_executed]")
+      expect(actual.stdout).to include("Batches' statuses in before_subset_queue: [:passed, :not_executed]")
+      expect(actual.stdout).to include("Batches' statuses in before_subset_queue: [:passed, :failed, :not_executed]")
+      expect(actual.stdout).to include("Batches' statuses in before_subset_queue: [:passed, :failed, :passed, :not_executed]")
+
+      expect(actual.stdout).to include("Batches' statuses in after_subset_queue: [:passed]")
+      expect(actual.stdout).to include("Batches' statuses in after_subset_queue: [:passed, :failed]")
+      expect(actual.stdout).to include("Batches' statuses in after_subset_queue: [:passed, :failed, :passed]")
+      expect(actual.stdout).to include("Batches' statuses in after_subset_queue: [:passed, :failed, :passed, :failed]")
+
+      expect(actual.stdout).to include('Current batch tests: ["spec_integration/a_spec.rb", "spec_integration/b_spec.rb"]')
+      expect(actual.stdout).to include('Current batch tests: ["spec_integration/c_spec.rb", "spec_integration/d_spec.rb"]')
+      expect(actual.stdout).to include('Current batch tests: ["spec_integration/e_spec.rb", "spec_integration/f_spec.rb"]')
+      expect(actual.stdout).to include('Current batch tests: ["spec_integration/g_spec.rb", "spec_integration/h_spec.rb"]')
+      expect(actual.stdout).to include('Current batch status: passed').twice
+      expect(actual.stdout).to include('Current batch status: failed').twice
+
+      expect(actual.exit_code).to eq 1
+    end
   end
 
   context 'when the RSpec seed is used' do

data/spec/knapsack_pro/config/env_spec.rb

@@ -17,6 +17,40 @@ describe KnapsackPro::Config::Env do
 
         it { should eq 4 }
       end
+
+      context 'when both KNAPSACK_PRO_CI_NODE_TOTAL and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_CI_NODE_TOTAL' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:node_total).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { '5' }
+          let(:ci_value) { 4 }
+
+          it { should eq 5 }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_CI_NODE_TOTAL to 5 which could be automatically determined from the CI environment as 4.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { '5' }
+          let(:ci_value) { 5 }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
     end
 
     context "when ENV doesn't exist" do
@@ -41,6 +75,40 @@ describe KnapsackPro::Config::Env do
         it { should eq 2 }
       end
 
+      context 'when both KNAPSACK_PRO_CI_NODE_INDEX and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_CI_NODE_INDEX' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:node_index).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { '3' }
+          let(:ci_value) { 2 }
+
+          it { should eq 3 }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_CI_NODE_INDEX to 3 which could be automatically determined from the CI environment as 2.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { '3' }
+          let(:ci_value) { 3 }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
+
       context 'when order of loading envs does matter' do
         context 'when GitLab CI' do
           before { stub_const("ENV", { 'CI_NODE_INDEX' => '2', 'GITLAB_CI' => 'true' }) }
@@ -70,6 +138,40 @@ describe KnapsackPro::Config::Env do
 
         it { should eq '8' }
       end
+
+      context 'when both KNAPSACK_PRO_CI_NODE_BUILD_ID and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_CI_NODE_BUILD_ID' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:node_build_id).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { '7' }
+          let(:ci_value) { '8' }
+
+          it { should eq '7' }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_CI_NODE_BUILD_ID to 7 which could be automatically determined from the CI environment as 8.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { '7' }
+          let(:ci_value) { '7' }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
     end
 
     context "when ENV does not exist" do
@@ -95,6 +197,40 @@ describe KnapsackPro::Config::Env do
 
         it { should eq 2 }
       end
+
+      context 'when both KNAPSACK_PRO_CI_NODE_RETRY_COUNT and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_CI_NODE_RETRY_COUNT' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:node_retry_count).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { '1' }
+          let(:ci_value) { 2 }
+
+          it { should eq 1 }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_CI_NODE_RETRY_COUNT to 1 which could be automatically determined from the CI environment as 2.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { '7' }
+          let(:ci_value) { '7' }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
     end
 
     context "when ENV doesn't exist" do
@@ -131,6 +267,40 @@ describe KnapsackPro::Config::Env do
 
         it { should eq 'fe61a08118d0d52e97c38666eba1eaf3' }
       end
+
+      context 'when both KNAPSACK_PRO_COMMIT_HASH and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_COMMIT_HASH' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:commit_hash).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { '3fa64859337f6e56409d49f865d13fd7' }
+          let(:ci_value) { 'fe61a08118d0d52e97c38666eba1eaf3' }
+
+          it { should eq '3fa64859337f6e56409d49f865d13fd7' }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_COMMIT_HASH to 3fa64859337f6e56409d49f865d13fd7 which could be automatically determined from the CI environment as fe61a08118d0d52e97c38666eba1eaf3.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { '3fa64859337f6e56409d49f865d13fd7' }
+          let(:ci_value) { '3fa64859337f6e56409d49f865d13fd7' }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
     end
 
     context "when ENV doesn't exist" do
@@ -154,6 +324,40 @@ describe KnapsackPro::Config::Env do
 
         it { should eq 'feature-branch' }
       end
+
+      context 'when both KNAPSACK_PRO_BRANCH and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_BRANCH' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:branch).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { 'master' }
+          let(:ci_value) { 'feature-branch' }
+
+          it { should eq 'master' }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_BRANCH to master which could be automatically determined from the CI environment as feature-branch.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { 'master' }
+          let(:ci_value) { 'master' }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
     end
 
     context "when ENV doesn't exist" do
@@ -177,6 +381,40 @@ describe KnapsackPro::Config::Env do
 
         it { should eq '/home/runner/myapp' }
       end
+
+      context 'when both KNAPSACK_PRO_PROJECT_DIR and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_PROJECT_DIR' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:project_dir).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { '/home/user/myapp' }
+          let(:ci_value) { '/home/runner/myapp' }
+
+          it { should eq '/home/user/myapp' }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_PROJECT_DIR to /home/user/myapp which could be automatically determined from the CI environment as /home/runner/myapp.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { '/home/user/myapp' }
+          let(:ci_value) { '/home/user/myapp' }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
     end
 
     context "when ENV doesn't exist" do
@@ -200,6 +438,40 @@ describe KnapsackPro::Config::Env do
 
         it { should eq 'Jane Doe' }
       end
+
+      context 'when both KNAPSACK_PRO_USER_SEAT and CI environment have value' do
+        let(:logger) { instance_double(Logger, info: nil) }
+
+        before do
+          stub_const("ENV", { 'KNAPSACK_PRO_USER_SEAT' => env_value })
+          expect(described_class).to receive(:ci_env_for).with(:user_seat).and_return(ci_value)
+          allow(KnapsackPro).to receive(:logger).and_return(logger)
+        end
+
+        context 'when values are different' do
+          let(:env_value) { 'John Doe' }
+          let(:ci_value) { 'Jane Doe' }
+
+          it { should eq 'John Doe' }
+
+          it 'logs a warning' do
+            expect(logger).to receive(:info).with(
+              'You have set the environment variable KNAPSACK_PRO_USER_SEAT to John Doe which could be automatically determined from the CI environment as Jane Doe.'
+            )
+            subject
+          end
+        end
+
+        context 'when values are the same' do
+          let(:env_value) { 'John Doe' }
+          let(:ci_value) { 'John Doe' }
+
+          it 'does not log a warning' do
+            expect(logger).not_to receive(:info)
+            subject
+          end
+        end
+      end
     end
 
     context "when ENV doesn't exist" do
@@ -345,7 +617,6 @@ describe KnapsackPro::Config::Env do
     end
   end
 
-
   describe '.regular_mode?' do
     subject { described_class.regular_mode? }
 
@@ -645,11 +916,18 @@ describe KnapsackPro::Config::Env do
           ['Unsupported CI', {}],
         ].each do |ci, env|
           it "on #{ci} it is false" do
+            stub_const("ENV", env.merge({ 'KNAPSACK_PRO_FIXED_QUEUE_SPLIT' => 'false' }))
+
             logger = instance_double(Logger)
             allow(KnapsackPro).to receive(:logger).and_return(logger)
-            expect(logger).not_to receive(:info)
-
-            stub_const("ENV", env.merge({ 'KNAPSACK_PRO_FIXED_QUEUE_SPLIT' => 'false' }))
+            ci_env = described_class.detected_ci.new.fixed_queue_split
+            if ci_env == false
+              expect(logger).not_to receive(:info)
+            else
+              expect(logger).to receive(:info).with(
+                'You have set the environment variable KNAPSACK_PRO_FIXED_QUEUE_SPLIT to false which could be automatically determined from the CI environment as true.'
+              )
+            end
 
             expect(subject).to eq(false)
           end
@@ -673,11 +951,18 @@ describe KnapsackPro::Config::Env do
           ['Unsupported CI', {}],
         ].each do |ci, env|
           it "on #{ci} it is true" do
+            stub_const("ENV", env.merge({ 'KNAPSACK_PRO_FIXED_QUEUE_SPLIT' => 'true' }))
+
             logger = instance_double(Logger)
             allow(KnapsackPro).to receive(:logger).and_return(logger)
-            expect(logger).not_to receive(:info)
-
-            stub_const("ENV", env.merge({ 'KNAPSACK_PRO_FIXED_QUEUE_SPLIT' => 'true' }))
+            ci_env = described_class.detected_ci.new.fixed_queue_split
+            if ci_env == true
+              expect(logger).not_to receive(:info)
+            else
+              expect(logger).to receive(:info).with(
+                'You have set the environment variable KNAPSACK_PRO_FIXED_QUEUE_SPLIT to true which could be automatically determined from the CI environment as false.'
+              )
+            end
 
             expect(subject).to eq(true)
           end
@@ -702,12 +987,12 @@ describe KnapsackPro::Config::Env do
         ['Unsupported CI', {}, true],
       ].each do |ci, env, expected|
         it "on #{ci} it is #{expected}" do
+          stub_const("ENV", env)
+
           logger = instance_double(Logger)
           expect(KnapsackPro).to receive(:logger).and_return(logger)
           expect(logger).to receive(:info).with("KNAPSACK_PRO_FIXED_QUEUE_SPLIT is not set. Using default value: #{expected}. Learn more at #{KnapsackPro::Urls::FIXED_QUEUE_SPLIT}")
 
-          stub_const("ENV", env)
-
           expect(subject).to eq(expected)
         end
       end

data/spec/knapsack_pro/hooks/queue_spec.rb

@@ -2,34 +2,32 @@ describe KnapsackPro::Hooks::Queue do
   describe '.call_before_queue' do
     subject { described_class.call_before_queue }
 
-    context 'when callback is not set' do
-      before do
-        described_class.reset_before_queue
-      end
+    before do
+      described_class.reset_before_queue
+    end
 
+    context 'when no callback is set' do
       it { should be_nil }
     end
 
-    context 'when callback is set multiple times' do
+    context 'when multiple callbacks are set' do
       let(:queue_id) { double }
 
-      before do
+      it 'calls each block' do
         expect(KnapsackPro::Config::Env).to receive(:queue_id).twice.and_return(queue_id)
 
-        $expected_called_blocks = []
+        expected_called_blocks = []
 
         described_class.before_queue do |q_id|
-          $expected_called_blocks << [:block_1_called, q_id]
+          expected_called_blocks << [:block_1_called, q_id]
         end
         described_class.before_queue do |q_id|
-          $expected_called_blocks << [:block_2_called, q_id]
+          expected_called_blocks << [:block_2_called, q_id]
         end
-      end
 
-      it 'each block is called' do
         subject
 
-        expect($expected_called_blocks).to eq([
+        expect(expected_called_blocks).to eq([
           [:block_1_called, queue_id],
           [:block_2_called, queue_id],
         ])
@@ -40,114 +38,158 @@ describe KnapsackPro::Hooks::Queue do
   describe '.call_before_subset_queue' do
     subject { described_class.call_before_subset_queue }
 
-    context 'when callback is not set' do
-      before do
-        described_class.reset_before_subset_queue
-      end
+    before do
+      described_class.reset_before_subset_queue
+    end
 
+    context 'when no callback is set' do
       it { should be_nil }
     end
 
-    context 'when callback is set multiple times' do
+    context 'when multiple callbacks are set' do
       let(:queue_id) { double }
       let(:subset_queue_id) { double }
 
-      before do
+      it 'calls each block' do
         expect(KnapsackPro::Config::Env).to receive(:queue_id).twice.and_return(queue_id)
         expect(KnapsackPro::Config::Env).to receive(:subset_queue_id).twice.and_return(subset_queue_id)
 
-        $expected_called_blocks = []
+        expected_called_blocks = []
 
         described_class.before_subset_queue do |q_id, subset_q_id|
-          $expected_called_blocks << [:block_1_called, q_id, subset_q_id]
+          expected_called_blocks << [:block_1_called, q_id, subset_q_id]
         end
         described_class.before_subset_queue do |q_id, subset_q_id|
-          $expected_called_blocks << [:block_2_called, q_id, subset_q_id]
+          expected_called_blocks << [:block_2_called, q_id, subset_q_id]
         end
-      end
 
-      it 'each block is called' do
         subject
 
-        expect($expected_called_blocks).to eq([
+        expect(expected_called_blocks).to eq([
           [:block_1_called, queue_id, subset_queue_id],
           [:block_2_called, queue_id, subset_queue_id],
         ])
       end
     end
+
+    context 'when a callback is set AND the queue is passed' do
+      let(:queue_id) { double }
+      let(:subset_queue_id) { double }
+      let(:queue) { instance_double(KnapsackPro::Queue) }
+
+      subject { described_class.call_before_subset_queue(queue) }
+
+      it 'calls each block' do
+        expect(KnapsackPro::Config::Env).to receive(:queue_id).and_return(queue_id)
+        expect(KnapsackPro::Config::Env).to receive(:subset_queue_id).and_return(subset_queue_id)
+
+        expected_called_blocks = []
+
+        described_class.before_subset_queue do |q_id, subset_q_id, queue|
+          expected_called_blocks << [:block_1_called, q_id, subset_q_id, queue]
+        end
+
+        subject
+
+        expect(expected_called_blocks).to eq([
+          [:block_1_called, queue_id, subset_queue_id, queue],
+        ])
+      end
+    end
   end
 
   describe '.call_after_subset_queue' do
     subject { described_class.call_after_subset_queue }
 
-    context 'when callback is not set' do
-      before do
-        described_class.reset_after_subset_queue
-      end
+    before do
+      described_class.reset_after_subset_queue
+    end
 
+    context 'when no callback is set' do
       it { should be_nil }
     end
 
-    context 'when callback is set multiple times' do
+    context 'when multiple callbacks are set' do
       let(:queue_id) { double }
       let(:subset_queue_id) { double }
 
-      before do
+      it 'calls each block' do
         expect(KnapsackPro::Config::Env).to receive(:queue_id).at_least(:once).and_return(queue_id)
         expect(KnapsackPro::Config::Env).to receive(:subset_queue_id).at_least(:once).and_return(subset_queue_id)
 
-        $expected_called_blocks = []
+        expected_called_blocks = []
 
         described_class.after_subset_queue do |q_id, subset_q_id|
-          $expected_called_blocks << [:block_1_called, q_id, subset_q_id]
+          expected_called_blocks << [:block_1_called, q_id, subset_q_id]
         end
         described_class.after_subset_queue do |q_id, subset_q_id|
-          $expected_called_blocks << [:block_2_called, q_id, subset_q_id]
+          expected_called_blocks << [:block_2_called, q_id, subset_q_id]
         end
-      end
 
-      it 'each block is called' do
         subject
 
-        expect($expected_called_blocks).to eq([
+        expect(expected_called_blocks).to eq([
           [:block_1_called, queue_id, subset_queue_id],
           [:block_2_called, queue_id, subset_queue_id],
         ])
       end
     end
+
+    context 'when a callback is set AND the queue is passed' do
+      let(:queue_id) { double }
+      let(:subset_queue_id) { double }
+      let(:queue) { instance_double(KnapsackPro::Queue) }
+
+      subject { described_class.call_after_subset_queue(queue) }
+
+      it 'calls each block' do
+        expect(KnapsackPro::Config::Env).to receive(:queue_id).and_return(queue_id)
+        expect(KnapsackPro::Config::Env).to receive(:subset_queue_id).and_return(subset_queue_id)
+
+        expected_called_blocks = []
+
+        described_class.after_subset_queue do |q_id, subset_q_id, queue|
+          expected_called_blocks << [:block_1_called, q_id, subset_q_id, queue]
+        end
+
+        subject
+
+        expect(expected_called_blocks).to eq([
+          [:block_1_called, queue_id, subset_queue_id, queue],
+        ])
+      end
+    end
   end
 
   describe '.call_after_queue' do
     subject { described_class.call_after_queue }
 
-    context 'when callback is not set' do
-      before do
-        described_class.reset_after_queue
-      end
+    before do
+      described_class.reset_after_queue
+    end
 
+    context 'when no callback is set' do
       it { should be_nil }
     end
 
-    context 'when callback is set multiple times' do
+    context 'when multiple callbacks are set' do
       let(:queue_id) { double }
 
-      before do
+      it 'calls each block' do
         expect(KnapsackPro::Config::Env).to receive(:queue_id).twice.and_return(queue_id)
 
-        $expected_called_blocks = []
+        expected_called_blocks = []
 
         described_class.after_queue do |q_id|
-          $expected_called_blocks << [:block_1_called, q_id]
+          expected_called_blocks << [:block_1_called, q_id]
         end
         described_class.after_queue do |q_id|
-          $expected_called_blocks << [:block_2_called, q_id]
+          expected_called_blocks << [:block_2_called, q_id]
         end
-      end
 
-      it 'each block is called' do
         subject
 
-        expect($expected_called_blocks).to eq([
+        expect(expected_called_blocks).to eq([
           [:block_1_called, queue_id],
           [:block_2_called, queue_id],
         ])

data/spec/knapsack_pro/queue_spec.rb

@@ -0,0 +1,35 @@
+describe KnapsackPro::Queue do
+  it 'simulates a Queue Mode build' do
+    queue = described_class.new
+
+    expect(queue.current_batch).to be_nil
+
+    # 1st batch
+    test_files_paths_1 = ['a_spec.rb', 'b_spec.rb']
+    queue.add_batch_for(test_files_paths_1)
+
+    expect(queue.current_batch.test_file_paths).to eq(['a_spec.rb', 'b_spec.rb'])
+    expect(queue.current_batch.status).to eq :not_executed
+    queue.mark_batch_passed
+    expect(queue.current_batch.status).to eq :passed
+
+
+    # 2nd batch
+    test_files_paths_2 = ['c_spec.rb', 'd_spec.rb']
+    queue.add_batch_for(test_files_paths_2)
+
+    expect(queue.current_batch.test_file_paths).to eq(['c_spec.rb', 'd_spec.rb'])
+    expect(queue.current_batch.status).to eq :not_executed
+    queue.mark_batch_failed
+    expect(queue.current_batch.status).to eq :failed
+
+
+    # last batch from the Queue API is always empty
+    test_files_paths_3 = []
+    queue.add_batch_for(test_files_paths_3)
+
+    expect(queue.size).to eq 2
+    expect(queue[0].status).to eq :passed
+    expect(queue[1].status).to eq :failed
+  end
+end

data/spec/spec_helper.rb

@@ -40,4 +40,8 @@ RSpec.configure do |config|
       FileUtils.rm_r(KNAPSACK_PRO_TMP_DIR) if File.exist?(KNAPSACK_PRO_TMP_DIR)
     end
   end
+
+  config.before(:each) do
+    allow_any_instance_of(KnapsackPro::Client::Connection).to receive(:net_http).and_return(Net::HTTP)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knapsack_pro
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.4.0
 platform: ruby
 authors:
 - ArturT
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-30 00:00:00.000000000 Z
+date: 2024-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -214,6 +214,7 @@ files:
 - lib/knapsack_pro/allocator.rb
 - lib/knapsack_pro/allocator_builder.rb
 - lib/knapsack_pro/base_allocator_builder.rb
+- lib/knapsack_pro/batch.rb
 - lib/knapsack_pro/build_distribution_fetcher.rb
 - lib/knapsack_pro/client/api/action.rb
 - lib/knapsack_pro/client/api/v1/base.rb
@@ -250,6 +251,7 @@ files:
 - lib/knapsack_pro/mask_string.rb
 - lib/knapsack_pro/presenter.rb
 - lib/knapsack_pro/pure/queue/rspec_pure.rb
+- lib/knapsack_pro/queue.rb
 - lib/knapsack_pro/queue_allocator.rb
 - lib/knapsack_pro/queue_allocator_builder.rb
 - lib/knapsack_pro/railtie.rb
@@ -348,6 +350,7 @@ files:
 - spec/knapsack_pro/pure/queue/rspec_pure_spec.rb
 - spec/knapsack_pro/queue_allocator_builder_spec.rb
 - spec/knapsack_pro/queue_allocator_spec.rb
+- spec/knapsack_pro/queue_spec.rb
 - spec/knapsack_pro/report_spec.rb
 - spec/knapsack_pro/repository_adapter_initiator_spec.rb
 - spec/knapsack_pro/repository_adapters/base_adapter_spec.rb
@@ -412,7 +415,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Knapsack Pro splits tests across parallel CI nodes and ensures each parallel
@@ -471,6 +474,7 @@ test_files:
 - spec/knapsack_pro/pure/queue/rspec_pure_spec.rb
 - spec/knapsack_pro/queue_allocator_builder_spec.rb
 - spec/knapsack_pro/queue_allocator_spec.rb
+- spec/knapsack_pro/queue_spec.rb
 - spec/knapsack_pro/report_spec.rb
 - spec/knapsack_pro/repository_adapter_initiator_spec.rb
 - spec/knapsack_pro/repository_adapters/base_adapter_spec.rb