knapsack_pro 1.20.1 → 1.22.2

data/lib/knapsack_pro/test_files_with_test_cases_composer.rb

@@ -0,0 +1,22 @@
+module KnapsackPro
+  class TestFilesWithTestCasesComposer
+    # Args:
+    #   All 3 arguments have structure: [{ 'path' => 'spec/a_spec.rb', 'time_execution' => 0.0 }]
+    #   time_execution is not always present (but it's not relevant here)
+    #
+    #   test_files - list of test files that you want to run tests for
+    #   slow_test_files - list of slow test files that should be split by test cases
+    #   test_file_cases - list of paths to test cases (test examples) inside of all slow test files (slow_test_files)
+    # Return:
+    #   Test files and test cases paths (it excludes test files that should be split by test cases (test examples))
+    def self.call(test_files, slow_test_files, test_file_cases)
+      slow_test_file_paths = KnapsackPro::TestFilePresenter.paths(slow_test_files)
+
+      test_files_without_slow_test_files = test_files.reject do |test_file|
+        slow_test_file_paths.include?(test_file.fetch('path'))
+      end
+
+      test_files_without_slow_test_files + test_file_cases
+    end
+  end
+end

data/lib/knapsack_pro/version.rb

@@ -1,3 +1,3 @@
 module KnapsackPro
-  VERSION = '1.20.1'
+  VERSION = '1.22.2'
 end

data/spec/knapsack_pro/adapters/base_adapter_spec.rb

@@ -3,6 +3,61 @@ describe KnapsackPro::Adapters::BaseAdapter do
     expect(described_class::TEST_DIR_PATTERN).to eq 'test/**{,/*/**}/*_test.rb'
   end
 
+  shared_examples '.slow_test_file? method' do
+    context 'when test_file_path is in slow test file paths' do
+      # add ./ before path to ensure KnapsackPro::TestFileCleaner.clean will clean it
+      let(:test_file_path) { './spec/models/user_spec.rb' }
+
+      it do
+        expect(subject).to be true
+      end
+    end
+
+    context 'when test_file_path is not in slow test file paths' do
+      let(:test_file_path) { './spec/models/article_spec.rb' }
+
+      it do
+        expect(subject).to be false
+      end
+    end
+  end
+
+  describe '.slow_test_file?' do
+    let(:adapter_class) { double }
+    let(:slow_test_files) do
+      [
+        { 'path' => 'spec/models/user_spec.rb' },
+        { 'path' => 'spec/controllers/users_spec.rb' },
+      ]
+    end
+
+    subject { described_class.slow_test_file?(adapter_class, test_file_path) }
+
+    before do
+      # reset class variable
+      described_class.instance_variable_set(:@slow_test_file_paths, nil)
+    end
+
+    context 'when slow test file pattern is present' do
+      before do
+        stub_const('ENV', {
+          'KNAPSACK_PRO_SLOW_TEST_FILE_PATTERN' => '{spec/models/*_spec.rb}',
+        })
+        expect(KnapsackPro::TestFileFinder).to receive(:slow_test_files_by_pattern).with(adapter_class).and_return(slow_test_files)
+      end
+
+      it_behaves_like '.slow_test_file? method'
+    end
+
+    context 'when slow test file pattern is not present' do
+      before do
+        expect(KnapsackPro::SlowTestFileDeterminer).to receive(:read_from_json_report).and_return(slow_test_files)
+      end
+
+      it_behaves_like '.slow_test_file? method'
+    end
+  end
+
   describe '.bind' do
     let(:adapter) { instance_double(described_class) }
 

data/spec/knapsack_pro/adapters/rspec_adapter_spec.rb

@@ -71,22 +71,21 @@ describe KnapsackPro::Adapters::RSpecAdapter do
       let(:tracker) { instance_double(KnapsackPro::Tracker) }
       let(:logger) { instance_double(Logger) }
       let(:global_time) { 'Global time: 01m 05s' }
+      let(:test_path) { 'spec/a_spec.rb' }
+      let(:example) { double }
+      let(:example_group) { double }
+      let(:current_example) do
+        OpenStruct.new(metadata: {
+          example_group: example_group
+        })
+      end
 
       context 'when rspec split by test examples is disabled' do
