status_cat 0.1.1 → 5.0.0

data/spec/helpers/status_cat/status_helper_spec.rb

@@ -1,73 +1,73 @@
 describe StatusCat::StatusHelper do
 
-  let( :checker ) { StatusCat::Checkers::ActiveRecord.new }
-  let( :name ) { t( :name, :scope => :status_cat ).freeze }
-  let( :value ) { t( :value, :scope => :status_cat ).freeze }
-  let( :status ) { t( :status, :scope => :status_cat ).freeze }
-  let( :ok ) { t( :ok, :scope => :status_cat ).freeze }
+  let(:checker) { StatusCat::Checkers::ActiveRecord.new }
+  let(:name) { t(:name, scope: :status_cat).freeze }
+  let(:value) { t(:value, scope: :status_cat).freeze }
+  let(:status) { t(:status, scope: :status_cat).freeze }
+  let(:ok) { t(:ok, scope: :status_cat).freeze }
 
   describe '#status_header' do
 
     it 'generates a status table header' do
       expected = "<tr><th>#{name}</th><th>#{value}</th><th>#{status}</th></tr>"
-      expect( helper.status_header ).to eql( expected )
+      expect(helper.status_header).to eql(expected)
     end
   end
 
   describe '#status_row' do
 
     it 'generates a status table row' do
-      expected = "<tr><td style=\"#{helper.status_style( checker )}\">#{checker.name}</td><td>#{checker.value}</td><td>#{ok}</td></tr>"
-      expect( helper.status_row( checker ) ).to eql( expected )
+      expected = "<tr><td style=\"#{helper.status_style(checker)}\">#{checker.name}</td><td>#{checker.value}</td><td>#{ok}</td></tr>"
+      expect(helper.status_row(checker)).to eql(expected)
     end
 
     it 'uses status_style to style the status column' do
       style = :gangnam
-      expect( helper ).to receive( :status_style ).and_return( style )
+      expect(helper).to receive(:status_style).and_return(style)
       expected = "<tr><td style=\"#{style}\">#{checker.name}</td><td>#{checker.value}</td><td>#{ok}</td></tr>"
-      expect( helper.status_row( checker ) ).to eql( expected )
+      expect(helper.status_row(checker)).to eql(expected)
     end
   end
 
   describe '#status_cell' do
 
     it 'returns the status as a table cell' do
-      expected = "<td>foo</td>"
-      expect( helper.status_cell( 'foo' ) ).to eql( expected )
+      expected = '<td>foo</td>'
+      expect(helper.status_cell('foo')).to eql(expected)
     end
 
     it 'converts array statuses into html lists' do
-      expected = "<td><ul><li>foo</li><li>bar</li></ul></td>"
-      expect( helper.status_cell( [ 'foo', 'bar' ] ) ).to eql( expected )
+      expected = '<td><ul><li>foo</li><li>bar</li></ul></td>'
+      expect(helper.status_cell(%w[foo bar])).to eql(expected)
     end
   end
 
   describe '#status_style' do
 
     it 'returns a green background when the status is nil' do
-      expect( checker ).to receive( :status ).and_return( nil )
-      expect( helper.status_style( checker ) ).to eql( 'background-color: green' )
+      expect(checker).to receive(:status).and_return(nil)
+      expect(helper.status_style(checker)).to eql('background-color: green')
     end
 
     it 'returns a red background when the status is not nil' do
-      expect( checker ).to receive( :status ).and_return( :fail )
-      expect( helper.status_style( checker ) ).to eql( 'background-color: red' )
+      expect(checker).to receive(:status).and_return(:fail)
+      expect(helper.status_style(checker)).to eql('background-color: red')
     end
   end
 
   describe '#status_table' do
 
     it 'generates a status table' do
-      expected = "<table border=\"1\">#{helper.status_header}#{helper.status_row( checker )}</table>"
-      expect( helper.status_table( [ checker ] ) ).to eql( expected )
+      expected = "<table border=\"1\">#{helper.status_header}#{helper.status_row(checker)}</table>"
+      expect(helper.status_table([checker])).to eql(expected)
     end
   end
 
   describe '#status_title' do
 
     it 'generates a page title' do
-      expected = "<h1>#{t( :h1, :scope => :status_cat )}</h1>"
-      expect( helper.status_title ).to eql( expected )
+      expected = "<h1>#{t(:h1, scope: :status_cat)}</h1>"
+      expect(helper.status_title).to eql(expected)
     end
   end
 
@@ -75,10 +75,10 @@ describe StatusCat::StatusHelper do
 
     it 'generates a text status report' do
       all = StatusCat::Status.all
