status_cat 0.1.0 → 0.1.1

data/spec/helpers/status_cat/status_helper_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe StatusCat::StatusHelper do
 
   let( :checker ) { StatusCat::Checkers::ActiveRecord.new }
@@ -12,25 +10,23 @@ describe StatusCat::StatusHelper do
 
     it 'generates a status table header' do
       expected = "<tr><th>#{name}</th><th>#{value}</th><th>#{status}</th></tr>"
-      helper.status_header.should 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>"
-      helper.status_row( checker ).should eql( expected )
+      expect( helper.status_row( checker ) ).to eql( expected )
     end
 
     it 'uses status_style to style the status column' do
       style = :gangnam
-      helper.should_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>"
-      helper.status_row( checker ).should eql( expected )
+      expect( helper.status_row( checker ) ).to eql( expected )
     end
-
   end
 
   describe '#status_cell' do
@@ -44,77 +40,70 @@ describe StatusCat::StatusHelper do
       expected = "<td><ul><li>foo</li><li>bar</li></ul></td>"
       expect( helper.status_cell( [ 'foo', 'bar' ] ) ).to eql( expected )
     end
-
   end
 
   describe '#status_style' do
 
     it 'returns a green background when the status is nil' do
-      checker.should_receive( :status ).and_return( nil )
-      helper.status_style( checker ).should 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
-      checker.should_receive( :status ).and_return( :fail )
-      helper.status_style( checker ).should 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>"
-      helper.status_table( [ checker ] ).should eql( expected )
+      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>"
-      helper.status_title.should eql( expected )
+      expect( helper.status_title ).to eql( expected )
     end
-
   end
 
   describe '#status_report' do
 
     it 'generates a text status report' do
       all = StatusCat::Status.all
-      all.each { |s| s.stub( :status ).and_return( nil ) }
+      all.each { |s| allow( s ).to receive( :status ).and_return( nil ) }
 
-      helper.status_report( all ).should eql_file( 'spec/data/report.txt' )
+      actual = helper.status_report( all )
+      all.each { |s| expect( actual ).to match( /#{s}/ ) }
     end
-
   end
 
   describe '#status_report_format' 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| s.stub( :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
-      status_report_format.should eql_file( 'spec/data/status_report_format.txt' )
+      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 )
-      helper.status_report_header.should eql( expected )
+      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 )
-      helper.status_report_header( format ).should eql( expected )
+      expect( helper.status_report_header( format ) ).to eql( expected )
     end
-
   end
-
 end

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

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe StatusCat::Checkers::ActionMailer do
 
   let( :checker ) { StatusCat::Checkers::ActionMailer.new.freeze }
@@ -7,12 +5,12 @@ describe StatusCat::Checkers::ActionMailer do
   it_should_behave_like 'a status checker'
 
   it 'provides configuration' do
-    checker.config.should 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 ]}"
-    checker.value.should eql( expected )
+    expect( checker.value ).to eql( expected )
   end
 
   #############################################################################
@@ -36,11 +34,10 @@ describe StatusCat::Checkers::ActionMailer do
     context 'pass' do
 
       it 'passes if it can make an SMTP connection' do
-        Net::SMTP.should_receive( :start )
+        expect( Net::SMTP ).to receive( :start )
         checker = StatusCat::Checkers::ActionMailer.new
-        checker.status.should be_nil
+        expect( checker.status ).to be_nil
       end
-
     end
 
     #############################################################################
@@ -52,21 +49,18 @@ describe StatusCat::Checkers::ActionMailer do
       let( :exception ) { Net::SMTPAuthenticationError.new }
 
       it 'returns an error message if it can not make an SMTP connection' do
-        Net::SMTP.should_receive( :start ).and_raise( exception )
+        expect( Net::SMTP ).to receive( :start ).and_raise( exception )
         checker = StatusCat::Checkers::ActionMailer.new
-        checker.status.should 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
-        smtp.stub( :send_message ).and_raise( exception )
-        Net::SMTP.should_receive( :start ).and_yield( smtp )
+        allow( smtp ).to receive( :send_message ).and_raise( exception )
+        allow( Net::SMTP ).to receive( :start ).and_yield( smtp )
         checker = StatusCat::Checkers::ActionMailer.new
-        checker.status.should be( exception )
+        expect( checker.status ).to be( exception )
       end
-
     end
-
   end
-
 end

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

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe StatusCat::Checkers::ActiveRecord do
 
   let( :checker ) { StatusCat::Checkers::ActiveRecord.new.freeze }
