knapsack_pro 1.20.2 → 1.21.0

data/spec/knapsack_pro/allocator_builder_spec.rb

@@ -8,8 +8,11 @@ describe KnapsackPro::AllocatorBuilder do
     subject { allocator_builder.allocator }
 
     before do
-      test_files = double
-      expect(allocator_builder).to receive(:test_files).and_return(test_files)
+      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)
+
+      fallback_mode_test_files = double
+      expect(allocator_builder).to receive(:fallback_mode_test_files).and_return(fallback_mode_test_files)
 
       repository_adapter = double
       expect(KnapsackPro::RepositoryAdapterInitiator).to receive(:call).and_return(repository_adapter)
@@ -20,7 +23,8 @@ describe KnapsackPro::AllocatorBuilder do
       expect(KnapsackPro::Config::Env).to receive(:ci_node_index).and_return(ci_node_index)
 
       expect(KnapsackPro::Allocator).to receive(:new).with(
-        test_files: test_files,
+        fast_and_slow_test_files_to_run: fast_and_slow_test_files_to_run,
+        fallback_mode_test_files: fallback_mode_test_files,
         ci_node_total: ci_node_total,
         ci_node_index: ci_node_index,
         repository_adapter: repository_adapter,

data/spec/knapsack_pro/allocator_spec.rb

@@ -1,12 +1,14 @@
 describe KnapsackPro::Allocator do
-  let(:test_files) { double }
+  let(:fast_and_slow_test_files_to_run) { double }
+  let(:fallback_mode_test_files) { double }
   let(:ci_node_total) { double }
   let(:ci_node_index) { double }
   let(:repository_adapter) { instance_double(KnapsackPro::RepositoryAdapters::EnvAdapter, commit_hash: double, branch: double) }
 
   let(:allocator) do
     described_class.new(
-      test_files: test_files,
+      fast_and_slow_test_files_to_run: fast_and_slow_test_files_to_run,
+      fallback_mode_test_files: fallback_mode_test_files,
       ci_node_total: ci_node_total,
       ci_node_index: ci_node_index,
       repository_adapter: repository_adapter
@@ -20,7 +22,7 @@ describe KnapsackPro::Allocator do
 
     before do
       encrypted_test_files = double
-      expect(KnapsackPro::Crypto::Encryptor).to receive(:call).with(test_files).and_return(encrypted_test_files)
+      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)
@@ -64,7 +66,7 @@ describe KnapsackPro::Allocator do
         end
 
         before do
-          expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(test_files, response['test_files']).and_call_original
+          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'] }
@@ -114,7 +116,7 @@ describe KnapsackPro::Allocator do
       context 'when fallback mode started' do
         before do
           test_flat_distributor = instance_double(KnapsackPro::TestFlatDistributor)
-          expect(KnapsackPro::TestFlatDistributor).to receive(:new).with(test_files, ci_node_total).and_return(test_flat_distributor)
+          expect(KnapsackPro::TestFlatDistributor).to receive(:new).with(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' },

data/spec/knapsack_pro/base_allocator_builder_spec.rb

@@ -100,8 +100,22 @@ describe KnapsackPro::BaseAllocatorBuilder do
     end
   end
 
-  describe '#test_files' do
-    subject { allocator_builder.test_files }
+  describe '#fallback_mode_test_files' do
+    subject { allocator_builder.fallback_mode_test_files }
+
+    it do
+      test_file_pattern = double
+      expect(KnapsackPro::TestFilePattern).to receive(:call).with(adapter_class).and_return(test_file_pattern)
+
+      test_files = double
+      expect(KnapsackPro::TestFileFinder).to receive(:call).with(test_file_pattern).and_return(test_files)
+
+      expect(subject).to eq test_files
+    end
+  end
+
+  describe '#fast_and_slow_test_files_to_run' do
+    subject { allocator_builder.fast_and_slow_test_files_to_run }
 
     context 'when looking for test files on disk by default' do
       it do
@@ -115,10 +129,10 @@ describe KnapsackPro::BaseAllocatorBuilder do
       end
     end
 
-    context 'when RSpec adapter and rspec split by test examples is enabled' do
+    context 'when RSpec adapter AND rspec split by test examples is enabled' do
       let(:adapter_class) { KnapsackPro::Adapters::RSpecAdapter }
-      let(:test_files) { double(size: 1000) }
-      let(:cmd) { 'bundle exec rake knapsack_pro:rspec_test_example_detector' }
+      let(:test_files_to_run) { double }
+      let(:cmd) { 'RACK_ENV=test RAILS_ENV=test bundle exec rake knapsack_pro:rspec_test_example_detector' }
 
       before do
         expect(KnapsackPro::Config::Env).to receive(:rspec_split_by_test_examples?).and_return(true)
@@ -126,53 +140,91 @@ describe KnapsackPro::BaseAllocatorBuilder do
         test_file_pattern = double
         expect(KnapsackPro::TestFilePattern).to receive(:call).with(adapter_class).and_return(test_file_pattern)
 
-        expect(KnapsackPro::TestFileFinder).to receive(:call).with(test_file_pattern).and_return(test_files)
+        expect(KnapsackPro::TestFileFinder).to receive(:call).with(test_file_pattern).and_return(test_files_to_run)
+      end
+
+      context 'when RSpec version < 3.3.0' do
+        before do
+          stub_const('RSpec::Core::Version::STRING', '3.2.0')
+        end
 
-        expect(Kernel).to receive(:system).with(cmd).and_return(cmd_result)
+        it do
+          expect { subject }.to raise_error RuntimeError, 'RSpec >= 3.3.0 is required to split test files by test examples. Learn more: https://github.com/KnapsackPro/knapsack_pro-ruby#split-test-files-by-test-cases'
+        end
       end
 
       context 'when rake task to detect RSpec test examples works' do
+        let(:slow_test_files) { double(size: 5) }
         let(:cmd_result) { true }
         let(:test_file_example_paths) { double }
         let(:logger) { instance_double(Logger) }
+        let(:test_files_with_test_cases) { double }
 
         before do
-          rspec_test_example_detector = instance_double(KnapsackPro::TestCaseDetectors::RSpecTestExampleDetector)
-          expect(KnapsackPro::TestCaseDetectors::RSpecTestExampleDetector).to receive(:new).and_return(rspec_test_example_detector)
-          expect(rspec_test_example_detector).to receive(:test_file_example_paths).and_return(test_file_example_paths)
+          expect(allocator_builder).to receive(:get_slow_test_files).and_return(slow_test_files)
 
-          expect(KnapsackPro).to receive(:logger).at_least(1).and_return(logger)
-        end
+          expect(KnapsackPro).to receive(:logger).and_return(logger)
 
-        context 'when up to 1000 test files detected on disk' do
-          let(:test_files) { double(size: 1000) }
+          expect(Kernel).to receive(:system).with(cmd).and_return(cmd_result)
 
-          it do
-            expect(logger).to receive(:warn).with("Generating RSpec test examples JSON report to prepare your test suite to be split by test examples (by individual 'it's. Thanks to that a single test file can be split across parallel CI nodes). Analyzing 1000 test files.")
+          rspec_test_example_detector = instance_double(KnapsackPro::TestCaseDetectors::RSpecTestExampleDetector)
+          expect(KnapsackPro::TestCaseDetectors::RSpecTestExampleDetector).to receive(:new).and_return(rspec_test_example_detector)
+          expect(rspec_test_example_detector).to receive(:test_file_example_paths).and_return(test_file_example_paths)
 
-            expect(subject).to eq test_file_example_paths
-          end
+          expect(KnapsackPro::TestFilesWithTestCasesComposer).to receive(:call).with(test_files_to_run, slow_test_files, test_file_example_paths).and_return(test_files_with_test_cases)
         end
 
-        context 'when more than 1000 test files detected on disk' do
-          let(:test_files) { double(size: 1001) }
-
-          it do
-            expect(logger).to receive(:warn).with("Generating RSpec test examples JSON report to prepare your test suite to be split by test examples (by individual 'it's. Thanks to that a single test file can be split across parallel CI nodes). Analyzing 1001 test files.")
-            expect(logger).to receive(:warn).with('You have more than 1000 test files, it may take longer to generate test examples. Please wait...')
+        it do
+          expect(logger).to receive(:info).with("Generating RSpec test examples JSON report for slow test files to prepare it to be split by test examples (by individual 'it's. Thanks to that a single slow test file can be split across parallel CI nodes). Analyzing 5 slow test files.")
 
-            expect(subject).to eq test_file_example_paths
-          end
+          expect(subject).to eq test_files_with_test_cases
         end
       end
 
       context 'when rake task to detect RSpec test examples failed' do
+        let(:slow_test_files) { double(size: 5) }
         let(:cmd_result) { false }
 
+        before do
+          expect(allocator_builder).to receive(:get_slow_test_files).and_return(slow_test_files)
+
+          expect(Kernel).to receive(:system).with(cmd).and_return(cmd_result)
+        end
+
         it do
-          expect { subject }.to raise_error(RuntimeError, 'Could not generate JSON report for RSpec. Rake task failed when running bundle exec rake knapsack_pro:rspec_test_example_detector')
+          expect { subject }.to raise_error(RuntimeError, 'Could not generate JSON report for RSpec. Rake task failed when running RACK_ENV=test RAILS_ENV=test bundle exec rake knapsack_pro:rspec_test_example_detector')
         end
       end
     end
   end
+
+  describe 'private #get_slow_test_files' do
+    subject { allocator_builder.send(:get_slow_test_files) }
+
+    before do
+      expect(KnapsackPro::Config::Env).to receive(:slow_test_file_pattern).and_return(slow_test_file_pattern)
+    end
+
+    context 'when slow test file pattern is present' do
+      let(:slow_test_files) { double(:slow_test_files_based_on_pattern, size: 3) }
+      let(:slow_test_file_pattern) { double }
+
+      before do
+        expect(KnapsackPro::TestFileFinder).to receive(:slow_test_files_by_pattern).with(adapter_class).and_return(slow_test_files)
+      end
+
+      it { expect(subject).to eq slow_test_files }
+    end
+
+    context 'when slow test file pattern is not present' do
+      let(:slow_test_files) { double(:slow_test_files_based_on_api, size: 2) }
+      let(:slow_test_file_pattern) { nil }
+
+      before do
+        expect(KnapsackPro::SlowTestFileFinder).to receive(:call).with(adapter_class).and_return(slow_test_files)
+      end
+
+      it { expect(subject).to eq slow_test_files }
+    end
+  end
 end

data/spec/knapsack_pro/build_distribution_fetcher_spec.rb

@@ -0,0 +1,89 @@
+describe KnapsackPro::BuildDistributionFetcher do
+  describe '.call' do
+    subject { described_class.call }
+
+    it do
+      build_distribution_fetcher = instance_double(described_class)
+      expect(described_class).to receive(:new).and_return(build_distribution_fetcher)
+      result = double
+      expect(build_distribution_fetcher).to receive(:call).and_return(result)
+
+      expect(subject).to eq result
+    end
+  end
+
+  describe '#call' do
+    let(:ci_node_total) { double }
+    let(:ci_node_index) { double }
+    let(:repository_adapter) { instance_double(KnapsackPro::RepositoryAdapters::EnvAdapter, commit_hash: double, branch: double) }
+
+    subject { described_class.new.call }
+
+    before do
+      expect(KnapsackPro::RepositoryAdapterInitiator).to receive(:call).and_return(repository_adapter)
+
+      expect(KnapsackPro::Config::Env).to receive(:ci_node_total).and_return(ci_node_total)
+      expect(KnapsackPro::Config::Env).to receive(:ci_node_index).and_return(ci_node_index)
+
+      action = double
+      expect(KnapsackPro::Client::API::V1::BuildDistributions).to receive(:last).with({
+        commit_hash: repository_adapter.commit_hash,
+        branch: repository_adapter.branch,
+        node_total: ci_node_total,
+        node_index: ci_node_index,
+      }).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 }
+        let(:response) { 'fake error response' }
+
+        it do
+          expect { subject }.to raise_error(ArgumentError, response)
+        end
+      end
+
+      context 'when response has no errors' do
+        let(:errors?) { false }
+        let(:response) do
+          {
+            'build_distribution_id' => 'be2b95b1-1b8b-43a3-9d66-cabebbf135b8',
+            'time_execution' => 2.5,
+            'test_files' => [
+              { 'path' => 'a_spec.rb', 'time_execution' => 1.5 },
+              { 'path' => 'b_spec.rb', 'time_execution' => 1.0 },
+            ]
+          }
+        end
+
+        it { expect(subject).to be_a described_class::BuildDistributionEntity }
+        it { expect(subject.time_execution).to eq 2.5 }
+        it do
+          expect(subject.test_files).to eq([
+            { 'path' => 'a_spec.rb', 'time_execution' => 1.5 },
+            { 'path' => 'b_spec.rb', 'time_execution' => 1.0 },
+          ])
+        end
+      end
+    end
+
+    context 'when not successful request to API' do
+      let(:success?) { false }
+      let(:errors?) { false }
+      let(:response) { double }
+
+      it { expect(subject).to be_a described_class::BuildDistributionEntity }
+      it { expect(subject.time_execution).to eq 0.0 }
+      it { expect(subject.test_files).to eq([]) }
+    end
+  end
+end

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

@@ -38,4 +38,35 @@ describe KnapsackPro::Client::API::V1::BuildDistributions do
       expect(subject).to eq action
     end
   end
+
+  describe '.last' do
+    let(:commit_hash) { double }
+    let(:branch) { double }
+    let(:node_total) { double }
+    let(:node_index) { double }
+
+    subject do
+      described_class.last(
+        commit_hash: commit_hash,
+        branch: branch,
+        node_total: node_total,
+        node_index: node_index,
+      )
+    end
+
+    it do
+      action = double
+      expect(KnapsackPro::Client::API::Action).to receive(:new).with({
+        endpoint_path: '/v1/build_distributions/last',
+        http_method: :get,
+        request_hash: {
+          commit_hash: commit_hash,
+          branch: branch,
+          node_total: node_total,
+          node_index: node_index,
+        }
+      }).and_return(action)
+      expect(subject).to eq action
+    end
+  end
 end

data/spec/knapsack_pro/client/connection_spec.rb

@@ -1,167 +1,229 @@
+shared_examples 'when request got response from API' do
+  context 'when body response is JSON and API response code is 400' do
+    let(:body) { '{"errors": "value"}' }
+    let(:code) { '400' } # it must be string code
+
+    before do
+      expect(KnapsackPro).to receive(:logger).exactly(4).and_return(logger)
+      expect(logger).to receive(:debug).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+      expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
+      expect(logger).to receive(:debug).with('API response:')
+    end
+
+    it do
+      parsed_response = { 'errors' => 'value' }
+
+      expect(logger).to receive(:error).with(parsed_response)
+
+      expect(subject).to eq(parsed_response)
+      expect(connection.success?).to be true
+      expect(connection.errors?).to be true
+    end
+  end
+
+  context 'when body response is JSON with build_distribution_id' do
+    let(:body) { '{"build_distribution_id": "seed-uuid"}' }
+    let(:code) { '200' } # it must be string code
+
+    before do
+      expect(KnapsackPro).to receive(:logger).exactly(5).and_return(logger)
+      expect(logger).to receive(:debug).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+      expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
+      expect(logger).to receive(:debug).with("Test suite split seed: seed-uuid")
+      expect(logger).to receive(:debug).with('API response:')
+    end
+
+    it do
+      parsed_response = { 'build_distribution_id' => 'seed-uuid' }
+
+      expect(logger).to receive(:debug).with(parsed_response)
+
+      expect(subject).to eq(parsed_response)
+      expect(connection.success?).to be true
+      expect(connection.errors?).to be false
+    end
+  end
+
+  context 'when body response is empty' do
+    let(:body) { '' }
+    let(:code) { '200' } # it must be string code
+
+    before do
+      expect(KnapsackPro).to receive(:logger).exactly(4).and_return(logger)
+      expect(logger).to receive(:debug).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+      expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
+      expect(logger).to receive(:debug).with('API response:')
+    end
+
+    it do
+      expect(logger).to receive(:debug).with('')
+
+      expect(subject).to eq('')
+      expect(connection.success?).to be true
+      expect(connection.errors?).to be false
+    end
+  end
+end
+
+shared_examples 'when retry request' do
+  context 'when body response is JSON and API response code is 500' do
+    let(:body) { '{"error": "Internal Server Error"}' }
+    let(:code) { '500' } # it must be string code
+
+    before do
+      expect(KnapsackPro).to receive(:logger).at_least(1).and_return(logger)
+      expect(logger).to receive(:debug).exactly(3).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+      expect(logger).to receive(:debug).exactly(3).with('API request UUID: fake-uuid')
+      expect(logger).to receive(:debug).exactly(3).with('API response:')
+    end
+
+    it do
+      parsed_response = { 'error' => 'Internal Server Error' }
+
+      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(server_error.inspect)
+
+      expect(logger).to receive(:warn).with("Wait 4s and retry request to Knapsack Pro API.")
+      expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
+      expect(Kernel).to receive(:sleep).with(4)
+      expect(Kernel).to receive(:sleep).with(8)
+
+      expect(subject).to eq(parsed_response)
+
+      expect(connection.success?).to be false
+      expect(connection.errors?).to be true
+    end
+  end
+end
+
 describe KnapsackPro::Client::Connection do
   let(:endpoint_path) { '/v1/fake_endpoint' }
-  let(:http_method) { :post }
   let(:request_hash) { { fake: 'hash' } }
+  let(:http_method) { :post }
   let(:action) do
     instance_double(KnapsackPro::Client::API::Action,
                     endpoint_path: endpoint_path,
                     http_method: http_method,
                     request_hash: request_hash)
   end
+  let(:test_suite_token) { '3fa64859337f6e56409d49f865d13fd7' }
 
   let(:connection) { described_class.new(action) }
 
   before do
     stub_const('ENV', {
       'KNAPSACK_PRO_ENDPOINT' => 'http://api.knapsackpro.test:3000',
-      'KNAPSACK_PRO_TEST_SUITE_TOKEN' => '3fa64859337f6e56409d49f865d13fd7',
+      'KNAPSACK_PRO_TEST_SUITE_TOKEN' => test_suite_token,
     })
   end
 
   describe '#call' do
     let(:logger) { instance_double(Logger) }
+    let(:http) { instance_double(Net::HTTP) }
+    let(:http_response) do
+      header = { 'X-Request-Id' => 'fake-uuid' }
+      instance_double(Net::HTTPOK, body: body, header: header, code: code)
+    end
 
     subject { connection.call }
 
-    context 'when http method is POST' do
-      before do
-        http = instance_double(Net::HTTP)
+    before do
+      expect(Net::HTTP).to receive(:new).with('api.knapsackpro.test', 3000).and_return(http)
 
-        expect(Net::HTTP).to receive(:new).with('api.knapsackpro.test', 3000).and_return(http)
+      expect(http).to receive(:use_ssl=).with(false)
+      expect(http).to receive(:open_timeout=).with(15)
+      expect(http).to receive(:read_timeout=).with(15)
+    end
 
-        expect(http).to receive(:use_ssl=).with(false)
-        expect(http).to receive(:open_timeout=).with(15)
-        expect(http).to receive(:read_timeout=).with(15)
+    context 'when http method is POST' do
+      let(:http_method) { :post }
 
-        header = { 'X-Request-Id' => 'fake-uuid' }
-        http_response = instance_double(Net::HTTPOK, body: body, header: header, code: code)
+      before do
         expect(http).to receive(:post).with(
           endpoint_path,
-          "{\"fake\":\"hash\",\"test_suite_token\":\"3fa64859337f6e56409d49f865d13fd7\"}",
+          request_hash.to_json,
           {
             'Content-Type' => 'application/json',
             'Accept' => 'application/json',
             'KNAPSACK-PRO-CLIENT-NAME' => 'knapsack_pro-ruby',
             'KNAPSACK-PRO-CLIENT-VERSION' => KnapsackPro::VERSION,
+            'KNAPSACK-PRO-TEST-SUITE-TOKEN' => test_suite_token,
           }
         ).and_return(http_response)
       end
 
-      context 'when body response is json and API response code is 400' do
-        let(:body) { '{"errors": "value"}' }
-        let(:code) { '400' } # it must be string code
-
-        before do
-          expect(KnapsackPro).to receive(:logger).exactly(3).and_return(logger)
-          expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
-          expect(logger).to receive(:debug).with('API response:')
-        end
-
-        it do
-          parsed_response = { 'errors' => 'value' }
-
-          expect(logger).to receive(:error).with(parsed_response)
-
-          expect(subject).to eq(parsed_response)
-          expect(connection.success?).to be true
-          expect(connection.errors?).to be true
-        end
+      it_behaves_like 'when request got response from API' do
+        let(:expected_http_method) { 'POST' }
       end
+    end
 
-      context 'when body response is json with build_distribution_id' do
-        let(:body) { '{"build_distribution_id": "seed-uuid"}' }
-        let(:code) { '200' } # it must be string code
-
-        before do
-          expect(KnapsackPro).to receive(:logger).exactly(4).and_return(logger)
-          expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
-          expect(logger).to receive(:debug).with("Test suite split seed: seed-uuid")
-          expect(logger).to receive(:debug).with('API response:')
-        end
-
-        it do
-          parsed_response = { 'build_distribution_id' => 'seed-uuid' }
-
-          expect(logger).to receive(:debug).with(parsed_response)
+    context 'when http method is GET' do
+      let(:http_method) { :get }
 
-          expect(subject).to eq(parsed_response)
-          expect(connection.success?).to be true
-          expect(connection.errors?).to be false
-        end
+      before do
+        uri = URI.parse("http://api.knapsackpro.test:3000#{endpoint_path}")
+        uri.query = URI.encode_www_form(request_hash)
+        expect(http).to receive(:get).with(
+          uri,
+          {
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json',
+            'KNAPSACK-PRO-CLIENT-NAME' => 'knapsack_pro-ruby',
+            'KNAPSACK-PRO-CLIENT-VERSION' => KnapsackPro::VERSION,
+            'KNAPSACK-PRO-TEST-SUITE-TOKEN' => test_suite_token,
+          }
+        ).and_return(http_response)
       end
 
-      context 'when body response is empty' do
-        let(:body) { '' }
-        let(:code) { '200' } # it must be string code
-
-        before do
-          expect(KnapsackPro).to receive(:logger).exactly(3).and_return(logger)
-          expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
-          expect(logger).to receive(:debug).with('API response:')
-        end
-
-        it do
-          expect(logger).to receive(:debug).with('')
-
-          expect(subject).to eq('')
-          expect(connection.success?).to be true
-          expect(connection.errors?).to be false
-        end
+      it_behaves_like 'when request got response from API' do
+        let(:expected_http_method) { 'GET' }
       end
     end
 
     context 'when retry request for http method POST' do
-      before do
-        http = instance_double(Net::HTTP)
+      let(:http_method) { :post }
 
-        expect(Net::HTTP).to receive(:new).exactly(3).with('api.knapsackpro.test', 3000).and_return(http)
-
-        expect(http).to receive(:use_ssl=).exactly(3).with(false)
-        expect(http).to receive(:open_timeout=).exactly(3).with(15)
-        expect(http).to receive(:read_timeout=).exactly(3).with(15)
-
-        header = { 'X-Request-Id' => 'fake-uuid' }
-        http_response = instance_double(Net::HTTPOK, body: body, header: header, code: code)
+      before do
         expect(http).to receive(:post).exactly(3).with(
           endpoint_path,
-          "{\"fake\":\"hash\",\"test_suite_token\":\"3fa64859337f6e56409d49f865d13fd7\"}",
+          request_hash.to_json,
           {
             'Content-Type' => 'application/json',
             'Accept' => 'application/json',
             'KNAPSACK-PRO-CLIENT-NAME' => 'knapsack_pro-ruby',
             'KNAPSACK-PRO-CLIENT-VERSION' => KnapsackPro::VERSION,
+            'KNAPSACK-PRO-TEST-SUITE-TOKEN' => test_suite_token,
           }
         ).and_return(http_response)
       end
 
-      context 'when body response is json and API response code is 500' do
-        let(:body) { '{"error": "Internal Server Error"}' }
-        let(:code) { '500' } # it must be string code
-
-        before do
-          expect(KnapsackPro).to receive(:logger).at_least(1).and_return(logger)
-          expect(logger).to receive(:debug).exactly(3).with('API request UUID: fake-uuid')
-          expect(logger).to receive(:debug).exactly(3).with('API response:')
-        end
-
-        it do
-          parsed_response = { 'error' => 'Internal Server Error' }
-
-          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(server_error.inspect)
+      it_behaves_like 'when retry request' do
+        let(:expected_http_method) { 'POST' }
+      end
+    end
 
-          expect(logger).to receive(:warn).with("Wait 4s and retry request to Knapsack Pro API.")
-          expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
-          expect(Kernel).to receive(:sleep).with(4)
-          expect(Kernel).to receive(:sleep).with(8)
+    context 'when retry request for http method GET' do
+      let(:http_method) { :get }
 
-          expect(subject).to eq(parsed_response)
+      before do
+        uri = URI.parse("http://api.knapsackpro.test:3000#{endpoint_path}")
+        uri.query = URI.encode_www_form(request_hash)
+        expect(http).to receive(:get).exactly(3).with(
+          uri,
+          {
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json',
+            'KNAPSACK-PRO-CLIENT-NAME' => 'knapsack_pro-ruby',
+            'KNAPSACK-PRO-CLIENT-VERSION' => KnapsackPro::VERSION,
+            'KNAPSACK-PRO-TEST-SUITE-TOKEN' => test_suite_token,
+          }
+        ).and_return(http_response)
+      end
 
-          expect(connection.success?).to be false
-          expect(connection.errors?).to be true
-        end
+      it_behaves_like 'when retry request' do
+        let(:expected_http_method) { 'GET' }
       end
     end
   end