status_cat 0.1.1 → 5.0.0

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

@@ -1,24 +1,24 @@
 describe StatusCat::Checkers::Profilesio do
 
-  let( :checker ) { StatusCat::Checkers::Profilesio.new.freeze }
-  let( :response ) { double( "response", :code => 200 ) }
-  let( :key ) { 'env_profilesio_key' }
+  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
+  before(:each) do
+    allow(HTTParty).to receive(:get).and_return(response)
+    StatusCat::Checkers::Profilesio.api_key = key
   end
 
   it_should_behave_like 'a status checker'
 
   it 'sets the value' do
-    expect( checker.value ).to eql( key )
+    expect(checker.value).to eql(key)
   end
 
   context 'pass' do
 
     it 'passes on connection to Profilesio' do
-      expect( checker.status ).to be_nil
+      expect(checker.status).to be_nil
     end
 
   end
@@ -26,13 +26,13 @@ describe StatusCat::Checkers::Profilesio do
   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
+      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
+      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,37 +1,36 @@
-require 'aws-sdk'
-
 describe StatusCat::Checkers::S3 do
 
-  let( :checker ) { StatusCat::Checkers::S3.new.freeze }
+  let(:checker) { StatusCat::Checkers::S3.new.freeze }
+
+  before(:each) do
 
-  before( :each ) do
-    allow( AWS::S3 ).to receive( :new ).and_return( @s3 = double( AWS::S3 ) )
+    allow(Aws::S3::Resource).to receive(:new).and_return(@s3 = double(Aws::S3::Resource))
   end
 
   it_should_behave_like 'a status checker'
 
-  it 'tolerates AWS being undefined' do
-    aws = Object.send(:remove_const, :AWS)
-    expect( checker.status ).to_not be_nil
-    Object.const_set( :AWS, aws )
+  it 'tolerates the gem misssing' do
+    gem = Object.send(:remove_const, :Aws)
+    expect(checker.status).to eql('aws-sdk gem is not installed')
+    Object.const_set(:Aws, gem)
   end
 
   it 'uses the aws access key as the value' do
-    expect( checker.value ).to eql( AWS.config.access_key_id )
+    expect(checker.value).to eql(Aws.config[:credentials].access_key_id)
   end
 
   it 'fails if there is an exception talking to S3' do
-    expect( @s3 ).to receive( :buckets ).and_raise( 'error' )
-    expect( checker.status ).to_not be_nil
+    expect(@s3).to receive(:buckets).and_raise('error')
+    expect(checker.status).to_not be_nil
   end
 
   it 'fails if there are no S3 buckets' do
-      expect( @s3 ).to receive( :buckets ).and_return( [] )
-      expect( checker.status ).to_not be_nil
-    end
+    expect(@s3).to receive(:buckets).and_return([])
+    expect(checker.status).to_not be_nil
+  end
 
   it 'passes if it finds S3 buckets' do
-    expect( @s3 ).to receive( :buckets ).and_return( [ 1 ] )
-    expect( checker.status ).to be_nil
+    expect(@s3).to receive(:buckets).and_return([1])
+    expect(checker.status).to be_nil
   end
-end
+end

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

@@ -1,33 +1,39 @@
 describe StatusCat::Checkers::SendHub do
 
-  let( :checker ) { StatusCat::Checkers::SendHub.new.freeze }
+  let(:checker) { StatusCat::Checkers::SendHub.new.freeze }
 
   it_should_behave_like 'a status checker'
 
   describe '#initialize' do
 
+    it 'tolerates the gem misssing' do
+      gem = Object.send(:remove_const, :SendHub)
+      expect(checker.status).to eql('ruby-sendhub gem is not installed')
+      Object.const_set(:SendHub, gem)
+    end
+
     it 'sets the value' do
-      expect( checker.value ).to eql( ENV[ 'SEND_HUB_NUMBER' ] )
+      expect(checker.value).to eql(StatusCat::Checkers::SendHub.number)
     end
 
     context 'pass' do
 
       it 'passes if it can connect to SendHub' do
-        expect( checker.status ).to be_nil
+        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
+        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
+        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
+end

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

@@ -1,42 +1,36 @@
-require 'stripe'
-
 describe StatusCat::Checkers::Stripe do
 
-  let( :checker ) { StatusCat::Checkers::Stripe.new.freeze }
-  let( :email ) { 'foo@bar.com' }
-
-  before( :each ) do
-    allow( Stripe::Account ).to receive( :retrieve ).and_return( @stripe = double( Stripe::Account ) )
-  end
+  let(:checker) { StatusCat::Checkers::Stripe.new.freeze }
+  let(:email) { 'foo@bar.com' }
 
   it_should_behave_like 'a status checker'
 
