knapsack_pro 0.17.0 → 0.18.0

data/spec/knapsack_pro/adapters/rspec_adapter_spec.rb

@@ -112,5 +112,16 @@ describe KnapsackPro::Adapters::RSpecAdapter do
         subject.bind_save_report
       end
     end
+
+    describe '#bind_save_queue_report' do
+      it do
+        expect(config).to receive(:after).with(:suite).and_yield
+        expect(::RSpec).to receive(:configure).and_yield(config)
+
+        expect(KnapsackPro::Report).to receive(:save_subset_queue_to_file)
+
+        subject.bind_save_queue_report
+      end
+    end
   end
 end

data/spec/knapsack_pro/allocator_builder_spec.rb

@@ -22,24 +22,14 @@ describe KnapsackPro::AllocatorBuilder do
       ci_node_index = double
       expect(KnapsackPro::Config::Env).to receive(:ci_node_index).and_return(ci_node_index)
 
-      expect(KnapsackPro::Allocator).to receive(:new).with({
+      expect(KnapsackPro::Allocator).to receive(:new).with(
         test_files: test_files,
         ci_node_total: ci_node_total,
         ci_node_index: ci_node_index,
         repository_adapter: repository_adapter,
-      }).and_return(allocator)
+      ).and_return(allocator)
     end
 
     it { should eq allocator }
   end
-
-  describe '#test_dir' do
-    subject { allocator_builder.test_dir }
-
-    before do
-      expect(KnapsackPro::TestFilePattern).to receive(:call).and_return('spec/**{,/*/**}/*_spec.rb')
-    end
-
-    it { should eq 'spec' }
-  end
 end

data/spec/knapsack_pro/base_allocator_builder_spec.rb

@@ -0,0 +1,22 @@
+describe KnapsackPro::BaseAllocatorBuilder do
+  let(:adapter_class) { KnapsackPro::Adapters::BaseAdapter }
+  let(:allocator_builder) { described_class.new(adapter_class) }
+
+  describe '#allocator' do
+    subject { allocator_builder.allocator }
+
+    it do
+      expect { subject }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#test_dir' do
+    subject { allocator_builder.test_dir }
+
+    before do
+      expect(KnapsackPro::TestFilePattern).to receive(:call).with(adapter_class).and_return('spec/**{,/*/**}/*_spec.rb')
+    end
+
+    it { should eq 'spec' }
+  end
+end

data/spec/knapsack_pro/client/api/v1/queues_spec.rb

@@ -0,0 +1,42 @@
+describe KnapsackPro::Client::API::V1::Queues do
+  describe '.queue' do
+    let(:can_initialize_queue) { double }
+    let(:commit_hash) { double }
+    let(:branch) { double }
+    let(:node_total) { double }
+    let(:node_index) { double }
+    let(:test_files) { double }
+
+    subject do
+      described_class.queue(
+        can_initialize_queue: can_initialize_queue,
+        commit_hash: commit_hash,
+        branch: branch,
+        node_total: node_total,
+        node_index: node_index,
+        test_files: test_files
+      )
+    end
+
+    it do
+      node_build_id = double
+      expect(KnapsackPro::Config::Env).to receive(:ci_node_build_id).and_return(node_build_id)
+
+      action = double
+      expect(KnapsackPro::Client::API::Action).to receive(:new).with({
+        endpoint_path: '/v1/queues/queue',
+        http_method: :post,
+        request_hash: {
+          can_initialize_queue: can_initialize_queue,
+          commit_hash: commit_hash,
+          branch: branch,
+          node_total: node_total,
+          node_index: node_index,
+          node_build_id: node_build_id,
+          test_files: test_files
+        }
+      }).and_return(action)
+      expect(subject).to eq action
+    end
+  end
+end

data/spec/knapsack_pro/config/ci/base_spec.rb

@@ -1,6 +1,7 @@
 describe KnapsackPro::Config::CI::Base do
   its(:node_total) { should be nil }
   its(:node_index) { should be nil }
+  its(:node_build_id) { should be nil }
   its(:commit_hash) { should be nil }
   its(:branch) { should be nil }
   its(:project_dir) { should be nil }

