knapsack_pro 9.0.0 → 9.1.0

data/spec/knapsack_pro/report_spec.rb

@@ -1,232 +0,0 @@
-describe KnapsackPro::Report do
-  describe '.save' do
-    subject { described_class.save }
-
-    it do
-      test_files = [double]
-      tracker = instance_double(KnapsackPro::Tracker, to_a: test_files)
-      expect(KnapsackPro).to receive(:tracker).and_return(tracker)
-      expect(described_class).to receive(:create_build_subset).with(test_files)
-
-      subject
-    end
-  end
-
-  describe '.save_subset_queue_to_file' do
-    let(:fake_path) { SecureRandom.uuid }
-
-    subject { described_class.save_subset_queue_to_file }
-
-    before do
-      test_files = [{path: fake_path}]
-      tracker = instance_double(KnapsackPro::Tracker, to_a: test_files)
-      expect(KnapsackPro).to receive(:tracker).and_return(tracker)
-
-      subset_queue_id = 'fake-subset-queue-id'
-      expect(KnapsackPro::Config::Env).to receive(:subset_queue_id).and_return(subset_queue_id)
-
-      expect(KnapsackPro::Config::TempFiles).to receive(:ensure_temp_directory_exists!)
-
-      queue_id = 'fake-queue-id'
-      expect(KnapsackPro::Config::Env).to receive(:queue_id).twice.and_return(queue_id)
-    end
-
-    it do
-      subject
-
-      expect(
-        JSON.parse(
-          File.read('.knapsack_pro/queue/fake-queue-id/fake-subset-queue-id.json')
-        )
-      ).to eq([
-        { 'path' => fake_path }
-      ])
-    end
-  end
-
-  describe '.save_node_queue_to_api' do
-    context 'when json files with recorded time does exist and test files have measured and default time execution' do
-      let(:json_test_file_a_path) { double }
-      let(:json_test_file_a) { [{ 'path' => 'a_spec.rb', 'time_execution' => 0.1234 }] }
-
-      let(:json_test_file_b_path) { double }
-      let(:json_test_file_b) { [{ 'path' => 'b_spec.rb', 'time_execution' => KnapsackPro::Tracker::DEFAULT_TEST_FILE_TIME }] }
-
-      subject { described_class.save_node_queue_to_api }
-
-      before do
-        queue_id = 'fake-queue-id'
-        expect(KnapsackPro::Config::Env).to receive(:queue_id).and_return(queue_id)
-
-        expect(Dir).to receive(:glob).with('.knapsack_pro/queue/fake-queue-id/*.json').and_return([
-          json_test_file_a_path,
-          json_test_file_b_path
-        ])
-
-        expect(File).to receive(:read).with(json_test_file_a_path).and_return(json_test_file_a.to_json)
-        expect(File).to receive(:read).with(json_test_file_b_path).and_return(json_test_file_b.to_json)
-      end
-
-      it 'creates build subset for 2 recorded test files timing' do
-        expect(KnapsackPro).not_to receive(:logger)
-
-        expect(described_class).to receive(:create_build_subset).with(
-          json_test_file_a + json_test_file_b
-        )
-
-        subject
-      end
-    end
-
-    context 'when json files with recorded time does exist and all test files have default time execution' do
-      let(:json_test_file_a_path) { double }
-      let(:json_test_file_a) { [{ 'path' => 'a_spec.rb', 'time_execution' => KnapsackPro::Tracker::DEFAULT_TEST_FILE_TIME }] }
-
-      let(:json_test_file_b_path) { double }
-      let(:json_test_file_b) { [{ 'path' => 'b_spec.rb', 'time_execution' => KnapsackPro::Tracker::DEFAULT_TEST_FILE_TIME }] }
-
-      subject { described_class.save_node_queue_to_api }
-
-      before do
-        queue_id = 'fake-queue-id'
-        expect(KnapsackPro::Config::Env).to receive(:queue_id).and_return(queue_id)
-
-        expect(Dir).to receive(:glob).with('.knapsack_pro/queue/fake-queue-id/*.json').and_return([
-          json_test_file_a_path,
-          json_test_file_b_path
-        ])
-
-        expect(File).to receive(:read).with(json_test_file_a_path).and_return(json_test_file_a.to_json)
-        expect(File).to receive(:read).with(json_test_file_b_path).and_return(json_test_file_b.to_json)
-      end
-
-      it 'logs error on lost info about recorded timing for test files due missing json files AND creates empty build subset' do
-        logger = instance_double(Logger)
-        expect(KnapsackPro).to receive(:logger).exactly(4).and_return(logger)
-        expect(logger).to receive(:warn).with('2 test files were executed on this CI node but the recorded time was lost due to:')
-        expect(logger).to receive(:warn).with('1. Please ensure you do not remove the contents of the .knapsack_pro directory between tests run.')
-        expect(logger).to receive(:warn).with("2. Ensure you've added Knapsack::Adapters::RSpecAdapter.bind in your rails_helper.rb or spec_helper.rb. Please follow the installation guide again: https://knapsackpro.com/perma/ruby/installation-guide")
-        expect(logger).to receive(:warn).with('3. Another potential reason for this warning is that all your tests are empty test files, pending tests, or they have syntax errors, and the time execution was not recorded for them.')
-
-        expect(described_class).to receive(:create_build_subset).with(
-          json_test_file_a + json_test_file_b
-        )
-
-        subject
-      end
-    end
-
-    context 'when json files with recorded time does not exist' do
-      subject { described_class.save_node_queue_to_api }
-
-      before do
-        queue_id = 'fake-queue-id'
-        expect(KnapsackPro::Config::Env).to receive(:queue_id).and_return(queue_id)
-
-        expect(Dir).to receive(:glob).with('.knapsack_pro/queue/fake-queue-id/*.json').and_return([])
-      end
-
-      it 'logs warning about reasons why no test files were executed on this CI node' do
-        logger = instance_double(Logger)
-        expect(KnapsackPro).to receive(:logger).exactly(2).and_return(logger)
-        expect(logger).to receive(:warn).with('No test files were executed on this CI node.')
-        expect(logger).to receive(:debug).with('This CI node likely started work late after the test files were already executed by other CI nodes consuming the queue.')
-
-        expect(described_class).to receive(:create_build_subset).with([])
-
-        subject
-      end
-    end
-  end
-
-  describe '.create_build_subset' do
-    subject { described_class.create_build_subset(test_files) }
-
-    before do
-      commit_hash = double
-      branch = double
-      repository_adapter = instance_double(KnapsackPro::RepositoryAdapters::EnvAdapter, commit_hash: commit_hash, branch: branch)
-      expect(KnapsackPro::RepositoryAdapterInitiator).to receive(:call).and_return(repository_adapter)
-
-      unsymbolize_test_files = double
-      expect(KnapsackPro::Utils).to receive(:unsymbolize).with(test_files).and_return(unsymbolize_test_files)
-
-      encrypted_test_files = double
-      expect(KnapsackPro::Crypto::Encryptor).to receive(:call).with(unsymbolize_test_files).and_return(encrypted_test_files)
-
-      encrypted_branch = double
-      expect(KnapsackPro::Crypto::BranchEncryptor).to receive(:call).with(repository_adapter.branch).and_return(encrypted_branch)
-
-      node_total = double
-      node_index = double
-      expect(KnapsackPro::Config::Env).to receive(:ci_node_total).and_return(node_total)
-      expect(KnapsackPro::Config::Env).to receive(:ci_node_index).and_return(node_index)
-
-      action = double
-      expect(KnapsackPro::Client::API::V1::BuildSubsets).to receive(:create).with({
-        commit_hash: commit_hash,
-        branch: encrypted_branch,
-        node_total: node_total,
-        node_index: node_index,
-        test_files: encrypted_test_files,
-      }).and_return(action)
-
-      connection = instance_double(KnapsackPro::Client::Connection, success?: success?, errors?: errors?)
-      expect(KnapsackPro::Client::Connection).to receive(:new).with(action).and_return(connection).and_return(connection)
-
-      response = double
-      expect(connection).to receive(:call).and_return(response)
-    end
-
-    shared_examples_for 'create_build_subset method' do
-      context 'when success' do
-        let(:success?) { true }
-
-        context 'when response has errors' do
-          let(:errors?) { true }
-
-          it do
-            expect {
-              subject
-            }.to raise_error(ArgumentError)
-          end
-        end
-
-        context 'when response has no errors' do
-          let(:errors?) { false }
-
-          it do
-            logger = instance_double(Logger)
-            expect(KnapsackPro).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:debug).with('Saved time execution report on Knapsack Pro API server.')
-            subject
-          end
-        end
-      end
-
-      context 'when failure' do
-        let(:success?) { false }
-        let(:errors?) { nil }
-
-        it do
-          logger = instance_double(Logger)
-          expect(KnapsackPro).to receive(:logger).and_return(logger)
-          expect(logger).to receive(:warn).with('Time execution report was not saved on Knapsack Pro API server due to connection problem.')
-          subject
-        end
-      end
-    end
-
-    context "when test files doesn't exist" do
-      let(:test_files) { [] }
-
-      it_behaves_like 'create_build_subset method'
-    end
-
-    context 'when test files exists' do
-      let(:test_files) { [double] }
-
-      it_behaves_like 'create_build_subset method'
-    end
-  end
-end

