backup_checksum 3.0.23

data/spec/notifier/prowl_spec.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Notifier::Prowl do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:notifier) do
+    Backup::Notifier::Prowl.new(model) do |prowl|
+      prowl.application = 'application'
+      prowl.api_key     = 'api_key'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should sets the correct values' do
+      notifier.application.should == 'application'
+      notifier.api_key.should     == 'api_key'
+
+      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::Prowl.clear_defaults! }
+
+      it 'should use the configuration defaults' do
+        Backup::Configuration::Notifier::Prowl.defaults do |prowl|
+          prowl.application = 'default_app'
+          prowl.api_key     = 'default_api_key'
+
+          prowl.on_success = false
+          prowl.on_warning = false
+          prowl.on_failure = false
+        end
+        notifier = Backup::Notifier::Prowl.new(model)
+        notifier.application.should == 'default_app'
+        notifier.api_key.should     == 'default_api_key'
+
+        notifier.on_success.should == false
+        notifier.on_warning.should == false
+        notifier.on_failure.should == false
+      end
+
+      it 'should override the configuration defaults' do
+        Backup::Configuration::Notifier::Prowl.defaults do |prowl|
+          prowl.application = 'old_app'
+          prowl.api_key     = 'old_api_key'
+
+          prowl.on_success = true
+          prowl.on_warning = false
+          prowl.on_failure = false
+        end
+        notifier = Backup::Notifier::Prowl.new(model) do |prowl|
+          prowl.application = 'new_app'
+          prowl.api_key     = 'new_api_key'
+
+          prowl.on_success = false
+          prowl.on_warning = true
+          prowl.on_failure = true
+        end
+
+        notifier.application.should == 'new_app'
+        notifier.api_key.should     == 'new_api_key'
+
+        notifier.on_success.should == false
+        notifier.on_warning.should == true
+        notifier.on_failure.should == true
+      end
+    end # context 'when using configuration defaults'
+  end
+
+  describe '#notify!' do
+    context 'when status is :success' do
+      it 'should send Success message' do
+        notifier.expects(:send_message).with(
+          '[Backup::Success]'
+        )
+        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]'
+        )
+        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]'
+        )
+        notifier.send(:notify!, :failure)
+      end
+    end
+  end # describe '#notify!'
+
+  describe '#send_message' do
+    it 'should send the given message' do
+      client = mock
+      Prowler.expects(:new).with(
+        :application => 'application', :api_key => 'api_key'
+      ).returns(client)
+      client.expects(:notify).with(
+        'a message',
+        'test label (test_trigger)'
+      )
+
+      notifier.send(:send_message, 'a message')
+    end
+  end
+
+end

data/spec/notifier/twitter_spec.rb

@@ -0,0 +1,132 @@
+# 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
+
+  describe '#initialize' do
+    it 'should sets the correct values' 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
+
+    context 'when using configuration defaults' do
+      after { Backup::Configuration::Notifier::Twitter.clear_defaults! }
+
+      it 'should use the configuration defaults' do
+        Backup::Configuration::Notifier::Twitter.defaults do |twitter|
+          twitter.consumer_key       = 'some_consumer_key'
+          twitter.consumer_secret    = 'some_consumer_secret'
+          twitter.oauth_token        = 'some_oauth_token'
+          twitter.oauth_token_secret = 'some_oauth_token_secret'
+
+          twitter.on_success = false
+          twitter.on_warning = false
+          twitter.on_failure = false
+        end
+        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 the configuration defaults' do
+        Backup::Configuration::Notifier::Twitter.defaults do |twitter|
+          twitter.consumer_key       = 'old_consumer_key'
+          twitter.consumer_secret    = 'old_consumer_secret'
+          twitter.oauth_token        = 'old_oauth_token'
+          twitter.oauth_token_secret = 'old_oauth_token_secret'
+
+          twitter.on_success = true
+          twitter.on_warning = false
+          twitter.on_failure = false
+        end
+        notifier = Backup::Notifier::Twitter.new(model) do |twitter|
+          twitter.consumer_key       = 'new_consumer_key'
+          twitter.consumer_secret    = 'new_consumer_secret'
+          twitter.oauth_token        = 'new_oauth_token'
+          twitter.oauth_token_secret = 'new_oauth_token_secret'
+
+          twitter.on_success = false
+          twitter.on_warning = true
+          twitter.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 using configuration defaults'
+  end
+
+  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,225 @@
+# 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(:checksum_creator)  { 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)
+        model.expects(:checksum_creator).in_sequence(s).returns(checksum_creator)
+        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)
+        packager.instance_variable_get(:@checksum_creator).should be(checksum_creator)
+      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)
+        model.expects(:checksum_creator).in_sequence(s).returns(checksum_creator)
+        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)
+        packager.instance_variable_get(:@checksum_creator).should be(checksum_creator)
+      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
+      class Checksum
+        def checksum_with
+        end
+      end
+    end
+
+    let(:package)   { Fake::Package.new }
+    let(:encryptor) { Fake::Encryptor.new }
+    let(:splitter)  { Fake::Splitter.new }
+    let(:checksum_creator)  { Fake::Checksum.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)
+        packager.instance_variable_set(:@checksum_creator,  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)
+        packager.instance_variable_set(:@checksum_creator,  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