knapsack_pro 6.0.4 → 7.0.0

data/spec/knapsack_pro/adapters/base_adapter_spec.rb

@@ -159,7 +159,7 @@ describe KnapsackPro::Adapters::BaseAdapter do
       it do
         logger = instance_double(Logger)
         expect(KnapsackPro).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:debug).with('Test suite time execution recording enabled.')
+        expect(logger).to receive(:debug).with('Regular Mode enabled.')
       end
       it { expect(subject).to receive(:bind_time_tracker) }
       it { expect(subject).to receive(:bind_save_report) }
@@ -168,24 +168,22 @@ describe KnapsackPro::Adapters::BaseAdapter do
     context 'when queue recording enabled' do
       let(:queue_recording_enabled?) { true }
 
-      before do
-        allow(subject).to receive(:bind_before_queue_hook)
-        allow(subject).to receive(:bind_time_tracker)
-      end
-
-      it do
+      it 'calls queue hooks in proper order before binding time tracker' do
         logger = instance_double(Logger)
         expect(KnapsackPro).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:debug).with('Test suite time execution queue recording enabled.')
+        expect(logger).to receive(:debug).with('Queue Mode enabled.')
+
+        expect(subject).to receive(:bind_before_queue_hook).ordered
+        expect(subject).to receive(:bind_after_queue_hook).ordered
+        expect(subject).to receive(:bind_time_tracker).ordered
       end
-      it { expect(subject).to receive(:bind_before_queue_hook) }
-      it { expect(subject).to receive(:bind_time_tracker) }
     end
 
     context 'when recording disabled' do
-      it { expect(subject).not_to receive(:bind_time_tracker) }
       it { expect(subject).not_to receive(:bind_save_report) }
       it { expect(subject).not_to receive(:bind_before_queue_hook) }
+      it { expect(subject).not_to receive(:bind_after_queue_hook) }
+      it { expect(subject).not_to receive(:bind_time_tracker) }
     end
   end
 
@@ -212,4 +210,12 @@ describe KnapsackPro::Adapters::BaseAdapter do
       }.to raise_error(NotImplementedError)
     end
   end
+
+  describe '#bind_after_queue_hook' do
+    it do
+      expect {
+        subject.bind_after_queue_hook
+      }.to raise_error(NotImplementedError)
+    end
+  end
 end

data/spec/knapsack_pro/adapters/cucumber_adapter_spec.rb

@@ -203,16 +203,13 @@ describe KnapsackPro::Adapters::CucumberAdapter do
       end
     end
 
-    describe '#bind_queue_mode' do
+    describe '#bind_after_queue_hook' do
       it do
-        expect(subject).to receive(:bind_before_queue_hook)
-        expect(subject).to receive(:bind_time_tracker)
-
         expect(::Kernel).to receive(:at_exit).and_yield
         expect(KnapsackPro::Hooks::Queue).to receive(:call_after_subset_queue)
         expect(KnapsackPro::Report).to receive(:save_subset_queue_to_file)
 
-        subject.bind_queue_mode
+        subject.bind_after_queue_hook
       end
     end
   end

data/spec/knapsack_pro/adapters/rspec_adapter_spec.rb

@@ -341,24 +341,13 @@ describe KnapsackPro::Adapters::RSpecAdapter do
       end
 
       context 'with no focus' do
-        let(:logger) { instance_double(Logger) }
-        let(:duration) { 65 }
-        let(:global_time) { 'Global time execution for tests: 01m 05s' }
-        let(:time_tracker) { instance_double(KnapsackPro::Formatters::TimeTracker) }
-
         it 'records time for current test path' do
           expect(config).to receive(:around).with(:each).and_yield(current_example)
-          expect(config).to receive(:after).with(:suite).and_yield
-          expect(::RSpec).to receive(:configure).twice.and_yield(config)
+          expect(config).to receive(:append_after).with(:suite)
+          expect(::RSpec).to receive(:configure).at_least(1).and_yield(config)
 
           expect(current_example).to receive(:run)
 
-          expect(time_tracker).to receive(:batch_duration).and_return(duration)
-          expect(KnapsackPro::Formatters::TimeTrackerFetcher).to receive(:call).and_return(time_tracker)
-
-          expect(KnapsackPro).to receive(:logger).and_return(logger)
-          expect(logger).to receive(:debug).with(global_time)
-
           subject.bind_time_tracker
         end
       end
@@ -378,16 +367,5 @@ describe KnapsackPro::Adapters::RSpecAdapter do
         subject.bind_save_report
       end
     end