data/spec/knapsack_pro/repository_adapter_initiator_spec.rb

@@ -1,21 +0,0 @@
-describe KnapsackPro::RepositoryAdapterInitiator do
-  describe '.call' do
-    subject { described_class.call }
-
-    before do
-      expect(KnapsackPro::Config::Env).to receive(:repository_adapter).and_return(repository_adapter)
-    end
-
-    context 'when repository adapter is git' do
-      let(:repository_adapter) { 'git' }
-
-      it { should be_instance_of KnapsackPro::RepositoryAdapters::GitAdapter }
-    end
-
-    context 'when default repository adapter' do
-      let(:repository_adapter) { nil }
-
-      it { should be_instance_of KnapsackPro::RepositoryAdapters::EnvAdapter }
-    end
-  end
-end

data/spec/knapsack_pro/repository_adapters/base_adapter_spec.rb

@@ -1,13 +0,0 @@
-describe KnapsackPro::RepositoryAdapters::BaseAdapter do
-  describe '#commit_hash' do
-    it do
-      expect { subject.commit_hash }.to raise_error NotImplementedError
-    end
-  end
-
-  describe '#branch' do
-    it do
-      expect { subject.branch }.to raise_error NotImplementedError
-    end
-  end
-end

data/spec/knapsack_pro/repository_adapters/env_adapter_spec.rb

