knapsack_pro 9.0.0 → 9.1.0

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

@@ -1,73 +0,0 @@
-describe KnapsackPro::Runners::Queue::BaseRunner do
-  describe '.run' do
-    it do
-      expect {
-        described_class.run(nil)
-      }.to raise_error NotImplementedError
-    end
-  end
-
-  describe '.run_tests' do
-    it do
-      expect {
-        described_class.run_tests(nil, nil, nil, nil)
-      }.to raise_error NotImplementedError
-    end
-  end
-
-  describe 'instance methods' do
-    let(:adapter_class) { double }
-    let(:runner) do
-      described_class.new(adapter_class)
-    end
-    let(:allocator) { instance_double(KnapsackPro::QueueAllocator) }
-    let(:allocator_builder) { instance_double(KnapsackPro::QueueAllocatorBuilder) }
-
-    before do
-      expect(KnapsackPro::QueueAllocatorBuilder).to receive(:new).with(adapter_class).and_return(allocator_builder)
-      expect(allocator_builder).to receive(:allocator).and_return(allocator)
-    end
-
-    describe '#test_file_paths' do
-      subject { runner.test_file_paths(args) }
-
-      context 'when can_initialize_queue flag has value' do
-        let(:can_initialize_queue) { double }
-        let(:executed_test_files) { double }
-        let(:args) do
-          {
-            can_initialize_queue: can_initialize_queue,
-            executed_test_files: executed_test_files,
-          }
-        end
-        let(:test_file_paths) { double }
-
-        before do
-          expect(allocator).to receive(:test_file_paths).with(can_initialize_queue, executed_test_files).and_return(test_file_paths)
-        end
-
-        it { should eq test_file_paths }
-      end
-
-      context 'when can_initialize_queue flag has no value' do
-        let(:args) { {} }
-
-        it do
-          expect { subject }.to raise_error(KeyError)
-        end
-      end
-    end
-
-    describe '#test_dir' do
-      let(:test_dir) { double }
-
-      subject { runner.test_dir }
-
-      before do
-        expect(allocator_builder).to receive(:test_dir).and_return(test_dir)
-      end
-
-      it { should eq test_dir }
-    end
-  end
-end

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

