backup-agoddard 3.0.27

data/spec/notifier/pushover_spec.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Notifier::Pushover do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:notifier) do
+    Backup::Notifier::Pushover.new(model) do |notifier|
+      notifier.user = 'user_token'
+      notifier.token = 'app_token'
+      notifier.title = 'title'
+    end
+  end
+
+  it 'should be a subclass of Notifier::Base' do
+    Backup::Notifier::Pushover.
+      superclass.should == Backup::Notifier::Base
+  end
+
+  describe '#initialize' do
+    after { Backup::Notifier::Pushover.clear_defaults! }
+
+    it 'should load pre-configured defaults through Base' do
+      Backup::Notifier::Pushover.any_instance.expects(:load_defaults!)
+      notifier
+    end
+
+    it 'should pass the model reference to Base' do
+      notifier.instance_variable_get(:@model).should == model
+    end
+
+    context 'when no pre-configured defaults have been set' do
+      it 'should use the values given' do
+        notifier.user.should       == 'user_token'
+        notifier.token.should      == 'app_token'
+        notifier.device.should     be_nil
+        notifier.priority.should   be_nil
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
+      end
+
+      it 'should use default values if none are given' do
+        notifier = Backup::Notifier::Pushover.new(model)
+        notifier.token.should      be_nil
+        notifier.user.should       be_nil
+        notifier.device.should     be_nil
+        notifier.priority.should   be_nil
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
+      end
+    end # context 'when no pre-configured defaults have been set'
+
+    context 'when pre-configured defaults have been set' do
+      before do
+        Backup::Notifier::Pushover.defaults do |n|
+          n.token          = 'the_token'
+          n.user           = 'the_user'
+          n.on_failure     = false
+        end
+      end
+
+      it 'should use pre-configured defaults' do
+        notifier = Backup::Notifier::Pushover.new(model)
+
+        notifier.token.should      == 'the_token'
+        notifier.user.should       == 'the_user'
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == false
+      end
+
+      it 'should override pre-configured defaults' do
+        notifier = Backup::Notifier::Pushover.new(model) do |n|
+          n.token          = 'new_token'
+          n.user           = 'new_user'
+          n.on_success     = false
+          n.on_failure     = true
+        end
+
+        notifier.token.should          == 'new_token'
+        notifier.user.should           == 'new_user'
+
+        notifier.on_success.should     == false
+        notifier.on_warning.should     == true
+        notifier.on_failure.should     == true
+      end
+    end # context 'when pre-configured defaults have been set'
+  end # describe '#initialize'
+
+  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
+
+    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
+
+    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!'
+end

