polishgeeks-dev-tools 1.0.0

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

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Command::YmlParser do
+  subject { described_class.new }
+
+  let(:config) { double }
+  let(:file) { rand.to_s }
+  let(:line) { rand.to_s }
+  let(:row) { { file: file, lines: [line] } }
+
+  describe '#execute' do
+    let(:results) { [file] }
+    let(:json) { { key: 'test', value: 'test' } }
+    before do
+      expect(Dir)
+        .to receive(:[])
+        .and_return(results)
+      expect(subject)
+        .to receive(:parse_yaml)
+        .with(file)
+        .and_return(json)
+      expect(subject)
+        .to receive(:check_params)
+        .and_return(json)
+    end
+
+    it 'should execute the command' do
+      subject.execute
+    end
+  end
+
+  describe '#label' do
+    it { expect(subject.label).to eq 'Yaml parser' }
+  end
+
+  describe '#error_message' do
+    let(:output) { [file: file, lines: [line]] }
+    let(:expected) { "Following yml files have nil as a value:\n#{file}:\n - Key '#{line}'\n" }
+    before do
+      subject.instance_variable_set('@output', output)
+    end
+
+    it 'should return lines with nil value' do
+      expect(subject.error_message).to eq expected
+    end
+  end
+
+  describe '#valid?' do
+    before do
+      subject.instance_variable_set('@output', '')
+    end
+
+    it { expect(subject.valid?).to eq true }
+  end
+
+  describe '#file_error' do
+    let(:expected) { "\n#{file}:\n - Key '#{line}'" }
+
+    it { expect(subject.send(:file_error, row)).to eq expected }
+  end
+
+  describe '#config_path' do
+    let(:expected) { '/**/*.yml.example' }
+    before do
+      expect(File)
+        .to receive(:expand_path)
+        .and_return('')
+    end
+    it { expect(subject.send(:config_path)).to eq expected }
+  end
+
+  describe '#sanitize' do
+    let(:file_path) { PolishGeeks::DevTools.app_root + '/config/' + file }
+
+    it { expect(subject.send(:sanitize, file_path)).to eq file }
+  end
+
+  describe '#parse_yaml' do
+    before do
+      expect(File)
+        .to receive(:open)
+        .with(file)
+        .and_return(file)
+      expect(YAML)
+        .to receive(:load)
+        .and_return(file)
+    end
+    it { expect(subject.send(:parse_yaml, file)).to eq file }
+  end
+
+  describe '#check_params' do
+    context 'when file have nil value' do
+      let(:hash) { { key: 'my_key', val: { user: 'test', pass: nil } } }
+
+      it { expect(subject.send(:check_params, hash)).to eq [:pass] }
+    end
+
+    context 'when file have not nil value' do
+      let(:hash) { { key: 'key', val: 'val' } }
+
+      it { expect(subject.send(:check_params, hash)).to be_empty }
+    end
+  end
+end

data/spec/lib/polishgeeks/dev-tools/config_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Config do
+  subject { described_class.new }
+
+  described_class::COMMANDS.each do |attribute|
+    describe "#{attribute}=" do
+      let(:value) { rand }
+      before { subject.public_send(:"#{attribute}=", value) }
+
+      it 'should assign a given value' do
+        expect(subject.public_send(attribute)).to eq value
+      end
+    end
+
+    describe "#{attribute}?" do
+      let(:value) { rand(2) == 0 }
+      before { subject.public_send(:"#{attribute}=", value) }
+
+      it 'should assign a given value' do
+        expect(subject.public_send(:"#{attribute}?")).to eq value
+      end
+    end
+  end
+
+  describe '.setup' do
+    subject { described_class }
+    let(:instance) { described_class.new }
+    let(:block) { -> {} }
+
+    before do
+      instance
+
+      expect(subject)
+        .to receive(:new)
+        .and_return(instance)
+
+      expect(block)
+        .to receive(:call)
+        .with(instance)
+
+      expect(instance)
+        .to receive(:freeze)
+    end
+
+    it { subject.setup(&block) }
+  end
+
+  describe '#detect_framework' do
+    before do
+      subject. detect_framework
+    end
+
+    describe '#rails?' do
+      context 'when Rails is not defined' do
+        it { expect(subject.rails?).to eq false }
+      end
+    end
+
+    describe '#sinatra?' do
+      context 'when Sinatra is not defined' do
+        it { expect(subject.sinatra?).to eq false }
+      end
+    end
+  end
+
+  describe '#initialize' do
+    described_class::COMMANDS.each do |attribute|
+      it "should have #{attribute} command turned on by default" do
+        expect(subject.public_send(attribute)).to eq true
+      end
+    end
+
+    it 'should have simplecov_threshold set to 100 by default' do
+      expect(subject.simplecov_threshold).to eq 100
+    end
+  end
+end

