knapsack_pro 2.5.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3c6506b6cb33b35562900366ecc93d2a8d34e48eaf51edcc35245a09773a8ff
-  data.tar.gz: 359e6b4067fa1a3944f9f17dad8b461d8c4d08c24f63804fd6d0c93149b44e7c
+  metadata.gz: ab52ffbbe5618da1d1c70e11493e6dcd474542a8fe19dc11b57c673f3fc5b939
+  data.tar.gz: e53495530e21c903b56921a47a6cd27de056f3cc2cbb3f2804df99f0bc6d4542
 SHA512:
-  metadata.gz: de1fb35de1f6492879849f0889e627bb448a90a5544951d6475702394de4ac5ba7d8573ebae2bceb3f758d1f397a755bfd2f366feca8c12e2ca63144d8726959
-  data.tar.gz: d5f58a08ed60fa8c441d8c2e664004f6d5c83abdf67c5ee67f63958705f5fe21ba2bd7df307f23daf2127dbabe15be0935c0609ab3e6779545b299483e39898c
+  metadata.gz: 732b7ce526fa01c176e5a958bd6cf71eab989fce6bcf160334157dd1e7b65b37c6b31ecc0ad603b4780df0a925059eaf5f212174d1bff37f89ab86c807d4ac30
+  data.tar.gz: baa2ef028990a02e332f0f5e1d985db760f44ae3c1b090128c696dea5f77e2a89659381e7a081a2c67eb1d870cec09b9a16d9b11e0dbe4315622fd7a458889b1

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Change Log
 
+### 2.10.0
+
+* Add support for an attempt to connect to existing Queue on API side to reduce slow requests number
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/133
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.9.0...v2.10.0
+
+### 2.9.0
+
+* Use `Process.clock_gettime` to measure track execution time
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/132
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.8.0...v2.9.0
+
+### 2.8.0
+
+* More actionable error message when RSpec split by examples is not working due to RSpec dry-run failure
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/130
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.7.0...v2.8.0
+
+### 2.7.0
+
+* Add support for env var `KNAPSACK_PRO_TEST_FILE_LIST_SOURCE_FILE` to allow accepting file containing test files to run
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/129
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.6.0...v2.7.0
+
+### 2.6.0
+
+* Improve logger to show failed requests URL and when retry will happen
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/127
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.5.0...v2.6.0
+
 ### 2.5.0
 
 * Add production branch to non encryptable branches names

data/README.md

@@ -50,7 +50,7 @@ We keep this old FAQ in README to not break old links spread across the web. You
 
 # Requirements
 
-`>= Ruby 2.0.0`
+`>= Ruby 2.1.0`
 
 # Table of Contents
 
