backup 3.0.27 → 3.1.0

data/spec/encryptor/open_ssl_spec.rb

@@ -1,148 +0,0 @@
-# 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

@@ -1,306 +0,0 @@
-# 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