-  it 'tolerates Stripe being undefined' do
-    stripe = Object.send(:remove_const, :Stripe)
-    expect( checker.status ).to_not be_nil
-    Object.const_set( :Stripe, stripe )
+  it 'tolerates the gem misssing' do
+    gem = Object.send(:remove_const, :Stripe)
+    expect(checker.status).to eql('stripe gem is not installed')
+    Object.const_set(:Stripe, gem)
   end
 
   it 'fails if there is an exception talking to Stripe' do
-    expect( @stripe ).to receive( :email ).and_raise( 'error' )
-    expect( checker.status ).to_not be_nil
+    expect(@stripe).to receive(:email).and_raise('test error')
+    expect(checker.status).to_not be_nil
   end
 
   it 'fails if charging is not enabled' do
-    expect( @stripe ).to receive( :charge_enabled ).and_return( false )
-    expect( @stripe ).to receive( :email ).and_return( email )
-    expect( checker.status ).to_not be_nil
+    expect(@stripe).to receive(:charge_enabled).and_return(false)
+    expect(@stripe).to receive(:email).and_return(email)
+    expect(checker.status).to_not be_nil
   end
 
   it 'passes if charging is enabled' do
-    expect( @stripe ).to receive( :charge_enabled ).and_return( true )
-    expect( @stripe ).to receive( :email ).and_return( email )
-    expect( checker.status ).to be_nil
+    expect(@stripe).to receive(:charge_enabled).and_return(true)
+    expect(@stripe).to receive(:email).and_return(email)
+    expect(checker.status).to be_nil
   end
 
   it 'uses the account email as the value' do
-    expect( @stripe ).to receive( :charge_enabled ).and_return( true )
-    expect( @stripe ).to receive( :email ).and_return( email )
-    expect( checker.value ).to eql( email )
+    expect(@stripe).to receive(:charge_enabled).and_return(true)
+    expect(@stripe).to receive(:email).and_return(email)
+    expect(checker.value).to eql(email)
   end
-end
+end

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

@@ -1,33 +1,39 @@
 describe StatusCat::Checkers::Twilio do
 
-  let( :checker ) { StatusCat::Checkers::Twilio.new.freeze }
+  let(:checker) { StatusCat::Checkers::Twilio.new.freeze }
 
   it_should_behave_like 'a status checker'
 
   describe '#initialize' do
 
+    it 'tolerates the gem misssing' do
+      gem = Object.send(:remove_const, :Twilio)
+      expect(checker.status).to eql('twilio-ruby gem is not installed')
+      Object.const_set(:Twilio, gem)
+    end
+
     it 'sets the value' do
-      expect( checker.value ).to eql( ENV[ 'TWILIO_SID' ] )
+      expect(checker.value).to eql(StatusCat::Checkers::Twilio.sid)
     end
 
     context 'pass' do
 
       it 'passes if it can connect to Twilio' do
-        expect( checker.status ).to be_nil
+        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
+        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
+        expect(@twilio_messages).to receive(:total).and_raise('This is only a test')
+        expect(checker.status).to_not be_nil
       end
     end
   end
-end
+end

data/spec/lib/status_cat/config_spec.rb

@@ -1,57 +1,57 @@
 describe StatusCat::Config do
 
-  let( :config ) { StatusCat::Config.instance }
+  let(:config) { StatusCat::Config.instance }
 
   it 'is a singleton' do
-    expect( config ).to be( StatusCat::Config.instance )
+    expect(config).to be(StatusCat::Config.instance)
   end
 
   describe 'attributes' do
 
     it 'has an #authenticate accessor' do
-       config.authenticate = config.authenticate
-      expect( config.authenticate ).to eql( config.authenticate )
+      config.authenticate = config.authenticate
+      expect(config.authenticate).to eql(config.authenticate)
     end
 
     it 'has an #authorize accessor' do
       config.authorize = config.authorize
-      expect( config.authorize ).to eql( config.authorize )
+      expect(config.authorize).to eql(config.authorize)
     end
 
     it 'has an #enabled accessor' do
-      expect( config.enabled ).to_not be_nil
+      expect(config.enabled).to_not be_nil
       config.enabled = config.enabled
-      expect( config.enabled ).to eql( config.enabled )
+      expect(config.enabled).to eql(config.enabled)
     end
 
     it 'has a #from accessor' do
-      expect( config.from ).to_not be_nil
+      expect(config.from).to_not be_nil
       config.from = config.from
-      expect( config.from ).to eql( config.from )
+      expect(config.from).to eql(config.from)
     end
 
     it 'has a #layout accessor' do
-      expect( config.layout ).to_not be_nil
+      expect(config.layout).to_not be_nil
       config.layout = config.layout
