backup 3.0.20 → 3.0.21

data/spec/notifier/base_spec.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe 'Backup::Notifier::Base' do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:notifier) { Backup::Notifier::Base.new(model) }
+
+  describe '#initialize' do
+
+    it "sets the correct defaults" do
+      notifier.on_success.should == true
+      notifier.on_warning.should == true
+      notifier.on_failure.should == true
+    end
+
+    context 'when using configuration defaults' do
+      after { Backup::Configuration::Notifier::Base.clear_defaults! }
+
+      it 'uses configuration defaults' do
+        Backup::Configuration::Notifier::Base.defaults do |notifier|
+          notifier.on_success = false
+          notifier.on_warning = false
+          notifier.on_failure = false
+        end
+
+        base = Backup::Notifier::Base.new(model)
+        base.on_success.should == false
+        base.on_warning.should == false
+        base.on_failure.should == false
+      end
+    end
+
+  end # describe '#initialize'
+
+  describe '#perform!' do
+    before do
+      notifier.expects(:log!)
+      Backup::Template.expects(:new).with({:model => model})
+    end
+
+    context 'when failure is false' do
+      context 'when no warnings were issued' do
+        before do
+          Backup::Logger.expects(:has_warnings?).returns(false)
+        end
+
+        it 'should call #notify! with :success' do
+          notifier.expects(:notify!).with(:success)
+          notifier.perform!
+        end
+      end
+
+      context 'when warnings were issued' do
+        before do
+          Backup::Logger.expects(:has_warnings?).returns(true)
+        end
+
+        it 'should call #notify! with :warning' do
+          notifier.expects(:notify!).with(:warning)
+          notifier.perform!
+        end
+      end
+    end # context 'when failure is false'
+
+    context 'when failure is true' do
+      it 'should call #notify with :failure' do
+        notifier.expects(:notify!).with(:failure)
+        notifier.perform!(true)
+      end
+    end
+  end # describe '#perform!'
+
+  describe '#notifier_name' do
+    it 'should return class name without Backup:: namespace' do
+      notifier.send(:notifier_name).should == 'Notifier::Base'
+    end
+  end
+
+  describe '#log!' do
+    it 'should log a message' do
+      Backup::Logger.expects(:message).with(
+        "Notifier::Base started notifying about the process."
+      )
+      notifier.send(:log!)
+    end
+  end
+
+end

data/spec/notifier/campfire_spec.rb

@@ -3,8 +3,9 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Notifier::Campfire do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
   let(:notifier) do
-    Backup::Notifier::Campfire.new do |campfire|
+    Backup::Notifier::Campfire.new(model) do |campfire|
       campfire.api_token = 'token'
       campfire.subdomain = 'subdomain'
       campfire.room_id   = 'room_id'
@@ -12,7 +13,7 @@ describe Backup::Notifier::Campfire do
   end
 
   describe '#initialize' do
-    it 'sets the correct defaults' do
+    it 'should sets the correct values' do
       notifier.api_token.should == 'token'
       notifier.subdomain.should == 'subdomain'
       notifier.room_id.should   == 'room_id'
@@ -22,150 +23,177 @@ describe Backup::Notifier::Campfire do
       notifier.on_failure.should == true
     end
 
-    it 'uses and overrides configuration defaults' do
-      Backup::Configuration::Notifier::Campfire.defaults do |campfire|
-        campfire.api_token  = 'old_token'
-        campfire.on_success = false
-      end
-        notifier           = Backup::Notifier::Campfire.new do |campfire|
-        campfire.api_token = 'new_token'
-      end
+    context 'when using configuration defaults' do
+      after { Backup::Configuration::Notifier::Campfire.clear_defaults! }
 
-      notifier.api_token.should  == 'new_token'
-      notifier.on_success.should == false
-      notifier.on_warning.should == true
-      notifier.on_failure.should == true
-    end
-  end
+      it 'should use the configuration defaults' do
+        Backup::Configuration::Notifier::Campfire.defaults do |campfire|
+          campfire.api_token  = 'some_token'
+          campfire.subdomain  = 'some_subdomain'
+          campfire.room_id    = 'some_room_id'
 