data/spec/lib/polishgeeks/dev-tools/hash_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Hash do
+  describe 'same_key_structure?' do
+    subject { h1.same_key_structure?(h2) }
+
+    context 'when both are empty' do
+      let(:h1) { PolishGeeks::DevTools::Hash.new }
+      let(:h2) { PolishGeeks::DevTools::Hash.new }
+
+      it { expect(subject).to be true }
+    end
+
+    context 'when first hash is not equal to second' do
+      context 'on the first level' do
+        let(:h1) { PolishGeeks::DevTools::Hash.new.merge(a: 1) }
+        let(:h2) { PolishGeeks::DevTools::Hash.new.merge(b: 1) }
+
+        it { expect(subject).to be false }
+      end
+
+      context 'on the second level' do
+        let(:h1) { PolishGeeks::DevTools::Hash.new.merge(a: { b: 2 }) }
+        let(:h2) { PolishGeeks::DevTools::Hash.new.merge(a: { c: 3 }) }
+
+        it { expect(subject).to be false }
+      end
+    end
+
+    context 'when they have same structure but different data' do
+      let(:h1) { PolishGeeks::DevTools::Hash.new.merge(a: { b: rand }) }
+      let(:h2) { PolishGeeks::DevTools::Hash.new.merge(a: { b: rand }) }
+
+      it { expect(subject).to be true }
+    end
+  end
+end