@@ -1,209 +0,0 @@
-describe KnapsackPro::Runners::Queue::CucumberRunner do
-  describe '.run' do
-    let(:test_suite_token_cucumber) { 'fake-token' }
-    let(:queue_id) { 'fake-queue-id' }
-    let(:test_dir) { 'fake-features-dir' }
-    let(:runner) do
-      instance_double(described_class, test_dir: test_dir)
-    end
-
-    subject { described_class.run(args) }
-
-    before do
-      expect(described_class).to receive(:require).with('cucumber/rake/task')
-
-      expect(KnapsackPro::Config::Env).to receive(:test_suite_token_cucumber).and_return(test_suite_token_cucumber)
-      expect(KnapsackPro::Config::EnvGenerator).to receive(:set_queue_id).and_return(queue_id)
-
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_TEST_SUITE_TOKEN', test_suite_token_cucumber)
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_QUEUE_MODE_ENABLED', 'true')
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_QUEUE_ID', queue_id)
-
-      expect(KnapsackPro::Config::Env).to receive(:set_test_runner_adapter).with(KnapsackPro::Adapters::CucumberAdapter)
-
-      expect(described_class).to receive(:new).with(KnapsackPro::Adapters::CucumberAdapter).and_return(runner)
-    end
-
-    context 'when args are provided' do
-      let(:args) { '--retry 5 --no-strict-flaky' }
-
-      it do
-        expected_exitstatus = 0
-        expected_accumulator = {
-          status: :completed,
-          exitstatus: expected_exitstatus
-        }
-        accumulator = {
-          status: :next,
-          runner: runner,
-          can_initialize_queue: true,
-          args: args,
-          exitstatus: 0,
-          node_test_file_paths: [],
-        }
-        expect(described_class).to receive(:handle_signal!)
-        expect(described_class).to receive(:run_tests).with(accumulator).and_return(expected_accumulator)
-
-        expect(Kernel).to receive(:exit).with(expected_exitstatus)
-
-        subject
-      end
-    end
-
-    context 'when args are not provided' do
-      let(:args) { nil }
-
-      it do
-        expected_exitstatus = 0
-        expected_accumulator = {
-          status: :completed,
-          exitstatus: expected_exitstatus
-        }
-        accumulator = {
-          status: :next,
-          runner: runner,
-          can_initialize_queue: true,
-          args: nil,
-          exitstatus: 0,
-          node_test_file_paths: [],
-        }
-        expect(described_class).to receive(:handle_signal!)
-        expect(described_class).to receive(:run_tests).with(accumulator).and_return(expected_accumulator)
-
-        expect(Kernel).to receive(:exit).with(expected_exitstatus)
-
-        subject
-      end
-    end
-  end
-
-  describe '.run_tests' do
-    let(:test_dir) { 'fake-features-dir' }
-    let(:runner) do
-      instance_double(described_class, test_dir: test_dir)
-    end
-    let(:can_initialize_queue) { double(:can_initialize_queue) }
-    let(:args) { '--retry 5 --no-strict-flaky' }
-    let(:exitstatus) { 0 }
-    let(:node_test_file_paths) { [] }
-    let(:accumulator) do
-      {
-        runner: runner,
-        can_initialize_queue: can_initialize_queue,
-        args: args,
-        exitstatus: exitstatus,
-        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: node_test_file_paths).and_return(test_file_paths)
-    end
-
-    context 'when test files exist' do
-      let(:test_file_paths) { ['features/a.feature', 'features/b.feature'] }
-      let(:child_status) { double }
-
-      before do
-        subset_queue_id = 'fake-subset-queue-id'
-        expect(KnapsackPro::Config::EnvGenerator).to receive(:set_subset_queue_id).and_return(subset_queue_id)
-
-        expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_SUBSET_QUEUE_ID', subset_queue_id)
-
-        tracker = instance_double(KnapsackPro::Tracker)
-        expect(KnapsackPro).to receive(:tracker).twice.and_return(tracker)
-        expect(tracker).to receive(:reset!)
-        expect(tracker).to receive(:set_prerun_tests).with(test_file_paths)
-
-        expect(KnapsackPro::Hooks::Queue).to receive(:call_before_subset_queue)
-
-        # .cucumber_run
-        expect(Kernel).to receive(:system).with('bundle exec cucumber --retry 5 --no-strict-flaky --require fake-features-dir -- "features/a.feature" "features/b.feature"')
-
-        expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_BEFORE_QUEUE_HOOK_CALLED', 'true')
-
-        allow(described_class).to receive(:child_status).and_return(child_status)
-        expect(child_status).to receive(:exited?).and_return(process_exited)
-        allow(child_status).to receive(:exitstatus).and_return(exitstatus)
-      end
-
-      context 'when system process finished (exited)' do
-        let(:process_exited) { true }
-
-        context 'when tests are passing' do
-          let(:exitstatus) { 0 }
-
-          it 'returns exit code 0' do
-            expect(subject).to eq({
-              status: :next,
-              runner: runner,
-              can_initialize_queue: false,
-              args: args,
-              exitstatus: exitstatus,
-              node_test_file_paths: test_file_paths,
-            })
-          end
-        end
-
-        context 'when tests are failing' do
-          let(:exitstatus) { 1 }
-
-          it 'returns exit code 1' do
-            expect(subject).to eq({
-              status: :next,
-              runner: runner,
-              can_initialize_queue: false,
-              args: args,
-              exitstatus: 1, # tests failed
-              node_test_file_paths: test_file_paths,
-            })
-          end
-        end
-      end
-
-      context 'when system process did not finish (it has not exited)' do
-        let(:process_exited) { false }
-
-        it 'raises an error' do
-          expect { subject }.to raise_error(RuntimeError, /^Cucumber process execution failed/)
-        end
-      end
-    end
-
-    context 'when test files do not exist' do
-      let(:test_file_paths) { [] }
-
-      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)
-
-          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 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)
-          expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
-
-          expect(subject).to eq({
-            status: :completed,
-            exitstatus: exitstatus,
-          })
-        end
-      end
-    end
-  end
-end

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

