polishgeeks-dev-tools 1.2.1 → 1.3.0

data/lib/polishgeeks/dev-tools/commands/readme.rb

@@ -1,32 +0,0 @@
-module PolishGeeks
-  module DevTools
-    module Commands
-      # Checks README.rb exists
-      class Readme < Base
-        self.type = :validator
-
-        # Executes this command
-        # @return [String] command output
-        def execute
-          readme = File.join(::PolishGeeks::DevTools.app_root, 'README.md')
-          @output = File.exist?(readme)
-        end
-
-        # @return [String] label with this validator description
-        def label
-          'README.rb required'
-        end
-
-        # @return [String] error message
-        def error_message
-          "README.rb doesn't exist!"
-        end
-
-        # @return [Boolean] true if README.rb exist
-        def valid?
-          @output
-        end
-      end
-    end
-  end
-end

data/spec/lib/polishgeeks/dev-tools/commands/base_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe PolishGeeks::DevTools::Commands::Base do
-  subject { described_class.new }
-
-  describe '#execute' do
-    let(:error) { PolishGeeks::DevTools::Errors::NotImplementedError }
-    it { expect { subject.execute }. to raise_error(error) }
-  end
-
-  describe '#valid?' do
-    let(:error) { PolishGeeks::DevTools::Errors::NotImplementedError }
-    it { expect { subject.valid? }. to raise_error(error) }
-  end
-
-  describe '#error_message' do
-    let(:output) { rand.to_s }
-
-    before do
-      subject.instance_variable_set('@output', output)
-    end
-
-    it 'by default should equal raw output' do
-      expect(subject.error_message).to eq output
-    end
-  end
-
-  describe '#ensure_executable!' do
-    context 'when there are validators' do
-      let(:validator_class) { PolishGeeks::DevTools::Validators::Base }
-
-      before do
-        expect(described_class)
-          .to receive(:validators)
-          .and_return([validator_class])
-
-        expect_any_instance_of(validator_class)
-          .to receive(:valid?)
-          .and_return(true)
-      end
-
-      it { expect { subject.ensure_executable! }.not_to raise_error }
-    end
-
-    context 'when we dont require any validators' do
-      before do
-        expect(described_class)
-          .to receive(:validators)
-          .and_return([])
-      end
-
-      it { expect { subject.ensure_executable! }.not_to raise_error }
-    end
-  end
-end

data/spec/lib/polishgeeks/dev-tools/commands/brakeman_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe PolishGeeks::DevTools::Commands::Brakeman do
-  subject { described_class }
-
-  describe '#validators' do
-    it 'should work only when we have Rails framework' do
-      expect(subject.validators).to eq [PolishGeeks::DevTools::Validators::Rails]
-    end
-  end
-end
-
-RSpec.describe PolishGeeks::DevTools::Commands::Brakeman do
-  subject { described_class.new }
-
-  describe '#execute' do
-    context 'when we run brakeman' do
-      before do
-        expect_any_instance_of(PolishGeeks::DevTools::Shell)
-          .to receive(:execute)
-          .with('bundle exec brakeman -q')
-      end
-
-      it 'should execute the command' do
-        subject.execute
-      end
-    end
-  end
-
-  describe '#valid?' do
-    context 'when warnings are equal 0' do
-      before do
-        expect(subject)
-          .to receive(:warnings)
-          .and_return(0)
-      end
-
-      context 'and errors are equal 0' do
-        before do
-          expect(subject)
-            .to receive(:errors)
-            .and_return(0)
-        end
-
-        it 'should return true' do
-          expect(subject.valid?).to eq true
-        end
-      end
-
-      context 'and errors are not equal 0' do
-        before do
-          expect(subject)
-            .to receive(:errors)
-            .and_return(1)
-        end
-
-        it 'should return true' do
-          expect(subject.valid?).to eq false
-        end
-      end
-    end
-  end
-
-  describe 'label' do
-    let(:models) { rand(1000) }
-    let(:controllers) { rand(1000) }
-    let(:templates) { rand(1000) }
-
-    before do
-      expect(subject).to receive(:models).and_return(models)
-      expect(subject).to receive(:controllers).and_return(controllers)
-      expect(subject).to receive(:templates).and_return(templates)
-    end
-
-    it 'should use details' do
-      label = "Brakeman (#{controllers} con, #{models} mod, #{templates} temp)"
-      expect(subject.label).to eq label
-    end
-  end
-
-  describe 'counter' do
-    described_class::REGEXPS.each do |name, _regexp|
-      describe "##{name}" do
-        let(:amount) { rand(1000) }
-
-        before do
-          subject.instance_variable_set(:@output, "#{name.to_s.capitalize} #{amount}")
-        end
-
-        it 'should return a proper value' do
-          expect(subject.send(name)).to eq amount
-        end
-      end
-    end
-  end
-end