data/spec/knapsack_pro/config/ci/buildkite_spec.rb

@@ -33,6 +33,19 @@ describe KnapsackPro::Config::CI::Buildkite do
     end
   end
 
+  describe '#node_build_id' do
+    subject { described_class.new.node_build_id }
+
+    context 'when environment exists' do
+      let(:env) { { 'BUILDKITE_BUILD_NUMBER' => 1514 } }
+      it { should eql 1514 }
+    end
+
+    context "when environment doesn't exist" do
+      it { should be nil }
+    end
+  end
+
   describe '#commit_hash' do
     subject { described_class.new.commit_hash }
 

data/spec/knapsack_pro/config/ci/circle_spec.rb

@@ -33,6 +33,19 @@ describe KnapsackPro::Config::CI::Circle do
     end
   end
 
+  describe '#node_build_id' do
+    subject { described_class.new.node_build_id }
+
+    context 'when environment exists' do
+      let(:env) { { 'CIRCLE_BUILD_NUM' => 123 } }
+      it { should eql 123 }
+    end
+
+    context "when environment doesn't exist" do
+      it { should be nil }
+    end
+  end
+
   describe '#commit_hash' do
     subject { described_class.new.commit_hash }
 

data/spec/knapsack_pro/config/ci/semaphore_spec.rb

@@ -33,6 +33,19 @@ describe KnapsackPro::Config::CI::Semaphore do
     end
   end
 
+  describe '#node_build_id' do
+    subject { described_class.new.node_build_id }
+
+    context 'when environment exists' do
+      let(:env) { { 'SEMAPHORE_BUILD_NUMBER' => 23 } }
+      it { should eql 23 }
+    end
+
+    context "when environment doesn't exist" do
+      it { should be nil }
+    end
+  end
+
   describe '#commit_hash' do
     subject { described_class.new.commit_hash }
 

data/spec/knapsack_pro/config/ci/snap_ci_spec.rb

@@ -33,6 +33,19 @@ describe KnapsackPro::Config::CI::SnapCI do
     end
   end
 
+  describe '#node_build_id' do
+    subject { described_class.new.node_build_id }
+
+    context 'when environment exists' do
+      let(:env) { { 'SNAP_PIPELINE_COUNTER' => 123 } }
+      it { should eql 123 }
+    end
+
+    context "when environment doesn't exist" do
+      it { should be nil }
+    end
+  end
+
   describe '#commit_hash' do
     subject { described_class.new.commit_hash }
 

data/spec/knapsack_pro/config/ci/travis_spec.rb

@@ -19,6 +19,19 @@ describe KnapsackPro::Config::CI::Travis do
     it { should be nil }
   end
 
+  describe '#node_build_id' do
+    subject { described_class.new.node_build_id }
+
+    context 'when environment exists' do
+      let(:env) { { 'TRAVIS_BUILD_NUMBER' => 4 } }
+      it { should eql 4 }
+    end
+
+    context "when environment doesn't exist" do
+      it { should be nil }
+    end
+  end
+
   describe '#commit_hash' do
     subject { described_class.new.commit_hash }
 

data/spec/knapsack_pro/config/env_generator_spec.rb

@@ -0,0 +1,52 @@
+describe KnapsackPro::Config::EnvGenerator do
+  describe '.set_queue_id' do
+    subject { described_class.set_queue_id }
+
+    context 'when queue id exists' do
+      before do
+        stub_const("ENV", { 'KNAPSACK_PRO_QUEUE_ID' => 'fake-queue-id' })
+      end
+
+      it do
+        expect { subject }.to raise_error('Queue ID already generated.')
+      end
+    end
+
+    context "when queue id doesn't exist" do
+      before { stub_const("ENV", {}) }
+
+      it do
+        subject
+        expect(ENV['KNAPSACK_PRO_QUEUE_ID']).not_to be_nil
+      end
+
+      it do
+        now = DateTime.new(2016, 1, 9, 0, 0, 0)
+
+        Timecop.freeze(now) do
+          uuid = 'fake-uuid'
+          expect(SecureRandom).to receive(:uuid).and_return(uuid)
+
+          subject
+
+          expect(ENV['KNAPSACK_PRO_QUEUE_ID']).to eq '1452297600_fake-uuid'
+        end
+      end
+    end
+  end
+
+  describe '.set_subset_queue_id' do
+    subject { described_class.set_subset_queue_id }
+
+    before { stub_const("ENV", {}) }
+
+    it do
+      uuid = 'fake-uuid'
+      expect(SecureRandom).to receive(:uuid).and_return(uuid)
+
+      subject
+
+      expect(ENV['KNAPSACK_PRO_SUBSET_QUEUE_ID']).to eq uuid
+    end
+  end
+end