-        let(:test_path) { 'spec/a_spec.rb' }
-        let(:example) { double }
-        let(:example_group) { double }
-        let(:current_example) do
-          OpenStruct.new(metadata: {
-            example_group: example_group
-          })
-        end
-
         before do
           expect(KnapsackPro::Config::Env).to receive(:rspec_split_by_test_examples?).and_return(false)
         end
 
-        it do
+        it 'records time for current test path' do
           expect(config).to receive(:around).with(:each).and_yield(example)
           expect(config).to receive(:after).with(:suite).and_yield
           expect(::RSpec).to receive(:configure).and_yield(config)
@@ -112,32 +111,69 @@ describe KnapsackPro::Adapters::RSpecAdapter do
 
       context 'when rspec split by test examples is enabled' do
         let(:test_example_path) { 'spec/a_spec.rb[1:1]' }
-        let(:example) { double }
 
         before do
           expect(KnapsackPro::Config::Env).to receive(:rspec_split_by_test_examples?).and_return(true)
         end
 
-        it do
-          expect(config).to receive(:around).with(:each).and_yield(example)
-          expect(config).to receive(:after).with(:suite).and_yield
-          expect(::RSpec).to receive(:configure).and_yield(config)
+        context 'when current test_path is a slow test file' do
+          before do
+            expect(described_class).to receive(:slow_test_file?).with(described_class, test_path).and_return(true)
+          end
 
-          expect(example).to receive(:id).and_return(test_example_path)
+          it 'records time for example.id' do
+            expect(example).to receive(:id).and_return(test_example_path)
 
-          allow(KnapsackPro).to receive(:tracker).and_return(tracker)
-          expect(tracker).to receive(:current_test_path=).with(test_example_path)
-          expect(tracker).to receive(:start_timer)
+            expect(config).to receive(:around).with(:each).and_yield(example)
+            expect(config).to receive(:after).with(:suite).and_yield
+            expect(::RSpec).to receive(:configure).and_yield(config)
 
-          expect(example).to receive(:run)
+            expect(::RSpec).to receive(:current_example).twice.and_return(current_example)
+            expect(described_class).to receive(:test_path).with(example_group).and_return(test_path)
 
-          expect(tracker).to receive(:stop_timer)
+            allow(KnapsackPro).to receive(:tracker).and_return(tracker)
+            expect(tracker).to receive(:current_test_path=).with(test_example_path)
+            expect(tracker).to receive(:start_timer)
 
-          expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
-          expect(KnapsackPro).to receive(:logger).and_return(logger)
-          expect(logger).to receive(:debug).with(global_time)
+            expect(example).to receive(:run)
 
-          subject.bind_time_tracker
+            expect(tracker).to receive(:stop_timer)
+
+            expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
+            expect(KnapsackPro).to receive(:logger).and_return(logger)
+            expect(logger).to receive(:debug).with(global_time)
+
+            subject.bind_time_tracker
+          end
+        end
+
+        context 'when current test_path is not a slow test file' do
+          before do
+            expect(described_class).to receive(:slow_test_file?).with(described_class, test_path).and_return(false)
+          end
+
+          it 'records time for current test path' do
+            expect(config).to receive(:around).with(:each).and_yield(example)
+            expect(config).to receive(:after).with(:suite).and_yield
+            expect(::RSpec).to receive(:configure).and_yield(config)
+
+            expect(::RSpec).to receive(:current_example).twice.and_return(current_example)
+            expect(described_class).to receive(:test_path).with(example_group).and_return(test_path)
+
+            allow(KnapsackPro).to receive(:tracker).and_return(tracker)
+            expect(tracker).to receive(:current_test_path=).with(test_path)
+            expect(tracker).to receive(:start_timer)
+
+            expect(example).to receive(:run)
+
+            expect(tracker).to receive(:stop_timer)
+
+            expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
+            expect(KnapsackPro).to receive(:logger).and_return(logger)
+            expect(logger).to receive(:debug).with(global_time)
+
+            subject.bind_time_tracker
+          end
         end
       end
     end

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