-  describe '#perform!' do
-    let(:model)     { Backup::Model.new('trigger', 'label') {} }
-    let(:interface) { Backup::Notifier::Campfire::Interface }
-    let(:attrs)     { [notifier.room_id, notifier.subdomain, notifier.api_token] }
-    let(:room)      { Backup::Notifier::Campfire::Room.new(*attrs) }
-    let(:base_uri)  { "https://#{notifier.subdomain}.campfirenow.com" }
-    let(:room_url)  { "/room/#{notifier.room_id}/speak.json" }
-    let(:message)   { '[Backup::%s] label (trigger)' }
-
-    before do
-      notifier.on_success = false
-      notifier.on_warning = false
-      notifier.on_failure = false
-    end
+          campfire.on_success = false
+          campfire.on_warning = false
+          campfire.on_failure = false
+        end
+        notifier = Backup::Notifier::Campfire.new(model)
+        notifier.api_token.should == 'some_token'
+        notifier.subdomain.should == 'some_subdomain'
+        notifier.room_id.should   == 'some_room_id'
+
+        notifier.on_success.should == false
+        notifier.on_warning.should == false
+        notifier.on_failure.should == false
+      end
 
-    context 'success' do
+      it 'should override the configuration defaults' do
+        Backup::Configuration::Notifier::Campfire.defaults do |campfire|
+          campfire.api_token  = 'old_token'
+          campfire.subdomain  = 'old_subdomain'
+          campfire.room_id    = 'old_room_id'
 
-      context 'when on_success is true' do
-        before { notifier.on_success = true }
+          campfire.on_success = true
+          campfire.on_warning = false
+          campfire.on_failure = false
+        end
+        notifier = Backup::Notifier::Campfire.new(model) do |campfire|
+          campfire.api_token  = 'new_token'
+          campfire.subdomain  = 'new_subdomain'
+          campfire.room_id    = 'new_room_id'
+
+          campfire.on_success = false
+          campfire.on_warning = true
+          campfire.on_failure = true
+        end
 
-        it 'sends success message' do
-          notifier.expects(:log!)
-          interface.expects(:room).with(*attrs).returns(room)
-          interface.expects(:base_uri).with(base_uri)
-          interface.expects(:basic_auth).with(notifier.api_token, 'x')
-          message_body = message % 'Success'
-          interface.expects(:post).with(room_url, :body => {
-            :message => { :body => message_body, :type => 'Textmessage' }
-          }.to_json)
+        notifier.api_token.should == 'new_token'
+        notifier.subdomain.should == 'new_subdomain'
+        notifier.room_id.should   == 'new_room_id'
 
-          notifier.perform!(model)
-        end
+        notifier.on_success.should == false
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
       end
+    end # context 'when using configuration defaults'
+  end
 
-      context 'when on_success is false' do
-        it 'sends no message' do
-          notifier.expects(:log!).never
-          notifier.expects(:notify!).never
-          room.expects(:send_message).never
-          interface.expects(:post).never
+  describe '#notify!' do
+    context 'when status is :success' do
+      it 'should send Success message' do
+        notifier.expects(:send_message).with(
+          '[Backup::Success] test label (test_trigger)'
+        )
+        notifier.send(:notify!, :success)
+      end
+    end
 
-          notifier.perform!(model)
-        end
+    context 'when status is :warning' do
+      it 'should send Warning message' do
+        notifier.expects(:send_message).with(
+          '[Backup::Warning] test label (test_trigger)'
+        )
+        notifier.send(:notify!, :warning)
       end
+    end
 
-    end # context 'success'
+    context 'when status is :failure' do
+      it 'should send Failure message' do
+        notifier.expects(:send_message).with(
+          '[Backup::Failure] test label (test_trigger)'
+        )
+        notifier.send(:notify!, :failure)
+      end
+    end
+  end # describe '#notify!'
 
-    context 'warning' do
-      before { Backup::Logger.stubs(:has_warnings?).returns(true) }
+  describe '#send_message' do
+    it 'should send a message' do
+      room = mock
+      Backup::Notifier::Campfire::Interface.expects(:room).
+          with('room_id', 'subdomain', 'token').returns(room)
+      room.expects(:message).with('a message')
 