-      expect( config.layout ).to eql( config.layout )
+      expect(config.layout).to eql(config.layout)
     end
 
     it 'has a #noreply accessor' do
-      expect( config.noreply ).to_not be_nil
+      expect(config.noreply).to_not be_nil
       config.noreply = config.noreply
-      expect( config.noreply ).to eql( config.noreply )
+      expect(config.noreply).to eql(config.noreply)
     end
 
     it 'has a #to accessor' do
-      expect( config.to ).to_not be_nil
+      expect(config.to).to_not be_nil
       config.to = config.to
-      expect( config.to ).to eql( config.to )
+      expect(config.to).to eql(config.to)
     end
 
     it 'has an #subject accessor' do
-      expect( config.subject ).to_not be_nil
+      expect(config.subject).to_not be_nil
       config.subject = config.subject
-      expect( config.subject ).to eql( config.subject )
+      expect(config.subject).to eql(config.subject)
     end
   end
 
@@ -59,21 +59,21 @@ describe StatusCat::Config do
 
     it 'defaults the #enabled list to all StatusCat::Checkers::Base subclasses' do
       descendants = StatusCat::Checkers::Base.descendants
-      expect( StatusCat::Checkers::Base ).to receive( :descendants ).and_return( descendants )
+      expect(StatusCat::Checkers::Base).to receive(:descendants).and_return(descendants)
 
       config.enabled = nil
-      config.send( :initialize )
-      expect( config.enabled ).to_not be_nil
+      config.send(:initialize)
+      expect(config.enabled).to_not be_nil
     end
   end
 
   describe '#authenticate_with' do
 
-    before( :each ) do
+    before(:each) do
       @authenticate = config.authenticate
     end
 
-    after( :each ) do
+    after(:each) do
       config.authenticate = @authenticate
     end
 
@@ -83,7 +83,7 @@ describe StatusCat::Config do
         true
       end
 
-      expect( config.authenticate ).to_not be_nil
+      expect(config.authenticate).to_not be_nil
     end
 
     it 'returns a block' do
@@ -92,23 +92,23 @@ describe StatusCat::Config do
         @test = true
       end
 
-      instance_eval( &config.authenticate_with )
-      expect( @test ).to be( true )
+      instance_eval(&config.authenticate_with)
+      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 )
+      instance_eval(&config.authenticate_with)
     end
   end
 
   describe '#authorize_with' do
 
-    before( :each ) do
+    before(:each) do
       @authorize = config.authorize
     end
 
-    after( :each ) do
+    after(:each) do
       config.authorize = @authorize
     end
 
@@ -118,7 +118,7 @@ describe StatusCat::Config do
         true
       end
 
-      expect( config.authorize ).to_not be_nil
+      expect(config.authorize).to_not be_nil
     end
 
     it 'returns a block' do
@@ -127,14 +127,13 @@ describe StatusCat::Config do
         @test = true
       end
 
-      instance_eval( &config.authorize_with )
-      expect( @test ).to be( true )
+      instance_eval(&config.authorize_with)
+      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 )
+      instance_eval(&config.authorize_with)
     end
   end
 end
-

data/spec/lib/status_cat/engine_spec.rb

@@ -1,6 +1,6 @@
 describe StatusCat::Engine do
 
   it 'isolates the StatusCat namespace' do
-    expect( StatusCat::Engine.isolated ).to be( true )
+    expect(StatusCat::Engine.isolated).to be(true)
   end
-end
+end

data/spec/lib/status_cat/status_spec.rb

@@ -8,12 +8,12 @@ describe StatusCat::Status do
 
     it 'returns an array of enabled checkers' do
       enabled = StatusCat::Config.instance.enabled
-      expect( StatusCat::Config.instance ).to receive( :enabled ).and_return( enabled )
+      expect(StatusCat::Config.instance).to receive(:enabled).and_return(enabled)
 
       all = StatusCat::Status.all
-      expect( all ).to be_an_instance_of( Array )
-      expect( all.length ).to eql( StatusCat::Checkers::Base.descendants.length )
-      all.each { |checker| expect( checker ).to be_a_kind_of( StatusCat::Checkers::Base ) }
+      expect(all).to be_an_instance_of(Array)
+      expect(all.length).to eql(StatusCat::Checkers::Base.descendants.length)
+      all.each { |checker| expect(checker).to be_a_kind_of(StatusCat::Checkers::Base) }
     end
   end
 
@@ -23,32 +23,32 @@ describe StatusCat::Status do
 
   describe '::check' do
 
-    def checker_array_should_have_names( actual, expected )
-      expect( actual ).to be_a_kind_of( Array )
-      expect( actual.length ).to eql( expected.length )
-      actual.each_index { |i| expect( actual[ i ].name ).to be( expected[ i ] ) }
+    def checker_array_should_have_names(actual, expected)
+      expect(actual).to be_a_kind_of(Array)
+      expect(actual.length).to eql(expected.length)
+      actual.each_index { |i| expect(actual[i].name).to be(expected[i]) }
     end
 
     it 'defaults to all checkers' do
