knapsack_pro 0.0.1 → 0.1.0

data/spec/knapsack_pro/adapters/rspec_adapter_spec.rb

@@ -0,0 +1,94 @@
+describe KnapsackPro::Adapters::RSpecAdapter do
+  it do
+    expect(described_class::TEST_DIR_PATTERN).to eq 'spec/**/*_spec.rb'
+  end
+
+  context do
+    before { expect(::RSpec).to receive(:configure) }
+    it_behaves_like 'adapter'
+  end
+
+  describe '.test_path' do
+    let(:current_example_metadata) do
+      {
+        file_path: '1_shared_example.rb',
+        parent_example_group: {
+          file_path: '2_shared_example.rb',
+          parent_example_group: {
+            file_path: 'a_spec.rb'
+          }
+        }
+      }
+    end
+
+    subject { described_class.test_path(current_example_metadata) }
+
+    it { should eql 'a_spec.rb' }
+
+    context 'with turnip features' do
+      let(:current_example_metadata) do
+        {
+          file_path: "./spec/features/logging_in.feature",
+          turnip: true,
+          parent_example_group: {
+            file_path: "gems/turnip-1.2.4/lib/turnip/rspec.rb",
+          }
+        }
+      end
+
+      subject { described_class.test_path(current_example_metadata) }
+
+      it { should eql './spec/features/logging_in.feature' }
+    end
+  end
+
+  describe 'bind methods' do
+    let(:config) { double }
+
+    describe '#bind_time_tracker' do
+      let(:tracker) { instance_double(KnapsackPro::Tracker) }
+      let(:logger) { instance_double(Logger) }
+      let(:test_path) { 'spec/a_spec.rb' }
+      let(:global_time) { 'Global time: 01m 05s' }
+      let(:example_group) { double }
+      let(:current_example) do
+        OpenStruct.new(metadata: {
+          example_group: example_group
+        })
+      end
+
+      it do
+        expect(config).to receive(:before).with(:each).and_yield
+        expect(config).to receive(:after).with(:each).and_yield
+        expect(config).to receive(:after).with(:suite).and_yield
+        expect(::RSpec).to receive(:configure).and_yield(config)
+
+        expect(::RSpec).to receive(:current_example).twice.and_return(current_example)
+        expect(described_class).to receive(:test_path).with(example_group).and_return(test_path)
+
+        allow(KnapsackPro).to receive(:tracker).and_return(tracker)
+        expect(tracker).to receive(:current_test_path=).with(test_path)
+        expect(tracker).to receive(:start_timer)
+
+        expect(tracker).to receive(:stop_timer)
+
+        expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
+        expect(KnapsackPro).to receive(:logger).and_return(logger)
+        expect(logger).to receive(:info).with(global_time)
+
+        subject.bind_time_tracker
+      end
+    end
+
+    describe '#bind_save_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)
+
+        subject.bind_save_report
+      end
+    end
+  end
+end

data/spec/knapsack_pro/allocator_builder_spec.rb

@@ -0,0 +1,45 @@
+describe KnapsackPro::AllocatorBuilder 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)
+
+      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)
+    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/allocator_spec.rb

