backup 3.0.19 → 3.0.20

data/spec/notifier/campfire_spec.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Notifier::Campfire do
   let(:notifier) do
@@ -11,21 +11,21 @@ describe Backup::Notifier::Campfire do
     end
   end
 
-  it do
-    notifier.api_token.should == 'token'
-    notifier.subdomain.should == 'subdomain'
-    notifier.room_id.should   == 'room_id'
+  describe '#initialize' do
+    it 'sets the correct defaults' do
+      notifier.api_token.should == 'token'
+      notifier.subdomain.should == 'subdomain'
+      notifier.room_id.should   == 'room_id'
 
-    notifier.on_success.should == true
-    notifier.on_failure.should == true
-  end
+      notifier.on_success.should == true
+      notifier.on_warning.should == true
+      notifier.on_failure.should == true
+    end
 
-  describe 'defaults' do
-    it do
+    it 'uses and overrides configuration defaults' do
       Backup::Configuration::Notifier::Campfire.defaults do |campfire|
         campfire.api_token  = 'old_token'
         campfire.on_success = false
-        campfire.on_failure = true
       end
         notifier           = Backup::Notifier::Campfire.new do |campfire|
         campfire.api_token = 'new_token'
@@ -33,64 +33,139 @@ describe Backup::Notifier::Campfire do
 
       notifier.api_token.should  == 'new_token'
       notifier.on_success.should == false
+      notifier.on_warning.should == true
       notifier.on_failure.should == true
     end
   end
 
-  describe '#initialize' do
-    it do
-      Backup::Notifier::Campfire.any_instance.expects(:set_defaults!)
-      Backup::Notifier::Campfire.new
-    end
-  end
-
   describe '#perform!' do
-    let(:model) { Backup::Model.new('blah', 'blah') {} }
+    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
 
-    context "when successful" do
-      it do
-        Backup::Logger.expects(:message).with("Backup::Notifier::Campfire started notifying about the process.")
-        notifier.expects("notify_success!")
-        notifier.on_success = true
-        notifier.perform!(model)
+    context 'success' do
+
+      context 'when on_success is true' do
+        before { notifier.on_success = true }
+
+        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.perform!(model)
+        end
       end
 
-      it do
-        notifier.expects("notify_success!").never
-        notifier.on_success = false
-        notifier.perform!(model)
+      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
+
+          notifier.perform!(model)
+        end
       end
-    end
 
-    context "when failed" do
-      it do
-        Backup::Logger.expects(:message).with("Backup::Notifier::Campfire started notifying about the process.")
-        notifier.expects("notify_failure!")
-        notifier.on_failure = true
-        notifier.perform!(model, Exception.new)
+    end # context 'success'
+
+    context 'warning' do
+      before { Backup::Logger.stubs(:has_warnings?).returns(true) }
+
+      context 'when on_success is true' do
+        before { notifier.on_success = true }
+
+        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)
+
+          notifier.perform!(model)
+        end
       end
 
-      it do
-        notifier.expects("notify_failure!").never
-        notifier.on_failure = false
-        notifier.perform!(model, Exception.new)
+      context 'when on_warning is true' do
+        before { notifier.on_warning = true }
+
+        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)
+
+          notifier.perform!(model)
+        end
       end
-    end
-  end
 
-  describe Backup::Notifier::Campfire::Interface do
-    let(:room) do
-      Backup::Notifier::Campfire::Room.new('room_id', 'subdomain', 'token')
-    end
+      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 do
-      room.api_token.should == 'token'
-      room.subdomain.should == 'subdomain'
-      room.room_id.should   == 'room_id'
-    end
-  end
+          notifier.perform!(model)
+        end
+      end
+
+    end # context 'warning'
+
+    context 'failure' do
+
+      context 'when on_failure is true' do
+        before { notifier.on_failure = true }
+
+        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)
+
+          notifier.perform!(model, Exception.new)
+        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
+
+          notifier.perform!(model, Exception.new)
+        end
+      end
+
+    end # context 'failure'
+
+  end # describe '#perform!'
 end

data/spec/notifier/hipchat_spec.rb

@@ -0,0 +1,193 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Notifier::Hipchat do
+  let(:notifier) do
+    Backup::Notifier::Hipchat.new do |notifier|
+      notifier.from = 'application'
+      notifier.token = 'token'
+      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'
+      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 on_success is true' do
+        before { notifier.on_success = true }
+
+        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)
+        end
+      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
+
+          notifier.perform!(model)
+        end
+      end
+
+    end # context 'success'
+
+    context 'warning' do
+      before { Backup::Logger.stubs(:has_warnings?).returns(true) }
+
+      context 'when on_success is true' do
+        before { notifier.on_success = 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
+      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
+      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
+      end
+
+    end # context 'warning'
+
+    context 'failure' do
+
+      context 'when on_failure is true' do
+        before { notifier.on_failure = 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)
+          }
+
+          notifier.perform!(model, Exception.new)
+        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
+
+          notifier.perform!(model, Exception.new)
+        end
+      end
+
+    end # context 'failure'
+
+    it 'will convert a single room param to an array' do
+      notifier.on_success = true
+      notifier.rooms_notified = 'one_room'
+
+      hipchat_client.expects(:[]).with('one_room').returns(stub(:send))
+
+      notifier.perform!(model)
+      notifier.rooms_notified.should == ['one_room']
+    end
+
+  end # describe '#perform!'
+end