-      context 'when on_success is true' do
-        before { notifier.on_success = true }
+      notifier.send(:send_message, 'a message')
+    end
+  end
 
-        it 'sends warning message' do
-          notifier.expects(:log!)
-          interface.expects(:room).with(*attrs).returns(room)
-          interface.expects(:base_uri).with(base_uri)
-          interface.expects(:basic_auth).with(notifier.api_token, 'x')
-          message_body = message % 'Warning'
-          interface.expects(:post).with(room_url, :body => {
-            :message => { :body => message_body, :type => 'Textmessage' }
-          }.to_json)
+end
 
-          notifier.perform!(model)
-        end
-      end
+describe 'Backup::Notifier::Campfire::Interface' do
+  let(:interface) { Backup::Notifier::Campfire::Interface }
 
-      context 'when on_warning is true' do
-        before { notifier.on_warning = true }
+  it 'should include HTTParty' do
+    interface.included_modules.should include(HTTParty)
+  end
 
-        it 'sends warning message' do
-          notifier.expects(:log!)
-          interface.expects(:room).with(*attrs).returns(room)
-          interface.expects(:base_uri).with(base_uri)
-          interface.expects(:basic_auth).with(notifier.api_token, 'x')
-          message_body = message % 'Warning'
-          interface.expects(:post).with(room_url, :body => {
-            :message => { :body => message_body, :type => 'Textmessage' }
-          }.to_json)
+  it 'should set the proper headers' do
+    interface.headers['Content-Type'].should == 'application/json'
+  end
 
-          notifier.perform!(model)
-        end
-      end
+  describe '.room' do
+    let(:room) { mock }
 
-      context 'when on_success and on_warning are false' do
-        it 'sends no message' do
-          notifier.expects(:log!).never
-          notifier.expects(:notify!).never
-          room.expects(:send_message).never
-          interface.expects(:post).never
+    it 'should create and return a new Room' do
+      Backup::Notifier::Campfire::Room.expects(:new).
+          with('room_id', 'subdomain', 'api_token').returns(room)
 
-          notifier.perform!(model)
-        end
-      end
+      interface.room('room_id', 'subdomain', 'api_token').should == room
+    end
+  end
+end
 
-    end # context 'warning'
+describe 'Backup::Notifier::Campfire::Room' do
+  let(:room) do
+    Backup::Notifier::Campfire::Room.new('room_id', 'subdomain', 'api_token')
+  end
 
-    context 'failure' do
+  it 'should set the given values for the room' do
+    room.room_id.should   == 'room_id'
+    room.subdomain.should == 'subdomain'
+    room.api_token.should == 'api_token'
+  end
 
-      context 'when on_failure is true' do
-        before { notifier.on_failure = true }
+  describe '#message' do
+    it 'should wrap #send_message' do
+      room.expects(:send_message).with('a message')
 
-        it 'sends failure message' do
-          notifier.expects(:log!)
-          interface.expects(:room).with(*attrs).returns(room)
-          interface.expects(:base_uri).with(base_uri)
-          interface.expects(:basic_auth).with(notifier.api_token, 'x')
-          message_body = message % 'Failure'
-          interface.expects(:post).with(room_url, :body => {
-            :message => { :body => message_body, :type => 'Textmessage' }
-          }.to_json)
+      room.message('a message')
+    end
+  end
 
-          notifier.perform!(model, Exception.new)
-        end
-      end
+  describe '#send_message' do
+    it 'should pass a JSON formatted HTTParty.post to #post' do
+      room.expects(:post).with('speak',
+        {
+          :body => {
+            :message => {
+              :body => 'a message',
+              :type => 'Textmessage'
+            }
+          }.to_json
+        }
+      )
+      room.send(:send_message, 'a message')
+    end
+  end
 
-      context 'when on_failure is false' do
-        it 'sends no message' do
-          notifier.expects(:log!).never
-          notifier.expects(:notify!).never
-          room.expects(:send_message).never
-          interface.expects(:post).never
+  describe '#post' do
+    let(:interface) { Backup::Notifier::Campfire::Interface }
 