-
-    describe '#bind_before_queue_hook' do
-      it do
-        expect(config).to receive(:before).with(:suite).and_yield
-        expect(::RSpec).to receive(:configure).and_yield(config)
-
-        expect(KnapsackPro::Hooks::Queue).to receive(:call_before_queue)
-
-        subject.bind_before_queue_hook
-      end
-    end
   end
 end

data/spec/knapsack_pro/config/env_spec.rb

@@ -511,40 +511,6 @@ describe KnapsackPro::Config::Env do
     end
   end
 
-  describe '.modify_default_rspec_formatters' do
-    subject { described_class.modify_default_rspec_formatters }
-
-    context 'when ENV exists' do
-      let(:modify_default_rspec_formatters) { 'false' }
-      before { stub_const("ENV", { 'KNAPSACK_PRO_MODIFY_DEFAULT_RSPEC_FORMATTERS' => modify_default_rspec_formatters }) }
-      it { should eq modify_default_rspec_formatters }
-    end
-
-    context "when ENV doesn't exist" do
-      it { should be true }
-    end
-  end
-
-  describe '.modify_default_rspec_formatters?' do
-    subject { described_class.modify_default_rspec_formatters? }
-
-    before do
-      expect(described_class).to receive(:modify_default_rspec_formatters).and_return(modify_default_rspec_formatters)
-    end
-
-    context 'when enabled' do
-      let(:modify_default_rspec_formatters) { true }
-
-      it { should be true }
-    end
-
-    context 'when disabled' do
-      let(:modify_default_rspec_formatters) { false }
-
-      it { should be false }
-    end
-  end
-
   describe '.branch_encrypted' do
     subject { described_class.branch_encrypted }
 
@@ -975,7 +941,7 @@ describe KnapsackPro::Config::Env do
     end
 
     context "when ENV doesn't exist" do
-      it { should eql ::Logger::DEBUG }
+      it { should eql ::Logger::INFO }
     end
   end
 

data/spec/knapsack_pro/formatters/time_tracker_specs.rb

@@ -4,6 +4,7 @@
 require 'rspec/core'
 require 'knapsack_pro'
 require 'stringio'
+require 'tempfile'
 require_relative '../../../lib/knapsack_pro/formatters/time_tracker'
 
 class TestTimeTracker
@@ -327,24 +328,6 @@ class TestTimeTracker
     end
   end
 
-  def test_batch_duration
-    KnapsackPro::Formatters::TimeTracker.define_method(:rspec_split_by_test_example?) do |_file|
-      false
-    end
-
-    spec = <<~SPEC
-      describe "KnapsackPro::Formatters::TimeTracker" do
-        it do
-          expect(1).to eq 1
-        end
-      end
-    SPEC
-
-    run_specs(spec) do |_, _, time_tracker|
-      raise unless time_tracker.batch_duration > 0.0
-    end
-  end
-
   def test_unexecuted_test_files
     KnapsackPro::Formatters::TimeTracker.define_method(:rspec_split_by_test_example?) do |_file|
       false
@@ -372,14 +355,6 @@ class TestTimeTracker
     KnapsackPro::Formatters::TimeTracker.define_method(:rspec_split_by_test_example?) do |_file|
       false
     end
-    KnapsackPro::Formatters::TimeTracker.class_eval do
-      alias_method :original_stop, :stop
-
-      # In Regular Mode, #subset is called before #stop.
-      # This test makes #stop a noop to simulate that behavior.
-      define_method(:stop) do |_|
-      end
-    end
 
     spec = <<~SPEC
       describe "KnapsackPro::Formatters::TimeTracker" do
@@ -401,23 +376,20 @@ class TestTimeTracker
       raise unless files[0]["time_execution"] > 0.10
       raise unless files[0]["time_execution"] < 0.15
     end
-
-  ensure
-    KnapsackPro::Formatters::TimeTracker.class_eval do
-      undef :stop
-      alias_method :stop, :original_stop
-    end
   end
 
   private
 
   def run_specs(specs)
-    paths = Array(specs).map.with_index do |spec, i|
-      path = "spec/knapsack_pro/formatters/#{i}_#{SecureRandom.uuid}_spec.rb"
-      File.open(path, 'w') { |file| file.write(spec) }
-      path
+    files = Array(specs).map.with_index do |spec, i|
+      file = Tempfile.new(["time_tracker_#{i}", "_spec.rb"], "./spec/knapsack_pro/formatters/")
+      file.write(spec)
+      file.rewind
+      file
     end
 