data/spec/lib/polishgeeks/dev-tools/commands/readme_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe PolishGeeks::DevTools::Commands::Readme do
-  subject { described_class.new }
-
-  let(:config) { double }
-
-  describe '#execute' do
-    it 'should execute the command' do
-      subject.execute
-    end
-  end
-
-  describe '#label' do
-    let(:expected) { 'README.rb required' }
-
-    it { expect(subject.label).to eq expected }
-  end
-
-  describe '#error_message' do
-    let(:expected) { "README.rb doesn't exist!" }
-    let(:output) { false }
-
-    it { expect(subject.error_message).to eq expected }
-  end
-
-  describe '#valid?' do
-    context 'when README.md exist' do
-      before do
-        subject.instance_variable_set('@output', true)
-      end
-
-      it 'should return true' do
-        expect(subject.valid?).to be true
-      end
-    end
-  end
-end

data/spec/lib/polishgeeks/dev-tools/commands/rspec_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe PolishGeeks::DevTools::Commands::Rspec do
-  subject { described_class.new }
-
-  describe '#execute' do
-    context 'when we run rspec' do
-      before do
-        expect_any_instance_of(PolishGeeks::DevTools::Shell)
-          .to receive(:execute)
-          .with('bundle exec rspec spec')
-      end
-
-      it 'should execute the command' do
-        subject.execute
-      end
-    end
-  end
-
-  describe '#valid?' do
-    context 'when there are some failures' do
-      before do
-        subject.instance_variable_set(:@output, '2 failures')
-      end
-
-      it 'should return false' do
-        expect(subject.valid?).to eq false
-      end
-    end
-
-    context 'when there are not any failures' do
-      before do
-        subject.instance_variable_set(:@output, '0 failures')
-      end
-
-      it 'should return true' do
-        expect(subject.valid?).to eq true
-      end
-    end
-  end
-
-  describe '#label' do
-    context 'when we run rspec' do
-      let(:label) { '10 examples, 5 failures, 2 pending' }
-
-      before do
-        subject.instance_variable_set(:@output, label)
-      end
-
-      it 'should return the label' do
-        expect(subject.label).to eq 'Rspec (10 ex, 5 fa, 2 pe)'
-      end
-    end
-  end
-
-  describe '.generator?' do
-    it { expect(described_class.generator?).to eq false }
-  end
-
-  describe '.validator?' do
-    it { expect(described_class.validator?).to eq true }
-  end
-end

data/spec/lib/polishgeeks/dev-tools/commands/rubocop_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe PolishGeeks::DevTools::Commands::Rubocop do
-  subject { described_class.new }
-
-  describe '#execute' do
-    let(:path) { '/' }
-    before do
-      expect(ENV)
-        .to receive(:[])
-        .with('BUNDLE_GEMFILE')
-        .and_return(path)
-        .at_least(:once)
-    end
-
-    context 'when app config exists' do
-      before do
-        expect(File)
-          .to receive(:exist?)
-          .and_return(true)
-        expect_any_instance_of(PolishGeeks::DevTools::Shell)
-          .to receive(:execute)
-          .with("bundle exec rubocop -c #{path}.rubocop.yml #{PolishGeeks::DevTools.app_root}")
-      end
-
-      it 'should execute the command' do
-        subject.execute
-      end
-    end
-
-    context 'when app config does not exist' do
-      let(:path) { Dir.pwd }
-      let(:app_root) { PolishGeeks::DevTools.app_root }
-      let(:cmd_expected) { "bundle exec rubocop -c #{path}/config/rubocop.yml #{app_root}" }
-
-      before do
-        expect(PolishGeeks::DevTools)
-          .to receive(:gem_root)
-          .and_return(path)
-        expect(File)
-          .to receive(:exist?)
-          .and_return(false)
-        expect_any_instance_of(PolishGeeks::DevTools::Shell)
-          .to receive(:execute)
-          .with(cmd_expected)
-      end
-
-      it 'should execute the command' do
-        subject.execute
-      end
-    end
-  end
-
-  describe '#valid?' do
-    context 'when offenses count is equal 0' do
-      before do
-        expect(subject)
-          .to receive(:offenses_count)
-          .and_return(0)
-      end
-
-      it 'should return true' do
-        expect(subject.valid?).to eq true
-      end
-    end
-
-    context 'when offenses count is different from 0' do
-      before do
-        expect(subject)
-          .to receive(:offenses_count)
-          .and_return(100)
-      end
-
-      it 'should return false' do
-        expect(subject.valid?).to eq false
-      end
-    end
-  end
-
-  describe '#label' do
-    context 'when we run rubocop' do
-      before do
-        expect(subject)
-          .to receive(:files_count)
-          .and_return(10)
-        expect(subject)
-          .to receive(:offenses_count)
-          .and_return(5)
-      end
-      it 'should return the label' do
-        expect(subject.label).to eq 'Rubocop (10 files, 5 offenses)'
-      end
-    end
-  end
-
-  describe '#files_count' do
-    context 'when we count files' do
-      before do
-        subject.instance_variable_set(:@output, '10 files inspected')
-      end
-
-      it 'should return a proper value' do
-        expect(subject.send(:files_count)).to eq 10
-      end
-    end
-  end
-
-  describe '#offenses_count' do
-    context 'when we count offenses' do
-      before do
-        subject.instance_variable_set(:@output, '5 offenses detected')
-      end
-
-      it 'should return a proper value' do
-        expect(subject.send(:offenses_count)).to eq 5
-      end
-    end
-  end
-
-  describe '.generator?' do
-    it { expect(described_class.generator?).to eq false }
-  end
-
-  describe '.validator?' do
-    it { expect(described_class.validator?).to eq true }
-  end
-end