-          notifier.perform!(model, Exception.new)
-        end
-      end
+    it 'should send an HTTParty.post with the given options through Interface' do
+      room.expects(:room_url_for).with('an_action').returns('a_room_url')
+      interface.expects(:base_uri).with('https://subdomain.campfirenow.com')
+      interface.expects(:basic_auth).with('api_token', 'x')
+      interface.expects(:post).with('a_room_url', { :hash => 'of options' })
 
-    end # context 'failure'
+      room.send(:post, 'an_action', :hash => 'of options')
+    end
+  end
 
-  end # describe '#perform!'
+  describe '#room_url_for' do
+    it 'should return a properly formated url for the given action' do
+      room.send(:room_url_for, 'my_action').should ==
+         '/room/room_id/my_action.json'
+    end
+  end
 end

data/spec/notifier/hipchat_spec.rb

@@ -3,191 +3,186 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Notifier::Hipchat do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
   let(:notifier) do
-    Backup::Notifier::Hipchat.new do |notifier|
-      notifier.from = 'application'
+    Backup::Notifier::Hipchat.new(model) do |notifier|
       notifier.token = 'token'
+      notifier.from = 'application'
       notifier.rooms_notified = ['room1', 'room2']
-      notifier.notify_users = true
     end
   end
 
   describe '#initialize' do
 
-    it "sets the correct defaults" do
-      notifier.from.should == 'application'
-      notifier.token.should == 'token'
-      notifier.success_color.should == 'yellow'
-      notifier.warning_color.should == 'yellow'
-      notifier.failure_color.should == 'yellow'
+    it 'should set the correct values and defaults' do
+      notifier.token.should           == 'token'
+      notifier.from.should            == 'application'
+      notifier.rooms_notified.should  == ['room1', 'room2']
+      notifier.notify_users.should    == false
+      notifier.success_color.should   == 'yellow'
+      notifier.warning_color.should   == 'yellow'
+      notifier.failure_color.should   == 'yellow'
+
       notifier.on_success.should == true
       notifier.on_warning.should == true
       notifier.on_failure.should == true
     end
 
-    it 'uses and overrides configuration defaults' do
-      Backup::Configuration::Notifier::Hipchat.defaults do |notifier|
-        notifier.token = 'old'
-        notifier.from = 'before'
-        notifier.success_color = 'green'
-      end
-      hipchat = Backup::Notifier::Hipchat.new do |notifier|
-        notifier.token = 'new'
-        notifier.from = 'after'
-        notifier.failure_color = 'red'
-      end
-
-      hipchat.token.should == 'new'
-      hipchat.from.should == 'after'
-      hipchat.success_color.should == 'green'
-      hipchat.warning_color.should == 'yellow'
-      hipchat.failure_color.should == 'red'
-      hipchat.on_success.should == true
-      hipchat.on_warning.should == true
-      hipchat.on_failure.should == true
-    end
-
-  end # describe '#initialize'
-
-  describe '#perform!' do
-    let(:model) { Backup::Model.new('trigger', 'label') {} }
-    let(:hipchat_mock) { mock }
-    let(:hipchat_client) { HipChat::Client.any_instance }
-    let(:message) { '[Backup::%s] label (trigger)' }
-
-    before do
-      notifier.on_success = false
-      notifier.on_warning = false
-      notifier.on_failure = false
-      notifier.success_color = 'green'
-      notifier.warning_color = 'yellow'
-      notifier.failure_color = 'red'
-    end
-
-    context 'success' do
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Notifier::Hipchat.clear_defaults! }
 
-      context 'when on_success is true' do
-        before { notifier.on_success = true }
+      it 'should use the configuration defaults' do
+        Backup::Configuration::Notifier::Hipchat.defaults do |notifier|
+          notifier.token          = 'old'
+          notifier.from           = 'before'
+          notifier.success_color  = 'green'
 