data/spec/knapsack_pro/config/env_spec.rb

@@ -47,6 +47,29 @@ describe KnapsackPro::Config::Env do
     end
   end
 
+  describe '.ci_node_build_id' do
+    subject { described_class.ci_node_build_id }
+
+    context 'when ENV exists' do
+      context 'when KNAPSACK_PRO_CI_NODE_BUILD_ID has value' do
+        before { stub_const("ENV", { 'KNAPSACK_PRO_CI_NODE_BUILD_ID' => '7' }) }
+        it { should eq '7' }
+      end
+
+      context 'when CI environment has value' do
+        before do
+          expect(described_class).to receive(:ci_env_for).with(:node_build_id).and_return('8')
+        end
+
+        it { should eq '8' }
+      end
+    end
+
+    context "when ENV doesn't exist" do
+      it { should eq 'missing-build-id' }
+    end
+  end
+
   describe '.commit_hash' do
     subject { described_class.commit_hash }
 
@@ -178,6 +201,73 @@ describe KnapsackPro::Config::Env do
     end
   end
 
+  describe '.queue_recording_enabled' do
+    subject { described_class.queue_recording_enabled }
+
+    context 'when ENV exists' do
+      let(:queue_recording_enabled) { 'true' }
+      before { stub_const("ENV", { 'KNAPSACK_PRO_QUEUE_RECORDING_ENABLED' => queue_recording_enabled }) }
+      it { should eq queue_recording_enabled }
+    end
+
+    context "when ENV doesn't exist" do
+      it { should be_nil }
+    end
+  end
+
+  describe '.queue_recording_enabled?' do
+    subject { described_class.queue_recording_enabled? }
+
+    before do
+      expect(described_class).to receive(:queue_recording_enabled).and_return(queue_recording_enabled)
+    end
+
+    context 'when enabled' do
+      let(:queue_recording_enabled) { 'true' }
+
+      it { should be true }
+    end
+
+    context 'when disabled' do
+      let(:queue_recording_enabled) { nil }
+
+      it { should be false }
+    end
+  end
+
+  describe '.queue_id' do
+    subject { described_class.queue_id }
+
+    context 'when ENV exists' do
+      let(:queue_id) { 'fake-queue-id' }
+      before { stub_const("ENV", { 'KNAPSACK_PRO_QUEUE_ID' => queue_id }) }
+      it { should eq queue_id }
+    end
+
+    context "when ENV doesn't exist" do
+      before { stub_const("ENV", {}) }
+      it do
+        expect { subject }.to raise_error('Missing Queue ID')
+      end
+    end
+  end
+
+  describe '.subset_queue_id' do
+    subject { described_class.subset_queue_id }
+
+    context 'when ENV exists' do
+      let(:subset_queue_id) { 'fake-subset-queue-id' }
+      before { stub_const("ENV", { 'KNAPSACK_PRO_SUBSET_QUEUE_ID' => subset_queue_id }) }
+      it { should eq subset_queue_id }
+    end
+
+    context "when ENV doesn't exist" do
+      it do
+        expect { subject }.to raise_error('Missing Subset Queue ID')
+      end
+    end
+  end
+
   describe '.test_files_encrypted' do
     subject { described_class.test_files_encrypted }
 

data/spec/knapsack_pro/queue_allocator_builder_spec.rb