+    paths = files.map(&:path).map { _1.sub("./", "") }
+
     options = ::RSpec::Core::ConfigurationOptions.new([
       "--format", KnapsackPro::Formatters::TimeTracker.to_s,
       *paths,
@@ -436,7 +408,6 @@ class TestTimeTracker
     yield(paths, times, time_tracker)
 
   ensure
-    paths.each { |path| File.delete(path) }
     # Need to reset because RSpec keeps reusing the same instance.
     time_tracker.instance_variable_set(:@queue, {}) if time_tracker
     time_tracker.instance_variable_set(:@started, time_tracker.send(:now)) if time_tracker

data/spec/knapsack_pro/hooks/queue_spec.rb

@@ -93,8 +93,8 @@ describe KnapsackPro::Hooks::Queue do
       let(:subset_queue_id) { double }
 
       before do
-        expect(KnapsackPro::Config::Env).to receive(:queue_id).twice.and_return(queue_id)
-        expect(KnapsackPro::Config::Env).to receive(:subset_queue_id).twice.and_return(subset_queue_id)
+        expect(KnapsackPro::Config::Env).to receive(:queue_id).at_least(:once).and_return(queue_id)
+        expect(KnapsackPro::Config::Env).to receive(:subset_queue_id).at_least(:once).and_return(subset_queue_id)
 
         $expected_called_blocks = []
 

data/spec/knapsack_pro/presenter_spec.rb

@@ -8,7 +8,7 @@ describe KnapsackPro::Presenter do
       expect(KnapsackPro).to receive(:tracker).and_return(tracker)
     end
 
-    it { should eql "Global time execution for tests: 01h 02m 03s" }
+    it { should eql "Global test execution duration: 01h 02m 03s" }
   end
 
   describe '.pretty_seconds' do

data/spec/knapsack_pro/pure/queue/rspec_pure_spec.rb

@@ -0,0 +1,224 @@
+require(KnapsackPro.root + '/lib/knapsack_pro/formatters/time_tracker')
+require(KnapsackPro.root + '/lib/knapsack_pro/extensions/rspec_extension')
+
+describe KnapsackPro::Pure::Queue::RSpecPure do
+  let(:rspec_pure) { described_class.new }
+
+  describe '#add_knapsack_pro_formatters_to' do
+    subject { rspec_pure.add_knapsack_pro_formatters_to(spec_opts) }
+
+    context 'when no spec_opts' do
+      let(:spec_opts) { nil }
+
+      it 'returns no spec_opts' do
+        expect(subject).to be nil
+      end
+    end
+
+    context 'when spec_opts have Knapsack Pro formatters' do
+      let(:spec_opts) { '--color --format d --format KnapsackPro::Formatters::TimeTracker' }
+
+      it 'returns spec_opts' do
+        expect(subject).to eq spec_opts
+      end
+    end
+
+    context 'when spec_opts have no Knapsack Pro formatters' do
+      let(:spec_opts) { '--color --format d' }
+
+      it 'returns spec_opts with added Knapsack Pro formatters' do
+        expect(subject).to eq '--color --format d --format KnapsackPro::Formatters::TimeTracker'
+      end
+    end
+  end
+
+  describe '#error_exit_code' do
+    subject { rspec_pure.error_exit_code(rspec_error_exit_code) }
+
+    context 'when RSpec has no defined error exit code' do
+      let(:rspec_error_exit_code) { nil }
+
+      it 'returns 1 as the default exit code' do
+        expect(subject).to eq 1
+      end
+    end
+
+    context 'when RSpec has a defined error exit code' do
+      let(:rspec_error_exit_code) { 2 }
+
+      it 'returns the custom exit code' do
+        expect(subject).to eq rspec_error_exit_code
+      end
+    end
+  end
+
+  describe '#args_with_seed_option_added_when_viable' do
+    let(:order_option) { KnapsackPro::Adapters::RSpecAdapter.order_option(args) }
+
+    subject { rspec_pure.args_with_seed_option_added_when_viable(order_option, seed, args) }
+
+    context 'when the order option is not random' do
+      let(:args) { ['--order', 'defined'] }
+      let(:seed) { KnapsackPro::Extensions::RSpecExtension::Seed.new(value: nil, used?: false) }
+
+      it 'does not add the seed option to args' do
+        expect(subject).to eq ['--order', 'defined']
+      end
+    end
+
+    ['random', 'rand'].each do |random_option_value|
+      context "when the order option is `#{random_option_value}`" do
+        let(:args) { ['--order', random_option_value] }
+
+        context 'when the seed is not used' do
+          let(:seed) { KnapsackPro::Extensions::RSpecExtension::Seed.new(value: '123', used?: false) }
+
+          it 'does not add the seed option to args' do
+            expect(subject).to eq ['--order', random_option_value]
+          end
+        end
+
+        context 'when the seed is used' do
+          let(:seed) { KnapsackPro::Extensions::RSpecExtension::Seed.new(value: '123', used?: true) }
+
+          it 'adds the seed option to args' do
+            expect(subject).to eq ['--order', random_option_value, '--seed', '123']
+          end
+        end
+      end
+    end
+
+    context 'when the order option is `rand:123`' do
+      let(:args) { ['--order', 'rand:123'] }
+      let(:seed) { KnapsackPro::Extensions::RSpecExtension::Seed.new(value: '123', used?: true) }
+
+      it 'does not add the seed option to args' do
+        expect(subject).to eq ['--order', 'rand:123']
+      end
+    end
+
+    context 'when the order option is not set in args AND seed is used' do
+      let(:args) { ['--format', 'documentation'] }
+      let(:seed) { KnapsackPro::Extensions::RSpecExtension::Seed.new(value: '123', used?: true) }
+
+      it 'adds the seed option to args' do
+        expect(subject).to eq ['--format', 'documentation', '--seed', '123']
+      end
+    end
+
+    context 'when the order option is not set in args AND seed is not used' do
+      let(:args) { ['--format', 'documentation'] }
+      let(:seed) { KnapsackPro::Extensions::RSpecExtension::Seed.new(value: '123', used?: false) }
+
+      it 'does not add the seed option to args' do
+        expect(subject).to eq ['--format', 'documentation']
+      end
+    end
+  end
+
+  describe '#prepare_cli_args' do
+    subject { rspec_pure.prepare_cli_args(args, has_format_option, test_dir) }
+
+    context 'when no args' do
+      let(:args) { nil }
+      let(:has_format_option) { false }
+      let(:test_dir) { 'spec' }
+
+      it 'adds the default progress formatter and the default path and the time tracker formatter' do
+        expect(subject).to eq [
+          '--format', 'progress',
+          '--default-path', 'spec',
+          '--format', 'KnapsackPro::Formatters::TimeTracker',
+        ]
+      end
+    end
+
+    context 'when args are present and a custom test directory is set' do
+      let(:args) { '--color --profile' }
+      let(:has_format_option) { false }
+      let(:test_dir) { 'custom_spec_dir' }
+
+      it do
+        expect(subject).to eq [
+          '--color',
+          '--profile',
+          '--format', 'progress',
+          '--default-path', 'custom_spec_dir',
+          '--format', 'KnapsackPro::Formatters::TimeTracker',
+        ]
+      end
+    end
+
+    context 'when args are present and has format option' do
+      let(:args) { '--color --profile --format d' }
+      let(:has_format_option) { true }
+      let(:test_dir) { 'spec' }
+
+      it 'uses the format option from args instead of the default formatter' do
+        expect(subject).to eq [
+          '--color',
+          '--profile',
+          '--format', 'd',
+          '--default-path', 'spec',
+          '--format', 'KnapsackPro::Formatters::TimeTracker',
+        ]
+      end
+    end
+  end
+
+  describe '#rspec_command' do
+    let(:args) { ['--format', 'documentation'] }
+    let(:test_file_paths) { ['a_spec.rb', 'b_spec.rb'] }
+
+    subject { rspec_pure.rspec_command(args, test_file_paths, scope) }
+
+    context 'when there are no test file paths' do
+      let(:scope) { :queue_finished }
+      let(:test_file_paths) { [] }
+
+      it 'returns no messages' do
+        expect(subject).to eq []
+      end
+    end
+
+    context 'when a subset of queue (a batch of tests fetched from the Queue API)' do
+      let(:scope) { :batch_finished }
+
+      it 'returns messages with the RSpec command' do
+        expect(subject).to eq([
+          'To retry the last batch of tests fetched from the Queue API, please run the following command on your machine:',
+          'bundle exec rspec --format documentation "a_spec.rb" "b_spec.rb"',
+        ])
+      end
+    end
+
+    context 'when all tests fetched from the Queue API' do
+      let(:scope) { :queue_finished }
+
+      it 'returns messages with the RSpec command' do
+        expect(subject).to eq([
+          'To retry all the tests assigned to this CI node, please run the following command on your machine:',
+          'bundle exec rspec --format documentation "a_spec.rb" "b_spec.rb"',
+        ])
+      end
+    end
+
+    describe '#exit_summary' do
+      subject { rspec_pure.exit_summary(unexecuted_test_files) }
+
+      context 'when there are no unexecuted test files' do
+        let(:unexecuted_test_files) { [] }
+
+        it { expect(subject).to be_nil }
+      end
+
+      context 'when there are unexecuted test files' do
+        let(:unexecuted_test_files) { ['b_spec.rb', 'c_spec.rb'] }
+
+        it 'returns a warning message' do
+          expect(subject).to eq 'Unexecuted tests on this CI node (including pending tests): b_spec.rb c_spec.rb'
+        end
+      end
+    end
+  end
+end

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

@@ -24,7 +24,7 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
       expect(described_class).to receive(:new).with(KnapsackPro::Adapters::CucumberAdapter).and_return(runner)
     end
 
-    context 'when args provided' do
+    context 'when args are provided' do
       let(:args) { '--retry 5 --no-strict-flaky' }
 
       it do
@@ -39,7 +39,7 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
           can_initialize_queue: true,
           args: args,
           exitstatus: 0,
-          all_test_file_paths: [],
+          node_test_file_paths: [],
         }
         expect(described_class).to receive(:handle_signal!)
         expect(described_class).to receive(:run_tests).with(accumulator).and_return(expected_accumulator)
@@ -50,7 +50,7 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
       end
     end
 
-    context 'when args not provided' do
+    context 'when args are not provided' do
       let(:args) { nil }
 
       it do
@@ -65,7 +65,7 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
           can_initialize_queue: true,
           args: nil,
           exitstatus: 0,
-          all_test_file_paths: [],
+          node_test_file_paths: [],
         }
         expect(described_class).to receive(:handle_signal!)
         expect(described_class).to receive(:run_tests).with(accumulator).and_return(expected_accumulator)