@@ -0,0 +1,80 @@
+describe KnapsackPro::Allocator do
+  let(:test_files) { double }
+  let(:ci_node_total) { double }
+  let(:ci_node_index) { double }
+  let(:repository_adapter) { instance_double(KnapsackPro::RepositoryAdapters::EnvAdapter, commit_hash: double, branch: double) }
+
+  let(:allocator) do
+    described_class.new(
+      test_files: test_files,
+      ci_node_total: ci_node_total,
+      ci_node_index: ci_node_index,
+      repository_adapter: repository_adapter
+    )
+  end
+
+  describe '#test_file_paths' do
+    let(:response) { double }
+
+    subject { allocator.test_file_paths }
+
+    before do
+      action = double
+      expect(KnapsackPro::Client::API::V1::BuildDistributions).to receive(:subset).with({
+        commit_hash: repository_adapter.commit_hash,
+        branch: repository_adapter.branch,
+        node_total: ci_node_total,
+        node_index: ci_node_index,
+        test_files: 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
+
+        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 }
+
+      before do
+        test_flat_distributor = instance_double(KnapsackPro::TestFlatDistributor)
+        expect(KnapsackPro::TestFlatDistributor).to receive(:new).with(test_files, ci_node_total).and_return(test_flat_distributor)
+        expect(test_flat_distributor).to receive(:test_files_for_node).with(ci_node_index).and_return([
+          { 'path' => 'c_spec.rb' },
+          { 'path' => 'd_spec.rb' },
+        ])
+      end
+
+      it { should eq ['c_spec.rb', 'd_spec.rb'] }
+    end
+  end
+end

data/spec/knapsack_pro/client/api/action_spec.rb

@@ -0,0 +1,17 @@
+describe KnapsackPro::Client::API::Action do
+  let(:endpoint_path) { double }
+  let(:http_method) { double }
+  let(:request_hash) { double }
+
+  subject do
+    described_class.new(
+      endpoint_path: endpoint_path,
+      http_method: http_method,
+      request_hash: request_hash
+    )
+  end
+
+  its(:endpoint_path) { should eq endpoint_path }
+  its(:http_method) { should eq http_method }
+  its(:request_hash) { should eq request_hash }
+end

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

@@ -0,0 +1,2 @@
+describe KnapsackPro::Client::API::V1::Base do
+end

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

@@ -0,0 +1,35 @@
+describe KnapsackPro::Client::API::V1::BuildDistributions do
+  describe '.subset' do
+    let(:commit_hash) { double }
+    let(:branch) { double }
+    let(:node_total) { double }
+    let(:node_index) { double }
+    let(:test_files) { double }
+
+    subject do
+      described_class.subset(
+        commit_hash: commit_hash,
+        branch: branch,
+        node_total: node_total,
+        node_index: node_index,
+        test_files: test_files
+      )
+    end
+
+    it do
+      action = double
+      expect(KnapsackPro::Client::API::Action).to receive(:new).with({
+        endpoint_path: '/v1/build_distributions/subset',
+        http_method: :post,
+        request_hash: {
+          commit_hash: commit_hash,
+          branch: branch,
+          node_total: node_total,
+          node_index: node_index,
+          test_files: test_files
+        }
+      }).and_return(action)
+      expect(subject).to eq action
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+describe KnapsackPro::Client::API::V1::BuildSubsets do
+  describe '.create' do
+    let(:commit_hash) { double }
+    let(:branch) { double }
+    let(:node_total) { double }
+    let(:node_index) { double }
+    let(:test_files) { double }
+
+    subject do
+      described_class.create(
+        commit_hash: commit_hash,
+        branch: branch,
+        node_total: node_total,
+        node_index: node_index,
+        test_files: test_files
+      )
+    end
+
+    it do
+      action = double
+      expect(KnapsackPro::Client::API::Action).to receive(:new).with({
+        endpoint_path: '/v1/build_subsets',
+        http_method: :post,
+        request_hash: {
+          commit_hash: commit_hash,
+          branch: branch,
+          node_total: node_total,
+          node_index: node_index,
+          test_files: test_files
+        }
+      }).and_return(action)
+      expect(subject).to eq action
+    end
+  end
+end

data/spec/knapsack_pro/client/connection_spec.rb

@@ -0,0 +1,138 @@
+describe KnapsackPro::Client::Connection do
+  let(:endpoint_path) { '/v1/fake_endpoint' }
+  let(:http_method) { :post }
+  let(:request_hash) { { fake: 'hash' } }
+  let(:action) do
+    instance_double(KnapsackPro::Client::API::Action,
+                    endpoint_path: endpoint_path,
+                    http_method: http_method,
+                    request_hash: request_hash)
+  end
+
+  let(:connection) { described_class.new(action) }
+
+  before do
+    stub_const('ENV', {
+      'KNAPSACK_PRO_ENDPOINT' => 'http://api.knapsackpro.dev:3000',
+      'KNAPSACK_PRO_TEST_SUITE_TOKEN' => '3fa64859337f6e56409d49f865d13fd7',
+    })
+  end
+
+  describe '#call' do
+    let(:logger) { instance_double(Logger) }
+
+    subject { connection.call }
+
+    context 'when http method is POST' do
+      before do
+        http = instance_double(Net::HTTP)
+
+        expect(Net::HTTP).to receive(:new).with('api.knapsackpro.dev', 3000).and_return(http)
+
+        expect(http).to receive(:use_ssl=).with(false)
+        expect(http).to receive(:open_timeout=).with(15)
+        expect(http).to receive(:read_timeout=).with(15)
+
+        header = { 'X-Request-Id' => 'fake-uuid' }
+        http_response = instance_double(Net::HTTPOK, body: body, header: header)
+        expect(http).to receive(:post).with(
+          endpoint_path,
+          "{\"fake\":\"hash\",\"test_suite_token\":\"3fa64859337f6e56409d49f865d13fd7\"}",
+          { "Content-Type" => "application/json", "Accept" => "application/json" }
+        ).and_return(http_response)
+
+        expect(KnapsackPro).to receive(:logger).exactly(3).and_return(logger)
+        expect(logger).to receive(:info).with('API request UUID: fake-uuid')
+        expect(logger).to receive(:info).with('API response:')
+      end
+
+      context 'when body response is json' do
+        let(:body) { '{"errors": "value"}' }
+
+        it do
+          parsed_response = { 'errors' => 'value' }
+
+          expect(logger).to receive(:error).with(parsed_response)
+
+          expect(subject).to eq(parsed_response)
+          expect(connection.success?).to be true
+          expect(connection.errors?).to be true
+        end
+      end
+
+      context 'when body response is empty' do
+        let(:body) { '' }
+
+        it do
+          expect(logger).to receive(:info).with('')
+
+          expect(subject).to eq('')
+          expect(connection.success?).to be true
+          expect(connection.errors?).to be false
+        end
+      end
+    end
+  end
+
+  describe '#success?' do
+    subject { connection.success? }
+
+    before do
+      allow(connection).to receive(:response).and_return(response)
+    end
+
+    context 'when response has no value' do
+      let(:response) { nil }
+
+      it { should be false }
+    end
+
+    context 'when response has value' do
+      let(:response) do
+        { 'fake' => 'response' }
+      end
+
+      it { should be true }
+    end
+  end
+
+  describe '#errors?' do
+    subject { connection.errors? }
+
+    before do
+      allow(connection).to receive(:response).and_return(response)
+    end
+
+    context 'when response has no value' do
+      let(:response) { nil }
+
+      it { should be false }
+    end
+
+    context 'when response has value' do
+      context 'when response has no errors' do
+        let(:response) do
+          { 'fake' => 'response' }
+        end
+
+        it { should be false }
+      end
+
+      context 'when response has errors' do
+        let(:response) do
+          { 'errors' => [{ 'field' => 'is wrong' }] }
+        end
+
+        it { should be true }
+      end
+
+      context 'when response has error (i.e. internal server error)' do
+        let(:response) do
+          { 'error' => 'Internal Server Error' }
+        end
+
+        it { should be true }
+      end
+    end
+  end
+end