@@ -0,0 +1,38 @@
+describe KnapsackPro::QueueAllocatorBuilder do
+  let(:adapter_class) { KnapsackPro::Adapters::BaseAdapter }
+  let(:allocator_builder) { described_class.new(adapter_class) }
+
+  describe '#allocator' do
+    let(:allocator) { double }
+
+    subject { allocator_builder.allocator }
+
+    before do
+      test_file_pattern = double
+      expect(KnapsackPro::TestFilePattern).to receive(:call).with(adapter_class).and_return(test_file_pattern)
+
+      test_files = double
+      expect(KnapsackPro::TestFileFinder).to receive(:call).with(test_file_pattern).and_return(test_files)
+
+      repository_adapter = double
+      expect(KnapsackPro::RepositoryAdapterInitiator).to receive(:call).and_return(repository_adapter)
+
+      ci_node_total = double
+      expect(KnapsackPro::Config::Env).to receive(:ci_node_total).and_return(ci_node_total)
+      ci_node_index = double
+      expect(KnapsackPro::Config::Env).to receive(:ci_node_index).and_return(ci_node_index)
+      ci_node_build_id = double
+      expect(KnapsackPro::Config::Env).to receive(:ci_node_build_id).and_return(ci_node_build_id)
+
+      expect(KnapsackPro::QueueAllocator).to receive(:new).with(
+        test_files: test_files,
+        ci_node_total: ci_node_total,
+        ci_node_index: ci_node_index,
+        ci_node_build_id: ci_node_build_id,
+        repository_adapter: repository_adapter,
+      ).and_return(allocator)
+    end
+
+    it { should eq allocator }
+  end
+end

data/spec/knapsack_pro/queue_allocator_spec.rb

@@ -0,0 +1,85 @@
+describe KnapsackPro::QueueAllocator do
+  let(:test_files) { double }
+  let(:ci_node_total) { double }
+  let(:ci_node_index) { double }
+  let(:ci_node_build_id) { double }
+  let(:repository_adapter) { instance_double(KnapsackPro::RepositoryAdapters::EnvAdapter, commit_hash: double, branch: double) }
+
+  let(:queue_allocator) do
+    described_class.new(
+      test_files: test_files,
+      ci_node_total: ci_node_total,
+      ci_node_index: ci_node_index,
+      ci_node_build_id: ci_node_build_id,
+      repository_adapter: repository_adapter
+    )
+  end
+
+  describe '#test_file_paths' do
+    let(:can_initialize_queue) { double }
+    let(:response) { double }
+
+    subject { queue_allocator.test_file_paths(can_initialize_queue) }
+
+    before do
+      encrypted_test_files = double
+      expect(KnapsackPro::Crypto::Encryptor).to receive(:call).with(test_files).and_return(encrypted_test_files)
+
+      action = double
+      expect(KnapsackPro::Client::API::V1::Queues).to receive(:queue).with(
+        can_initialize_queue: can_initialize_queue,
+        commit_hash: repository_adapter.commit_hash,
+        branch: repository_adapter.branch,
+        node_total: ci_node_total,
+        node_index: ci_node_index,
+        node_build_id: ci_node_build_id,
+        test_files: encrypted_test_files,
+      ).and_return(action)
+
+      connection = instance_double(KnapsackPro::Client::Connection,
+                                   call: response,
+                                   success?: success?,
+                                   errors?: errors?)
+      expect(KnapsackPro::Client::Connection).to receive(:new).with(action).and_return(connection)
+    end
+
+    context 'when successful request to API' 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 }
+        let(:response) do
+          {
+            'test_files' => [
+              { 'path' => 'a_spec.rb' },
+              { 'path' => 'b_spec.rb' },
+            ]
+          }
+        end
+
+        before do
+          expect(KnapsackPro::Crypto::Decryptor).to receive(:call).with(test_files, response['test_files']).and_call_original
+        end
+
+        it { should eq ['a_spec.rb', 'b_spec.rb'] }
+      end
+    end
+
+    context 'when not successful request to API' do
+      let(:success?) { false }
+      let(:errors?) { false }
+
+      it do
+        expect { subject }.to raise_error("Couldn't connect with Knapsack Pro API. Response: #{response}")
+      end
+    end
+  end
+end