-      names = StatusCat::Status.all.map { |checker| checker.name }
+      names = StatusCat::Status.all.map(&:name)
       checkers = StatusCat::Status.check
-      checker_array_should_have_names( checkers, names )
+      checker_array_should_have_names(checkers, names)
     end
 
     it 'returns all checkers when :all is specified' do
-      names = StatusCat::Status.all.map { |checker| checker.name }
-      checkers = StatusCat::Status.check( :all )
-      checker_array_should_have_names( checkers, names )
+      names = StatusCat::Status.all.map(&:name)
+      checkers = StatusCat::Status.check(:all)
+      checker_array_should_have_names(checkers, names)
     end
 
     it 'returns a single checker when given a single symbolic name' do
-      expect( StatusCat::Status.check( :active_record ) ).to be_an_instance_of( StatusCat::Checkers::ActiveRecord )
+      expect(StatusCat::Status.check(:active_record)).to be_an_instance_of(StatusCat::Checkers::ActiveRecord)
     end
 
     it 'returns an array of checkers when given an array of symbolic name' do
-      names = [ :active_record, :action_mailer ]
-      checkers = StatusCat::Status.check( names )
-      checker_array_should_have_names( checkers, names )
+      names = [:active_record, :action_mailer]
+      checkers = StatusCat::Status.check(names)
+      checker_array_should_have_names(checkers, names)
     end
   end
 
@@ -59,16 +59,16 @@ describe StatusCat::Status do
   describe '::cron' do
 
     it 'delivers email if ::failed is not empty' do
-      failed = [ StatusCat::Checkers::Base.new ]
-      mail =  StatusCat::StatusMailer.failure( failed )
-      expect( StatusCat::Status ).to receive( :failed ).and_return( failed )
-      expect( StatusCat::StatusMailer ).to receive( :failure ).with( failed ).and_return( mail )
+      failed = [StatusCat::Checkers::Base.new]
+      mail = StatusCat::StatusMailer.failure(failed)
+      expect(StatusCat::Status).to receive(:failed).and_return(failed)
+      expect(StatusCat::StatusMailer).to receive(:failure).with(failed).and_return(mail)
       StatusCat::Status.cron
     end
 
     it 'does not email when ::failed is empty' do
-      expect( StatusCat::Status ).to receive( :failed ).and_return( [] )
-      expect( StatusCat::StatusMailer ).to_not receive( :failure )
+      expect(StatusCat::Status).to receive(:failed).and_return([])
+      expect(StatusCat::StatusMailer).to_not receive(:failure)
       StatusCat::Status.cron
     end
   end
@@ -80,8 +80,8 @@ describe StatusCat::Status do
   describe '::factory' do
 
     it 'constructs a checker given its symbolic name' do
-      expect( StatusCat::Status.factory( :action_mailer ) ).to be_an_instance_of( StatusCat::Checkers::ActionMailer )
-      expect( StatusCat::Status.factory( :active_record ) ).to be_an_instance_of( StatusCat::Checkers::ActiveRecord )
+      expect(StatusCat::Status.factory(:action_mailer)).to be_an_instance_of(StatusCat::Checkers::ActionMailer)
+      expect(StatusCat::Status.factory(:active_record)).to be_an_instance_of(StatusCat::Checkers::ActiveRecord)
     end
   end
 
@@ -91,22 +91,21 @@ describe StatusCat::Status do
 
   describe '::failed' do
 
-    before( :each ) do
+    before(:each) do
       @pass = StatusCat::Checkers::Base.new
 
       @fail = StatusCat::Checkers::Base.new
-      allow( @fail ).to receive( :status ).and_return( :fail )
+      allow(@fail).to receive(:status).and_return(:fail)
     end
 
     it 'returns only failed checkers from ::all' do
-      expect(  StatusCat::Status ).to receive( :all ).and_return( [ @pass, @fail ] )
-      expect( StatusCat::Status.failed ).to eql( [ @fail ] )
+      expect(StatusCat::Status).to receive(:all).and_return([@pass, @fail])
+      expect(StatusCat::Status.failed).to eql([@fail])
     end
 
     it 'returns an empty list if all checkers pass' do
-      expect( StatusCat::Status ).to receive( :all ).and_return( [ @pass ] )
-      expect( StatusCat::Status.failed ).to eql( [] )
+      expect(StatusCat::Status).to receive(:all).and_return([@pass])
+      expect(StatusCat::Status.failed).to eql([])
     end
   end
 end
-