@@ -85,21 +85,21 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
     let(:can_initialize_queue) { double(:can_initialize_queue) }
     let(:args) { '--retry 5 --no-strict-flaky' }
     let(:exitstatus) { 0 }
-    let(:all_test_file_paths) { [] }
+    let(:node_test_file_paths) { [] }
     let(:accumulator) do
       {
         runner: runner,
         can_initialize_queue: can_initialize_queue,
         args: args,
         exitstatus: exitstatus,
-        all_test_file_paths: all_test_file_paths,
+        node_test_file_paths: node_test_file_paths,
       }
     end
 
     subject { described_class.run_tests(accumulator) }
 
     before do
-      expect(runner).to receive(:test_file_paths).with(can_initialize_queue: can_initialize_queue, executed_test_files: all_test_file_paths).and_return(test_file_paths)
+      expect(runner).to receive(:test_file_paths).with(can_initialize_queue: can_initialize_queue, executed_test_files: node_test_file_paths).and_return(test_file_paths)
     end
 
     context 'when test files exist' do
@@ -129,7 +129,7 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
         allow(child_status).to receive(:exitstatus).and_return(exitstatus)
       end
 
-      context 'when system process finished its work (exited)' do
+      context 'when system process finished (exited)' do
         let(:process_exited) { true }
 
         context 'when tests are passing' do
