knapsack_pro 0.0.1 → 0.1.0

data/spec/knapsack_pro/logger_wrapper_spec.rb

@@ -0,0 +1,15 @@
+describe KnapsackPro::LoggerWrapper do
+  let(:io) { StringIO.new }
+  let(:logger) { ::Logger.new(io) }
+  let(:logger_wrapper) { described_class.new(logger) }
+
+  subject { io.string }
+
+  [:debug, :info, :warn, :error, :fatal].each do |log_level|
+    describe "##{log_level}" do
+      before {logger_wrapper.public_send(log_level, 'Test message') }
+
+      it { should eq "[knapsack_pro] Test message\n" }
+    end
+  end
+end

data/spec/knapsack_pro/presenter_spec.rb

@@ -0,0 +1,57 @@
+describe KnapsackPro::Presenter do
+  describe '.global_time' do
+    let(:tracker) { instance_double(KnapsackPro::Tracker, global_time: 60*62+3) }
+
+    subject { described_class.global_time }
+
+    before do
+      expect(KnapsackPro).to receive(:tracker).and_return(tracker)
+    end
+
+    it { should eql "Global time execution for tests: 01h 02m 03s" }
+  end
+
+  describe '.pretty_seconds' do
+    subject { described_class.pretty_seconds(seconds) }
+
+    context 'when less then one second' do
+      let(:seconds) { 0.987 }
+      it { should eql '0.987s' }
+    end
+
+    context 'when one second' do
+      let(:seconds) { 1 }
+      it { should eql '01s' }
+    end
+
+    context 'when only seconds' do
+      let(:seconds) { 5 }
+      it { should eql '05s' }
+    end
+
+    context 'when only minutes' do
+      let(:seconds) { 120 }
+      it { should eql '02m' }
+    end
+
+    context 'when only hours' do
+      let(:seconds) { 60*60*3 }
+      it { should eql '03h' }
+    end
+
+    context 'when minutes and seconds' do
+      let(:seconds) { 180+9 }
+      it { should eql '03m 09s' }
+    end
+
+    context 'when all' do
+      let(:seconds) { 60*60*4+120+7 }
+      it { should eql '04h 02m 07s' }
+    end
+
+    context 'when negative seconds' do
+      let(:seconds) { -67 }
+      it { should eql '-01m 07s' }
+    end
+  end
+end

data/spec/knapsack_pro/report_spec.rb

@@ -0,0 +1,68 @@
+describe KnapsackPro::Report do
+  describe '.save' do
+    subject { described_class.save }
+
+    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)
+
+      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)
+
+      test_files = double
+      tracker = instance_double(KnapsackPro::Tracker, to_a: test_files)
+      expect(KnapsackPro).to receive(:tracker).and_return(tracker)
+
+      action = double
+      expect(KnapsackPro::Client::API::V1::BuildSubsets).to receive(:create).with({
+        commit_hash: commit_hash,
+        branch: branch,
+        node_total: node_total,
+        node_index: node_index,
+        test_files: 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
+
+    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(:info).with('Saved time execution report on API server.')
+          subject
+        end
+      end
+    end
+
+    context 'when failure' do
+      let(:success?) { false }
+      let(:errors?) { nil }
+
+      it { subject }
+    end
+  end
+end

data/spec/knapsack_pro/repository_adapter_initiator_spec.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,27 @@
+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['CIRCLE_SHA1']
+  end
+
+  describe '#branch' do
+    subject { described_class.new.branch }
+
+    it { should_not be_nil }
+    it { should eq circle_branch } if ENV['CIRCLE_BRANCH']
+  end
+end

data/spec/knapsack_pro/runners/base_runner_spec.rb

@@ -0,0 +1,61 @@
+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::Allocator) }
+    let(:allocator_builder) { instance_double(KnapsackPro::AllocatorBuilder) }
+
+    before do
+      expect(KnapsackPro::AllocatorBuilder).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
+  end
+end

data/spec/knapsack_pro/runners/cucumber_runner_spec.rb