data/spec/notifier/mail_spec.rb

@@ -1,97 +1,313 @@
 # encoding: utf-8
 
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Notifier::Mail do
-  let(:notifier) do
-    Backup::Notifier::Mail.new do |mail|
-      mail.from                 = 'my.sender.email@gmail.com'
-      mail.to                   = 'my.receiver.email@gmail.com'
-      mail.address              = 'smtp.gmail.com'
-      mail.port                 = 587
-      mail.domain               = 'your.host.name'
-      mail.user_name            = 'user'
-      mail.password             = 'secret'
-      mail.authentication       = 'plain'
-      mail.enable_starttls_auto = true
-    end
-  end
-
-  it do
-    notifier.from.should                 == 'my.sender.email@gmail.com'
-    notifier.to.should                   == 'my.receiver.email@gmail.com'
-    notifier.address.should              == 'smtp.gmail.com'
-    notifier.port.should                 == 587
-    notifier.domain.should               == 'your.host.name'
-    notifier.user_name.should            == 'user'
-    notifier.password.should             == 'secret'
-    notifier.authentication.should       == 'plain'
-    notifier.enable_starttls_auto.should == true
-
-    notifier.on_success.should == true
-    notifier.on_failure.should == true
-  end
-
-  describe 'defaults' do
-    it do
-      Backup::Configuration::Notifier::Mail.defaults do |mail|
-        mail.to         = 'some.receiver.email@gmail.com'
-        mail.on_success = false
-        mail.on_failure = true
+
+  describe '#initialize' do
+
+    context 'specifying the delivery_method' do
+
+      it 'creates a new notifier using Mail::SMTP' do
+        notifier = Backup::Notifier::Mail.new do |mail|
+          mail.delivery_method      = :smtp
+          mail.from                 = 'my.sender.email@gmail.com'
+          mail.to                   = 'my.receiver.email@gmail.com'
+          mail.address              = 'smtp.gmail.com'
+          mail.port                 = 587
+          mail.domain               = 'your.host.name'
+          mail.user_name            = 'user'
+          mail.password             = 'secret'
+          mail.authentication       = 'plain'
+          mail.enable_starttls_auto = true
+        end
+
+        notifier.mail.delivery_method.should
+            be_an_instance_of ::Mail::SMTP
+
+        notifier.delivery_method.should      == 'smtp'
+        notifier.from.should                 == 'my.sender.email@gmail.com'
+        notifier.to.should                   == 'my.receiver.email@gmail.com'
+        notifier.address.should              == 'smtp.gmail.com'
+        notifier.port.should                 == 587
+        notifier.domain.should               == 'your.host.name'
+        notifier.user_name.should            == 'user'
+        notifier.password.should             == 'secret'
+        notifier.authentication.should       == 'plain'
+        notifier.enable_starttls_auto.should == true
+        notifier.openssl_verify_mode.should  be_nil
+        notifier.sendmail.should             be_nil
+        notifier.sendmail_args.should        be_nil
+        notifier.mail_folder.should          be_nil
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
       end
-      notifier = Backup::Notifier::Mail.new do |mail|
-        mail.from = 'my.sender.email@gmail.com'
+
+      it 'creates a new notifier using Mail::Sendmail' do
+        notifier = Backup::Notifier::Mail.new do |mail|
+          mail.delivery_method      = :sendmail
+          mail.from                 = 'my.sender.email@gmail.com'
+          mail.to                   = 'my.receiver.email@gmail.com'
+          mail.sendmail             = '/path/to/sendmail'
+          mail.sendmail_args        = '-i -t -X/tmp/traffic.log'
+        end
+
+        notifier.mail.delivery_method.should
+            be_an_instance_of ::Mail::Sendmail
+
+        notifier.delivery_method.should      == 'sendmail'
+        notifier.from.should                 == 'my.sender.email@gmail.com'
+        notifier.to.should                   == 'my.receiver.email@gmail.com'
+        notifier.address.should              be_nil
+        notifier.port.should                 be_nil
+        notifier.domain.should               be_nil
+        notifier.user_name.should            be_nil
+        notifier.password.should             be_nil
+        notifier.authentication.should       be_nil
+        notifier.enable_starttls_auto.should be_nil
+        notifier.openssl_verify_mode.should  be_nil
+        notifier.sendmail.should             == '/path/to/sendmail'
+        notifier.sendmail_args.should        == '-i -t -X/tmp/traffic.log'
+        notifier.mail_folder.should          be_nil
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
       end
 
