polishgeeks-dev-tools 1.0.0

data/spec/lib/polishgeeks/dev-tools/command/allowed_extensions_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Command::AllowedExtensions do
+  subject { described_class.new }
+
+  describe '#execute' do
+    let(:file_name) { 'file.rb' }
+    let(:files) { [PolishGeeks::DevTools.app_root + '/config/' + file_name] }
+    before do
+      expect(Dir)
+        .to receive(:[])
+        .and_return(files)
+      expect(described_class::ALLOWED_EXTENSIONS)
+        .to receive(:any?)
+        .and_return(allow_extension)
+
+      subject.execute
+    end
+
+    context 'when we dont have invalid files' do
+      let(:allow_extension) { true }
+      it { expect(subject.output).to eq [] }
+    end
+
+    context 'when we have invalid files' do
+      let(:allow_extension) { false }
+      it { expect(subject.output).to eq [file_name] }
+    end
+  end
+
+  describe '#label' do
+    let(:expected) { 'Allowed Extensions' }
+
+    it { expect(subject.label).to eq expected }
+  end
+
+  describe '#error_message' do
+    let(:output) { [rand.to_s, rand.to_s] }
+    let(:expected) do
+      'Following files are not allowed in config directory:'\
+      "\n\n#{output.join("\n")}\n"
+    end
+
+    before do
+      subject.instance_variable_set('@output', output)
+    end
+
+    it { expect(subject.error_message).to eq expected }
+  end
+
+  describe do
+    before do
+      subject.instance_variable_set('@output', output)
+    end
+
+    context 'when output is empty' do
+      let(:output) { '' }
+      it { expect(subject.valid?).to eq true }
+    end
+
+    context 'when output is empty' do
+      let(:output) { rand.to_s }
+      it { expect(subject.valid?).to eq false }
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Command::Base do
+  subject { described_class.new }
+
+  describe '#execute' do
+    it { expect { subject.execute }. to raise_error(NotImplementedError) }
+  end
+
+  describe '#valid?' do
+    it { expect { subject.valid? }. to raise_error(NotImplementedError) }
+  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 '#new' do
+    it 'should execute ensure_framework_if_required' do
+      expect_any_instance_of(described_class)
+        .to receive(:ensure_framework_if_required)
+        .once
+
+      described_class.new
+    end
+  end
+
+  describe '#ensure_framework_if_required' do
+    context 'when there is no framework required' do
+      before { described_class.framework = nil }
+
+      it { expect { subject.send(:ensure_framework_if_required) }.to_not raise_error }
+    end
+
+    context 'when there rails is required' do
+      before { described_class.framework = :rails }
+
+      context 'and it is included' do
+        before do
+          expect(PolishGeeks::DevTools)
+            .to receive(:config)
+            .and_return(double(rails?: true))
+            .exactly(2).times
+        end
+
+        it { expect { subject.send(:ensure_framework_if_required) }.to_not raise_error }
+      end
+
+      context 'and it is not included' do
+        before do
+          expect(PolishGeeks::DevTools)
+            .to receive(:config)
+            .and_return(double(rails?: false))
+        end
+
+        it 'should raise exception' do
+          error = described_class::MissingFramework
+          expect { subject.send(:ensure_framework_if_required) }.to raise_error(error, 'rails')
+        end
+      end
+    end
+
+    context 'when there sinatra is required' do
+      before { described_class.framework = :sinatra }
+
+      context 'and it is included' do
+        before do
+          expect(PolishGeeks::DevTools)
+            .to receive(:config)
+            .and_return(double(sinatra?: true))
+            .exactly(2).times
+        end
+
+        it { expect { subject.send(:ensure_framework_if_required) }.to_not raise_error }
+      end
+
+      context 'and it is not included' do
+        before do
+          expect(PolishGeeks::DevTools)
+            .to receive(:config)
+            .and_return(double(sinatra?: false))
+        end
+
+        it 'should raise exception' do
+          error = described_class::MissingFramework
+          expect { subject.send(:ensure_framework_if_required) }.to raise_error(error, 'sinatra')
+        end
+      end
+    end
+  end
+
+  describe 'class type definer' do
+    subject { described_class.dup }
+
+    context 'when it is generator' do
+      before { subject.type = :generator }
+
+      describe '.generator?' do
+        it { expect(subject.generator?).to eq true }
+      end
+
+      describe '.validator?' do
+        it { expect(subject.validator?).to eq false }
+      end
+    end
+
+    context 'when it is validator' do
+      before { subject.type = :validator }
+
+      describe '.generator?' do
+        it { expect(subject.generator?).to eq false }
+      end
+
+      describe '.validator?' do
+        it { expect(subject.validator?).to eq true }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Command::Brakeman do
+  subject { described_class.new }
+  let(:config) { double(rails?: true) }
+
+  before do
+    expect(PolishGeeks::DevTools)
+      .to receive(:config)
+      .and_return(config)
+
+    subject
+  end
+
+  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/command/coverage_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Command::Coverage 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 'Coverage 95.0% covered - 65.0% required'
+      end
+    end
+  end
+
+  describe '#error_message' do
+    context 'when we run simplecov and cc 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 the error message' do
+        expect(subject.error_message)
+          .to eq 'Coverage level should more or equal to 95.0%. was: 65.0'
+      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/command/examples_comparator_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Command::ExamplesComparator do
+  subject { described_class.new }
+
+  let(:example_file) { rand.to_s }
+  let(:dedicated_file) { rand.to_s }
+
+  describe '#execute' do
+    let(:config_path) { rand.to_s }
+
+    before do
+      expect(subject)
+        .to receive(:config_path)
+        .and_return(config_path)
+
+      expect(subject)
+        .to receive(:same_key_structure?)
+        .and_return(compare_result)
+
+      expect(Dir)
+        .to receive(:[])
+        .with(config_path)
+        .and_return([example_file])
+    end
+
+    context 'when compared files structure is the same' do
+      let(:compare_result) { true }
+
+      it 'should put a successful message into output' do
+        subject.execute
+
+        expect(subject.output).to include 'success'
+      end
+    end
+
+    context 'when compared files structure is not the same' do
+      let(:compare_result) { false }
+
+      it 'should put a failed message into output' do
+        subject.execute
+        expect(subject.output).to include 'failed'
+      end
+    end
+  end
+
+  describe '#config_path' do
+    let(:expected) do
+      "#{File.expand_path(PolishGeeks::DevTools.app_root + '/config')}/**/*.yml.example"
+    end
+
+    it 'should be equal to expected message' do
+      expect(subject.send(:config_path)).to eq expected
+    end
+  end
+
+  describe '#successful_compare' do
+    let(:compare_header) { rand.to_s }
+    let(:expected) { "\e[32m success\e[0m - #{compare_header}\n" }
+
+    it 'should be equal to expected message' do
+      expect(subject.send(:successful_compare, compare_header)).to eq expected
+    end
+  end
+
+  describe '#failed_compare' do
+    let(:compare_header) { rand.to_s }
+    let(:expected) { "\e[31m failed\e[0m - #{compare_header} - structure not equal\n" }
+
+    it 'should be equal to expected message' do
+      expect(subject.send(:failed_compare, compare_header)).to eq expected
+    end
+  end
+
+  describe '#compare_header' do
+    let(:expected) { "#{File.basename(example_file)} and #{File.basename(dedicated_file)}" }
+
+    it 'should be equal to expected message' do
+      expect(subject.send(:compare_header, example_file, dedicated_file)).to eq expected
+    end
+  end
+
+  describe '#same_key_structure?' do
+    let(:structure1) { double }
+    let(:structure2) { double }
+    let(:hash) { double }
+
+    before do
+      expect(PolishGeeks::DevTools::Hash)
+        .to receive(:new)
+        .and_return(hash)
+        .exactly(2).times
+
+      expect(YAML)
+        .to receive(:load_file)
+        .with(example_file)
+        .and_return(structure1)
+
+      expect(YAML)
+        .to receive(:load_file)
+        .with(dedicated_file)
+        .and_return(structure2)
+
+      expect(hash)
+        .to receive(:merge!)
+        .exactly(2).times
+
+      expect(hash)
+        .to receive(:same_key_structure?)
+        .and_return(result)
+    end
+
+    context 'when structure is the same' do
+      let(:result) { true }
+
+      it '' do
+        executed = subject.send(
+          :same_key_structure?,
+          example_file,
+          dedicated_file
+        )
+
+        expect(executed).to eq result
+      end
+    end
+
+    context 'when structure is not the same' do
+      let(:result) { false }
+
+      it '' do
+        executed = subject.send(
+          :same_key_structure?,
+          example_file,
+          dedicated_file
+        )
+
+        expect(executed).to eq result
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'when example files have the same structure' do
+      before do
+        subject.instance_variable_set(:@output, 'OK')
+      end
+
+      it 'should return true' do
+        expect(subject.valid?).to eq true
+      end
+    end
+
+    context 'when example files do not have the same structure' do
+      before do
+        subject.instance_variable_set(:@output, 'failed')
+      end
+
+      it 'should return false' do
+        expect(subject.valid?).to eq false
+      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