@@ -0,0 +1,47 @@
+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' }
+
+    after { described_class.run(args) }
+
+    before do
+      stub_const("ENV", { 'KNAPSACK_PRO_TEST_SUITE_TOKEN_CUCUMBER' => 'cucumber-token' })
+
+      stringify_test_file_paths = 'features/a.feature features/b.feature'
+      runner = instance_double(described_class,
+                               stringify_test_file_paths: stringify_test_file_paths)
+      expect(described_class).to receive(:new)
+      .with(KnapsackPro::Adapters::CucumberAdapter).and_return(runner)
+
+      expect(Kernel).to receive(:system).with('KNAPSACK_PRO_RECORDING_ENABLED=true KNAPSACK_PRO_TEST_SUITE_TOKEN=cucumber-token bundle exec cucumber --custom-arg -- features/a.feature features/b.feature')
+    end
+
+    context 'when command exit with success code' do
+      let(:exitstatus) { 0 }
+
+      before do
+        expect($?).to receive(:exitstatus).and_return(exitstatus)
+      end
+
+      it do
+        expect(Kernel).not_to receive(:exit)
+      end
+    end
+
+    context 'when command exit without success code' do
+      let(:exitstatus) { 1 }
+
+      before do
+        expect($?).to receive(:exitstatus).twice.and_return(exitstatus)
+      end
+
+      it do
+        expect(Kernel).to receive(:exit).with(exitstatus)
+      end
+    end
+  end
+end

data/spec/knapsack_pro/runners/minitest_runner_spec.rb

@@ -0,0 +1,34 @@
+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
+
+    it do
+      test_file_paths = ['test_fake/a_test.rb', 'test_fake/b_test.rb']
+      runner = instance_double(described_class,
+                               test_dir: 'test',
+                               test_file_paths: test_file_paths)
+      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_RECORDING_ENABLED']).to eq 'true'
+    end
+  end
+end

data/spec/knapsack_pro/runners/rspec_runner_spec.rb

@@ -0,0 +1,49 @@
+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' }
+
+    after { described_class.run(args) }
+
+    before do
+      stub_const("ENV", { 'KNAPSACK_PRO_TEST_SUITE_TOKEN_RSPEC' => 'rspec-token' })
+
+      stringify_test_file_paths = 'spec/a_spec.rb spec/b_spec.rb'
+      runner = instance_double(described_class,
+                               test_dir: 'spec',
+                               stringify_test_file_paths: stringify_test_file_paths)
+      expect(described_class).to receive(:new)
+      .with(KnapsackPro::Adapters::RSpecAdapter).and_return(runner)
+
+      expect(Kernel).to receive(:system)
+      .with('KNAPSACK_PRO_RECORDING_ENABLED=true KNAPSACK_PRO_TEST_SUITE_TOKEN=rspec-token bundle exec rspec --profile --color --default-path spec -- spec/a_spec.rb spec/b_spec.rb')
+    end
+
+    context 'when command exit with success code' do
+      let(:exitstatus) { 0 }
+
+      before do
+        expect($?).to receive(:exitstatus).and_return(exitstatus)
+      end
+
+      it do
+        expect(Kernel).not_to receive(:exit)
+      end
+    end
+
+    context 'when command exit without success code' do
+      let(:exitstatus) { 1 }
+
+      before do
+        expect($?).to receive(:exitstatus).twice.and_return(exitstatus)
+      end
+
+      it do
+        expect(Kernel).to receive(:exit).with(exitstatus)
+      end
+    end
+  end
+end

data/spec/knapsack_pro/task_loader_spec.rb

@@ -0,0 +1,14 @@
+describe KnapsackPro::TaskLoader do
+  describe '#load_tasks' do
+    let(:rspec_rake_task_path) { "#{KnapsackPro.root}/lib/tasks/rspec.rake" }
+    let(:cucumber_rake_task_path) { "#{KnapsackPro.root}/lib/tasks/cucumber.rake" }
+    let(:minitest_rake_task_path) { "#{KnapsackPro.root}/lib/tasks/minitest.rake" }
+
+    before { allow(subject).to receive(:import) }
+    after { subject.load_tasks }
+
+    it { expect(subject).to receive(:import).with(rspec_rake_task_path) }
+    it { expect(subject).to receive(:import).with(cucumber_rake_task_path) }
+    it { expect(subject).to receive(:import).with(minitest_rake_task_path) }
+  end
+end