backup-agoddard 3.0.27

data/spec/encryptor/open_ssl_spec.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Encryptor::OpenSSL do
+  let(:encryptor) do
+    Backup::Encryptor::OpenSSL.new do |e|
+      e.password      = 'mypassword'
+      e.password_file = '/my/password/file'
+      e.base64        = true
+      e.salt          = true
+    end
+  end
+
+  it 'should be a subclass of Encryptor::Base' do
+    Backup::Encryptor::OpenSSL.
+      superclass.should == Backup::Encryptor::Base
+  end
+
+  describe '#initialize' do
+    after { Backup::Encryptor::OpenSSL.clear_defaults! }
+
+    it 'should load pre-configured defaults' do
+      Backup::Encryptor::OpenSSL.any_instance.expects(:load_defaults!)
+      encryptor
+    end
+
+    context 'when no pre-configured defaults have been set' do
+      it 'should use the values given' do
+        encryptor.password.should       == 'mypassword'
+        encryptor.password_file.should  == '/my/password/file'
+        encryptor.base64.should         == true
+        encryptor.salt.should           == true
+      end
+
+      it 'should use default values if none are given' do
+        encryptor = Backup::Encryptor::OpenSSL.new
+        encryptor.password.should       be_nil
+        encryptor.password_file.should  be_nil
+        encryptor.base64.should         be_false
+        encryptor.salt.should           be_true
+      end
+    end # context 'when no pre-configured defaults have been set'
+
+    context 'when pre-configured defaults have been set' do
+      before do
+        Backup::Encryptor::OpenSSL.defaults do |e|
+          e.password      = 'default_password'
+          e.password_file = '/default/password/file'
+          e.base64        = 'default_base64'
+          e.salt          = 'default_salt'
+        end
+      end
+
+      it 'should use pre-configured defaults' do
+        encryptor = Backup::Encryptor::OpenSSL.new
+        encryptor.password      = 'default_password'
+        encryptor.password_file = '/default/password/file'
+        encryptor.base64        = 'default_base64'
+        encryptor.salt          = 'default_salt'
+      end
+
+      it 'should override pre-configured defaults' do
+        encryptor.password.should       == 'mypassword'
+        encryptor.password_file.should  == '/my/password/file'
+        encryptor.base64.should         == true
+        encryptor.salt.should           == true
+      end
+    end # context 'when pre-configured defaults have been set'
+  end # describe '#initialize'
+
+  describe '#encrypt_with' do
+    it 'should yield the encryption command and extension' do
+      encryptor.expects(:log!)
+      encryptor.expects(:utility).with(:openssl).returns('openssl_cmd')
+      encryptor.expects(:options).returns('cmd_options')
+
+      encryptor.encrypt_with do |command, ext|
+        command.should == 'openssl_cmd cmd_options'
+        ext.should == '.enc'
+      end
+    end
+  end
+
+  describe '#options' do
+    let(:encryptor) { Backup::Encryptor::OpenSSL.new }
+
+    before do
+      # salt is true by default
+      encryptor.salt = false
+    end
+
+    context 'with no options given' do
+      it 'should always include cipher command' do
+        encryptor.send(:options).should match(/^aes-256-cbc\s.*$/)
+      end
+
+      it 'should add #password option whenever #password_file not given' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -k ''"
+      end
+    end
+
+    context 'when #password_file is given' do
+      before { encryptor.password_file = 'password_file' }
+
+      it 'should add #password_file option' do
+        encryptor.send(:options).should ==
+            'aes-256-cbc -pass file:password_file'
+      end
+
+      it 'should add #password_file option even when #password given' do
+        encryptor.password = 'password'
+        encryptor.send(:options).should ==
+            'aes-256-cbc -pass file:password_file'
+      end
+    end
+
+    context 'when #password is given (without #password_file given)' do
+      before { encryptor.password = 'password' }
+
+      it 'should include the given password in the #password option' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -k 'password'"
+      end
+    end
+
+    context 'when #base64 is true' do
+      before { encryptor.base64 = true }
+
+      it 'should add the option' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -base64 -k ''"
+      end
+    end
+
+    context 'when #salt is true' do
+      before { encryptor.salt = true }
+
+      it 'should add the option' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -salt -k ''"
+      end
+    end
+
+  end # describe '#options'
+
+end