-      notifier.to.should   == 'some.receiver.email@gmail.com'
-      notifier.from.should == 'my.sender.email@gmail.com'
-      notifier.on_success.should == false
-      notifier.on_failure.should == true
-    end
-  end
+      it 'creates a new notifier using Mail::FileDelivery' do
+        notifier = Backup::Notifier::Mail.new do |mail|
+          mail.delivery_method      = :file
+          mail.from                 = 'my.sender.email@gmail.com'
+          mail.to                   = 'my.receiver.email@gmail.com'
+          mail.mail_folder          = '/path/to/backup/mails'
+        end
 
-  describe '#initialize' do
-    it do
-      Backup::Notifier::Mail.any_instance.expects(:set_defaults!)
-      Backup::Notifier::Mail.new
-    end
-  end
+        notifier.mail.delivery_method.should
+            be_an_instance_of ::Mail::FileDelivery
+
+        notifier.delivery_method.should      == 'file'
+        notifier.from.should                 == 'my.sender.email@gmail.com'
+        notifier.to.should                   == 'my.receiver.email@gmail.com'
+        notifier.address.should              be_nil
+        notifier.port.should                 be_nil
+        notifier.domain.should               be_nil
+        notifier.user_name.should            be_nil
+        notifier.password.should             be_nil
+        notifier.authentication.should       be_nil
+        notifier.enable_starttls_auto.should be_nil
+        notifier.openssl_verify_mode.should  be_nil
+        notifier.sendmail.should             be_nil
+        notifier.sendmail_args.should        be_nil
+        notifier.mail_folder.should          == '/path/to/backup/mails'
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
+      end
+
+    end # context 'specifying the delivery_method'
+
+    context 'without specifying the delivery_method' do
+
+      it 'uses Mail::SMTP by default' do
+        [nil, :foo, 'foo'].each do |val|
+          notifier = Backup::Notifier::Mail.new do |mail|
+            mail.delivery_method = val
+            mail.from            = 'my.sender.email@gmail.com'
+            mail.to              = 'my.receiver.email@gmail.com'
+          end
+
+          notifier.delivery_method.should      == 'smtp'
+          notifier.from.should                 == 'my.sender.email@gmail.com'
+          notifier.to.should                   == 'my.receiver.email@gmail.com'
+        end
+      end
+
+    end # context 'without specifying the delivery_method'
+
+    describe 'setting configuration defaults' do
+      let(:config) { Backup::Configuration::Notifier::Mail }
+      after { config.clear_defaults! }
+
+      it 'uses and overrides configuration defaults' do
+        config.defaults do |mail|
+          mail.delivery_method = :file
+          mail.to         = 'some.receiver.email@gmail.com'
+          mail.from       = 'default.sender.email@gmail.com'
+          mail.on_success = false
+        end
+
+        config.delivery_method.should == :file
+        config.to.should              == 'some.receiver.email@gmail.com'
+        config.from.should            == 'default.sender.email@gmail.com'
+        config.on_success.should      == false
+
+        notifier = Backup::Notifier::Mail.new do |mail|
+          mail.mail_folder = '/my/backup/mails'
+          mail.from = 'my.sender.email@gmail.com'
+          mail.on_warning = false
+        end
+
+        notifier.delivery_method.should == 'file'
+        notifier.mail_folder = '/my/backup/mails'
+        notifier.to.should   == 'some.receiver.email@gmail.com'
+        notifier.from.should == 'my.sender.email@gmail.com'
+
+        notifier.on_success.should == false
+        notifier.on_warning.should == false
+        notifier.on_failure.should == true
+      end
+
+    end # describe 'setting configuration defaults'
+
+  end # describe '#initialize'
 
   describe '#perform!' do
-    let(:model) { Backup::Model.new('blah', 'blah') {} }
+    let(:model) { Backup::Model.new('trigger', 'label') {} }
+    let(:message) { '[Backup::%s] label (trigger)' }
+    let(:notifier) do
+      Backup::Notifier::Mail.new do |mail|
+        mail.delivery_method = :test
+      end
+    end
+
     before do
       notifier.on_success = false
+      notifier.on_warning = false
       notifier.on_failure = false
+      ::Mail::TestMailer.deliveries.clear
     end
 