-        it 'sends success message' do
-          notifier.expects(:log!)
-          hipchat_client.expects(:[]).with('room1').returns(hipchat_mock)
-          hipchat_client.expects(:[]).with('room2').returns(hipchat_mock)
-          hipchat_mock.expects(:send).twice.with {|user, msg, hash|
-            (user.should == notifier.from) &&
-            (msg.should == message % 'Success') &&
-            (hash[:color].should == notifier.success_color) &&
-            (hash[:notify].should == notifier.notify_users)
-          }
-
-          notifier.perform!(model)
+          notifier.on_failure     = false
         end
+        hipchat = Backup::Notifier::Hipchat.new(model)
+
+        hipchat.token.should           == 'old'
+        hipchat.from.should            == 'before'
+        hipchat.rooms_notified.should  == []
+        hipchat.notify_users.should    == false
+        hipchat.success_color.should   == 'green'
+        hipchat.warning_color.should   == 'yellow'
+        hipchat.failure_color.should   == 'yellow'
+
+        hipchat.on_success.should == true
+        hipchat.on_warning.should == true
+        hipchat.on_failure.should == false
       end
 
-      context 'when on_success is false' do
-        it 'sends no message' do
-          notifier.expects(:log!).never
-          notifier.expects(:notify!).never
-          hipchat_client.expects(:[]).never
+      it 'should override the configuration defaults' do
+        Backup::Configuration::Notifier::Hipchat.defaults do |notifier|
+          notifier.token          = 'old'
+          notifier.from           = 'before'
+          notifier.success_color  = 'green'
 
-          notifier.perform!(model)
+          notifier.on_failure     = false
         end
-      end
+        hipchat = Backup::Notifier::Hipchat.new(model) do |notifier|
+          notifier.token          = 'new'
+          notifier.from           = 'after'
+          notifier.failure_color  = 'red'
 
-    end # context 'success'
+          notifier.on_success     = false
+          notifier.on_failure     = true
+        end
 
-    context 'warning' do
-      before { Backup::Logger.stubs(:has_warnings?).returns(true) }
+        hipchat.token.should          == 'new'
+        hipchat.from.should           == 'after'
+        hipchat.success_color.should  == 'green'
+        hipchat.warning_color.should  == 'yellow'
+        hipchat.failure_color.should  == 'red'
+
+        hipchat.on_success.should     == false
+        hipchat.on_warning.should     == true
+        hipchat.on_failure.should     == true
+      end
+    end # context 'when setting configuration defaults'
 
-      context 'when on_success is true' do
-        before { notifier.on_success = true }
+  end # describe '#initialize'
 
-        it 'sends warning message' do
-          notifier.expects(:log!)
-          hipchat_client.expects(:[]).with('room1').returns(hipchat_mock)
-          hipchat_client.expects(:[]).with('room2').returns(hipchat_mock)
-          hipchat_mock.expects(:send).twice.with {|user, msg, hash|
-            (user.should == notifier.from) &&
-            (msg.should == message % 'Warning') &&
-            (hash[:color].should == notifier.warning_color) &&
-            (hash[:notify].should == notifier.notify_users)
-          }
+  describe '#notify!' do
+    before do
+      notifier.success_color = 'green'
+      notifier.warning_color = 'yellow'
+      notifier.failure_color = 'red'
+    end
 
-          notifier.perform!(model)
-        end
+    context 'when status is :success' do
+      it 'should send Success message' do
+        notifier.expects(:send_message).with(
+          '[Backup::Success] test label (test_trigger)', 'green'
+        )
+        notifier.send(:notify!, :success)
       end
+    end
 
-      context 'when on_warning is true' do
-        before { notifier.on_warning = true }
-
-        it 'sends warning message' do
-          notifier.expects(:log!)
-          hipchat_client.expects(:[]).with('room1').returns(hipchat_mock)
-          hipchat_client.expects(:[]).with('room2').returns(hipchat_mock)
-          hipchat_mock.expects(:send).twice.with {|user, msg, hash|
-            (user.should == notifier.from) &&
-            (msg.should == message % 'Warning') &&
-            (hash[:color].should == notifier.warning_color) &&
-            (hash[:notify].should == notifier.notify_users)
-          }
-
-          notifier.perform!(model)
-        end
+    context 'when status is :warning' do
+      it 'should send Warning message' do
+        notifier.expects(:send_message).with(
+          '[Backup::Warning] test label (test_trigger)', 'yellow'
+        )
+        notifier.send(:notify!, :warning)
       end
