Draft files needed for Cucumber Queue Mode

bin/knapsack_pro

@@ -9,6 +9,7 @@ MAP = {
   'rspec' => KnapsackPro::Runners::RSpecRunner,
   'queue:rspec' => KnapsackPro::Runners::Queue::RSpecRunner,
   'cucumber' => KnapsackPro::Runners::CucumberRunner,
+  'queue:cucumber' => KnapsackPro::Runners::Queue::CucumberRunner,
   'minitest' => KnapsackPro::Runners::MinitestRunner,
   'queue:minitest' => KnapsackPro::Runners::Queue::MinitestRunner,
   'test_unit' => KnapsackPro::Runners::TestUnitRunner,

lib/knapsack_pro.rb

@@ -64,6 +64,7 @@
 require_relative 'knapsack_pro/runners/spinach_runner'
 require_relative 'knapsack_pro/runners/queue/base_runner'
 require_relative 'knapsack_pro/runners/queue/rspec_runner'
+require_relative 'knapsack_pro/runners/queue/cucumber_runner'
 require_relative 'knapsack_pro/runners/queue/minitest_runner'
 require_relative 'knapsack_pro/crypto/encryptor'
 require_relative 'knapsack_pro/crypto/branch_encryptor'

lib/knapsack_pro/adapters/cucumber_adapter.rb

@@ -62,6 +62,10 @@ def Around(*tag_expressions, &proc)
           ::Cucumber::RbSupport::RbDsl.register_rb_hook('around', tag_expressions, proc)
         end
       end
+
+      def bind_before_queue_hook
+        # TODO
+      end
     end
   end
 end

lib/knapsack_pro/runners/queue/cucumber_runner.rb

@@ -0,0 +1,102 @@
+module KnapsackPro
+  module Runners
+    module Queue
+      class CucumberRunner < BaseRunner
+        def self.run(args)
+          # TODO change this file to cucumber stuff
+          require 'minitest'
+
+          ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_minitest
+          ENV['KNAPSACK_PRO_QUEUE_RECORDING_ENABLED'] = 'true'
+          ENV['KNAPSACK_PRO_QUEUE_ID'] = KnapsackPro::Config::EnvGenerator.set_queue_id
+
+          runner = new(KnapsackPro::Adapters::MinitestAdapter)
+
+          # Add test_dir to load path to make work:
+          #   require 'test_helper'
+          # in test files.
+          $LOAD_PATH.unshift(runner.test_dir)
+
+          cli_args = (args || '').split
+
+          accumulator = {
+            status: :next,
+            runner: runner,
+            can_initialize_queue: true,
+            args: cli_args,
+            exitstatus: 0,
+            all_test_file_paths: [],
+          }
+          while accumulator[:status] == :next
+            accumulator = run_tests(accumulator)
+          end
+
+          Kernel.exit(accumulator[:exitstatus])
+        end
+
+        def self.run_tests(accumulator)
+          runner = accumulator.fetch(:runner)
+          can_initialize_queue = accumulator.fetch(:can_initialize_queue)
+          args = accumulator.fetch(:args)
+          exitstatus = accumulator.fetch(:exitstatus)
+          all_test_file_paths = accumulator.fetch(:all_test_file_paths)
+
+          test_file_paths = runner.test_file_paths(
+            can_initialize_queue: can_initialize_queue,
+            executed_test_files: all_test_file_paths
+          )
+
+          if test_file_paths.empty?
+            KnapsackPro::Hooks::Queue.call_after_queue
+
+            KnapsackPro::Report.save_node_queue_to_api
+
+            return {
+              status: :completed,
+              exitstatus: exitstatus,
+            }
+          else
+            subset_queue_id = KnapsackPro::Config::EnvGenerator.set_subset_queue_id
+            ENV['KNAPSACK_PRO_SUBSET_QUEUE_ID'] = subset_queue_id
+
+            KnapsackPro.tracker.reset!
+            KnapsackPro.tracker.set_prerun_tests(test_file_paths)
+
+            all_test_file_paths += test_file_paths
+
+            result = minitest_run(runner, test_file_paths, args)
+            exitstatus = 1 unless result
+
+            KnapsackPro::Hooks::Queue.call_after_subset_queue
+
+            KnapsackPro::Report.save_subset_queue_to_file
+
+            return {
+              status: :next,
+              runner: runner,
+              can_initialize_queue: false,
+              args: args,
+              exitstatus: exitstatus,
+              all_test_file_paths: all_test_file_paths,
+            }
+          end
+        end
+
+        private
+
+        def self.minitest_run(runner, test_file_paths, args)
+          test_file_paths.each do |test_file_path|
+            require "./#{test_file_path}"
+          end
+
+          # duplicate args because Minitest modifies args
+          result = Minitest.run(args.dup)
+
+          Minitest::Runnable.reset
+
+          result
+        end
+      end
+    end
+  end
+end

lib/tasks/queue/cucumber.rake

@@ -0,0 +1,9 @@
+require 'knapsack_pro'
+
+namespace :knapsack_pro do
+  namespace :queue do
+    task :cucumber, [:cucumber_args] do |_, args|
+      KnapsackPro::Runners::Queue::CucumberRunner.run(args[:cucumber_args])
+    end
+  end
+end

spec/knapsack_pro/runners/queue/cucumber_runner_spec.rb

@@ -0,0 +1,174 @@
+describe KnapsackPro::Runners::Queue::CucumberRunner do
+  describe '.run' do
+    # TODO change this file to cucumber stuff
+    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_RECORDING_ENABLED', 'true')
+      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_QUEUE_ID', queue_id)
+
+      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 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,
+          all_test_file_paths: [],
+        }
+        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 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,
+          all_test_file_paths: [],
+        }
+        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(:all_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,
+      }
+    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)
+    end
+
+    context 'when test files exist' do
+      let(:test_file_paths) { ['a_test.rb', 'b_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
+        expect(described_class).to receive(:require).with('./a_test.rb')
+        expect(described_class).to receive(:require).with('./b_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_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,
+            all_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
+            all_test_file_paths: test_file_paths,
+          })
+        end
+      end
+    end
+
+    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)
+
+        expect(subject).to eq({
+          status: :completed,
+          exitstatus: exitstatus,
+        })
+      end
+    end
+  end
+end