@@ -1,203 +0,0 @@
-describe KnapsackPro::Runners::Queue::MinitestRunner do
-  describe '.run' do
-    let(:test_suite_token_minitest) { 'fake-token' }
-    let(:queue_id) { 'fake-queue-id' }
-    let(:test_dir) { 'fake-test-dir' }
-    let(:runner) do
-      instance_double(described_class, test_dir: test_dir)
-    end
-
-    subject { described_class.run(args) }
-
-    before do
-      expect(described_class).to receive(:require).with('minitest')
-
-      expect(KnapsackPro::Config::Env).to receive(:test_suite_token_minitest).and_return(test_suite_token_minitest)
-      expect(KnapsackPro::Config::EnvGenerator).to receive(:set_queue_id).and_return(queue_id)
-
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_TEST_SUITE_TOKEN', test_suite_token_minitest)
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_QUEUE_MODE_ENABLED', 'true')
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_QUEUE_ID', queue_id)
-
-      expect(KnapsackPro::Config::Env).to receive(:set_test_runner_adapter).with(KnapsackPro::Adapters::MinitestAdapter)
-
-      expect(described_class).to receive(:new).with(KnapsackPro::Adapters::MinitestAdapter).and_return(runner)
-
-      expect($LOAD_PATH).to receive(:unshift).with(test_dir)
-    end
-
-    context 'when args are provided' do
-      let(:args) { '--verbose --pride' }
-
-      it do
-        expected_exitstatus = 0
-        expected_accumulator = {
-          status: :completed,
-          exitstatus: expected_exitstatus
-        }
-        accumulator = {
-          status: :next,
-          runner: runner,
-          can_initialize_queue: true,
-          args: ['--verbose', '--pride'],
-          exitstatus: 0,
-          node_test_file_paths: [],
-        }
-        expect(described_class).to receive(:handle_signal!)
-        expect(described_class).to receive(:run_tests).with(accumulator).and_return(expected_accumulator)
-
-        expect(Kernel).to receive(:exit).with(expected_exitstatus)
-
-        subject
-      end
-    end
-
-    context 'when args are not provided' do
-      let(:args) { nil }
-
-      it do
-        expected_exitstatus = 0
-        expected_accumulator = {
-          status: :completed,
-          exitstatus: expected_exitstatus
-        }
-        accumulator = {
-          status: :next,
-          runner: runner,
-          can_initialize_queue: true,
-          args: [],
-          exitstatus: 0,
-          node_test_file_paths: [],
-        }
-        expect(described_class).to receive(:handle_signal!)
-        expect(described_class).to receive(:run_tests).with(accumulator).and_return(expected_accumulator)
-
-        expect(Kernel).to receive(:exit).with(expected_exitstatus)
-
-        subject
-      end
-    end
-  end
-
-  describe '.run_tests' do
-    let(:runner) { instance_double(described_class) }
-    let(:can_initialize_queue) { double(:can_initialize_queue) }
-    let(:args) { ['--verbose', '--pride'] }
-    let(:exitstatus) { 0 }
-    let(:node_test_file_paths) { [] }
-    let(:accumulator) do
-      {
-        runner: runner,
-        can_initialize_queue: can_initialize_queue,
-        args: args,
-        exitstatus: exitstatus,
-        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: node_test_file_paths).and_return(test_file_paths)
-    end
-
-    context 'when test files exist' do
-      let(:test_file_paths) { ['a_test.rb', 'b_test.rb', 'fake_path_test.rb'] }
-
-      before do
-        subset_queue_id = 'fake-subset-queue-id'
-        expect(KnapsackPro::Config::EnvGenerator).to receive(:set_subset_queue_id).and_return(subset_queue_id)
-
-        expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_SUBSET_QUEUE_ID', subset_queue_id)
-
-        tracker = instance_double(KnapsackPro::Tracker)
-        expect(KnapsackPro).to receive(:tracker).twice.and_return(tracker)
-        expect(tracker).to receive(:reset!)
-        expect(tracker).to receive(:set_prerun_tests).with(test_file_paths)
-
-        # .minitest_run
-        allow(File).to receive(:exist?)
-        expect(File).to receive(:exist?).with('./a_test.rb').and_return(true)
-        expect(File).to receive(:exist?).with('./b_test.rb').and_return(true)
-        expect(File).to receive(:exist?).with('./fake_path_test.rb').and_return(false)
-        expect(described_class).to receive(:require).with('./a_test.rb')
-        expect(described_class).to receive(:require).with('./b_test.rb')
-        expect(described_class).to_not receive(:require).with('./fake_path_test.rb')
-
-        expect(Minitest).to receive(:run).with(args).and_return(is_tests_green)
-
-        expect(Minitest::Runnable).to receive(:reset)
-
-        expect(KnapsackPro::Hooks::Queue).to receive(:call_before_subset_queue)
-
-        expect(KnapsackPro::Hooks::Queue).to receive(:call_after_subset_queue)
-
-        expect(KnapsackPro::Report).to receive(:save_subset_queue_to_file)
-      end
-
-      context 'when tests are passing' do
-        let(:is_tests_green) { true }
-
-        it 'returns exit code 0' do
-          expect(subject).to eq({
-            status: :next,
-            runner: runner,
-            can_initialize_queue: false,
-            args: args,
-            exitstatus: exitstatus,
-            node_test_file_paths: test_file_paths,
-          })
-        end
-      end
-
-      context 'when tests are failing' do
-        let(:is_tests_green) { false }
-
-        it 'returns exit code 1' do
-          expect(subject).to eq({
-            status: :next,
-            runner: runner,
-            can_initialize_queue: false,
-            args: args,
-            exitstatus: 1, # tests failed
-            node_test_file_paths: test_file_paths,
-          })
-        end
-      end
-    end
-
-    context 'when test files do not exist' do
-      let(:test_file_paths) { [] }
-
-      context 'when node_test_file_paths exists' do
-        let(:node_test_file_paths) { ['a_test.rb'] }
-
-        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 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)
-          expect(KnapsackPro::Report).to receive(:save_node_queue_to_api)
-
-          expect(subject).to eq({
-            status: :completed,
-            exitstatus: exitstatus,
-          })
-        end
-      end
-    end
-  end
-end