data/spec/notifier/twitter_spec.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Notifier::Twitter do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:notifier) do
+    Backup::Notifier::Twitter.new(model) do |twitter|
+      twitter.consumer_key       = 'consumer_key'
+      twitter.consumer_secret    = 'consumer_secret'
+      twitter.oauth_token        = 'oauth_token'
+      twitter.oauth_token_secret = 'oauth_token_secret'
+    end
+  end
+
+  it 'should be a subclass of Notifier::Base' do
+    Backup::Notifier::Twitter.
+      superclass.should == Backup::Notifier::Base
+  end
+
+  describe '#initialize' do
+    after { Backup::Notifier::Twitter.clear_defaults! }
+
+    it 'should load pre-configured defaults through Base' do
+      Backup::Notifier::Twitter.any_instance.expects(:load_defaults!)
+      notifier
+    end
+
+    it 'should pass the model reference to Base' do
+      notifier.instance_variable_get(:@model).should == model
+    end
+
+    context 'when no pre-configured defaults have been set' do
+      it 'should use the values given' do
+        notifier.consumer_key.should       == 'consumer_key'
+        notifier.consumer_secret.should    == 'consumer_secret'
+        notifier.oauth_token.should        == 'oauth_token'
+        notifier.oauth_token_secret.should == 'oauth_token_secret'
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
+      end
+
+      it 'should use default values if none are given' do
+        notifier = Backup::Notifier::Twitter.new(model)
+        notifier.consumer_key.should       be_nil
+        notifier.consumer_secret.should    be_nil
+        notifier.oauth_token.should        be_nil
+        notifier.oauth_token_secret.should be_nil
+
+        notifier.on_success.should == true
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
+      end
+    end # context 'when no pre-configured defaults have been set'
+
+    context 'when pre-configured defaults have been set' do
+      before do
+        Backup::Notifier::Twitter.defaults do |n|
+          n.consumer_key       = 'some_consumer_key'
+          n.consumer_secret    = 'some_consumer_secret'
+          n.oauth_token        = 'some_oauth_token'
+          n.oauth_token_secret = 'some_oauth_token_secret'
+
+          n.on_success = false
+          n.on_warning = false
+          n.on_failure = false
+        end
+      end
+
+      it 'should use pre-configured defaults' do
+        notifier = Backup::Notifier::Twitter.new(model)
+        notifier.consumer_key.should       == 'some_consumer_key'
+        notifier.consumer_secret.should    == 'some_consumer_secret'
+        notifier.oauth_token.should        == 'some_oauth_token'
+        notifier.oauth_token_secret.should == 'some_oauth_token_secret'
+
+        notifier.on_success.should == false
+        notifier.on_warning.should == false
+        notifier.on_failure.should == false
+      end
+
+      it 'should override pre-configured defaults' do
+        notifier = Backup::Notifier::Twitter.new(model) do |n|
+          n.consumer_key       = 'new_consumer_key'
+          n.consumer_secret    = 'new_consumer_secret'
+          n.oauth_token        = 'new_oauth_token'
+          n.oauth_token_secret = 'new_oauth_token_secret'
+
+          n.on_success = false
+          n.on_warning = true
+          n.on_failure = true
+        end
+
+        notifier.consumer_key.should       == 'new_consumer_key'
+        notifier.consumer_secret.should    == 'new_consumer_secret'
+        notifier.oauth_token.should        == 'new_oauth_token'
+        notifier.oauth_token_secret.should == 'new_oauth_token_secret'
+
+        notifier.on_success.should == false
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
+      end
+    end # context 'when pre-configured defaults have been set'
+  end # describe '#initialize'
+
+  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.instance_variable_get("@model").time})"
+        )
+        notifier.send(:notify!, :success)
+      end
+    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.instance_variable_get("@model").time})"
+        )
+        notifier.send(:notify!, :warning)
+      end
+    end
+
+    context 'when status is :failure' do
+      it 'should send Failure message' do
+        notifier.expects(:send_message).with(
+          "[Backup::Failure] test label (test_trigger) (@ #{notifier.instance_variable_get("@model").time})"
+        )
+        notifier.send(:notify!, :failure)
+      end
+    end
+  end # describe '#notify!'
+
+  describe '#send_message' do
+    it 'should send a message' do
+      client, config = mock, mock
+
+      ::Twitter.expects(:configure).yields(config)
+      config.expects(:consumer_key=).with('consumer_key')
+      config.expects(:consumer_secret=).with('consumer_secret')
+      config.expects(:oauth_token=).with('oauth_token')
+      config.expects(:oauth_token_secret=).with('oauth_token_secret')
+
+      ::Twitter::Client.expects(:new).returns(client)
+      client.expects(:update).with('a message')
+
+      notifier.send(:send_message, 'a message')
+    end
+  end
+end