data/spec/lib/polishgeeks/dev-tools/logger_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Logger do
+  subject { described_class.new }
+
+  let(:task) { PolishGeeks::DevTools::Command::Rubocop.new }
+  let(:tmp) { double }
+
+  describe '#log' do
+    context 'when we print an output' do
+      before do
+        expect(task)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:generator?)
+          .and_return(true)
+        expect(subject)
+          .to receive(:info)
+          .with(task)
+      end
+
+      it 'should return some information' do
+        subject.log(task)
+      end
+    end
+
+    context 'when we print an output with an error' do
+      before do
+        expect(tmp)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:generator?)
+          .and_return(false)
+        expect(tmp)
+          .to receive(:valid?)
+          .and_return(false)
+        expect(subject)
+          .to receive(:fatal)
+          .with(tmp)
+      end
+
+      it 'should raise RequirementsError' do
+        expect { subject.log(tmp) }
+          .to raise_error PolishGeeks::DevTools::Logger::RequirementsError
+      end
+    end
+  end
+
+  describe '#info' do
+    context 'when we print a final message for a validator' do
+      before do
+        expect(task)
+          .to receive(:label)
+          .and_return('Rubocop')
+        expect(task)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:generator?)
+          .and_return(false)
+        expect(task)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:validator?)
+          .and_return(true)
+      end
+
+      it 'should display "OK" text' do
+        expect(subject)
+          .to receive(:printf)
+          .with('%-40s %2s', 'Rubocop ', "\e[32mOK\e[0m\n")
+        subject.send(:info, task)
+      end
+    end
+
+    context 'when we print a final message for a generator' do
+      before do
+        expect(task)
+          .to receive(:label)
+          .and_return('Rubocop')
+        expect(task)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:generator?)
+          .and_return(true)
+        expect(task)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:validator?)
+          .and_return(false)
+      end
+
+      it 'should display "OK" text' do
+        expect(subject)
+          .to receive(:printf)
+          .with('%-40s %2s', 'Rubocop ', "\e[32mGENERATED\e[0m\n")
+        subject.send(:info, task)
+      end
+    end
+
+    context 'when a task fails' do
+      before do
+        expect(tmp)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:generator?)
+          .and_return(false)
+        expect(tmp)
+          .to receive(:class)
+          .and_return(tmp)
+        expect(tmp)
+          .to receive(:validator?)
+          .and_return(false)
+      end
+
+      it 'should raise UnknownTaskType' do
+        expect { subject.send(:info, tmp) }
+          .to raise_error PolishGeeks::DevTools::Logger::UnknownTaskType
+      end
+    end
+  end
+
+  describe '#fatal' do
+    context 'when a task failed' do
+      before do
+        expect(task)
+          .to receive(:label)
+          .and_return('Rubocop')
+        expect(task)
+          .to receive(:error_message)
+          .and_return('')
+      end
+
+      it 'should return a message' do
+        expect(subject)
+          .to receive(:printf)
+          .with('%-30s %20s', 'Rubocop ', "\e[31mFAILURE\e[0m\n\n")
+        subject.send(:fatal, task)
+      end
+    end
+  end
+
+  describe '#label' do
+    context 'when we get a label for task' do
+      before do
+        expect(task)
+          .to receive(:label)
+          .and_return('Rubocop')
+      end
+
+      it 'should return the label' do
+        expect(subject.send(:label, task)).to eq 'Rubocop'
+      end
+    end
+  end
+end

data/spec/lib/polishgeeks/dev-tools/output_storer_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::OutputStorer do
+  subject { described_class.new }
+
+  describe '#initialize' do
+    context 'when we execute the command' do
+      let(:commands) { %i(rubocop yard) }
+      let(:result) { { rubocop: '', yard: '' } }
+
+      before do
+        stub_const('PolishGeeks::DevTools::Config::COMMANDS', commands)
+      end
+
+      it 'should store an output' do
+        expect(subject.send(:initialize)).to eq result
+      end
+    end
+  end
+end

data/spec/lib/polishgeeks/dev-tools/runner_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe PolishGeeks::DevTools::Runner do
+  subject { described_class.new }
+
+  describe '#execute' do
+    let(:logger) { double }
+    let(:output_storer) { double }
+    let(:config) { PolishGeeks::DevTools::Config.new }
+
+    before do
+      expect(::PolishGeeks::DevTools::OutputStorer)
+        .to receive(:new)
+        .and_return(output_storer)
+
+      expect(::PolishGeeks::DevTools)
+        .to receive(:config)
+        .and_return(config)
+        .at_least(:once)
+
+      PolishGeeks::DevTools::Config::COMMANDS.each do |command|
+        config.public_send(:"#{command}=", true)
+
+        klass_name = command.to_s.gsub(/(?<=_|^)(\w)/) { |el| el.upcase }.gsub(/(?:_)(\w)/, '\1')
+        klass = Object.const_get("PolishGeeks::DevTools::Command::#{klass_name}")
+
+        instance = double
+        output = double
+
+        expect(klass)
+          .to receive(:new)
+          .and_return(instance)
+
+        expect(instance)
+          .to receive(:stored_output=)
+          .with(output_storer)
+
+        expect(instance)
+          .to receive(:execute)
+
+        expect(instance)
+          .to receive(:output)
+          .and_return(output)
+
+        expect(output_storer)
+          .to receive(:"#{command}=")
+          .with(output)
+
+        expect(logger)
+          .to receive(:log)
+          .with(instance)
+      end
+    end
+
+    it { subject.execute(logger) }
+  end
+end