@@ -1,27 +0,0 @@
-describe KnapsackPro::RepositoryAdapters::EnvAdapter do
-  it { should be_kind_of KnapsackPro::RepositoryAdapters::BaseAdapter }
-
-  describe '#commit_hash' do
-    let(:commit_hash) { double }
-
-    subject { described_class.new.commit_hash }
-
-    before do
-      expect(KnapsackPro::Config::Env).to receive(:commit_hash).and_return(commit_hash)
-    end
-
-    it { should eq commit_hash }
-  end
-
-  describe '#branch' do
-    let(:branch) { double }
-
-    subject { described_class.new.branch }
-
-    before do
-      expect(KnapsackPro::Config::Env).to receive(:branch).and_return(branch)
-    end
-
-    it { should eq branch }
-  end
-end

data/spec/knapsack_pro/repository_adapters/git_adapter_spec.rb

@@ -1,106 +0,0 @@
-describe KnapsackPro::RepositoryAdapters::GitAdapter do
-  let!(:circle_sha1) { ENV['CIRCLE_SHA1'] }
-  let!(:circle_branch) { ENV['CIRCLE_BRANCH'] }
-
-  before do
-    stub_const('ENV', {
-      'KNAPSACK_PRO_PROJECT_DIR' => KnapsackPro.root,
-    })
-  end
-
-  it { should be_kind_of KnapsackPro::RepositoryAdapters::BaseAdapter }
-
-  describe '#commit_hash' do
-    subject { described_class.new.commit_hash }
-
-    it { should_not be_nil }
-    its(:size) { should eq 40 }
-    it { should eq circle_sha1 } if ENV['CIRCLECI']
-  end
-
-  describe '#branch' do
-    subject { described_class.new.branch }
-
-    it { should_not be_nil }
-    it { should eq circle_branch } if ENV['CIRCLECI']
-  end
-
-  describe '#branches' do
-    subject { described_class.new.branches }
-
-    it { expect(subject.include?('main')).to be true }
-    it { expect(subject.include?(circle_branch)).to be true } if ENV['CIRCLECI']
-  end
-
-  describe '#build_author' do
-    it "returns the masked build author" do
-      allow_any_instance_of(KnapsackPro::RepositoryAdapters::GitAdapter).to receive(:git_build_author).and_return(
-        "John Doe <john.doe@example.com>" + "\n"
-      )
-
-      subject = KnapsackPro::RepositoryAdapters::GitAdapter.new
-
-      expect(subject.build_author).to eq 'Jo** Do* <jo**.do*@ex*****.co*>'
-    end
-
-    context "when the command raises an exception" do
-      it "returns the no-git author" do
-        allow_any_instance_of(KnapsackPro::RepositoryAdapters::GitAdapter).to receive(:git_build_author).and_raise(Exception)
-
-        subject = KnapsackPro::RepositoryAdapters::GitAdapter.new
-
-        expect(subject.build_author).to eq "no git <no.git@example.com>"
-      end
-    end
-
-    context "when the command returns an empty string" do
-      it "returns the no-git author" do
-        allow_any_instance_of(KnapsackPro::RepositoryAdapters::GitAdapter).to receive(:git_build_author).and_return("")
-
-        subject = KnapsackPro::RepositoryAdapters::GitAdapter.new
-
-        expect(subject.build_author).to eq "no git <no.git@example.com>"
-      end
-    end
-  end
-
-  describe '#commit_authors' do
-    it "returns the masked commit authors" do
-      allow_any_instance_of(KnapsackPro::RepositoryAdapters::GitAdapter).to receive(:git_commit_authors).and_return([
-        "     5\t3v0k4 <riccardo@example.com>\n",
-        "    10\tArtur Nowak <artur@example.com>\n",
-        "     2\tRiccardo <riccardo@example.com>\n",
-        "     3 \tshadre <shadi@example.com>\n",
-      ].join(""))
-
-      subject = KnapsackPro::RepositoryAdapters::GitAdapter.new
-
-      expect(subject.commit_authors).to eq([
-        { commits: 5, author: "3v0*4 <ri******@ex*****.co*>" },
-        { commits: 10, author: "Ar*** No*** <ar***@ex*****.co*>" },
-        { commits: 2, author: "Ri****** <ri******@ex*****.co*>" },
-        { commits: 3, author: "sh**** <sh***@ex*****.co*>" },
-      ])
-    end
-
-    context "when the authors command raises an exception" do
-      it "returns []" do
-        allow_any_instance_of(KnapsackPro::RepositoryAdapters::GitAdapter).to receive(:git_commit_authors).and_raise(Exception)
-
-        subject = KnapsackPro::RepositoryAdapters::GitAdapter.new
-
-        expect(subject.commit_authors).to eq []
-      end
-    end
-
-    context "when the authors command returns an empty string" do
-      it "returns []" do
-        allow_any_instance_of(KnapsackPro::RepositoryAdapters::GitAdapter).to receive(:git_commit_authors).and_return("")
-
-        subject = KnapsackPro::RepositoryAdapters::GitAdapter.new
-
-        expect(subject.commit_authors).to eq []
-      end
-    end
-  end
-end

