knapsack_pro 2.10.0 → 2.14.0

data/spec/knapsack_pro/queue_allocator_builder_spec.rb

@@ -8,11 +8,11 @@ describe KnapsackPro::QueueAllocatorBuilder do
     subject { allocator_builder.allocator }
 
     before do
-      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)
+      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_fallback_mode_test_files = double
-      expect(allocator_builder).to receive(:lazy_fallback_mode_test_files).and_return(lazy_fallback_mode_test_files)
+      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)
@@ -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(
-        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,
+        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,
         ci_node_build_id: ci_node_build_id,

data/spec/knapsack_pro/queue_allocator_spec.rb

@@ -1,8 +1,6 @@
 describe KnapsackPro::QueueAllocator do
-  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(: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(:ci_node_build_id) { double }
@@ -10,8 +8,8 @@ describe KnapsackPro::QueueAllocator do
 
   let(:queue_allocator) do
     described_class.new(
-      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,
+      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,
       ci_node_build_id: ci_node_build_id,
@@ -66,7 +64,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(lazy_loaded_fallback_mode_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' },
@@ -133,32 +131,20 @@ describe KnapsackPro::QueueAllocator 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 }
+              {
+                'test_files' => [
+                  { 'path' => 'a_spec.rb' },
+                  { 'path' => 'b_spec.rb' },
+                ]
+              }
             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'] }
+            before do
+              expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(fast_and_slow_test_files_to_run, response['test_files']).and_call_original
             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
+            it { should eq ['a_spec.rb', 'b_spec.rb'] }
           end
 
           context 'when response has code=ATTEMPT_CONNECT_TO_QUEUE_FAILED' do
@@ -172,7 +158,7 @@ describe KnapsackPro::QueueAllocator do
               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)
+              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.
@@ -212,32 +198,20 @@ describe KnapsackPro::QueueAllocator 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 }
+                    {
+                      'test_files' => [
+                        { 'path' => 'a_spec.rb' },
+                        { 'path' => 'b_spec.rb' },
+                      ]
+                    }
                   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'] }
+                  before do
+                    expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(fast_and_slow_test_files_to_run, response2['test_files']).and_call_original
                   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
+                  it { should eq ['a_spec.rb', 'b_spec.rb'] }
                 end
               end
             end
@@ -304,32 +278,20 @@ describe KnapsackPro::QueueAllocator 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 }
+              {
+                'test_files' => [
+                  { 'path' => 'a_spec.rb' },
+                  { 'path' => 'b_spec.rb' },
+                ]
+              }
             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'] }
+            before do
+              expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(fast_and_slow_test_files_to_run, response['test_files']).and_call_original
             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
+            it { should eq ['a_spec.rb', 'b_spec.rb'] }
           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/tracker_spec.rb

@@ -12,9 +12,7 @@ describe KnapsackPro::Tracker do
     subject { tracker.current_test_path }
 
     context 'when current_test_path not set' do
-      it do
-        expect { subject }.to raise_error("current_test_path needs to be set by Knapsack Pro Adapter's bind method")
-      end
+      it { expect(subject).to be_nil }
     end
 
     context 'when current_test_path set' do
@@ -58,6 +56,9 @@ describe KnapsackPro::Tracker do
       it { expect(tracker.test_files_with_time.keys.size).to eql 2 }
       it { expect(tracker.test_files_with_time['a_spec.rb'][:time_execution]).to be_within(delta).of(0.1) }
       it { expect(tracker.test_files_with_time['b_spec.rb'][:time_execution]).to be_within(delta).of(0.2) }
+      it 'resets current_test_path after time is measured' do
+        expect(tracker.current_test_path).to be_nil
+      end
       it_behaves_like '#to_a'
     end
 
@@ -83,6 +84,9 @@ describe KnapsackPro::Tracker do
       it { expect(tracker.test_files_with_time.keys.size).to eql 2 }
       it { expect(tracker.test_files_with_time['a_spec.rb'][:time_execution]).to be_within(delta).of(0) }
       it { expect(tracker.test_files_with_time['b_spec.rb'][:time_execution]).to be_within(delta).of(0) }
+      it 'resets current_test_path after time is measured' do
+        expect(tracker.current_test_path).to be_nil
+      end
       it_behaves_like '#to_a'
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knapsack_pro
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.14.0
 platform: ruby
 authors:
 - ArturT
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-25 00:00:00.000000000 Z
+date: 2021-04-15 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.