data/spec/package_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Package do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:package) { Backup::Package.new(model) }
+
+  before do
+    model.instance_variable_set(:@time, 'model_time')
+  end
+
+  describe '#initialize' do
+    it 'should set all variables' do
+      package.time.should           == 'model_time'
+      package.trigger.should        == 'test_trigger'
+      package.extension.should      == 'tar'
+      package.chunk_suffixes.should == []
+      package.version.should        == Backup::Version.current
+    end
+  end
+
+  describe '#filenames' do
+    context 'when the package files were not split' do
+      it 'should return an array with the single package filename' do
+        package.filenames.should == ['model_time.test_trigger.tar']
+      end
+
+      it 'should reflect changes in the extension' do
+        package.extension << '.enc'
+        package.filenames.should == ['model_time.test_trigger.tar.enc']
+      end
+    end
+
+    context 'when the package files were split' do
+      before { package.chunk_suffixes = ['aa', 'ab'] }
+      it 'should return an array of the package filenames' do
+        package.filenames.should == ['model_time.test_trigger.tar-aa',
+                                     'model_time.test_trigger.tar-ab']
+      end
+
+      it 'should reflect changes in the extension' do
+        package.extension << '.enc'
+        package.filenames.should == ['model_time.test_trigger.tar.enc-aa',
+                                     'model_time.test_trigger.tar.enc-ab']
+      end
+    end
+  end
+
+  describe '#basename' do
+    it 'should return the base filename for the package' do
+      package.basename.should == 'model_time.test_trigger.tar'
+    end
+
+    it 'should reflect changes in the extension' do
+      package.extension << '.enc'
+      package.basename.should == 'model_time.test_trigger.tar.enc'
+    end
+  end
+
+end

data/spec/packager_spec.rb