+    end
 
-      context 'when on_success and on_warning are false' do
-        it 'sends no message' do
-          notifier.expects(:log!).never
-          notifier.expects(:notify!).never
-          hipchat_client.expects(:[]).never
-
-          notifier.perform!(model)
-        end
+    context 'when status is :failure' do
+      it 'should send Failure message' do
+        notifier.expects(:send_message).with(
+          '[Backup::Failure] test label (test_trigger)', 'red'
+        )
+        notifier.send(:notify!, :failure)
       end
+    end
+  end # describe '#notify!'
+
+  describe '#send_message' do
+    let(:client)  { mock }
+    let(:room)    { mock }
+
+    it 'should handle rooms_notified being set as a single room string' do
+      notifier.rooms_notified = 'a_room'
+      HipChat::Client.expects(:new).with('token').returns(client)
+      client.expects(:[]).with('a_room').returns(room)
+      room.expects(:send).with(
+        'application',
+        'a message',
+        {:color => 'a color', :notify => false}
+      )
+
+      notifier.send(:send_message, 'a message', 'a color')
+    end
 
-    end # context 'warning'
+    context 'when notify_users is set to true' do
+      before { notifier.notify_users = true }
 
-    context 'failure' do
+      it 'should notify rooms with :notify => true' do
+        HipChat::Client.expects(:new).with('token').returns(client)
 
-      context 'when on_failure is true' do
-        before { notifier.on_failure = true }
+        client.expects(:[]).with('room1').returns(room)
+        room.expects(:send).with(
+          'application',
+          'a message',
+          {:color => 'a color', :notify => true}
+        )
 
-        it 'sends failure message' do
-          notifier.expects(:log!)
-          hipchat_client.expects(:[]).with('room1').returns(hipchat_mock)
-          hipchat_client.expects(:[]).with('room2').returns(hipchat_mock)
-          hipchat_mock.expects(:send).twice.with {|user, msg, hash|
-            (user.should == notifier.from) &&
-            (msg.should == message % 'Failure') &&
-            (hash[:color].should == notifier.failure_color) &&
-            (hash[:notify].should == notifier.notify_users)
-          }
+        client.expects(:[]).with('room2').returns(room)
+        room.expects(:send).with(
+          'application',
+          'a message',
+          {:color => 'a color', :notify => true}
+        )
 
-          notifier.perform!(model, Exception.new)
-        end
+        notifier.send(:send_message, 'a message', 'a color')
       end
+    end
 
-      context 'when on_failure is false' do
-        it 'sends no message' do
-          notifier.expects(:log!).never
-          notifier.expects(:notify!).never
-          hipchat_client.expects(:[]).never
+    context 'when notify_users is set to false' do
+      before { notifier.notify_users = false }
 
-          notifier.perform!(model, Exception.new)
-        end
-      end
-
-    end # context 'failure'
+      it 'should notify rooms with :notify => false' do
+        HipChat::Client.expects(:new).with('token').returns(client)
 
-    it 'will convert a single room param to an array' do
-      notifier.on_success = true
-      notifier.rooms_notified = 'one_room'
+        client.expects(:[]).with('room1').returns(room)
+        room.expects(:send).with(
+          'application',
+          'a message',
+          {:color => 'a color', :notify => false}
+        )
 
-      hipchat_client.expects(:[]).with('one_room').returns(stub(:send))
+        client.expects(:[]).with('room2').returns(room)
+        room.expects(:send).with(
+          'application',
+          'a message',
+          {:color => 'a color', :notify => false}
+        )
 
-      notifier.perform!(model)
-      notifier.rooms_notified.should == ['one_room']
+        notifier.send(:send_message, 'a message', 'a color')
+      end
     end
-
-  end # describe '#perform!'
+  end
 end