data/spec/knapsack_pro/runners/base_runner_spec.rb

@@ -1,87 +0,0 @@
-describe KnapsackPro::Runners::BaseRunner do
-  describe '.run' do
-    it do
-      expect {
-        described_class.run(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::RegularAllocator) }
-    let(:allocator_builder) { instance_double(KnapsackPro::RegularAllocatorBuilder) }
-
-    before do
-      expect(KnapsackPro::RegularAllocatorBuilder).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
-      let(:test_file_paths) { double }
-
-      subject { runner.test_file_paths }
-
-      before do
-        expect(allocator).to receive(:test_file_paths).and_return(test_file_paths)
-      end
-
-      it { should eq test_file_paths }
-    end
-
-    describe '#stringify_test_file_paths' do
-      let(:stringify_test_file_paths) { double }
-
-      subject { runner.stringify_test_file_paths }
-
-      before do
-        test_file_paths = double
-        expect(runner).to receive(:test_file_paths).and_return(test_file_paths)
-        expect(KnapsackPro::TestFilePresenter).to receive(:stringify_paths).with(test_file_paths).and_return(stringify_test_file_paths)
-      end
-
-      it { should eq stringify_test_file_paths }
-    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
-
-    describe '#test_files_to_execute_exist?' do
-      subject { runner.test_files_to_execute_exist? }
-
-      before do
-        expect(runner).to receive(:test_file_paths).and_return(test_file_paths)
-      end
-
-      context 'when test files exists' do
-        let(:test_file_paths) { ['a_spec.rb'] }
-
-        it { should be true }
-      end
-
-      context "when test files doesn't exist" do
-        let(:test_file_paths) { [] }
-
-        before do
-          logger = instance_double(Logger)
-          expect(KnapsackPro).to receive(:logger).and_return(logger)
-          expect(logger).to receive(:info).with("Knapsack Pro API returned no test files to execute for the node this time. The reason might be that you changed recently a number of total nodes or you removed some test files. Please create a new commit to get a better test suite split next time.")
-        end
-
-        it { should be false }
-      end
-    end
-  end
-end