data/spec/knapsack_pro/runners/rspec_runner_spec.rb

@@ -1,111 +0,0 @@
-require 'rspec/core/rake_task'
-
-describe KnapsackPro::Runners::RSpecRunner do
-  subject { described_class.new(KnapsackPro::Adapters::RSpecAdapter) }
-
-  it { should be_kind_of KnapsackPro::Runners::BaseRunner }
-
-  describe '.run' do
-    let(:args) { '--profile --color' }
-
-    let(:test_suite_token_rspec) { 'fake-token' }
-
-    subject { described_class.run(args) }
-
-    before do
-      expect(KnapsackPro::Config::Env).to receive(:test_suite_token_rspec).and_return(test_suite_token_rspec)
-
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_TEST_SUITE_TOKEN', test_suite_token_rspec)
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_REGULAR_MODE_ENABLED', 'true')
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_RSPEC_OPTIONS', args)
-
-      expect(KnapsackPro::Config::Env).to receive(:set_test_runner_adapter).with(KnapsackPro::Adapters::RSpecAdapter)
-
-      expect(described_class).to receive(:new)
-      .with(KnapsackPro::Adapters::RSpecAdapter).and_return(runner)
-    end
-
-    context 'when test files were returned by Knapsack Pro API' do
-      let(:test_dir) { 'fake-test-dir' }
-      let(:test_file_paths) { ['spec/a_spec.rb', 'spec/b_spec.rb[1:1]'] }
-      let(:stringify_test_file_paths) { test_file_paths.join(' ') }
-      let(:runner) do
-        instance_double(described_class,
-                        test_dir: test_dir,
-                        test_file_paths: test_file_paths,
-                        stringify_test_file_paths: stringify_test_file_paths,
-                        test_files_to_execute_exist?: true)
-      end
-      let(:task) { double }
-      let(:task_config) { double }
-
-      before do
-        expect(KnapsackPro::Adapters::RSpecAdapter).to receive(:verify_bind_method_called).ordered
-
-        expect(Rake::Task).to receive(:[]).with('knapsack_pro:rspec_run').at_least(1).and_return(task)
-
-        expect(RSpec::Core::RakeTask).to receive(:new).with('knapsack_pro:rspec_run').and_yield(task_config)
-        expect(RSpec::Core::ConfigurationOptions).to receive_message_chain(:new, :options).and_return({})
-        expect(task_config).to receive(:rspec_opts=).with('--profile --color --format progress --format KnapsackPro::Formatters::TimeTracker --default-path fake-test-dir spec/a_spec.rb spec/b_spec.rb[1:1]')
-        expect(task_config).to receive(:pattern=).with([])
-      end
-
-      shared_examples 'invokes RSpec rake task' do
-        context 'when rake task already exists' do
-          before do
-            expect(Rake::Task).to receive(:task_defined?).with('knapsack_pro:rspec_run').and_return(true)
-            expect(task).to receive(:clear)
-          end
-
-          it do
-            result = double(:result)
-            expect(task).to receive(:invoke).and_return(result)
-            expect(subject).to eq result
-          end
-        end
-
-        context "when rake task doesn't exist" do
-          before do
-            expect(Rake::Task).to receive(:task_defined?).with('knapsack_pro:rspec_run').and_return(false)
-            expect(task).not_to receive(:clear)
-          end
-
-          it do
-            result = double(:result)
-            expect(task).to receive(:invoke).and_return(result)
-            expect(subject).to eq result
-          end
-        end
-      end
-
-      context 'when the default log level' do
-        before do
-          expect(task_config).to receive(:verbose=).with(true)
-        end
-
-        it_behaves_like 'invokes RSpec rake task'
-      end
-
-      context 'when the warning log level' do
-        before do
-          expect(KnapsackPro::Config::Env).to receive(:log_level).and_return(::Logger::WARN)
-
-          expect(task_config).to receive(:verbose=).with(false)
-        end
-
-        it_behaves_like 'invokes RSpec rake task'
-      end
-    end
-
-    context 'when test files were not returned by Knapsack Pro API' do
-      let(:runner) do
-        instance_double(described_class,
-                        test_files_to_execute_exist?: false)
-      end
-
-      it "doesn't run tests" do
-        subject
-      end
-    end
-  end
-end