@@ -142,7 +142,7 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
               can_initialize_queue: false,
               args: args,
               exitstatus: exitstatus,
-              all_test_file_paths: test_file_paths,
+              node_test_file_paths: test_file_paths,
             })
           end
         end
@@ -157,13 +157,13 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
               can_initialize_queue: false,
               args: args,
               exitstatus: 1, # tests failed
-              all_test_file_paths: test_file_paths,
+              node_test_file_paths: test_file_paths,
             })
           end
         end
       end
 
-      context "when system process didn't finish its work (hasn't exited)" do
+      context 'when system process did not finish (it has not exited)' do
         let(:process_exited) { false }
 
         it 'raises an error' do
@@ -172,11 +172,11 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
       end
     end
 
-    context "when test files don't exist" do
+    context 'when test files do not exist' do
       let(:test_file_paths) { [] }
 
-      context 'when all_test_file_paths exist' do
-        let(:all_test_file_paths) { ['features/a.feature'] }
+      context 'when node_test_file_paths exists' do
+        let(:node_test_file_paths) { ['features/a.feature'] }
 
         it 'returns exit code 0' do
           expect(KnapsackPro::Adapters::CucumberAdapter).to receive(:verify_bind_method_called)
@@ -191,8 +191,8 @@ describe KnapsackPro::Runners::Queue::CucumberRunner do
         end
       end
 
-      context "when all_test_file_paths don't exist" do
-        let(:all_test_file_paths) { [] }
+      context 'when node_test_file_paths do not exist' do
+        let(:node_test_file_paths) { [] }
 
         it 'returns exit code 0' do
           expect(KnapsackPro::Hooks::Queue).to receive(:call_after_queue)