knapsack_pro 2.7.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e72536de9d4d9ec4a02e935742375b9d8023522f9c21ac8340a991bfdc7982cb
-  data.tar.gz: b7694088ff854a5579ec160fbb08c3219986a95512c2feea15ac6a359dc7aff5
+  metadata.gz: beae91b61b862b583d31eb96e90528168f2d744b85cf89ec657a2bb9eb3b605a
+  data.tar.gz: 2ddaec300265bd38f33438629a457d6e559f2a69ecb3e1b190deab30abebbdd1
 SHA512:
-  metadata.gz: 408aaada7954066b2a3266897aa9b145ce53f2f7409f99f4c8915e122c5deef0818bc14503da59cab1f20c1376a4b205466089c14eaa8c9cd1943699298f8d86
-  data.tar.gz: 85eef879c155557825347ede8671f1b65d9832a8e8b379e94efaf61573cbd676082d43d6219099a35cad008266ef8e16cd719553397c5b71f775ad0ab76f7e79
+  metadata.gz: 17eedf845e8b54b6e3fbcb9bb53a156b63d989eb09f55f7daf82a1c458838294ffa9d5da5ce55097f0ec309d64fa4c51b1ed375cb5a9ae425bf9311cdbee952d
+  data.tar.gz: 6533850f09175a000f07f8933b721aee0b250725c8243111631c5ae1de174f519e95213d79ad66797d088678852c4afb072b5f13c2df37802408b5b44f855dd5

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Change Log
 
+### 2.11.0
+
+* Verify test runner adapter bind method is called to track test files time execution and ensure `tmp/knapsack_pro` directory is not removed accidentally
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/137
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.10.1...v2.11.0
+
+### 2.10.1
+
+* Fix RSpec split by test examples feature broken by lazy generating of JSON report with test example ids
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/135
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.10.0...v2.10.1
+
+### 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

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
 

data/lib/knapsack_pro/adapters/base_adapter.rb

@@ -4,6 +4,11 @@ module KnapsackPro
       # Just example, please overwrite constant in subclass
       TEST_DIR_PATTERN = 'test/**{,/*/**}/*_test.rb'
 
+      def self.adapter_bind_method_called_file
+        adapter_name = self.to_s.gsub('::', '-')
+        "#{KnapsackPro::Config::Env::TMP_DIR}/#{adapter_name}-bind_method_called_for_node_#{KnapsackPro::Config::Env.ci_node_index}.txt"
+      end
+
       def self.slow_test_file?(adapter_class, test_file_path)
         @slow_test_file_paths ||=
           begin
@@ -26,7 +31,24 @@ module KnapsackPro
         adapter
       end
 
+      def self.verify_bind_method_called
+        ::Kernel.at_exit do
+          if File.exists?(adapter_bind_method_called_file)
+            File.delete(adapter_bind_method_called_file)
+          else
+            puts "\n\n"
+            KnapsackPro.logger.error('-'*10 + ' Configuration error ' + '-'*50)
+            KnapsackPro.logger.error("You forgot to call #{self}.bind method in your test runner configuration file. It is needed to record test files time execution. Please follow the installation guide to configure your project properly https://docs.knapsackpro.com/knapsack_pro-ruby/guide/")
+            KnapsackPro.logger.error("If you already have #{self}.bind method added and you still see this error then one of your tests must had to delete tmp/knapsack_pro directory from the disk accidentally. Please ensure you do not remove tmp/knapsack_pro directory: https://knapsackpro.com/faq/question/why-all-test-files-have-01s-time-execution-for-my-ci-build-in-user-dashboard")
+            Kernel.exit(1)
+          end
+        end
+      end
+
       def bind
+        FileUtils.mkdir_p(KnapsackPro::Config::Env::TMP_DIR)
+        File.write(self.class.adapter_bind_method_called_file, nil)
+
         if KnapsackPro::Config::Env.recording_enabled?
           KnapsackPro.logger.debug('Test suite time execution recording enabled.')
           bind_time_tracker

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

data/lib/knapsack_pro/config/env.rb