data/spec/knapsack_pro/runners/spinach_runner_spec.rb

@@ -1,56 +0,0 @@
-describe KnapsackPro::Runners::SpinachRunner do
-  subject { described_class.new(KnapsackPro::Adapters::SpinachAdapter) }
-
-  it { should be_kind_of KnapsackPro::Runners::BaseRunner }
-
-  describe '.run' do
-    let(:args) { '--custom-arg' }
-
-    subject { described_class.run(args) }
-
-    before do
-      stub_const("ENV", { 'KNAPSACK_PRO_TEST_SUITE_TOKEN_SPINACH' => 'spinach-token' })
-
-      expect(KnapsackPro::Config::Env).to receive(:set_test_runner_adapter).with(KnapsackPro::Adapters::SpinachAdapter)
-
-      expect(described_class).to receive(:new)
-      .with(KnapsackPro::Adapters::SpinachAdapter).and_return(runner)
-    end
-
-    context 'when test files were returned by Knapsack Pro API' do
-      let(:test_file_paths) { ['features/a.feature', 'features/b.feature'] }
-      let(:stringify_test_file_paths) { test_file_paths.join(' ') }
-      let(:test_dir) { 'fake-test-dir' }
-      let(:runner) do
-        instance_double(described_class,
-                        test_dir: test_dir,
-                        test_file_paths: test_file_paths,
-                        stringify_test_file_paths: stringify_test_file_paths,
-                        test_files_to_execute_exist?: true)
-      end
-
-      it do
-        expect(KnapsackPro::Adapters::SpinachAdapter).to receive(:verify_bind_method_called)
-
-        tracker = instance_double(KnapsackPro::Tracker)
-        expect(KnapsackPro).to receive(:tracker).and_return(tracker)
-        expect(tracker).to receive(:set_prerun_tests).with(test_file_paths)
-
-        expect(Kernel).to receive(:exec).with('KNAPSACK_PRO_REGULAR_MODE_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')
-
-        subject
-      end
-    end
-
-    context 'when test files were not returned by Knapsack Pro API' do
-      let(:runner) do
-        instance_double(described_class,
-                        test_files_to_execute_exist?: false)
-      end
-
-      it "doesn't run tests" do
-        subject
-      end
-    end
-  end
-end