@@ -10,7 +8,7 @@ describe StatusCat::Checkers::ActiveRecord 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 ]}"
-    checker.value.should eql( expected )
+    expect( checker.value ).to eql( expected )
   end
 
   describe '#status' do
@@ -18,24 +16,20 @@ describe StatusCat::Checkers::ActiveRecord do
     context 'pass' do
 
       it 'passes if it can execute a query against the database' do
-        ActiveRecord::Base.connection.stub( :execute )
+        allow( ActiveRecord::Base.connection ).to receive( :execute )
         checker = StatusCat::Checkers::ActiveRecord.new
-        checker.status.should be_nil
+        expect( checker.status ).to be_nil
       end
-
     end
 
     context 'fail' do
 
       it 'returns an error message if it fails to query the database' do
         fail = 'This is only a test'
-        ActiveRecord::Base.connection.should_receive( :execute ).and_raise( fail )
+        expect( ActiveRecord::Base.connection ).to receive( :execute ).and_raise( fail )
         checker = StatusCat::Checkers::ActiveRecord.new
-        checker.status.to_s.should eql( fail )
+        expect( checker.status.to_s ).to eql( fail )
       end
-
     end
-
   end
-
 end

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

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe StatusCat::Checkers::Base do
 
   let( :checker ) { StatusCat::Checkers::Base.new }
@@ -7,35 +5,32 @@ describe StatusCat::Checkers::Base do
   describe '#name' do
 
     it 'generates a symbolized class name' do
-      checker.name.should be( :base )
+      expect( checker.name ).to be( :base )
     end
-
   end
 
   describe 'attributes' do
 
     it 'has value and status readers' do
-      checker.value.should be_nil
-      checker.status.should be_nil
+      expect( checker.value ).to be_nil
+      expect( checker.status ).to be_nil
     end
-
   end
 
   describe '#to_s' do
 
     before( :each ) do
-      checker.stub( :value ).and_return( 'secret' )
-      checker.stub( :status ).and_return( 'fail' )
+      allow( checker ).to receive( :value ).and_return( 'secret' )
+      allow( checker ).to receive( :status ).and_return( 'fail' )
     end
 
     it 'generates a string' do
-      checker.to_s.should eql( "base | secret | fail\n" )
+      expect( checker.to_s ).to eql( "base | secret | fail\n" )
     end
 
     it 'accepts a format' do
-      checker.to_s( '%s * %s * %s' ).should eql( 'base * secret * fail' )
+      expect( checker.to_s( '%s * %s * %s' ) ).to eql( 'base * secret * fail' )
     end
-
   end
 
   describe '#fail_on_exception' do
@@ -43,14 +38,12 @@ 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 }
-      status.to_s.should eql( 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 }
-      status.should be_true
+      expect( status ).to be( true )
     end
-
   end
-
 end

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

@@ -1,14 +1,9 @@
-require 'spec_helper'
 require 'delayed_job_active_record'
 
 describe StatusCat::Checkers::DelayedJob do
 
   let( :checker ) { StatusCat::Checkers::DelayedJob.new.freeze }
 
-  before( :each ) do
-
-  end
-
   it_should_behave_like 'a status checker'
 
   it 'tolerates Delayed::Job being undefined' do
@@ -18,23 +13,22 @@ describe StatusCat::Checkers::DelayedJob do
   end
 
   it 'fails if there is an exception' do
-    ActiveRecord::Base.connection.should_receive( :execute ).and_raise( :error )
+    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
-    ActiveRecord::Base.connection.should_receive( :execute ).and_return( [1], [1] )
+    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
-    ActiveRecord::Base.connection.should_receive( :execute ).and_return( [1], [0] )
+    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
-    ActiveRecord::Base.connection.should_receive( :execute ).and_return( [1], [0] )
+    expect( ActiveRecord::Base.connection ).to receive( :execute ).and_return( [1], [0] )
     expect( checker.value ).to eql( 1 )
   end
-
 end

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