@@ -0,0 +1,213 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe 'Backup::Packager' do
+  let(:packager)  { Backup::Packager }
+
+  describe '#package!' do
+    let(:model)     { mock }
+    let(:package)   { mock }
+    let(:encryptor) { mock }
+    let(:splitter)  { mock }
+    let(:pipeline)  { mock }
+    let(:procedure) { mock }
+    let(:s)         { sequence '' }
+
+    context 'when pipeline command is successful' do
+      it 'should setup variables and perform packaging procedures' do
+        model.expects(:package).in_sequence(s).returns(package)
+        model.expects(:encryptor).in_sequence(s).returns(encryptor)
+        model.expects(:splitter).in_sequence(s).returns(splitter)
+        Backup::Pipeline.expects(:new).in_sequence(s).returns(pipeline)
+
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          'Packaging the backup files...'
+        )
+        packager.expects(:procedure).in_sequence(s).returns(procedure)
+        procedure.expects(:call).in_sequence(s)
+
+        pipeline.expects(:success?).in_sequence(s).returns(true)
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          'Packaging Complete!'
+        )
+
+        packager.package!(model)
+
+        packager.instance_variable_get(:@package).should be(package)
+        packager.instance_variable_get(:@encryptor).should be(encryptor)
+        packager.instance_variable_get(:@splitter).should be(splitter)
+        packager.instance_variable_get(:@pipeline).should be(pipeline)
+      end
+    end #context 'when pipeline command is successful'
+
+    context 'when pipeline command is not successful' do
+      it 'should raise an error' do
+        model.expects(:package).in_sequence(s).returns(package)
+        model.expects(:encryptor).in_sequence(s).returns(encryptor)
+        model.expects(:splitter).in_sequence(s).returns(splitter)
+        Backup::Pipeline.expects(:new).in_sequence(s).returns(pipeline)
+
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          'Packaging the backup files...'
+        )
+        packager.expects(:procedure).in_sequence(s).returns(procedure)
+        procedure.expects(:call).in_sequence(s)
+
+        pipeline.expects(:success?).in_sequence(s).returns(false)
+        pipeline.expects(:error_messages).in_sequence(s).returns('pipeline_errors')
+
+        expect do
+          packager.package!(model)
+        end.to raise_error(
+          Backup::Errors::Packager::PipelineError,
+          "Packager::PipelineError: Failed to Create Backup Package\n" +
+          "  pipeline_errors"
+        )
+
+        packager.instance_variable_get(:@package).should be(package)
+        packager.instance_variable_get(:@encryptor).should be(encryptor)
+        packager.instance_variable_get(:@splitter).should be(splitter)
+        packager.instance_variable_get(:@pipeline).should be(pipeline)
+      end
+    end #context 'when pipeline command is successful'
+  end # describe '#package!'
+
+  describe '#procedure' do
+
+    module Fake
+      def self.stack_trace
+        @stack ||= []
+      end
+      class Encryptor
+        def encrypt_with
+          Fake.stack_trace << :encryptor_before
+          yield 'encryption_command', '.enc'
+          Fake.stack_trace << :encryptor_after
+        end
+      end
+      class Splitter
+        def split_with
+          Fake.stack_trace << :splitter_before
+          yield 'splitter_command'
+          Fake.stack_trace << :splitter_after
+        end
+      end
+      class Package
+        attr_accessor :trigger, :extension
+        def basename
+          'base_filename.' + extension
+        end
+      end
+    end
+
+    let(:package)   { Fake::Package.new }
+    let(:encryptor) { Fake::Encryptor.new }
+    let(:splitter)  { Fake::Splitter.new }
+    let(:pipeline)  { mock }
+    let(:s)         { sequence '' }
+
+    before do
+      Fake.stack_trace.clear
+      packager.expects(:utility).with(:tar).returns('tar')
+      packager.instance_variable_set(:@package, package)
+      packager.instance_variable_set(:@pipeline, pipeline)
+      package.trigger = 'model_trigger'
+      package.extension = 'tar'
+    end
+
+    context 'when no encryptor or splitter are defined' do
+      it 'should package the backup without encryption into a single file' do
+        packager.instance_variable_set(:@encryptor, nil)
+        packager.instance_variable_set(:@splitter,  nil)
+
+        pipeline.expects(:<<).in_sequence(s).with(
+          "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'"
+        )
+        pipeline.expects(:<<).in_sequence(s).with(
+          "cat > #{ File.join(Backup::Config.tmp_path, 'base_filename.tar') }"
+        )
+        pipeline.expects(:run).in_sequence(s)
+
+        packager.send(:procedure).call
+      end
+    end
+
+    context 'when only an encryptor is configured' do
+      it 'should package the backup with encryption' do
+        packager.instance_variable_set(:@encryptor, encryptor)
+        packager.instance_variable_set(:@splitter,  nil)
+
+        pipeline.expects(:<<).in_sequence(s).with(
+          "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'"
+        )
+        pipeline.expects(:<<).in_sequence(s).with('encryption_command')
+        pipeline.expects(:<<).in_sequence(s).with(
+          "cat > #{ File.join(Backup::Config.tmp_path, 'base_filename.tar.enc') }"
+        )
+        pipeline.expects(:run).in_sequence(s).with do
+          Fake.stack_trace << :command_executed
+          true
+        end
+
+        packager.send(:procedure).call
+
+        Fake.stack_trace.should == [
+          :encryptor_before, :command_executed, :encryptor_after
+        ]
+      end
+    end
+
+    context 'when only a splitter is configured' do
+      it 'should package the backup without encryption through the splitter' do
+        packager.instance_variable_set(:@encryptor, nil)
+        packager.instance_variable_set(:@splitter,  splitter)
+
+        pipeline.expects(:<<).in_sequence(s).with(
+          "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'"
+        )
+        pipeline.expects(:<<).in_sequence(s).with('splitter_command')
+
+        pipeline.expects(:run).in_sequence(s).with do
+          Fake.stack_trace << :command_executed
+          true
+        end
+
+        packager.send(:procedure).call
+
+        Fake.stack_trace.should == [
+          :splitter_before, :command_executed, :splitter_after
+        ]
+      end
+    end
+
+    context 'when both an encryptor and a splitter are configured' do
+      it 'should package the backup with encryption through the splitter' do
+        packager.instance_variable_set(:@encryptor, encryptor)
+        packager.instance_variable_set(:@splitter,  splitter)
+
+        pipeline.expects(:<<).in_sequence(s).with(
+          "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'"
+        )
+        pipeline.expects(:<<).in_sequence(s).with('encryption_command')
+        pipeline.expects(:<<).in_sequence(s).with('splitter_command')
+
+        pipeline.expects(:run).in_sequence(s).with do
+          Fake.stack_trace << :command_executed
+          true
+        end
+
+        packager.send(:procedure).call
+
+        Fake.stack_trace.should == [
+          :encryptor_before, :splitter_before,
+          :command_executed,
+          :splitter_after, :encryptor_after
+        ]
+        package.extension.should == 'tar.enc'
+      end
+    end
+
+  end # describe '#procedure'
+
+end