@@ -8,6 +8,7 @@ module KnapsackPro
         'info'  => ::Logger::INFO,
         'debug' => ::Logger::DEBUG,
       }
+      TMP_DIR = 'tmp/knapsack_pro'
 
       class << self
         def ci_node_total

data/lib/knapsack_pro/queue_allocator.rb

@@ -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)
@@ -52,15 +61,22 @@ module KnapsackPro
       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
 

data/lib/knapsack_pro/report.rb

@@ -80,7 +80,7 @@ module KnapsackPro
 
     def self.queue_path
       queue_id = KnapsackPro::Config::Env.queue_id
-      "tmp/knapsack_pro/queue/#{queue_id}"
+      "#{KnapsackPro::Config::Env::TMP_DIR}/queue/#{queue_id}"
     end
   end
 end

data/lib/knapsack_pro/runners/cucumber_runner.rb

@@ -5,9 +5,12 @@ module KnapsackPro
         ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_cucumber
         ENV['KNAPSACK_PRO_RECORDING_ENABLED'] = 'true'
 
-        runner = new(KnapsackPro::Adapters::CucumberAdapter)
+        adapter_class = KnapsackPro::Adapters::CucumberAdapter
+        runner = new(adapter_class)
 
         if runner.test_files_to_execute_exist?
+          adapter_class.verify_bind_method_called
+
           require 'cucumber/rake/task'
 
           task_name = 'knapsack_pro:cucumber_run'

data/lib/knapsack_pro/runners/minitest_runner.rb

@@ -5,9 +5,12 @@ module KnapsackPro
         ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_minitest
         ENV['KNAPSACK_PRO_RECORDING_ENABLED'] = 'true'
 
-        runner = new(KnapsackPro::Adapters::MinitestAdapter)
+        adapter_class = KnapsackPro::Adapters::MinitestAdapter
+        runner = new(adapter_class)
 
         if runner.test_files_to_execute_exist?
+          adapter_class.verify_bind_method_called
+
           task_name = 'knapsack_pro:minitest_run'
 
           if Rake::Task.task_defined?(task_name)

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

@@ -39,6 +39,10 @@ module KnapsackPro
           )
 
           if test_file_paths.empty?
+            unless all_test_file_paths.empty?
+              KnapsackPro::Adapters::CucumberAdapter.verify_bind_method_called
+            end
+
             KnapsackPro::Hooks::Queue.call_after_queue
 
             KnapsackPro::Report.save_node_queue_to_api

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

@@ -46,6 +46,10 @@ module KnapsackPro
           )
 
           if test_file_paths.empty?
+            unless all_test_file_paths.empty?
+              KnapsackPro::Adapters::MinitestAdapter.verify_bind_method_called
+            end
+
             KnapsackPro::Hooks::Queue.call_after_queue
 
             KnapsackPro::Report.save_node_queue_to_api

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

@@ -53,6 +53,8 @@ module KnapsackPro
 
           if test_file_paths.empty?
             unless all_test_file_paths.empty?
+              KnapsackPro::Adapters::RSpecAdapter.verify_bind_method_called
+
               KnapsackPro::Formatters::RSpecQueueSummaryFormatter.print_summary
               KnapsackPro::Formatters::RSpecQueueProfileFormatterExtension.print_summary
 

data/lib/knapsack_pro/runners/rspec_runner.rb

@@ -5,9 +5,12 @@ module KnapsackPro
         ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_rspec
         ENV['KNAPSACK_PRO_RECORDING_ENABLED'] = 'true'
 
-        runner = new(KnapsackPro::Adapters::RSpecAdapter)
+        adapter_class = KnapsackPro::Adapters::RSpecAdapter
+        runner = new(adapter_class)
 
         if runner.test_files_to_execute_exist?
+          adapter_class.verify_bind_method_called
+
           require 'rspec/core/rake_task'
 
           task_name = 'knapsack_pro:rspec_run'

data/lib/knapsack_pro/runners/spinach_runner.rb