-      all.each { |s| allow( s ).to receive( :status ).and_return( nil ) }
+      all.each { |s| allow(s).to receive(:status).and_return(nil) }
 
-      actual = helper.status_report( all )
-      all.each { |s| expect( actual ).to match( /#{s}/ ) }
+      actual = helper.status_report(all)
+      all.each { |s| expect(actual).to match(/#{s}/) }
     end
   end
 
@@ -86,24 +86,24 @@ describe StatusCat::StatusHelper do
 
     it 'generates a format string and length based on the max length of the given checkers' do
       all = StatusCat::Status.all
-      all.each { |s| allow( s ).to receive( :status ).and_return( nil ) }
+      all.each { |s| allow(s).to receive(:status).and_return(nil) }
 
-      status_report_format = helper.status_report_format( all ).to_s
-      expect( status_report_format ).to match( /\["%\d+s | %\d+s | %\d+s\n", \d+\]/ )
+      status_report_format = helper.status_report_format(all).to_s
+      expect(status_report_format).to match(/\["%\d+s | %\d+s | %\d+s\n", \d+\]/)
     end
   end
 
   describe '#status_report_header' do
 
     it 'generates a header' do
-      expected = sprintf( StatusCat::Checkers::Base::FORMAT, name, value, status )
-      expect( helper.status_report_header ).to eql( expected )
+      expected = format(StatusCat::Checkers::Base::FORMAT, name, value, status)
+      expect(helper.status_report_header).to eql(expected)
     end
 
     it 'accepts a format string' do
       format = '%s * %s * %s'
-      expected = sprintf( format, name, value, status )
-      expect( helper.status_report_header( format ) ).to eql( expected )
+      expected = format(format, name, value, status)
+      expect(helper.status_report_header(format)).to eql(expected)
     end
   end
-end
+end

data/spec/hygiene_spec.rb

@@ -0,0 +1,14 @@
+describe 'hygiene' do
+
+  it('passes rubocop') { is_expected.to pass_rubocop }
+
+  it 'has a spec for every file' do
+    %w[app lib].each do |dir|
+      Dir.glob(File.join(ENGINE_ROOT, dir, '**', '*.{rb,erb,rake}')) do |path|
+        path = path.sub(%r{#{ENGINE_ROOT}/}, '')
+        expect(path).to have_a_spec
+      end
+    end
+  end
+
+end

data/spec/lib/status_cat/checkers/action_mailer_spec.rb

@@ -1,66 +1,63 @@
 describe StatusCat::Checkers::ActionMailer do
 
-  let( :checker ) { StatusCat::Checkers::ActionMailer.new.freeze }
+  let(:checker) { StatusCat::Checkers::ActionMailer.new.freeze }
 
   it_should_behave_like 'a status checker'
 
   it 'provides configuration' do
-    expect( checker.config ).to eql( ::ActionMailer::Base.smtp_settings )
+    expect(checker.config).to eql(::ActionMailer::Base.smtp_settings)
   end
 
   it 'constructs a value from the configuration' do
-    expected = "#{checker.config[ :address ]}:#{checker.config[ :port ]}"
-    expect( checker.value ).to eql( expected )
+    expected = "#{checker.address}:#{checker.port}"
+    expect(checker.value).to eql(expected)
   end
 
   #############################################################################
   # status
-  #############################################################################
 
   describe '#status' do
 
-    before( :each ) do
+    before(:each) do
       ::ActionMailer::Base.delivery_method = :smtp
     end
 
-    after( :each ) do
+    after(:each) do
       ::ActionMailer::Base.delivery_method = :test
     end
 
     #############################################################################
     # pass
-    #############################################################################
 
     context 'pass' do
 
       it 'passes if it can make an SMTP connection' do
-        expect( Net::SMTP ).to receive( :start )
+        expect(Net::SMTP).to receive(:start)
         checker = StatusCat::Checkers::ActionMailer.new
-        expect( checker.status ).to be_nil
+        expect(checker.status).to be_nil
       end
     end
 
     #############################################################################
     # fail
-    #############################################################################
 
     context 'fail' do
 
-      let( :exception ) { Net::SMTPAuthenticationError.new }
+      let(:exception) { Net::SMTPAuthenticationError.new }
 
       it 'returns an error message if it can not make an SMTP connection' do
-        expect( Net::SMTP ).to receive( :start ).and_raise( exception )
+        expect(Net::SMTP).to receive(:start).and_raise(exception)
         checker = StatusCat::Checkers::ActionMailer.new
-        expect( checker.status ).to be( exception )
+        expect(checker.status).to be(exception)
       end
 
       it 'returns an error message if it can not send a message' do
         smtp = Object.new
-        allow( smtp ).to receive( :send_message ).and_raise( exception )
-        allow( Net::SMTP ).to receive( :start ).and_yield( smtp )
+        allow(smtp).to receive(:helo).and_raise(exception)
+        allow(Net::SMTP).to receive(:start).and_yield(smtp)
         checker = StatusCat::Checkers::ActionMailer.new
-        expect( checker.status ).to be( exception )
+        expect(checker.status).to be(exception)
       end
     end
   end
-end
+end

data/spec/lib/status_cat/checkers/active_record_spec.rb

@@ -1,14 +1,14 @@
 describe StatusCat::Checkers::ActiveRecord do
 
-  let( :checker ) { StatusCat::Checkers::ActiveRecord.new.freeze }
+  let(:checker) { StatusCat::Checkers::ActiveRecord.new.freeze }
 
   it_should_behave_like 'a status checker'
 
   it 'constructs a value from the configuration' do
-    config = { :adapter => 'postgres', :username => 'dba', :database => 'test' }
-    expect( ::ActiveRecord::Base ).to receive( :connection_config ).and_return( config )
-    expected = "#{config[ :adapter ]}:#{config[ :username ]}@#{config[ :database ]}"
-    expect( checker.value ).to eql( expected )
+    config = { adapter: 'postgres', username: 'dba', database: 'test' }
+    allow(::ActiveRecord::Base).to receive(:connection_config).and_return(config)
+    expected = "#{config[:adapter]}:#{config[:username]}@#{config[:database]}"
+    expect(checker.value).to eql(expected)
   end
 
   describe '#status' do
@@ -16,9 +16,9 @@ describe StatusCat::Checkers::ActiveRecord do
     context 'pass' do
 
       it 'passes if it can execute a query against the database' do
-        allow( ActiveRecord::Base.connection ).to receive( :execute )
+        allow(ActiveRecord::Base.connection).to receive(:execute)
         checker = StatusCat::Checkers::ActiveRecord.new
-        expect( checker.status ).to be_nil
+        expect(checker.status).to be_nil
       end
     end
 
@@ -26,10 +26,10 @@ describe StatusCat::Checkers::ActiveRecord do
 
       it 'returns an error message if it fails to query the database' do
         fail = 'This is only a test'
-        expect( ActiveRecord::Base.connection ).to receive( :execute ).and_raise( fail )
+        expect(ActiveRecord::Base.connection).to receive(:execute).and_raise(fail)
         checker = StatusCat::Checkers::ActiveRecord.new
-        expect( checker.status.to_s ).to eql( fail )
+        expect(checker.status.to_s).to eql(fail)
       end
     end
   end
-end
+end

data/spec/lib/status_cat/checkers/base_spec.rb

@@ -1,35 +1,35 @@
 describe StatusCat::Checkers::Base do
 
-  let( :checker ) { StatusCat::Checkers::Base.new }
+  let(:checker) { StatusCat::Checkers::Base.new }
 
   describe '#name' do
 
     it 'generates a symbolized class name' do
-      expect( checker.name ).to be( :base )
+      expect(checker.name).to be(:base)
     end
   end
 
   describe 'attributes' do
 
     it 'has value and status readers' do
-      expect( checker.value ).to be_nil
-      expect( checker.status ).to be_nil
+      expect(checker.value).to be_nil
+      expect(checker.status).to be_nil
     end
   end
 
   describe '#to_s' do
 
-    before( :each ) do
-      allow( checker ).to receive( :value ).and_return( 'secret' )
-      allow( checker ).to receive( :status ).and_return( 'fail' )
+    before(:each) do
+      allow(checker).to receive(:value).and_return('secret')
+      allow(checker).to receive(:status).and_return('fail')
     end
 
     it 'generates a string' do
-      expect( checker.to_s ).to eql( "base | secret | fail\n" )
+      expect(checker.to_s).to eql("base | secret | fail\n")
     end
 
     it 'accepts a format' do
-      expect( checker.to_s( '%s * %s * %s' ) ).to eql( 'base * secret * fail' )
+      expect(checker.to_s('%s * %s * %s')).to eql('base * secret * fail')
     end
   end
 
@@ -37,13 +37,29 @@ describe StatusCat::Checkers::Base do
 
     it 'returns an exception if raised from the block given' do
       error = 'test'
-      status = checker.send( :fail_on_exception ) { raise error }
-      expect( status.to_s ).to eql( error )
+      status = checker.send(:fail_on_exception) { raise error }
+      expect(status.to_s).to eql(error)
     end
 
     it 'returns the results of the block when there is no exception' do
-      status = checker.send( :fail_on_exception ) { true }
-      expect( status ).to be( true )
+      status = checker.send(:fail_on_exception) { true }
+      expect(status).to be(true)
     end
   end
-end
+
+  describe '#gem_missing?' do
+
+    it 'returns false when present is true' do
+      expect(checker.send(:gem_missing?, 'foo', true)).to be(false)
+    end
+
+    it 'returns true when present is false' do
+      expect(checker.send(:gem_missing?, 'foo', false)).to be(true)
+    end
+
+    it 'sets status when present is false' do
+      checker.send(:gem_missing?, 'foo', false)
+      expect(checker.status).to eql('foo gem is not installed')
+    end
+  end
+end

data/spec/lib/status_cat/checkers/delayed_job_spec.rb

@@ -1,34 +1,32 @@
-require 'delayed_job_active_record'
-
 describe StatusCat::Checkers::DelayedJob do
 
-  let( :checker ) { StatusCat::Checkers::DelayedJob.new.freeze }
+  let(:checker) { StatusCat::Checkers::DelayedJob.new.freeze }
 
   it_should_behave_like 'a status checker'
 
-  it 'tolerates Delayed::Job being undefined' do
-    dj = Object.send(:remove_const, :Delayed)
-    expect( checker.status ).to_not be_nil
-    Object.const_set( :Delayed, dj )
+  it 'tolerates the gem missing' do
+    gem = Object.send(:remove_const, :Delayed)
+    expect(checker.status).to eql('delayed_job gem is not installed')
+    Object.const_set(:Delayed, gem)
   end
 
   it 'fails if there is an exception' do
-    expect( ActiveRecord::Base.connection ).to receive( :execute ).and_raise( :error )
-    expect( checker.status ).to_not be_nil
+    expect(ActiveRecord::Base.connection).to receive(:execute).and_raise(:error)
+    expect(checker.status).to_not be_nil
   end
 
   it 'fails if there are expired jobs' do
-    expect( ActiveRecord::Base.connection ).to receive( :execute ).and_return( [1], [1] )
-    expect( checker.status ).to_not be_nil
+    expect(ActiveRecord::Base.connection).to receive(:execute).and_return([1], [1])
+    expect(checker.status).to_not be_nil
   end
 
   it 'passes if there are no expired jobs' do
-    expect( ActiveRecord::Base.connection ).to receive( :execute ).and_return( [1], [0] )
-    expect( checker.status ).to be_nil
+    expect(ActiveRecord::Base.connection).to receive(:execute).and_return([1], [0])
+    expect(checker.status).to be_nil
   end
 
   it 'uses the job count as the value' do
-    expect( ActiveRecord::Base.connection ).to receive( :execute ).and_return( [1], [0] )
-    expect( checker.value ).to eql( 1 )
+    expect(ActiveRecord::Base.connection).to receive(:execute).and_return([1], [0])
+    expect(checker.value).to eql(1)
   end
-end
+end

data/spec/lib/status_cat/checkers/fitbit_spec.rb

@@ -1,33 +1,39 @@
 describe StatusCat::Checkers::Fitbit do
 
-  let( :checker ) { StatusCat::Checkers::Fitbit.new.freeze }
+  let(:checker) { StatusCat::Checkers::Fitbit.new.freeze }
 
   it_should_behave_like 'a status checker'
 
   describe '#initialize' do
 
+    it 'tolerates the gem missing' do
+      gem = Object.send(:remove_const, :Fitgem)
+      expect(checker.status).to eql('fitgem gem is not installed')
+      Object.const_set(:Fitgem, gem)
+    end
+
     it 'sets the value' do
-      expect( checker.value ).to eql( ENV[ 'FITBIT_CONSUMER_KEY' ] )
+      expect(checker.value).to eql(StatusCat::Checkers::Fitbit.consumer_key)
     end
 
     context 'pass' do
 
       it 'passes if it can connect to Fitbit' do
-        expect( checker.status ).to be_nil
+        expect(checker.status).to be_nil
       end
     end
 
     context 'fail' do
 
       it 'fails if it receives errors' do
-        expect( @fitgem ).to receive( :user_info ).and_return( { 'errors' => 'this is only a test' } )
-        expect( checker.status ).to_not be_nil
+        expect(@fitgem).to receive(:user_info).and_return('errors' => 'this is only a test')
+        expect(checker.status).to_not be_nil
       end
 
       it 'fails if there is an exception' do
-        expect( @fitgem ).to receive( :user_info ).and_raise( 'This is only a test' )
-        expect( checker.status ).to_not be_nil
+        expect(@fitgem).to receive(:user_info).and_raise('This is only a test')
+        expect(checker.status).to_not be_nil
       end
     end
   end
-end
+end