@@ -0,0 +1,33 @@
+describe StatusCat::Checkers::Fitbit do
+
+  let( :checker ) { StatusCat::Checkers::Fitbit.new.freeze }
+
+  it_should_behave_like 'a status checker'
+
+  describe '#initialize' do
+
+    it 'sets the value' do
+      expect( checker.value ).to eql( ENV[ 'FITBIT_CONSUMER_KEY' ] )
+    end
+
+    context 'pass' do
+
+      it 'passes if it can connect to Fitbit' do
+        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
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+describe StatusCat::Checkers::Profilesio do
+
+  let( :checker ) { StatusCat::Checkers::Profilesio.new.freeze }
+  let( :response ) { double( "response", :code => 200 ) }
+  let( :key ) { 'env_profilesio_key' }
+
+  before( :each ) do
+    allow( HTTParty ).to receive( :get ).and_return( response )
+    ENV['PROFILESIO_KEY'] = key
+  end
+
+  it_should_behave_like 'a status checker'
+
+  it 'sets the value' do
+    expect( checker.value ).to eql( key )
+  end
+
+  context 'pass' do
+
+    it 'passes on connection to Profilesio' do
+      expect( checker.status ).to be_nil
+    end
+
+  end
+
+  context 'fail' do
+
+    it 'fails if it receives a non 200 code' do
+      expect( response ).to receive( :code ).and_return( 404 )
+      expect( checker.status ).to_not be_nil
+    end
+
+    it 'fails if there is an exception' do
+      expect( response ).to receive( :code ).and_raise( 'No code for you!' )
+      expect( checker.status ).to_not be_nil
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'aws-sdk'
 
 describe StatusCat::Checkers::S3 do
@@ -6,7 +5,7 @@ describe StatusCat::Checkers::S3 do
   let( :checker ) { StatusCat::Checkers::S3.new.freeze }
 
   before( :each ) do
-    AWS::S3.stub( :new ).and_return( @s3 = double( AWS::S3 ) )
+    allow( AWS::S3 ).to receive( :new ).and_return( @s3 = double( AWS::S3 ) )
   end
 
   it_should_behave_like 'a status checker'
@@ -35,5 +34,4 @@ describe StatusCat::Checkers::S3 do
     expect( @s3 ).to receive( :buckets ).and_return( [ 1 ] )
     expect( checker.status ).to be_nil
   end
-
 end

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

@@ -0,0 +1,33 @@
+describe StatusCat::Checkers::SendHub do
+
+  let( :checker ) { StatusCat::Checkers::SendHub.new.freeze }
+
+  it_should_behave_like 'a status checker'
+
+  describe '#initialize' do
+
+    it 'sets the value' do
+      expect( checker.value ).to eql( ENV[ 'SEND_HUB_NUMBER' ] )
+    end
+
+    context 'pass' do
+
+      it 'passes if it can connect to SendHub' do
+        expect( checker.status ).to be_nil
+      end
+    end
+
+    context 'fail' do
+
+      it 'fails if it receives nil' do
+        expect( @send_hub ).to receive( :get_contacts ).and_return( nil )
+        expect( checker.status ).to_not be_nil
+      end
+
+      it 'fails if there is an exception' do
+        expect( @send_hub ).to receive( :get_contacts ).and_raise( 'This is only a test' )
+        expect( checker.status ).to_not be_nil
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'stripe'
 
 describe StatusCat::Checkers::Stripe do
@@ -7,7 +6,7 @@ describe StatusCat::Checkers::Stripe do
   let( :email ) { 'foo@bar.com' }
 
   before( :each ) do
-    Stripe::Account.stub( :retrieve ).and_return( @stripe = double( Stripe::Account ) )
+    allow( Stripe::Account ).to receive( :retrieve ).and_return( @stripe = double( Stripe::Account ) )
   end
 
   it_should_behave_like 'a status checker'
@@ -40,5 +39,4 @@ describe StatusCat::Checkers::Stripe do
     expect( @stripe ).to receive( :email ).and_return( email )
     expect( checker.value ).to eql( email )
   end
-
 end

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

@@ -0,0 +1,33 @@
+describe StatusCat::Checkers::Twilio do
+
+  let( :checker ) { StatusCat::Checkers::Twilio.new.freeze }
+
+  it_should_behave_like 'a status checker'
+
+  describe '#initialize' do
+
+    it 'sets the value' do
+      expect( checker.value ).to eql( ENV[ 'TWILIO_SID' ] )
+    end
+
+    context 'pass' do
+
+      it 'passes if it can connect to Twilio' do
+        expect( checker.status ).to be_nil
+      end
+    end
+
+    context 'fail' do
+
+      it 'fails if it receives nil' do
+        expect( @twilio_messages ).to receive( :total ).and_return( nil )
+        expect( checker.status ).to_not be_nil
+      end
+
+      it 'fails if there is an exception' do
+        expect( @twilio_messages ).to receive( :total ).and_raise( 'This is only a test' )
+        expect( checker.status ).to_not be_nil
+      end
+    end
+  end
+end