@@ -4,9 +4,12 @@ module KnapsackPro
       def self.run(args)
         ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_spinach
 
-        runner = new(KnapsackPro::Adapters::SpinachAdapter)
+        adapter_class = KnapsackPro::Adapters::SpinachAdapter
+        runner = new(adapter_class)
 
         if runner.test_files_to_execute_exist?
+          adapter_class.verify_bind_method_called
+
           cmd = %Q[KNAPSACK_PRO_RECORDING_ENABLED=true KNAPSACK_PRO_TEST_SUITE_TOKEN=#{ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN']} bundle exec spinach #{args} --features_path #{runner.test_dir} -- #{runner.stringify_test_file_paths}]
 
           Kernel.system(cmd)

data/lib/knapsack_pro/runners/test_unit_runner.rb

@@ -5,9 +5,12 @@ module KnapsackPro
         ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_test_unit
         ENV['KNAPSACK_PRO_RECORDING_ENABLED'] = 'true'
 
-        runner = new(KnapsackPro::Adapters::TestUnitAdapter)
+        adapter_class = KnapsackPro::Adapters::TestUnitAdapter
+        runner = new(adapter_class)
 
         if runner.test_files_to_execute_exist?
+          adapter_class.verify_bind_method_called
+
           require 'test/unit'
 
           cli_args =

data/lib/knapsack_pro/slow_test_file_determiner.rb

@@ -1,7 +1,7 @@
 module KnapsackPro
   class SlowTestFileDeterminer
     TIME_THRESHOLD_PER_CI_NODE = 0.7 # 70%
-    REPORT_DIR = 'tmp/knapsack_pro/slow_test_file_determiner'
+    REPORT_DIR = "#{KnapsackPro::Config::Env::TMP_DIR}/slow_test_file_determiner"
 
     # test_files: { 'path' => 'a_spec.rb', 'time_execution' => 0.0 }
     # time_execution: of build distribution (total time of CI build run)

data/lib/knapsack_pro/test_case_detectors/rspec_test_example_detector.rb

@@ -1,7 +1,7 @@
 module KnapsackPro
   module TestCaseDetectors
     class RSpecTestExampleDetector
-      REPORT_DIR = 'tmp/knapsack_pro/test_case_detectors/rspec'
+      REPORT_DIR = "#{KnapsackPro::Config::Env::TMP_DIR}/test_case_detectors/rspec"
 
       def generate_json_report
         require 'rspec/core'
@@ -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/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.7.0'
+  VERSION = '2.11.0'
 end

data/spec/knapsack_pro/adapters/base_adapter_spec.rb

@@ -22,6 +22,27 @@ describe KnapsackPro::Adapters::BaseAdapter do
     end
   end
 
+  describe '.adapter_bind_method_called_file' do
+    subject { described_class.adapter_bind_method_called_file }
+
+    before do
+      expect(KnapsackPro::Config::Env).to receive(:ci_node_index).and_return(ci_node_index)
+    end
+
+    context 'when CI node index 0' do
+      let(:ci_node_index) { 0 }
+
+      it { expect(subject).to eq 'tmp/knapsack_pro/KnapsackPro-Adapters-BaseAdapter-bind_method_called_for_node_0.txt' }
+
+    end
+
+    context 'when CI node index 1' do
+      let(:ci_node_index) { 1 }
+
+      it { expect(subject).to eq 'tmp/knapsack_pro/KnapsackPro-Adapters-BaseAdapter-bind_method_called_for_node_1.txt' }
+    end
+  end
+
   describe '.slow_test_file?' do
     let(:adapter_class) { double }
     let(:slow_test_files) do
@@ -71,11 +92,41 @@ describe KnapsackPro::Adapters::BaseAdapter do
     it { should eql adapter }
   end
 
+  describe '.verify_bind_method_called' do
+    subject { described_class.verify_bind_method_called }
+
+    before do
+      expect(::Kernel).to receive(:at_exit).and_yield
+      expect(File).to receive(:exists?).with('tmp/knapsack_pro/KnapsackPro-Adapters-BaseAdapter-bind_method_called_for_node_0.txt').and_return(adapter_bind_method_called_file_exists)
+    end
+
+    context 'when adapter bind method called' do
+      let(:adapter_bind_method_called_file_exists) { true }
+
+      it do
+        expect(File).to receive(:delete).with('tmp/knapsack_pro/KnapsackPro-Adapters-BaseAdapter-bind_method_called_for_node_0.txt')
+        subject
+      end
+    end
+
+    context 'when adapter bind method was not call' do
+      let(:adapter_bind_method_called_file_exists) { false }
+
+      it do
+        expect(Kernel).to receive(:exit).with(1)
+        subject
+      end
+    end
+  end
+
   describe '#bind' do
     let(:recording_enabled?) { false }
     let(:queue_recording_enabled?) { false }
 
     before do
+      expect(FileUtils).to receive(:mkdir_p).with('tmp/knapsack_pro')
+      expect(File).to receive(:write).with('tmp/knapsack_pro/KnapsackPro-Adapters-BaseAdapter-bind_method_called_for_node_0.txt', nil)
+
       expect(KnapsackPro::Config::Env).to receive(:recording_enabled?).and_return(recording_enabled?)
       expect(KnapsackPro::Config::Env).to receive(:queue_recording_enabled?).and_return(queue_recording_enabled?)
     end

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/queue_allocator_spec.rb

@@ -18,71 +18,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)
@@ -146,5 +88,220 @@ 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(: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
+
+          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(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(:response2) 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, response2['test_files']).and_call_original
+                  end
+
+                  it { should eq ['a_spec.rb', 'b_spec.rb'] }
+                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(: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
+      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/runners/cucumber_runner_spec.rb

@@ -34,6 +34,8 @@ describe KnapsackPro::Runners::CucumberRunner do
       let(:task) { double }
 
       before do
+        expect(KnapsackPro::Adapters::CucumberAdapter).to receive(:verify_bind_method_called)
+
         expect(Rake::Task).to receive(:[]).with('knapsack_pro:cucumber_run').at_least(1).and_return(task)
 
         t = double

data/spec/knapsack_pro/runners/minitest_runner_spec.rb

@@ -14,6 +14,10 @@ describe KnapsackPro::Runners::MinitestRunner do
     end
 
     context 'when test files were returned by Knapsack Pro API' do
+      before do
+        expect(KnapsackPro::Adapters::MinitestAdapter).to receive(:verify_bind_method_called)
+      end
+
       it 'runs tests' do
         test_file_paths = ['test_fake/a_test.rb', 'test_fake/b_test.rb']
         runner = instance_double(described_class,

data/spec/knapsack_pro/runners/queue/cucumber_runner_spec.rb

@@ -167,14 +167,34 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
     context "when test files don't exist" do
       let(:test_file_paths) { [] }
 
-      it 'returns exit code 0' do
-        expect(KnapsackPro::Hooks::Queue).to receive(:call_after_queue)
-        expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
+      context 'when all_test_file_paths exist' do
+        let(:all_test_file_paths) { ['features/a.feature'] }
 
-        expect(subject).to eq({
-          status: :completed,
-          exitstatus: exitstatus,
-        })
+        it 'returns exit code 0' do
+          expect(KnapsackPro::Adapters::CucumberAdapter).to receive(:verify_bind_method_called)
+
+          expect(KnapsackPro::Hooks::Queue).to receive(:call_after_queue)
+          expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
+
+          expect(subject).to eq({
+            status: :completed,
+            exitstatus: exitstatus,
+          })
+        end
+      end
+
+      context "when all_test_file_paths don't exist" do
+        let(:all_test_file_paths) { [] }
+
+        it 'returns exit code 0' do
+          expect(KnapsackPro::Hooks::Queue).to receive(:call_after_queue)
+          expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
+
+          expect(subject).to eq({
+            status: :completed,
+            exitstatus: exitstatus,
+          })
+        end
       end
     end
   end

data/spec/knapsack_pro/runners/queue/minitest_runner_spec.rb

@@ -159,14 +159,34 @@ describe KnapsackPro::Runners::Queue::MinitestRunner do
     context "when test files don't exist" do
       let(:test_file_paths) { [] }
 
-      it 'returns exit code 0' do
-        expect(KnapsackPro::Hooks::Queue).to receive(:call_after_queue)
-        expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
+      context 'when all_test_file_paths exist' do
+        let(:all_test_file_paths) { ['a_test.rb'] }
 
-        expect(subject).to eq({
-          status: :completed,
-          exitstatus: exitstatus,
-        })
+        it 'returns exit code 0' do
+          expect(KnapsackPro::Adapters::MinitestAdapter).to receive(:verify_bind_method_called)
+
+          expect(KnapsackPro::Hooks::Queue).to receive(:call_after_queue)
+          expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
+
+          expect(subject).to eq({
+            status: :completed,
+            exitstatus: exitstatus,
+          })
+        end
+      end
+
+      context "when all_test_file_paths don't exist" do
+        let(:all_test_file_paths) { [] }
+
+        it 'returns exit code 0' do
+          expect(KnapsackPro::Hooks::Queue).to receive(:call_after_queue)
+          expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
+
+          expect(subject).to eq({
+            status: :completed,
+            exitstatus: exitstatus,
+          })
+        end
       end
     end
   end

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

@@ -249,6 +249,8 @@ describe KnapsackPro::Runners::Queue::RSpecRunner do
         let(:all_test_file_paths) { ['a_spec.rb'] }
 
         it do
+          expect(KnapsackPro::Adapters::RSpecAdapter).to receive(:verify_bind_method_called)
+
           expect(KnapsackPro::Formatters::RSpecQueueSummaryFormatter).to receive(:print_summary)
           expect(KnapsackPro::Formatters::RSpecQueueProfileFormatterExtension).to receive(:print_summary)
 

data/spec/knapsack_pro/runners/rspec_runner_spec.rb

@@ -34,6 +34,8 @@ describe KnapsackPro::Runners::RSpecRunner do
       let(:task) { double }
 
       before do
+        expect(KnapsackPro::Adapters::RSpecAdapter).to receive(:verify_bind_method_called)
+
         expect(Rake::Task).to receive(:[]).with('knapsack_pro:rspec_run').at_least(1).and_return(task)
 
         t = double

data/spec/knapsack_pro/runners/spinach_runner_spec.rb

@@ -26,6 +26,8 @@ describe KnapsackPro::Runners::SpinachRunner do
       end
 
       before do
+        expect(KnapsackPro::Adapters::SpinachAdapter).to receive(:verify_bind_method_called)
+
         expect(Kernel).to receive(:system).with('KNAPSACK_PRO_RECORDING_ENABLED=true KNAPSACK_PRO_TEST_SUITE_TOKEN=spinach-token bundle exec spinach --custom-arg --features_path fake-test-dir -- features/a.feature features/b.feature')
       end
 

data/spec/knapsack_pro/runners/test_unit_runner_spec.rb

@@ -16,6 +16,8 @@ describe KnapsackPro::Runners::TestUnitRunner do
 
     context 'when test files were returned by Knapsack Pro API' do
       it 'runs tests' do
+        expect(KnapsackPro::Adapters::TestUnitAdapter).to receive(:verify_bind_method_called)
+
         test_file_paths = ['test-unit_fake/a_test.rb', 'test-unit_fake/b_test.rb']
         runner = instance_double(described_class,
                                  test_dir: 'test-unit_fake',

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knapsack_pro
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.11.0
 platform: ruby
 authors:
 - ArturT
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-04 00:00:00.000000000 Z
+date: 2021-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -408,7 +408,7 @@ metadata:
   documentation_uri: https://docs.knapsackpro.com/integration/
   homepage_uri: https://knapsackpro.com
   source_code_uri: https://github.com/KnapsackPro/knapsack_pro-ruby
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -424,7 +424,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Knapsack Pro splits tests across parallel CI nodes and ensures each parallel
   job finish work at a similar time.