@@ -3082,7 +3082,9 @@ The test file pattern and exclude pattern support any glob pattern handled by [`
 
 #### How to run a specific list of test files or only some tests from test file?
 
-:information_source: If you don't want to use the pattern [`KNAPSACK_PRO_TEST_FILE_PATTERN`](#how-can-i-run-tests-from-multiple-directories) to define a list of tests to run then read below.
+:information_source: If you don't want to use the pattern [`KNAPSACK_PRO_TEST_FILE_PATTERN`](#how-can-i-run-tests-from-multiple-directories) to define a list of tests to run then read below two options.
+
+**Option 1:**  
 
 If you want to run a specific list of test files that are explicitly defined by you or auto-generated by some kind of script you created then please use:
 
@@ -3090,7 +3092,24 @@ If you want to run a specific list of test files that are explicitly defined by
 
 Note `KNAPSACK_PRO_TEST_FILE_LIST` must be a list of test files comma separated. You can provide line number for tests inside of spec file in case of RSpec (this way you can run only one test or a group of tests from RSpec spec file). You can provide the same file a few times with different test line number.
 
-Note when you set `KNAPSACK_PRO_TEST_FILE_LIST` then below environment variables are ignored:
+**Option 2:** 
+
+Similarly, you can also provide a source file containing the test files that you would like to run. For example:
+`KNAPSACK_PRO_TEST_FILE_LIST_SOURCE_FILE=spec/fixtures/test_file_list_source_file.txt`  
+And the content of the source file can be any of the format below:
+
+```
+./spec/test1_spec.rb
+spec/test2_spec.rb[1]
+./spec/test3_spec.rb[1:2:3:4]
+./spec/test4_spec.rb:4
+./spec/test4_spec.rb:5
+```
+
+> Note that each of the line must be ending with `\n` the new line.
+
+Note when you set `KNAPSACK_PRO_TEST_FILE_LIST` or `KNAPSACK_PRO_TEST_FILE_LIST_SOURCE_FILE` then below environment variables are ignored:
+
 * `KNAPSACK_PRO_TEST_FILE_PATTERN`
 * `KNAPSACK_PRO_TEST_FILE_EXCLUDE_PATTERN`
 
@@ -3258,6 +3277,8 @@ $ gem build knapsack_pro.gemspec
 $ gem push knapsack_pro-X.X.X.gem
 ```
 
+Update the latest available gem version in `TestSuiteClientVersionChecker` for the Knapsack Pro API repository.
+
 ## Mentions
 
 List of articles where people mentioned Knapsack Pro:

data/lib/knapsack_pro/base_allocator_builder.rb

@@ -28,6 +28,10 @@ module KnapsackPro
       all_test_files_to_run
     end
 
+    def lazy_fallback_mode_test_files
+      lambda { fallback_mode_test_files }
+    end
+
     # detect test files present on the disk that should be run
     # this may include some fast test files + slow test files split by test cases
     def fast_and_slow_test_files_to_run
@@ -63,6 +67,10 @@ module KnapsackPro
       end
     end
 
+    def lazy_fast_and_slow_test_files_to_run
+      lambda { fast_and_slow_test_files_to_run }
+    end
+
     private
 
     attr_reader :adapter_class

data/lib/knapsack_pro/client/api/v1/queues.rb

@@ -3,11 +3,14 @@ module KnapsackPro
     module API
       module V1
         class Queues < Base
+          CODE_ATTEMPT_CONNECT_TO_QUEUE_FAILED = 'ATTEMPT_CONNECT_TO_QUEUE_FAILED'
+
           class << self
             def queue(args)
               request_hash = {
                 :fixed_queue_split => KnapsackPro::Config::Env.fixed_queue_split,
                 :can_initialize_queue => args.fetch(:can_initialize_queue),
+                :attempt_connect_to_queue => args.fetch(:attempt_connect_to_queue),
                 :commit_hash => args.fetch(:commit_hash),
                 :branch => args.fetch(:branch),
                 :node_total => args.fetch(:node_total),
@@ -15,7 +18,7 @@ module KnapsackPro
                 :node_build_id => KnapsackPro::Config::Env.ci_node_build_id,
               }
 
-              if request_hash[:can_initialize_queue]
+              if request_hash[:can_initialize_queue] && !request_hash[:attempt_connect_to_queue]
                 request_hash.merge!({
                   :test_files => args.fetch(:test_files)
                 })

data/lib/knapsack_pro/client/connection.rb

@@ -25,6 +25,11 @@ module KnapsackPro
         !!(response_body && (response_body['errors'] || response_body['error']))
       end
 
+      def api_code
+        return unless response_body
+        response_body['code']
+      end
+
       def server_error?
         status = http_response.code.to_i
         status >= 500 && status < 600
@@ -115,14 +120,19 @@ module KnapsackPro
 
         response_body
       rescue ServerError, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE, EOFError, SocketError, Net::OpenTimeout, Net::ReadTimeout, OpenSSL::SSL::SSLError => e
+        logger.warn("#{action.http_method.to_s.upcase} #{endpoint_url}")
+        logger.warn('Request failed due to:')
         logger.warn(e.inspect)
         retries += 1
         if retries < max_request_retries
           wait = retries * REQUEST_RETRY_TIMEBOX
-          logger.warn("Wait #{wait}s and retry request to Knapsack Pro API.")
           print_every = 2 # seconds
           (wait / print_every).ceil.times do |i|
-            logger.warn("Next request in #{wait - i * print_every}s...")
+            if i == 0
+              logger.warn("Wait for #{wait}s before retrying the request to Knapsack Pro API.")
+            else
+              logger.warn("#{wait - i * print_every}s left before retry...")
+            end
             Kernel.sleep(print_every)
           end
           retry

data/lib/knapsack_pro/config/env.rb

@@ -74,6 +74,10 @@ module KnapsackPro
           ENV['KNAPSACK_PRO_TEST_FILE_LIST']
         end
 
+        def test_file_list_source_file
+          ENV['KNAPSACK_PRO_TEST_FILE_LIST_SOURCE_FILE']
+        end
+
         def test_dir
           ENV['KNAPSACK_PRO_TEST_DIR']
         end

data/lib/knapsack_pro/queue_allocator.rb

@@ -1,8 +1,8 @@
 module KnapsackPro
   class QueueAllocator
     def initialize(args)
-      @fast_and_slow_test_files_to_run = args.fetch(:fast_and_slow_test_files_to_run)
-      @fallback_mode_test_files = args.fetch(:fallback_mode_test_files)
+      @lazy_fast_and_slow_test_files_to_run = args.fetch(:lazy_fast_and_slow_test_files_to_run)
+      @lazy_fallback_mode_test_files = args.fetch(:lazy_fallback_mode_test_files)
       @ci_node_total = args.fetch(:ci_node_total)
       @ci_node_index = args.fetch(:ci_node_index)
       @ci_node_build_id = args.fetch(:ci_node_build_id)
@@ -11,9 +11,18 @@ module KnapsackPro
 
     def test_file_paths(can_initialize_queue, executed_test_files)
       return [] if @fallback_activated
-      action = build_action(can_initialize_queue)
+      action = build_action(can_initialize_queue, attempt_connect_to_queue: can_initialize_queue)
       connection = KnapsackPro::Client::Connection.new(action)
       response = connection.call
+
+      # when attempt to connect to existing queue on API side failed because queue does not exist yet
+      if can_initialize_queue && connection.success? && connection.api_code == KnapsackPro::Client::API::V1::Queues::CODE_ATTEMPT_CONNECT_TO_QUEUE_FAILED
+        # make attempt to initalize a new queue on API side
+        action = build_action(can_initialize_queue, attempt_connect_to_queue: false)
+        connection = KnapsackPro::Client::Connection.new(action)
+        response = connection.call
+      end
+
       if connection.success?
         raise ArgumentError.new(response) if connection.errors?
         prepare_test_files(response)
@@ -37,40 +46,58 @@ module KnapsackPro
 
     private
 
-    attr_reader :fast_and_slow_test_files_to_run,
-      :fallback_mode_test_files,
+    attr_reader :lazy_fast_and_slow_test_files_to_run,
+      :lazy_fallback_mode_test_files,
       :ci_node_total,
       :ci_node_index,
       :ci_node_build_id,
       :repository_adapter
 
+    # This method might be slow because it reads test files from disk.
+    # This method can be very slow (a few seconds or more) when you use RSpec split by test examples feature because RSpec needs to generate JSON report with test examples ids
+    def lazy_loaded_fast_and_slow_test_files_to_run
+      @lazy_loaded_fast_and_slow_test_files_to_run ||= lazy_fast_and_slow_test_files_to_run.call
+    end
+
     def encrypted_test_files
-      KnapsackPro::Crypto::Encryptor.call(fast_and_slow_test_files_to_run)
+      KnapsackPro::Crypto::Encryptor.call(lazy_loaded_fast_and_slow_test_files_to_run)
     end
 
     def encrypted_branch
       KnapsackPro::Crypto::BranchEncryptor.call(repository_adapter.branch)
     end
 
-    def build_action(can_initialize_queue)
+    def build_action(can_initialize_queue, attempt_connect_to_queue:)
+      # read test files from disk only when needed because it can be slow operation
+      test_files =
+        if can_initialize_queue && !attempt_connect_to_queue
+          encrypted_test_files
+        end
+
       KnapsackPro::Client::API::V1::Queues.queue(
         can_initialize_queue: can_initialize_queue,
+        attempt_connect_to_queue: attempt_connect_to_queue,
         commit_hash: repository_adapter.commit_hash,
         branch: encrypted_branch,
         node_total: ci_node_total,
         node_index: ci_node_index,
         node_build_id: ci_node_build_id,
-        test_files: encrypted_test_files,
+        test_files: test_files,
       )
     end
 
     def prepare_test_files(response)
-      decrypted_test_files = KnapsackPro::Crypto::Decryptor.call(fast_and_slow_test_files_to_run, response['test_files'])
-      KnapsackPro::TestFilePresenter.paths(decrypted_test_files)
+      # when encryption is disabled we can avoid calling slow method lazy_loaded_fast_and_slow_test_files_to_run
+      if KnapsackPro::Config::Env.test_files_encrypted?
+        decrypted_test_files = KnapsackPro::Crypto::Decryptor.call(lazy_loaded_fast_and_slow_test_files_to_run, response['test_files'])
+        KnapsackPro::TestFilePresenter.paths(decrypted_test_files)
+      else
+        KnapsackPro::TestFilePresenter.paths(response['test_files'])
+      end
     end
 
     def fallback_test_files(executed_test_files)
-      test_flat_distributor = KnapsackPro::TestFlatDistributor.new(fallback_mode_test_files, ci_node_total)
+      test_flat_distributor = KnapsackPro::TestFlatDistributor.new(lazy_fallback_mode_test_files.call, ci_node_total)
       test_files_for_node_index = test_flat_distributor.test_files_for_node(ci_node_index)
       KnapsackPro::TestFilePresenter.paths(test_files_for_node_index) - executed_test_files
     end

data/lib/knapsack_pro/queue_allocator_builder.rb

@@ -2,8 +2,8 @@ module KnapsackPro
   class QueueAllocatorBuilder < BaseAllocatorBuilder
     def allocator
       KnapsackPro::QueueAllocator.new(
-        fast_and_slow_test_files_to_run: fast_and_slow_test_files_to_run,
-        fallback_mode_test_files: fallback_mode_test_files,
+        lazy_fast_and_slow_test_files_to_run: lazy_fast_and_slow_test_files_to_run,
+        lazy_fallback_mode_test_files: lazy_fallback_mode_test_files,
         ci_node_total: env.ci_node_total,
         ci_node_index: env.ci_node_index,
         ci_node_build_id: env.ci_node_build_id,

data/lib/knapsack_pro/test_case_detectors/rspec_test_example_detector.rb

@@ -33,7 +33,16 @@ module KnapsackPro
         options = ::RSpec::Core::ConfigurationOptions.new(cli_args)
         exit_code = ::RSpec::Core::Runner.new(options).run($stderr, $stdout)
         if exit_code != 0
-          raise 'There was problem to generate test examples for test suite'
+          debug_cmd = ([
+            'bundle exec rspec',
+          ] + cli_args).join(' ')
+
+          KnapsackPro.logger.error('-'*10 + ' START of actionable error message ' + '-'*50)
+          KnapsackPro.logger.error('There was a problem while generating test examples for the slow test files using the RSpec dry-run flag. To reproduce the error triggered by the RSpec, please try to run below command (this way, you can find out what is causing the error):')
+          KnapsackPro.logger.error(debug_cmd)
+          KnapsackPro.logger.error('-'*10 + ' END of actionable error message ' + '-'*50)
+
+          raise 'There was a problem while generating test examples for the slow test files. Please read actionable error message above.'
         end
       end
 

data/lib/knapsack_pro/test_file_finder.rb

@@ -63,6 +63,10 @@ module KnapsackPro
         return KnapsackPro::Config::Env.test_file_list.split(',').map(&:strip)
       end
 
+      if test_file_list_enabled && KnapsackPro::Config::Env.test_file_list_source_file
+        return File.read(KnapsackPro::Config::Env.test_file_list_source_file).split(/\n/)
+      end
+
       test_file_paths = Dir.glob(test_file_pattern).uniq
 
       excluded_test_file_paths =

data/lib/knapsack_pro/tracker.rb

@@ -90,11 +90,7 @@ module KnapsackPro
     end
 
     def now_without_mock_time
-      if defined?(Timecop)
-        Time.now_without_mock_time
-      else
-        Time.raw_now
-      end
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end
 end

data/lib/knapsack_pro/version.rb

@@ -1,3 +1,3 @@
 module KnapsackPro
-  VERSION = '2.5.0'
+  VERSION = '2.10.0'
 end

data/spec/fixtures/test_file_list_source_file.txt

@@ -0,0 +1,6 @@
+./spec/test1_spec.rb
+spec/test2_spec.rb[1]
+./spec/test3_spec.rb[1:2:3:4]
+./spec/test4_spec.rb:4
+./spec/test4_spec.rb:5
+

data/spec/knapsack_pro/client/api/v1/queues_spec.rb

@@ -11,6 +11,7 @@ describe KnapsackPro::Client::API::V1::Queues do
     subject do
       described_class.queue(
         can_initialize_queue: can_initialize_queue,
+        attempt_connect_to_queue: attempt_connect_to_queue,
         commit_hash: commit_hash,
         branch: branch,
         node_total: node_total,
@@ -24,8 +25,33 @@ describe KnapsackPro::Client::API::V1::Queues do
       expect(KnapsackPro::Config::Env).to receive(:ci_node_build_id).and_return(node_build_id)
     end
 
-    context 'when can_initialize_queue=true' do
+    context 'when can_initialize_queue=true and attempt_connect_to_queue=true' do
       let(:can_initialize_queue) { true }
+      let(:attempt_connect_to_queue) { true }
+
+      it 'does not send test_files among other params' do
+        action = double
+        expect(KnapsackPro::Client::API::Action).to receive(:new).with({
+          endpoint_path: '/v1/queues/queue',
+          http_method: :post,
+          request_hash: {
+            fixed_queue_split: fixed_queue_split,
+            can_initialize_queue: can_initialize_queue,
+            attempt_connect_to_queue: attempt_connect_to_queue,
+            commit_hash: commit_hash,
+            branch: branch,
+            node_total: node_total,
+            node_index: node_index,
+            node_build_id: node_build_id,
+          }
+        }).and_return(action)
+        expect(subject).to eq action
+      end
+    end
+
+    context 'when can_initialize_queue=true and attempt_connect_to_queue=false' do
+      let(:can_initialize_queue) { true }
+      let(:attempt_connect_to_queue) { false }
 
       it 'sends test_files among other params' do
         action = double
@@ -35,6 +61,7 @@ describe KnapsackPro::Client::API::V1::Queues do
           request_hash: {
             fixed_queue_split: fixed_queue_split,
             can_initialize_queue: can_initialize_queue,
+            attempt_connect_to_queue: attempt_connect_to_queue,
             commit_hash: commit_hash,
             branch: branch,
             node_total: node_total,
@@ -47,8 +74,9 @@ describe KnapsackPro::Client::API::V1::Queues do
       end
     end
 
-    context 'when can_initialize_queue=false' do
+    context 'when can_initialize_queue=false and attempt_connect_to_queue=false' do
       let(:can_initialize_queue) { false }
+      let(:attempt_connect_to_queue) { false }
 
       it 'does not send test_files among other params' do
         action = double
@@ -58,6 +86,7 @@ describe KnapsackPro::Client::API::V1::Queues do
           request_hash: {
             fixed_queue_split: fixed_queue_split,
             can_initialize_queue: can_initialize_queue,
+            attempt_connect_to_queue: attempt_connect_to_queue,
             commit_hash: commit_hash,
             branch: branch,
             node_total: node_total,

data/spec/knapsack_pro/client/connection_spec.rb

@@ -84,22 +84,22 @@ shared_examples 'when retry request' do
       expect(logger).to receive(:error).exactly(3).with(parsed_response)
 
       server_error = described_class::ServerError.new(parsed_response)
+      expect(logger).to receive(:warn).exactly(3).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+      expect(logger).to receive(:warn).exactly(3).with('Request failed due to:')
       expect(logger).to receive(:warn).exactly(3).with(server_error.inspect)
 
-      expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
-      expect(logger).to receive(:warn).with("Next request in 8s...")
-      expect(logger).to receive(:warn).with("Next request in 6s...")
-      expect(logger).to receive(:warn).with("Next request in 4s...")
-      expect(logger).to receive(:warn).with("Next request in 2s...")
-      expect(logger).to receive(:warn).with("Wait 16s and retry request to Knapsack Pro API.")
-      expect(logger).to receive(:warn).with("Next request in 16s...")
-      expect(logger).to receive(:warn).with("Next request in 14s...")
-      expect(logger).to receive(:warn).with("Next request in 12s...")
-      expect(logger).to receive(:warn).with("Next request in 10s...")
-      expect(logger).to receive(:warn).with("Next request in 8s...")
-      expect(logger).to receive(:warn).with("Next request in 6s...")
-      expect(logger).to receive(:warn).with("Next request in 4s...")
-      expect(logger).to receive(:warn).with("Next request in 2s...")
+      expect(logger).to receive(:warn).with("Wait for 8s before retrying the request to Knapsack Pro API.")
+      expect(logger).to receive(:warn).with("6s left before retry...")
+      expect(logger).to receive(:warn).with("4s left before retry...")
+      expect(logger).to receive(:warn).with("2s left before retry...")
+      expect(logger).to receive(:warn).with("Wait for 16s before retrying the request to Knapsack Pro API.")
+      expect(logger).to receive(:warn).with("14s left before retry...")
+      expect(logger).to receive(:warn).with("12s left before retry...")
+      expect(logger).to receive(:warn).with("10s left before retry...")
+      expect(logger).to receive(:warn).with("8s left before retry...")
+      expect(logger).to receive(:warn).with("6s left before retry...")
+      expect(logger).to receive(:warn).with("4s left before retry...")
+      expect(logger).to receive(:warn).with("2s left before retry...")
       expect(Kernel).to receive(:sleep).exactly(12).with(2)
 
       expect(subject).to eq(parsed_response)
@@ -123,27 +123,27 @@ shared_examples 'when retry request' do
         expect(logger).to receive(:error).exactly(4).with(parsed_response)
 
         server_error = described_class::ServerError.new(parsed_response)
+        expect(logger).to receive(:warn).exactly(4).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+        expect(logger).to receive(:warn).exactly(4).with('Request failed due to:')
         expect(logger).to receive(:warn).exactly(4).with(server_error.inspect)
 
-        expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
-        expect(logger).to receive(:warn).with("Next request in 8s...")
-        expect(logger).to receive(:warn).with("Next request in 6s...")
-        expect(logger).to receive(:warn).with("Next request in 4s...")
-        expect(logger).to receive(:warn).with("Next request in 2s...")
-
-        expect(logger).to receive(:warn).with("Wait 16s and retry request to Knapsack Pro API.")
-        expect(logger).to receive(:warn).with("Next request in 16s...")
-        expect(logger).to receive(:warn).with("Next request in 14s...")
-        expect(logger).to receive(:warn).with("Next request in 12s...")
-        expect(logger).to receive(:warn).with("Next request in 10s...")
-        expect(logger).to receive(:warn).with("Next request in 8s...")
-        expect(logger).to receive(:warn).with("Next request in 6s...")
-        expect(logger).to receive(:warn).with("Next request in 4s...")
-        expect(logger).to receive(:warn).with("Next request in 2s...")
-
-        expect(logger).to receive(:warn).with("Wait 24s and retry request to Knapsack Pro API.")
-        12.times do |i|
-          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        expect(logger).to receive(:warn).with("Wait for 8s before retrying the request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("6s left before retry...")
+        expect(logger).to receive(:warn).with("4s left before retry...")
+        expect(logger).to receive(:warn).with("2s left before retry...")
+
+        expect(logger).to receive(:warn).with("Wait for 16s before retrying the request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("14s left before retry...")
+        expect(logger).to receive(:warn).with("12s left before retry...")
+        expect(logger).to receive(:warn).with("10s left before retry...")
+        expect(logger).to receive(:warn).with("8s left before retry...")
+        expect(logger).to receive(:warn).with("6s left before retry...")
+        expect(logger).to receive(:warn).with("4s left before retry...")
+        expect(logger).to receive(:warn).with("2s left before retry...")
+
+        expect(logger).to receive(:warn).with("Wait for 24s before retrying the request to Knapsack Pro API.")
+        11.times do |i|
+          expect(logger).to receive(:warn).with("#{(i+1)*2}s left before retry...")
         end
 
         expect(Kernel).to receive(:sleep).exactly(4+8+12).with(2)
@@ -170,37 +170,37 @@ shared_examples 'when retry request' do
         expect(logger).to receive(:error).exactly(6).with(parsed_response)
 
         server_error = described_class::ServerError.new(parsed_response)
+        expect(logger).to receive(:warn).exactly(6).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+        expect(logger).to receive(:warn).exactly(6).with('Request failed due to:')
         expect(logger).to receive(:warn).exactly(6).with(server_error.inspect)
 
-        expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
-        expect(logger).to receive(:warn).with("Next request in 8s...")
-        expect(logger).to receive(:warn).with("Next request in 6s...")
-        expect(logger).to receive(:warn).with("Next request in 4s...")
-        expect(logger).to receive(:warn).with("Next request in 2s...")
-
-        expect(logger).to receive(:warn).with("Wait 16s and retry request to Knapsack Pro API.")
-        expect(logger).to receive(:warn).with("Next request in 16s...")
-        expect(logger).to receive(:warn).with("Next request in 14s...")
-        expect(logger).to receive(:warn).with("Next request in 12s...")
-        expect(logger).to receive(:warn).with("Next request in 10s...")
-        expect(logger).to receive(:warn).with("Next request in 8s...")
-        expect(logger).to receive(:warn).with("Next request in 6s...")
-        expect(logger).to receive(:warn).with("Next request in 4s...")
-        expect(logger).to receive(:warn).with("Next request in 2s...")
-
-        expect(logger).to receive(:warn).with("Wait 24s and retry request to Knapsack Pro API.")
-        12.times do |i|
-          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        expect(logger).to receive(:warn).with("Wait for 8s before retrying the request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("6s left before retry...")
+        expect(logger).to receive(:warn).with("4s left before retry...")
+        expect(logger).to receive(:warn).with("2s left before retry...")
+
+        expect(logger).to receive(:warn).with("Wait for 16s before retrying the request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("14s left before retry...")
+        expect(logger).to receive(:warn).with("12s left before retry...")
+        expect(logger).to receive(:warn).with("10s left before retry...")
+        expect(logger).to receive(:warn).with("8s left before retry...")
+        expect(logger).to receive(:warn).with("6s left before retry...")
+        expect(logger).to receive(:warn).with("4s left before retry...")
+        expect(logger).to receive(:warn).with("2s left before retry...")
+
+        expect(logger).to receive(:warn).with("Wait for 24s before retrying the request to Knapsack Pro API.")
+        11.times do |i|
+          expect(logger).to receive(:warn).with("#{(i+1)*2}s left before retry...")
         end
 
-        expect(logger).to receive(:warn).with("Wait 32s and retry request to Knapsack Pro API.")
-        16.times do |i|
-          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        expect(logger).to receive(:warn).with("Wait for 32s before retrying the request to Knapsack Pro API.")
+        15.times do |i|
+          expect(logger).to receive(:warn).with("#{(i+1)*2}s left before retry...")
         end
 
-        expect(logger).to receive(:warn).with("Wait 40s and retry request to Knapsack Pro API.")
-        20.times do |i|
-          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        expect(logger).to receive(:warn).with("Wait for 40s before retrying the request to Knapsack Pro API.")
+        19.times do |i|
+          expect(logger).to receive(:warn).with("#{(i+1)*2}s left before retry...")
         end
 
         expect(Kernel).to receive(:sleep).exactly(60).with(2)
@@ -227,37 +227,37 @@ shared_examples 'when retry request' do
         expect(logger).to receive(:error).exactly(6).with(parsed_response)
 
         server_error = described_class::ServerError.new(parsed_response)
+        expect(logger).to receive(:warn).exactly(6).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+        expect(logger).to receive(:warn).exactly(6).with('Request failed due to:')
         expect(logger).to receive(:warn).exactly(6).with(server_error.inspect)
 
-        expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
-        expect(logger).to receive(:warn).with("Next request in 8s...")
-        expect(logger).to receive(:warn).with("Next request in 6s...")
-        expect(logger).to receive(:warn).with("Next request in 4s...")
-        expect(logger).to receive(:warn).with("Next request in 2s...")
-
-        expect(logger).to receive(:warn).with("Wait 16s and retry request to Knapsack Pro API.")
-        expect(logger).to receive(:warn).with("Next request in 16s...")
-        expect(logger).to receive(:warn).with("Next request in 14s...")
-        expect(logger).to receive(:warn).with("Next request in 12s...")
-        expect(logger).to receive(:warn).with("Next request in 10s...")
-        expect(logger).to receive(:warn).with("Next request in 8s...")
-        expect(logger).to receive(:warn).with("Next request in 6s...")
-        expect(logger).to receive(:warn).with("Next request in 4s...")
-        expect(logger).to receive(:warn).with("Next request in 2s...")
-
-        expect(logger).to receive(:warn).with("Wait 24s and retry request to Knapsack Pro API.")
-        12.times do |i|
-          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        expect(logger).to receive(:warn).with("Wait for 8s before retrying the request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("6s left before retry...")
+        expect(logger).to receive(:warn).with("4s left before retry...")
+        expect(logger).to receive(:warn).with("2s left before retry...")
+
+        expect(logger).to receive(:warn).with("Wait for 16s before retrying the request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("14s left before retry...")
+        expect(logger).to receive(:warn).with("12s left before retry...")
+        expect(logger).to receive(:warn).with("10s left before retry...")
+        expect(logger).to receive(:warn).with("8s left before retry...")
+        expect(logger).to receive(:warn).with("6s left before retry...")
+        expect(logger).to receive(:warn).with("4s left before retry...")
+        expect(logger).to receive(:warn).with("2s left before retry...")
+
+        expect(logger).to receive(:warn).with("Wait for 24s before retrying the request to Knapsack Pro API.")
+        11.times do |i|
+          expect(logger).to receive(:warn).with("#{(i+1)*2}s left before retry...")
         end
 
-        expect(logger).to receive(:warn).with("Wait 32s and retry request to Knapsack Pro API.")
-        16.times do |i|
-          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        expect(logger).to receive(:warn).with("Wait for 32s before retrying the request to Knapsack Pro API.")
+        15.times do |i|
+          expect(logger).to receive(:warn).with("#{(i+1)*2}s left before retry...")
         end
 
-        expect(logger).to receive(:warn).with("Wait 40s and retry request to Knapsack Pro API.")
-        20.times do |i|
-          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        expect(logger).to receive(:warn).with("Wait for 40s before retrying the request to Knapsack Pro API.")
+        19.times do |i|
+          expect(logger).to receive(:warn).with("#{(i+1)*2}s left before retry...")
         end
 
         expect(Kernel).to receive(:sleep).exactly(60).with(2)

data/spec/knapsack_pro/config/env_spec.rb

@@ -238,6 +238,20 @@ describe KnapsackPro::Config::Env do
     end
   end
 
+  describe '.test_file_list_source_file' do
+    subject { described_class.test_file_list_source_file }
+
+    context 'when ENV exists' do
+      let(:test_file_list_source_file) { 'spec/fixtures/test_file_list_source_file.txt' }
+      before { stub_const("ENV", { 'KNAPSACK_PRO_TEST_FILE_LIST_SOURCE_FILE' => test_file_list_source_file }) }
+      it { should eq test_file_list_source_file }
+    end
+
+    context "when ENV doesn't exist" do
+      it { should be_nil }
+    end
+  end
+
   describe '.test_dir' do
     subject { described_class.test_dir }
 

data/spec/knapsack_pro/queue_allocator_builder_spec.rb

@@ -8,11 +8,11 @@ describe KnapsackPro::QueueAllocatorBuilder do
     subject { allocator_builder.allocator }
 
     before do
-      fast_and_slow_test_files_to_run = double
-      expect(allocator_builder).to receive(:fast_and_slow_test_files_to_run).and_return(fast_and_slow_test_files_to_run)
+      lazy_fast_and_slow_test_files_to_run = double
+      expect(allocator_builder).to receive(:lazy_fast_and_slow_test_files_to_run).and_return(lazy_fast_and_slow_test_files_to_run)
 
-      fallback_mode_test_files = double
-      expect(allocator_builder).to receive(:fallback_mode_test_files).and_return(fallback_mode_test_files)
+      lazy_fallback_mode_test_files = double
+      expect(allocator_builder).to receive(:lazy_fallback_mode_test_files).and_return(lazy_fallback_mode_test_files)
 
       repository_adapter = double
       expect(KnapsackPro::RepositoryAdapterInitiator).to receive(:call).and_return(repository_adapter)
@@ -25,8 +25,8 @@ describe KnapsackPro::QueueAllocatorBuilder do
       expect(KnapsackPro::Config::Env).to receive(:ci_node_build_id).and_return(ci_node_build_id)
 
       expect(KnapsackPro::QueueAllocator).to receive(:new).with(
-        fast_and_slow_test_files_to_run: fast_and_slow_test_files_to_run,
-        fallback_mode_test_files: fallback_mode_test_files,
+        lazy_fast_and_slow_test_files_to_run: lazy_fast_and_slow_test_files_to_run,
+        lazy_fallback_mode_test_files: lazy_fallback_mode_test_files,
         ci_node_total: ci_node_total,
         ci_node_index: ci_node_index,
         ci_node_build_id: ci_node_build_id,

data/spec/knapsack_pro/queue_allocator_spec.rb

@@ -1,6 +1,8 @@
 describe KnapsackPro::QueueAllocator do
-  let(:fast_and_slow_test_files_to_run) { double }
-  let(:fallback_mode_test_files) { double }
+  let(:lazy_loaded_fast_and_slow_test_files_to_run) { double }
+  let(:lazy_fast_and_slow_test_files_to_run) { double(call: lazy_loaded_fast_and_slow_test_files_to_run) }
+  let(:lazy_loaded_fallback_mode_test_files) { double }
+  let(:lazy_fallback_mode_test_files) { double(call: lazy_loaded_fallback_mode_test_files) }
   let(:ci_node_total) { double }
   let(:ci_node_index) { double }
   let(:ci_node_build_id) { double }
@@ -8,8 +10,8 @@ describe KnapsackPro::QueueAllocator do
 
   let(:queue_allocator) do
     described_class.new(
-      fast_and_slow_test_files_to_run: fast_and_slow_test_files_to_run,
-      fallback_mode_test_files: fallback_mode_test_files,
+      lazy_fast_and_slow_test_files_to_run: lazy_fast_and_slow_test_files_to_run,
+      lazy_fallback_mode_test_files: lazy_fallback_mode_test_files,
       ci_node_total: ci_node_total,
       ci_node_index: ci_node_index,
       ci_node_build_id: ci_node_build_id,
@@ -18,71 +20,13 @@ describe KnapsackPro::QueueAllocator do
   end
 
   describe '#test_file_paths' do
-    let(:can_initialize_queue) { double }
     let(:executed_test_files) { [] }
     let(:response) { double }
+    let(:api_code) { nil }
 
     subject { queue_allocator.test_file_paths(can_initialize_queue, executed_test_files) }
 
-    before do
-      encrypted_test_files = double
-      expect(KnapsackPro::Crypto::Encryptor).to receive(:call).with(fast_and_slow_test_files_to_run).and_return(encrypted_test_files)
-
-      encrypted_branch = double
-      expect(KnapsackPro::Crypto::BranchEncryptor).to receive(:call).with(repository_adapter.branch).and_return(encrypted_branch)
-
-      action = double
-      expect(KnapsackPro::Client::API::V1::Queues).to receive(:queue).with(
-        can_initialize_queue: can_initialize_queue,
-        commit_hash: repository_adapter.commit_hash,
-        branch: encrypted_branch,
-        node_total: ci_node_total,
-        node_index: ci_node_index,
-        node_build_id: ci_node_build_id,
-        test_files: encrypted_test_files,
-      ).and_return(action)
-
-      connection = instance_double(KnapsackPro::Client::Connection,
-                                   call: response,
-                                   success?: success?,
-                                   errors?: errors?)
-      expect(KnapsackPro::Client::Connection).to receive(:new).with(action).and_return(connection)
-    end
-
-    context 'when successful request to API' do
-      let(:success?) { true }
-
-      context 'when response has errors' do
-        let(:errors?) { true }
-
-        it do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context 'when response has no errors' do
-        let(:errors?) { false }
-        let(:response) do
-          {
-            'test_files' => [
-              { 'path' => 'a_spec.rb' },
-              { 'path' => 'b_spec.rb' },
-            ]
-          }
-        end
-
-        before do
-          expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(fast_and_slow_test_files_to_run, response['test_files']).and_call_original
-        end
-
-        it { should eq ['a_spec.rb', 'b_spec.rb'] }
-      end
-    end
-
-    context 'when not successful request to API' do
-      let(:success?) { false }
-      let(:errors?) { false }
-
+    shared_examples_for 'when connection to API failed (fallback mode)' do
       context 'when fallback mode is disabled' do
         before do
           expect(KnapsackPro::Config::Env).to receive(:fallback_mode_enabled?).and_return(false)
@@ -122,7 +66,7 @@ describe KnapsackPro::QueueAllocator do
       context 'when fallback mode started' do
         before do
           test_flat_distributor = instance_double(KnapsackPro::TestFlatDistributor)
-          expect(KnapsackPro::TestFlatDistributor).to receive(:new).with(fallback_mode_test_files, ci_node_total).and_return(test_flat_distributor)
+          expect(KnapsackPro::TestFlatDistributor).to receive(:new).with(lazy_loaded_fallback_mode_test_files, ci_node_total).and_return(test_flat_distributor)
           expect(test_flat_distributor).to receive(:test_files_for_node).with(ci_node_index).and_return([
             { 'path' => 'c_spec.rb' },
             { 'path' => 'd_spec.rb' },
@@ -146,5 +90,256 @@ describe KnapsackPro::QueueAllocator do
         end
       end
     end
+
+    context 'when can_initialize_queue=true' do
+      let(:can_initialize_queue) { true }
+
+      before do
+        encrypted_branch = double
+        expect(KnapsackPro::Crypto::BranchEncryptor).to receive(:call).with(repository_adapter.branch).and_return(encrypted_branch)
+
+        action = double
+        expect(KnapsackPro::Client::API::V1::Queues).to receive(:queue).with(
+          can_initialize_queue: can_initialize_queue,
+          attempt_connect_to_queue: true, # when can_initialize_queue=true then expect attempt_connect_to_queue=true
+          commit_hash: repository_adapter.commit_hash,
+          branch: encrypted_branch,
+          node_total: ci_node_total,
+          node_index: ci_node_index,
+          node_build_id: ci_node_build_id,
+          test_files: nil, # when attempt_connect_to_queue=true then expect test_files is nil to make fast request to API
+        ).and_return(action)
+
+        connection = instance_double(KnapsackPro::Client::Connection,
+                                     call: response,
+                                     success?: success?,
+                                     errors?: errors?,
+                                     api_code: api_code)
+        expect(KnapsackPro::Client::Connection).to receive(:new).with(action).and_return(connection)
+      end
+
+      context 'when successful request to API' do
+        let(:success?) { true }
+
+        context 'when response has errors' do
+          let(:errors?) { true }
+
+          it do
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'when response has no errors' do
+          let(:errors?) { false }
+
+          context 'when response returns test files (successful attempt to connect to queue already existing on the API side)' do
+            let(:test_files) do
+              [
+                { 'path' => 'a_spec.rb' },
+                { 'path' => 'b_spec.rb' },
+              ]
+            end
+            let(:response) do
+              { 'test_files' => test_files }
+            end
+
+            context 'when test files encryption is enabled' do
+              before do
+                expect(KnapsackPro::Config::Env).to receive(:test_files_encrypted?).and_return(true)
+                expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(lazy_loaded_fast_and_slow_test_files_to_run, response['test_files']).and_return(test_files)
+              end
+
+              it { should eq ['a_spec.rb', 'b_spec.rb'] }
+            end
+
+            context 'when test files encryption is disabled' do
+              before do
+                expect(KnapsackPro::Config::Env).to receive(:test_files_encrypted?).and_return(false)
+              end
+
+              it { should eq ['a_spec.rb', 'b_spec.rb'] }
+            end
+          end
+
+          context 'when response has code=ATTEMPT_CONNECT_TO_QUEUE_FAILED' do
+            let(:response) do
+              { 'code' => 'ATTEMPT_CONNECT_TO_QUEUE_FAILED' }
+            end
+            let(:api_code) { 'ATTEMPT_CONNECT_TO_QUEUE_FAILED' }
+
+            before do
+              encrypted_branch = double
+              expect(KnapsackPro::Crypto::BranchEncryptor).to receive(:call).with(repository_adapter.branch).and_return(encrypted_branch)
+
+              encrypted_test_files = double
+              expect(KnapsackPro::Crypto::Encryptor).to receive(:call).with(lazy_loaded_fast_and_slow_test_files_to_run).and_return(encrypted_test_files)
+
+              # 2nd request is no more an attempt to connect to queue.
+              # We want to try to initalize a new queue so we will also send list of test files from disk.
+              action = double
+              expect(KnapsackPro::Client::API::V1::Queues).to receive(:queue).with(
+                can_initialize_queue: can_initialize_queue,
+                attempt_connect_to_queue: false,
+                commit_hash: repository_adapter.commit_hash,
+                branch: encrypted_branch,
+                node_total: ci_node_total,
+                node_index: ci_node_index,
+                node_build_id: ci_node_build_id,
+                test_files: encrypted_test_files,
+              ).and_return(action)
+
+              connection = instance_double(KnapsackPro::Client::Connection,
+                                           call: response2,
+                                           success?: response2_success?,
+                                           errors?: response2_errors?,
+                                           api_code: nil)
+              expect(KnapsackPro::Client::Connection).to receive(:new).with(action).and_return(connection)
+            end
+
+            context 'when successful 2nd request to API' do
+              let(:response2_success?) { true }
+
+              context 'when 2nd response has errors' do
+                let(:response2_errors?) { true }
+                let(:response2) { nil }
+
+                it do
+                  expect { subject }.to raise_error(ArgumentError)
+                end
+              end
+
+              context 'when 2nd response has no errors' do
+                let(:response2_errors?) { false }
+
+                context 'when 2nd response returns test files (successful attempt to connect to queue already existing on the API side)' do
+                  let(:test_files) do
+                    [
+                      { 'path' => 'a_spec.rb' },
+                      { 'path' => 'b_spec.rb' },
+                    ]
+                  end
+                  let(:response2) do
+                    { 'test_files' => test_files }
+                  end
+
+                  context 'when test files encryption is enabled' do
+                    before do
+                      expect(KnapsackPro::Config::Env).to receive(:test_files_encrypted?).and_return(true)
+                      expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(lazy_loaded_fast_and_slow_test_files_to_run, response2['test_files']).and_return(test_files)
+                    end
+
+                    it { should eq ['a_spec.rb', 'b_spec.rb'] }
+                  end
+
+                  context 'when test files encryption is disabled' do
+                    before do
+                      expect(KnapsackPro::Config::Env).to receive(:test_files_encrypted?).and_return(false)
+                    end
+
+                    it { should eq ['a_spec.rb', 'b_spec.rb'] }
+                  end
+                end
+              end
+            end
+
+            context 'when not successful 2nd request to API' do
+              let(:response2_success?) { false }
+              let(:response2_errors?) { false }
+              let(:response2) { nil }
+
+              it_behaves_like 'when connection to API failed (fallback mode)'
+            end
+          end
+        end
+      end
+
+      context 'when not successful request to API' do
+        let(:success?) { false }
+        let(:errors?) { false }
+
+        it_behaves_like 'when connection to API failed (fallback mode)'
+      end
+    end
+
+    context 'when can_initialize_queue=false' do
+      let(:can_initialize_queue) { false }
+      let(:api_code) { nil }
+
+      before do
+        encrypted_branch = double
+        expect(KnapsackPro::Crypto::BranchEncryptor).to receive(:call).with(repository_adapter.branch).and_return(encrypted_branch)
+
+        action = double
+        expect(KnapsackPro::Client::API::V1::Queues).to receive(:queue).with(
+          can_initialize_queue: can_initialize_queue,
+          attempt_connect_to_queue: false, # when can_initialize_queue=false then expect attempt_connect_to_queue=false
+          commit_hash: repository_adapter.commit_hash,
+          branch: encrypted_branch,
+          node_total: ci_node_total,
+          node_index: ci_node_index,
+          node_build_id: ci_node_build_id,
+          test_files: nil, # when can_initialize_queue=false then expect test_files is nil to make fast request to API
+        ).and_return(action)
+
+        connection = instance_double(KnapsackPro::Client::Connection,
+                                     call: response,
+                                     success?: success?,
+                                     errors?: errors?,
+                                     api_code: api_code)
+        expect(KnapsackPro::Client::Connection).to receive(:new).with(action).and_return(connection)
+      end
+
+      context 'when successful request to API' do
+        let(:success?) { true }
+
+        context 'when response has errors' do
+          let(:errors?) { true }
+
+          it do
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'when response has no errors' do
+          let(:errors?) { false }
+
+          context 'when response returns test files (successful attempt to connect to queue already existing on the API side)' do
+            let(:test_files) do
+              [
+                { 'path' => 'a_spec.rb' },
+                { 'path' => 'b_spec.rb' },
+              ]
+            end
+            let(:response) do
+              { 'test_files' => test_files }
+            end
+
+            context 'when test files encryption is enabled' do
+              before do
+                expect(KnapsackPro::Config::Env).to receive(:test_files_encrypted?).and_return(true)
+                expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(lazy_loaded_fast_and_slow_test_files_to_run, response['test_files']).and_return(test_files)
+              end
+
+              it { should eq ['a_spec.rb', 'b_spec.rb'] }
+            end
+
+            context 'when test files encryption is disabled' do
+              before do
+                expect(KnapsackPro::Config::Env).to receive(:test_files_encrypted?).and_return(false)
+              end
+
+              it { should eq ['a_spec.rb', 'b_spec.rb'] }
+            end
+          end
+        end
+      end
+
+      context 'when not successful request to API' do
+        let(:success?) { false }
+        let(:errors?) { false }
+
+        it_behaves_like 'when connection to API failed (fallback mode)'
+      end
+    end
   end
 end

data/spec/knapsack_pro/test_case_detectors/rspec_test_example_detector_spec.rb

@@ -67,7 +67,7 @@ describe KnapsackPro::TestCaseDetectors::RSpecTestExampleDetector do
           let(:exit_code) { 1 }
 
           it do
-            expect { subject }.to raise_error(RuntimeError, 'There was problem to generate test examples for test suite')
+            expect { subject }.to raise_error(RuntimeError, 'There was a problem while generating test examples for the slow test files. Please read actionable error message above.')
           end
         end
       end

data/spec/knapsack_pro/test_file_finder_spec.rb

@@ -154,5 +154,23 @@ describe KnapsackPro::TestFileFinder do
         end
       end
     end
+
+    context 'when KNAPSACK_PRO_TEST_FILE_LIST_SOURCE_FILE is defined' do
+      let(:test_file_list_source_file) { 'spec/fixtures/test_file_list_source_file.txt' }
+
+      before do
+        stub_const("ENV", { 'KNAPSACK_PRO_TEST_FILE_LIST_SOURCE_FILE' => test_file_list_source_file })
+      end
+
+      it do
+        expect(subject).to eq([
+          { 'path' => 'spec/test1_spec.rb' },
+          { 'path' => 'spec/test2_spec.rb[1]' },
+          { 'path' => 'spec/test3_spec.rb[1:2:3:4]' },
+          { 'path' => 'spec/test4_spec.rb:4' },
+          { 'path' => 'spec/test4_spec.rb:5' },
+        ])
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knapsack_pro
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.10.0
 platform: ruby
 authors:
 - ArturT
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-22 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -308,6 +308,7 @@ files:
 - lib/tasks/salt.rake
 - lib/tasks/spinach.rake
 - lib/tasks/test_unit.rake
+- spec/fixtures/test_file_list_source_file.txt
 - spec/fixtures/vcr_cassettes/api/v1/build_distributions/subset/invalid_test_suite_token.yml
 - spec/fixtures/vcr_cassettes/api/v1/build_distributions/subset/success.yml
 - spec/fixtures/vcr_cassettes/api/v1/build_subsets/create/invalid_test_suite_token.yml
@@ -428,6 +429,7 @@ specification_version: 4
 summary: Knapsack Pro splits tests across parallel CI nodes and ensures each parallel
   job finish work at a similar time.
 test_files:
+- spec/fixtures/test_file_list_source_file.txt
 - spec/fixtures/vcr_cassettes/api/v1/build_distributions/subset/invalid_test_suite_token.yml
 - spec/fixtures/vcr_cassettes/api/v1/build_distributions/subset/success.yml
 - spec/fixtures/vcr_cassettes/api/v1/build_subsets/create/invalid_test_suite_token.yml