data/spec/errors_spec.rb

@@ -0,0 +1,306 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+# Note: none of these tests require the use of the ErrorsHelper
+describe 'Errors::Error' do
+  let(:klass) { Backup::Errors::Error }
+
+  it 'allow errors to cascade through the system' do
+    class ErrorA < klass; end
+    class ErrorB < klass; end
+    class ErrorC < klass; end
+    class ErrorD < klass; end
+
+    expect do
+      begin
+        begin
+          begin
+            raise ErrorA, 'an error occurred in Zone A'
+          rescue => err
+            raise ErrorB.wrap(err, <<-EOS)
+              an error occurred in Zone B
+
+              the following error should give a reason
+            EOS
+          end
+        rescue => err
+          raise ErrorC.wrap(err)
+        end
+      rescue => err
+        raise ErrorD.wrap(err, 'an error occurred in Zone D')
+      end
+    end.to raise_error(ErrorD,
+      "ErrorD: an error occurred in Zone D\n" +
+      "  Reason: ErrorC\n" +
+      "  ErrorB: an error occurred in Zone B\n" +
+      "  \n" +
+      "  the following error should give a reason\n" +
+      "  Reason: ErrorA\n" +
+      "  an error occurred in Zone A"
+    )
+  end
+
+  describe '#initialize' do
+
+    it 'creates a StandardError' do
+      klass.new.should be_a_kind_of StandardError
+    end
+
+    context 'when given a message' do
+
+      it 'formats a simple message' do
+        err = klass.new('error message')
+        err.message.should == 'Error: error message'
+      end
+
+      it 'formats a multi-line message' do
+        err = klass.new("   error message\n" +
+          "     This is a multi-line error message.\n" +
+          "It should be properly indented.   ")
+
+        err.message.should == "Error: error message\n" +
+            "  This is a multi-line error message.\n" +
+            "  It should be properly indented."
+      end
+
+      context 'when given an original error' do
+
+        it 'includes the original error' do
+          orig_err = StandardError.new('original message')
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: StandardError\n" +
+              "  original message"
+        end
+
+        it 'formats all messages' do
+          orig_err = StandardError.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new("   error message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.   ", orig_err)
+
+          err.message.should == "Error: error message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented.\n" +
+              "  Reason: StandardError\n" +
+              "  original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+        it 'uses the original error backtrace' do
+          begin
+            raise StandardError.new
+          rescue => err
+            klass.new(nil, err).backtrace.
+                should == err.backtrace
+          end
+        end
+
+        it 'reports if original error had no message' do
+          orig_err = StandardError.new
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: StandardError (no message given)"
+        end
+
+      end # context 'when given an original error'
+
+      context 'when given an original Errors::Error' do
+        let(:subklass) do
+          class SubKlass < klass; end
+          SubKlass
+        end
+
+        it 'includes the original error' do
+          orig_err = subklass.new('original message')
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: SubKlass\n" +
+              "  original message"
+        end
+
+        it 'formats all messages' do
+          orig_err = subklass.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new("   error message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.   ", orig_err)
+
+          err.message.should == "Error: error message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented.\n" +
+              "  Reason: SubKlass\n" +
+              "  original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+        it 'uses the original error backtrace' do
+          begin
+            raise subklass.new
+          rescue => err
+            klass.new(nil, err).backtrace.
+                should == err.backtrace
+          end
+        end
+
+        it 'reports if original error had no message' do
+          orig_err = subklass.new
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: SubKlass (no message given)"
+        end
+
+      end # context 'when given an original Errors::Error'
+
+    end # context 'when given a message'
+
+    context 'when given no message' do
+
+      it 'strips the module namespace from the default message' do
+        err = klass.new
+        err.message.should == 'Error'
+      end
+
+      context 'when given an original error' do
+
+        it 'uses the original error message' do
+          orig_err = StandardError.new
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: StandardError'
+
+          orig_err = StandardError.new('original message')
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: StandardError: original message'
+
+          orig_err = StandardError.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new(nil, orig_err)
+          err.message.should == "Error: StandardError: original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+      end # context 'when given an original error'
+
+      context 'when given an original Errors::Error' do
+        let(:subklass) do
+          class SubKlass < klass; end
+          SubKlass
+        end
+
+        it 'uses the original error message' do
+          orig_err = subklass.new
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: SubKlass'
+
+          orig_err = subklass.new('original message')
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: SubKlass: original message'
+
+          orig_err = subklass.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new(nil, orig_err)
+          err.message.should == "Error: SubKlass: original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+      end # context 'when given an original Errors::Error'
+
+    end # context 'when given no message'
+
+  end # describe '#initialize'
+
+  describe '#wrap' do
+    describe 'swaps the parameters to provide a cleaner way to' do
+
+      it 'raise a wrapped error with a message' do
+        orig_err = StandardError.new <<-EOS
+          original message
+          This is a multi-line error message.
+          It should be properly indented.
+        EOS
+
+        expect do
+          raise klass.wrap(orig_err), <<-EOS
+            error message
+            This is a multi-line error message.
+            It should be properly indented.
+          EOS
+        end.to raise_error(klass,
+          "Error: error message\n" +
+          "  This is a multi-line error message.\n" +
+          "  It should be properly indented.\n" +
+          "  Reason: StandardError\n" +
+          "  original message\n" +
+          "  This is a multi-line error message.\n" +
+          "  It should be properly indented."
+        )
+      end
+
+      it 'return a wrapped error with a message' do
+        orig_err = StandardError.new <<-EOS
+          original message
+          This is a multi-line error message.
+          It should be properly indented.
+        EOS
+
+        err = klass.wrap(orig_err, <<-EOS)
+          error message
+          This will wrap the original error
+          and it's message will be given below
+        EOS
+
+        err.message.should ==
+          "Error: error message\n" +
+          "  This will wrap the original error\n" +
+          "  and it's message will be given below\n" +
+          "  Reason: StandardError\n" +
+          "  original message\n" +
+          "  This is a multi-line error message.\n" +
+          "  It should be properly indented."
+      end
+
+    end # describe 'swaps the parameters to provide a cleaner way to'
+  end # describe '#wrap'
+
+end # describe 'Errors::Error'
+
+describe 'ErrorHelper' do
+  let(:base) { Backup::Errors }
+
+  it 'dynamically creates namespaces and subclasses of Errors::Error' do
+    Backup::Errors::FooBarError.new.
+        should be_a_kind_of base::Error
+    Backup::Errors::Foo::Bar::Error.new.
+        should be_a_kind_of base::Error
+  end
+
+  context 'new error classes created within new namespaces' do
+    it 'retain the added portion of namespace in their messages' do
+      orig_err = StandardError.new('original message')
+      err = base::FooMod::FooError.new('error message', orig_err)
+      err.message.should ==
+          "FooMod::FooError: error message\n" +
+          "  Reason: StandardError\n" +
+          "  original message"
+
+      err2 = base::Foo::Bar::Mod::FooBarError.wrap(err, 'foobar message')
+      err2.message.should ==
+          "Foo::Bar::Mod::FooBarError: foobar message\n" +
+          "  Reason: FooMod::FooError\n" +
+          "  error message\n" +
+          "  Reason: StandardError\n" +
+          "  original message"
+    end
+  end
+
+end # describe ErrorHelper