data/spec/lib/polishgeeks/dev-tools/commands/simplecov_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe PolishGeeks::DevTools::Commands::Simplecov do
-  subject { described_class }
-
-  describe '#validators' do
-    it 'should work only when we have Simplecov' do
-      expect(subject.validators).to eq [PolishGeeks::DevTools::Validators::Simplecov]
-    end
-  end
-end
-
-RSpec.describe PolishGeeks::DevTools::Commands::Simplecov do
-  subject { described_class.new }
-
-  let(:label) { '(95.00%) covered' }
-  let(:config) { double }
-
-  describe '#to_f' do
-    context 'when we run simplecov' do
-      before do
-        subject.instance_variable_set(:@output, label)
-      end
-
-      it 'should return number of coverage as a float value' do
-        expect(subject.to_f).to eq 95.00
-      end
-    end
-  end
-
-  describe '#execute' do
-    context 'when we run simplecov' do
-      let(:output) { OpenStruct.new(rspec: label) }
-
-      before do
-        subject.instance_variable_set(:@stored_output, output)
-      end
-
-      it 'should execute the command' do
-        expect(subject.execute).to eq label
-      end
-    end
-  end
-
-  describe '#valid?' do
-    context 'when cc level is greater or equal than expected' do
-      before do
-        expect(subject)
-          .to receive(:to_f)
-          .and_return(95.0)
-        expect(PolishGeeks::DevTools::Config)
-          .to receive(:config)
-          .and_return(config)
-        expect(config)
-          .to receive(:simplecov_threshold)
-          .and_return(65.0)
-      end
-
-      it 'should return true' do
-        expect(subject.valid?).to eq true
-      end
-    end
-
-    context 'when cc level is less than expected' do
-      before do
-        expect(subject)
-          .to receive(:to_f)
-          .and_return(65.0)
-        expect(PolishGeeks::DevTools::Config)
-          .to receive(:config)
-          .and_return(config)
-        expect(config)
-          .to receive(:simplecov_threshold)
-          .and_return(95.0)
-      end
-
-      it 'should return false' do
-        expect(subject.valid?).to eq false
-      end
-    end
-  end
-
-  describe '#label' do
-    context 'when we run simplecov and cc is greater or equal than expected' do
-      before do
-        expect(subject)
-          .to receive(:to_f)
-          .and_return(95.0)
-        expect(PolishGeeks::DevTools::Config)
-          .to receive(:config)
-          .and_return(config)
-        expect(config)
-          .to receive(:simplecov_threshold)
-          .and_return(65.0)
-      end
-
-      it 'should return the label' do
-        expect(subject.label).to eq 'SimpleCov covered 95.0%, required 65.0%'
-      end
-    end
-  end
-
-  describe '#error_message' do
-    context 'when we run simplecov and cc is less than expected' do
-      before { allow(subject).to receive(:to_f) { 65.0 } }
-
-      context 'and threshold is 95%' do
-        before { allow(subject).to receive(:threshold) { 95.0 } }
-
-        it 'should return the error message' do
-          expect(subject.error_message)
-            .to eq 'SimpleCov coverage level needs to be 95.0% or more, was 65.0%'
-        end
-      end
-
-      context 'and threshold is 100%' do
-        before { allow(subject).to receive(:threshold) { 100.0 } }
-
-        it 'should return the error message' do
-          expect(subject.error_message)
-            .to eq 'SimpleCov coverage level needs to be 100.0%, was 65.0%'
-        end
-      end
-    end
-  end
-
-  describe '.generator?' do
-    it { expect(described_class.generator?).to eq false }
-  end
-
-  describe '.validator?' do
-    it { expect(described_class.validator?).to eq true }
-  end
-end