-    context "when successful" do
-      it do
-        Backup::Logger.expects(:message).with("Backup::Notifier::Mail started notifying about the process.")
-        notifier.expects("notify_success!")
-        notifier.on_success = true
-        notifier.perform!(model)
+    context 'success' do
+
+      context 'when Notifier#on_success is true' do
+        before { notifier.on_success = true }
+
+        it 'sends the notification without an attached backup log' do
+          notifier.expects(:log!)
+          Backup::Template.any_instance.expects(:result).
+              with('notifier/mail/success.erb').
+              returns('message body')
+
+          notifier.perform!(model)
+          sent_message = ::Mail::TestMailer.deliveries.first
+          sent_message.subject.should == message % 'Success'
+          sent_message.multipart?.should be_false
+          sent_message.body.should == 'message body'
+          sent_message.has_attachments?.should be_false
+        end
       end
 
-      it do
-        notifier.expects("notify_success!").never
-        notifier.on_success = false
-        notifier.perform!(model)
+      context 'when Notifier#on_success is false' do
+        it 'does not send the notification' do
+          notifier.expects(:log!).never
+          notifier.expects(:notify!).never
+
+          notifier.perform!(model)
+          ::Mail::TestMailer.deliveries.should be_empty
+        end
       end
-    end
 
-    context "when failed" do
-      it do
-        Backup::Logger.expects(:message).with("Backup::Notifier::Mail started notifying about the process.")
-        notifier.expects("notify_failure!")
-        notifier.on_failure = true
-        notifier.perform!(model, Exception.new)
+    end # context 'success'
+
+    context 'warning' do
+      let(:log_messages){ ['line 1', 'line 2', 'line 3'] }
+
+      before do
+        Backup::Logger.stubs(:has_warnings?).returns(true)
+        Backup::Logger.stubs(:messages).returns(log_messages)
       end
 
-      it do
-        notifier.expects("notify_failure!").never
-        notifier.on_failure = false
-        notifier.perform!(model, Exception.new)
+      context 'when Notifier#on_warning is true' do
+        before { notifier.on_warning = true }
+
+        it 'sends the notification with an attached backup log' do
+          notifier.expects(:log!)
+          Backup::Template.any_instance.expects(:result).
+              with('notifier/mail/warning.erb').
+              returns('message body')
+
+          notifier.perform!(model)
+          sent_message = ::Mail::TestMailer.deliveries.first
+          sent_message.subject.should == message % 'Warning'
+          sent_message.body.multipart?.should be_true
+          sent_message.text_part.decoded.should == 'message body'
+          sent_message.attachments["#{model.time}.#{model.trigger}.log"].
+              read.should == "line 1\nline 2\nline 3"
+        end
       end
-    end
-  end
+
+      context 'when Notifier#on_success is true' do
+        before { notifier.on_success = true }
+
+        it 'sends the notification with an attched backup log' do
+          notifier.expects(:log!)
+          Backup::Template.any_instance.expects(:result).
+              with('notifier/mail/warning.erb').
+              returns('message body')
+
+          notifier.perform!(model)
+          sent_message = ::Mail::TestMailer.deliveries.first
+          sent_message.subject.should == message % 'Warning'
+          sent_message.body.multipart?.should be_true
+          sent_message.text_part.decoded.should == 'message body'
+          sent_message.attachments["#{model.time}.#{model.trigger}.log"].
+              read.should == "line 1\nline 2\nline 3"
+        end
+      end
+
+      context 'when Notifier#on_warning and Notifier#on_success are false' do
+        it 'does not send the notification' do
+          notifier.expects(:log!).never
+          notifier.expects(:notify!).never
+
+          notifier.perform!(model)
+          ::Mail::TestMailer.deliveries.should be_empty
+        end
+      end
+
+    end # context 'warning'
+
+    context 'failure' do
+      let(:log_messages){ ['line 1', 'line 2', 'line 3'] }
+
+      before do
+        Backup::Logger.stubs(:messages).returns(log_messages)
+      end
+
+      context 'when Notifier#on_failure is true' do
+        before { notifier.on_failure = true }
+
+        it 'sends the notification with an attached backup log' do
+          notifier.expects(:log!)
+          Backup::Template.any_instance.expects(:result).
+              with('notifier/mail/failure.erb').
+              returns('message body')
+
+          notifier.perform!(model, Exception.new)
+          sent_message = ::Mail::TestMailer.deliveries.first
+          sent_message.subject.should == message % 'Failure'
+          sent_message.body.multipart?.should be_true
+          sent_message.text_part.decoded.should == 'message body'
+          sent_message.attachments["#{model.time}.#{model.trigger}.log"].
+              read.should == "line 1\nline 2\nline 3"
+        end
+      end
+
+      context 'when Notifier#on_failure is false' do
+        it 'does not send the notification' do
+          notifier.expects(:log!).never
+          notifier.expects(:notify!).never
+
+          notifier.perform!(model, Exception.new)
+          ::Mail::TestMailer.deliveries.should be_empty
+        end
+      end
+
+    end # context 'failure'
+
+  end # describe '#perform!'
 end