data/spec/lib/status_cat/config_spec.rb

@@ -1,80 +1,82 @@
-require 'spec_helper'
-
 describe StatusCat::Config do
 
   let( :config ) { StatusCat::Config.instance }
 
   it 'is a singleton' do
-    config.should be( StatusCat::Config.instance )
+    expect( config ).to be( StatusCat::Config.instance )
   end
 
   describe 'attributes' do
 
     it 'has an #authenticate accessor' do
-      config.authenticate = StatusCat::Config::NIL_PROC
-      config.authenticate = config.authenticate
-      config.authenticate.should eql( config.authenticate )
+       config.authenticate = config.authenticate
+      expect( config.authenticate ).to eql( config.authenticate )
     end
 
     it 'has an #authorize accessor' do
-      config.authorize = StatusCat::Config::NIL_PROC
       config.authorize = config.authorize
-      config.authorize.should eql( config.authorize )
+      expect( config.authorize ).to eql( config.authorize )
     end
 
     it 'has an #enabled accessor' do
-      config.enabled.should_not be_nil
+      expect( config.enabled ).to_not be_nil
       config.enabled = config.enabled
-      config.enabled.should eql( config.enabled )
+      expect( config.enabled ).to eql( config.enabled )
     end
 
     it 'has a #from accessor' do
-      config.from.should_not be_nil
+      expect( config.from ).to_not be_nil
       config.from = config.from
-      config.from.should eql( config.from )
+      expect( config.from ).to eql( config.from )
     end
 
     it 'has a #layout accessor' do
-      config.layout.should_not be_nil
+      expect( config.layout ).to_not be_nil
       config.layout = config.layout
-      config.layout.should eql( config.layout )
+      expect( config.layout ).to eql( config.layout )
     end
 
     it 'has a #noreply accessor' do
-      config.noreply.should_not be_nil
+      expect( config.noreply ).to_not be_nil
       config.noreply = config.noreply
-      config.noreply.should eql( config.noreply )
+      expect( config.noreply ).to eql( config.noreply )
     end
 
     it 'has a #to accessor' do
-      config.to.should_not be_nil
+      expect( config.to ).to_not be_nil
       config.to = config.to
-      config.to.should eql( config.to )
+      expect( config.to ).to eql( config.to )
     end
 
     it 'has an #subject accessor' do
-      config.subject.should_not be_nil
+      expect( config.subject ).to_not be_nil
       config.subject = config.subject
-      config.subject.should eql( config.subject )
+      expect( config.subject ).to eql( config.subject )
     end
-
   end
 
   describe '#initialize' do
 
     it 'defaults the #enabled list to all StatusCat::Checkers::Base subclasses' do
       descendants = StatusCat::Checkers::Base.descendants
-      StatusCat::Checkers::Base.should_receive( :descendants ).and_return( descendants )
+      expect( StatusCat::Checkers::Base ).to receive( :descendants ).and_return( descendants )
 
       config.enabled = nil
       config.send( :initialize )
-      config.enabled.should_not be_nil
+      expect( config.enabled ).to_not be_nil
     end
-
   end
 
   describe '#authenticate_with' do
 
+    before( :each ) do
+      @authenticate = config.authenticate
+    end
+
+    after( :each ) do
+      config.authenticate = @authenticate
+    end
+
     it 'accepts a block' do
       config.authenticate = nil
       config.authenticate_with do
@@ -91,18 +93,25 @@ describe StatusCat::Config do
       end
 
       instance_eval( &config.authenticate_with )
-      expect( @test ).to be_true
+      expect( @test ).to be( true )
     end
 
     it 'returns a nil proc if none has been set' do
       config.authenticate = nil
       instance_eval( &config.authenticate_with )
     end
-
   end
 
   describe '#authorize_with' do
 
+    before( :each ) do
+      @authorize = config.authorize
+    end
+
+    after( :each ) do
+      config.authorize = @authorize
+    end
+
     it 'accepts a block' do
       config.authorize = nil
       config.authorize_with do
@@ -119,15 +128,13 @@ describe StatusCat::Config do
       end
 
       instance_eval( &config.authorize_with )
-      expect( @test ).to be_true
+      expect( @test ).to be( true )
     end
 
     it 'returns a nil proc if none has been set' do
       config.authorize = nil
       instance_eval( &config.authorize_with )
     end
-
   end
-
 end