data/spec/knapsack_pro/runners/cucumber_runner_spec.rb

@@ -1,92 +0,0 @@
-require 'cucumber/rake/task'
-
-describe KnapsackPro::Runners::CucumberRunner do
-  subject { described_class.new(KnapsackPro::Adapters::CucumberAdapter) }
-
-  it { should be_kind_of KnapsackPro::Runners::BaseRunner }
-
-  describe '.run' do
-    let(:args) { '--custom-arg' }
-
-    let(:test_suite_token_cucumber) { 'fake-token' }
-
-    subject { described_class.run(args) }
-
-    before do
-      expect(KnapsackPro::Config::Env).to receive(:test_suite_token_cucumber).and_return(test_suite_token_cucumber)
-
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_TEST_SUITE_TOKEN', test_suite_token_cucumber)
-      expect(ENV).to receive(:[]=).with('KNAPSACK_PRO_REGULAR_MODE_ENABLED', 'true')
-
-      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 test files were returned by Knapsack Pro API' do
-      let(:test_dir) { 'fake-test-dir' }
-      let(:test_file_paths) { ['features/fake1.scenario', 'features/fake2.scenario'] }
-      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 }
-
-      before do
-        expect(KnapsackPro::Adapters::CucumberAdapter).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(Rake::Task).to receive(:[]).with('knapsack_pro:cucumber_run').at_least(1).and_return(task)
-
-        t = double
-        expect(Cucumber::Rake::Task).to receive(:new).with('knapsack_pro:cucumber_run').and_yield(t)
-        expect(t).to receive(:cucumber_opts=).with('--custom-arg --require fake-test-dir -- features/fake1.scenario features/fake2.scenario')
-      end
-
-      context 'when task already exists' do
-        before do
-          expect(Rake::Task).to receive(:task_defined?).with('knapsack_pro:cucumber_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 task doesn't exist" do
-        before do
-          expect(Rake::Task).to receive(:task_defined?).with('knapsack_pro:cucumber_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 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/minitest_runner_spec.rb

@@ -1,57 +0,0 @@
-describe KnapsackPro::Runners::MinitestRunner do
-  subject { described_class.new(KnapsackPro::Adapters::MinitestAdapter) }
-
-  it { should be_kind_of KnapsackPro::Runners::BaseRunner }
-
-  describe '.run' do
-    let(:args) { '--custom-arg' }
-    let(:task_name) { 'knapsack_pro:minitest_run' }
-
-    subject { described_class.run(args) }
-
-    before do
-      stub_const("ENV", { 'KNAPSACK_PRO_TEST_SUITE_TOKEN_MINITEST' => 'minitest-token' })
-    end
-
-    context 'when test files were returned by Knapsack Pro API' do
-      let(:test_file_paths) { ['test_fake/a_test.rb', 'test_fake/b_test.rb'] }
-
-      before do
-        expect(KnapsackPro::Adapters::MinitestAdapter).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)
-      end
-
-      it 'runs tests' do
-        runner = instance_double(described_class,
-                                 test_dir: 'test',
-                                 test_file_paths: test_file_paths,
-                                 test_files_to_execute_exist?: true)
-        expect(described_class).to receive(:new)
-        .with(KnapsackPro::Adapters::MinitestAdapter).and_return(runner)
-
-        expect(Rake::Task.task_defined?(task_name)).to be false
-
-        subject
-
-        expect(Rake::Task.task_defined?(task_name)).to be true
-
-        expect(ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN']).to eq 'minitest-token'
-        expect(ENV['KNAPSACK_PRO_REGULAR_MODE_ENABLED']).to eq 'true'
-      end
-    end
-
-    context 'when test files were not returned by Knapsack Pro API' do
-      it "doesn't run tests" do
-        runner = instance_double(described_class,
-                                 test_files_to_execute_exist?: false)
-        expect(described_class).to receive(:new)
-        .with(KnapsackPro::Adapters::MinitestAdapter).and_return(runner)
-
-        subject
-      end
-    end
-  end
-end