knapsack_pro 2.9.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7985606018ab50713321190176606a281cdfbec98e7c4883569ddcc73fd1acad
-  data.tar.gz: e1564d27e3a6ab282657d131e0ccd134de831260cf240114cca213b32c804e27
+  metadata.gz: ab52ffbbe5618da1d1c70e11493e6dcd474542a8fe19dc11b57c673f3fc5b939
+  data.tar.gz: e53495530e21c903b56921a47a6cd27de056f3cc2cbb3f2804df99f0bc6d4542
 SHA512:
-  metadata.gz: 658af58fa87cff47e1c61cd48bc37a54574339a5450fe0cc77c8dac0001cdd0fad36ed0537fdb597ab23678c99446fcbf6793f574ee7ad99c12d05ee7be7a25f
-  data.tar.gz: 6ef3927c8ea007073102969878dea4c00cc3340912d49448803e4b62207e73fd289e6dcfb7a22b22eab4d21f9c72828933bfdccf0d509a2e904fda425e73cdcb
+  metadata.gz: 732b7ce526fa01c176e5a958bd6cf71eab989fce6bcf160334157dd1e7b65b37c6b31ecc0ad603b4780df0a925059eaf5f212174d1bff37f89ab86c807d4ac30
+  data.tar.gz: baa2ef028990a02e332f0f5e1d985db760f44ae3c1b090128c696dea5f77e2a89659381e7a081a2c67eb1d870cec09b9a16d9b11e0dbe4315622fd7a458889b1

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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

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/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

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

@@ -1,3 +1,3 @@
 module KnapsackPro
-  VERSION = '2.9.0'
+  VERSION = '2.10.0'
 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_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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knapsack_pro
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.0
 platform: ruby
 authors:
 - ArturT
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-21 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake