maximus 0.1.4 → 0.1.5

data/spec/maximus/config_spec.rb

@@ -5,20 +5,21 @@ describe Maximus::Config do
 
   subject(:config) do
     File.write(config_path, config_body)
-    described_class.new(config_body.blank? ? {} : { config_file: config_path })
+    config_contents = config_body.blank? ? {} : { config_file: config_path }
+    described_class.new(config_contents)
   end
 
   describe '#is_dev?', :isolated_environment do
     context 'setting root value is_dev to true' do
       let(:config_body) { 'is_dev: true' }
-      it 'is_dev should be true' do
+      it 'should be true' do
         expect(config.is_dev?).to be true
       end
     end
 
-    context 'is_dev is blank/not supplied' do
+    context 'is blank/not supplied' do
       let(:config_body) { '' }
-      it 'is_dev should default to false' do
+      it 'should default to false' do
         expect(config.is_dev?).to be false
       end
     end
@@ -33,7 +34,7 @@ describe Maximus::Config do
       end
     end
 
-    context 'not supplying a linter but relying on the default include all' do
+    context 'not supplying a linter but relying on the default' do
       let(:config_body) { '' }
       it 'should include a linter' do
         expect(config.settings.has_key?(:scsslint)).to be true
@@ -41,4 +42,96 @@ describe Maximus::Config do
     end
 
   end
+
+  describe '#domain', :isolated_environment do
+
+    context 'domain is provided' do
+
+      context 'without a port' do
+        let(:config_body) { 'domain: http://example.com' }
+        it 'should provide the domain' do
+          expect( config.domain ).to eq 'http://example.com'
+        end
+      end
+
+      context 'with a port' do
+        let(:config_body) { "domain: http://example.com\nport: 8080" }
+        it 'should provide the domain with port attached' do
+          expect( config.domain ).to eq 'http://example.com:8080'
+        end
+      end
+
+    end
+
+    context 'port is provided' do
+
+      context 'without a domain' do
+        let(:config_body) { 'port: 8080' }
+        it 'should provide the default domain with the port attached' do
+          expect( config.domain ).to eq 'http://localhost:8080'
+        end
+      end
+
+      context 'with a domain' do
+        let(:config_body) { "domain: http://example.com\nport: 8080" }
+        it 'should provide the domain with the port attached' do
+          expect( config.domain ).to eq 'http://example.com:8080'
+        end
+      end
+
+    end
+
+  end
+
+  describe '#split_paths', :isolated_environment do
+
+    context 'an array is provided' do
+      let(:config_body) { "paths: \n  - '/'\n  - '/about'"}
+      it 'should return the paths with labels' do
+        expect( config.settings[:paths] ).to eq ({ 'home' => '/', 'about' => '/about'})
+      end
+    end
+
+    context 'a hash is provided' do
+      let(:config_body) { "paths: \n  home: '/'\n  about: '/about'"}
+      it 'should return the paths with labels' do
+        expect( config.settings[:paths] ).to eq ({ 'home' => '/', 'about' => '/about'})
+      end
+    end
+
+    context 'nothing is provided' do
+      let(:config_body) { '' }
+      it 'should return the default path with label' do
+        expect( config.settings[:paths] ).to eq ({ 'home' => '/'})
+      end
+    end
+
+  end
+
+  describe '#load_config', :isolated_environment do
+
+    context 'a file path is provided' do
+      let(:config_body) { 'rubocop: spec/support/rubocop.yml' }
+      it 'should load the file' do
+        expect( YAML.load_file(config.settings[:rubocop])['Rubolinter'] ).to be true
+      end
+    end
+
+    context 'settings are provided' do
+      let(:config_body) { "rubocop:\n  Rubolinter: true" }
+      it 'should store the settings appropriately' do
+        expect( YAML.load_file(config.settings[:rubocop])['Rubolinter'] ).to be true
+      end
+    end
+
+    context 'a file path is provided but is non-existent' do
+      let(:config_body) { "rubocop: spec/support/not/a/real/file.yml" }
+      it 'should puts an error message and an empty hash' do
+        STDOUT.should_receive(:puts).with('spec/support/not/a/real/file.yml not found')
+        expect( YAML.load_file(config.settings[:rubocop]) ).to eq ({})
+      end
+    end
+
+  end
+
 end

data/spec/maximus/git_control_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe Maximus::GitControl do
+  let(:config) { {} }
+  let(:sha1) { 'db4aa677aa1cf8cf477d5e66df1ea875b4fa20b6' }
+  let(:sha2) { 'a2be59852c715382575b884e63c3e9bdee80e2db' }
+
+  subject(:git) do
+    conf_settings = config.merge({ root_dir: Dir.pwd })
+    conf = Maximus::Config.new(conf_settings)
+    described_class.new({ config: conf })
+  end
+
+  describe '#first_commit' do
+    context 'a git repo exists' do
+      it 'should return a hash equal to the first Maximus commit' do
+        expect( git.first_commit ).to eq '40f2a7a7cf676a25580e04b38e3004249ed6f8ce'
+      end
+    end
+  end
+
+  describe '#previous_commit' do
+
+    context 'a commit sha is provided' do
+      let(:sha) { '051ba36b4ddfcaca5361312e4f6613f6ea6ee123' }
+
+      context 'previous count is not provided' do
+        it 'should return the commit directly before the provided sha' do
+          expect( git.previous_commit(sha) ).to eq 'f0c02e5b9452fa4b8f1747aaa4fdf5c81099f575'
+        end
+      end
+
+      context 'previous count is provided' do
+        it 'should return the commit by n (previous count) commits before the provided sha' do
+          expect( git.previous_commit(sha, 5) ).to eq '82933a240cff983cbc0eb668cf58671fda5cc5a5'
+        end
+      end
+
+    end
+
+  end
+
+  describe '#commit_export' do
+
+    context 'commit sha is provided' do
+      it 'should return a formatted hash with information' do
+        sha = '051ba36b4ddfcaca5361312e4f6613f6ea6ee123'
+        export = git.commit_export(sha)
+
+        expect( export[:commit_sha] ).to eq sha
+        expect( export[:message] ).to eq 'misc'
+        expect( export[:git_author] ).to eq 'Tim Shedor'
+        expect( export[:git_author_email] ).to eq 'tim@finedesigngroup.com'
+        expect( Time.parse export[:commit_date] ).to eq Time.parse('2014-11-11 00:19:25 -0800')
+        expect( export[:diff] ).to be_a(Hash)
+        expect( export[:remote_repo] ).to be_a(String)
+        expect( export[:branch] ).to be_a(String)
+
+      end
+    end
+
+    context 'initial sha is provided' do
+      it 'should return a formatted hash with information' do
+        sha = '40f2a7a7cf676a25580e04b38e3004249ed6f8ce'
+        export = git.commit_export(sha)
+
+        expect( export[:commit_sha] ).to eq sha
+        expect( export[:message] ).to eq 'initial'
+        expect( export[:git_author] ).to eq 'Tim Shedor'
+        expect( export[:git_author_email] ).to eq 'tim@finedesigngroup.com'
+        expect( Time.parse export[:commit_date] ).to eq Time.parse('2014-10-31 18:16:17 -0700')
+        expect( export[:diff] ).to be_a(Hash)
+        expect( export[:remote_repo] ).to be_a(String)
+        expect( export[:branch] ).to be_a(String)
+      end
+    end
+
+  end
+
+  describe '#associations' do
+
+    it 'should be a hash' do
+      expect( git.associations ).to be_a(Hash)
+    end
+
+  end
+
+  describe '#set_psuedo_commit' do
+
+    context 'words are provided' do
+
+      context 'master is supplied' do
+        let(:config) { { commit: 'master' } }
+        it 'should return the master sha' do
+          expect( git.send(:set_psuedo_commit) ).to eq `git -C #{Dir.pwd} rev-parse --branches=master HEAD`.strip!
+        end
+      end
+
+      context 'last is supplied' do
+        let(:config) { { commit: 'last' } }
+        it 'should return the previous_commit sha' do
+          expect( git.send(:set_psuedo_commit) ).to eq `git -C #{Dir.pwd} rev-parse HEAD^`.strip!
+        end
+      end
+
+      context 'working is supplied' do
+        let(:config) { { commit: 'working' } }
+        it 'should return the word "working"' do
+          expect( git.send(:set_psuedo_commit) ).to eq 'working'
+        end
+      end
+
+    end
+
+    context 'a commit hash is provided' do
+      let(:config) { { commit: '22126a6ba227d81f770d13c302e6225f7463f7be' } }
+      it 'should return the provided hash' do
+        expect( git.send(:set_psuedo_commit) ).to eq '22126a6ba227d81f770d13c302e6225f7463f7be'
+      end
+    end
+
+  end
+
+  describe '#associations' do
+
+    it 'should be a hash' do
+      expect( git.associations ).to be_a(Hash)
+    end
+
+  end
+
+  describe '#commit_range', :isolated_environment do
+
+    context 'shas are provided' do
+
+      it 'should return an array of shas in between' do
+        shas = ['a2be59852c715382575b884e63c3e9bdee80e2db', 'e20fe614d323782e5cab4215942e4f22ddb98464', 'db4aa677aa1cf8cf477d5e66df1ea875b4fa20b6']
+        expect( git.send(:commit_range, sha1, sha2) ).to eq shas
+      end
+
+      context 'duplicate shas are provided' do
+        let(:sha1) { 'a2be59852c715382575b884e63c3e9bdee80e2db' }
+
+        it 'should only return that commit' do
+          expect( git.send(:commit_range, sha1, sha2) ).to eq [sha1]
+        end
+      end
+
+      context 'a psuedo_commit is passed in the config' do
+        let(:config) { { commit: 'master' } }
+        it 'should not return a sha' do
+          expect( git.send(:commit_range, sha1, sha2) ).to eq ["git #{sha1}"]
+        end
+      end
+
+    end
+
+  end
+
+  describe '#compare', :isolated_environment do
+
+    context 'commit is not supplied in the config' do
+      it 'should return a hash with commit shas, file associations, and changed line numbers' do
+        result = git.compare(sha1, sha2)
+        expect( result ).to be_a(Hash)
+        expect( result.keys ).to eq ["db4aa677aa1cf8cf477d5e66df1ea875b4fa20b6", "e20fe614d323782e5cab4215942e4f22ddb98464", "a2be59852c715382575b884e63c3e9bdee80e2db"]
+      end
+    end
+
+  end
+
+end

data/spec/maximus/helper_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Maximus::Helper do
+
+  subject(:dummy_class) do
+    Class.new { extend Maximus::Helper }
+  end
+
+  describe '#is_rails?', :isolated_environment do
+
+    context 'when Rails is not defined' do
+      it 'should be nil' do
+        expect(dummy_class.is_rails?).to be_nil
+      end
+    end
+
+  end
+
+  describe '#root_dir', :isolated_environment do
+
+    context 'when project is not a Rails app' do
+      it 'should be the current directory' do
+        expect(dummy_class.root_dir).to eq(Dir.pwd)
+      end
+    end
+  end
+
+  describe '#node_module_exists', :isolated_environment do
+
+    context 'when a command does not exist' do
+
+      it 'should exit the script' do
+        expect { dummy_class.node_module_exists('bash_func') }.to raise_error(SystemExit, "Missing command bash_func: Please run `npm install -g bash_func` And try again\n")
+      end
+
+      context 'and a custom install message is passed' do
+        it 'should print the install message' do
+          expect { dummy_class.node_module_exists('bash_func', 'premium_package_manager install') }.to raise_error(SystemExit, "Missing command bash_func: Please run `premium_package_manager install bash_func` And try again\n")
+        end
+      end
+
+    end
+
+  end
+
+  describe '#truthy?', :isolated_environment do
+
+    context 'when a true value is passed' do
+      it 'should be true' do
+        expect( dummy_class.truthy? 'true' ).to be true
+        expect( dummy_class.truthy? '1' ).to be true
+        expect( dummy_class.truthy? 'yes' ).to be true
+        expect( dummy_class.truthy? 'y' ).to be true
+      end
+    end
+
+    context 'when a false value is passed' do
+      it 'should be false' do
+        expect( dummy_class.truthy? 'false' ).to be false
+        expect( dummy_class.truthy? '0' ).to be false
+        expect( dummy_class.truthy? 'no' ).to be false
+        expect( dummy_class.truthy? 'n' ).to be false
+      end
+    end
+
+  end
+
+  describe '#path_exists?', :isolated_environment do
+
+    context 'when a nonexistent path(s) is passed' do
+      it 'should be false' do
+        STDOUT.should_receive(:puts).with('/fake/path/to/nowhere does not exist')
+        expect( dummy_class.path_exists? '/fake/path/to/nowhere' ).to be false
+      end
+    end
+
+    context 'when a real path is passed' do
+      it 'should be true' do
+        expect( dummy_class.path_exists? '.' ).to be true
+      end
+    end
+
+  end
+
+  describe '#lines_added_to_range', :isolated_environment do
+
+    context 'when a functional hash is provided' do
+      let(:lines_added) { { changes: ['0..5', '11..14'] } }
+
+      it 'should return an array of numbers' do
+        expect( dummy_class.lines_added_to_range lines_added ).to eq( [ 0,1,2,3,4,5, 11,12,13,14] )
+      end
+    end
+  end
+
+
+end

data/spec/maximus/lint_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'rainbow'
+require 'rainbow/ext/string'
+
+describe Maximus::Lint do
+  let(:data) {
+    {"/Users/Tim/dummy/app/assets/stylesheets/application.css"=>[{"line"=>1, "column"=>1, "length"=>1, "severity"=>"warning", "reason"=>"Use `//` comments everywhere", "linter"=>"Comment"}], "/Users/Tim/dummy/app/assets/stylesheets/main.css.scss"=>[{"line"=>2, "column"=>3, "length"=>16, "severity"=>"warning", "reason"=>"Properties should be ordered margin, max-width", "linter"=>"PropertySortOrder"}]}
+  }
+
+  subject(:lint) { described_class.new }
+
+  describe '#refine', :isolated_environment do
+    context 'data is blank' do
+      let(:data) { }
+      it 'should provide a blank response' do
+        STDOUT.should_receive(:puts).with("#{''.color(:green)}: #{'[0]'.color(:yellow)}#{' [0]'.color(:red)}")
+        blank_response = { lint_warnings: [], lint_errors: [], lint_conventions: [], lint_refactors: [], raw_data: "{}" }
+        expect( lint.refine(data) ).to eq blank_response
+      end
+    end
+
+    context 'data is an error' do
+      let(:data) { 'No such linter available' }
+      it 'should report the error' do
+        STDOUT.should_receive(:puts).with("Error from : No such linter available")
+        expect( lint.refine(data) ).to be_nil
+      end
+    end
+
+    context 'data is provided' do
+      it 'should be a Hash' do
+        # As a string
+        # Tests lint_summarize
+        2.times { STDOUT.should_receive(:puts).with("#{''.color(:green)}: #{'[2]'.color(:yellow)}#{' [0]'.color(:red)}") }
+
+        expect( lint.refine(data) ).to be_a(Hash)
+        expect( lint.refine(data.to_json) ).to be_a(Hash)
+      end
+    end
+  end
+
+  describe '#evaluate_severities', :isolated_environment do
+    it 'should be a Hash' do
+      resp = lint.send(:evaluate_severities, data)
+
+      expect( resp ).to be_a(Hash)
+      expect( resp[:lint_warnings].length ).to eq 2
+    end
+  end
+
+end