backup 3.0.19 → 3.0.20

data/spec/database/riak_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Database::Riak do
+
+  before do
+    Backup::Database::Riak.any_instance.stubs(:load_defaults!)
+  end
+
+  let(:db) do
+    Backup::Database::Riak.new do |db|
+      db.name      = 'mydatabase'
+      db.node      = 'riak@localhost'
+      db.cookie    = 'riak'
+    end
+  end
+
+  describe '#new' do
+    it 'should read the adapter details correctly' do
+      db.name.should      == 'mydatabase'
+      db.node.should      == 'riak@localhost'
+      db.cookie.should    == 'riak'
+    end
+  end
+
+  describe '#riakadmin_string' do
+    it 'should return the full riakadmin string' do
+      db.riakadmin.should == "riak-admin backup riak@localhost riak"
+    end
+  end
+
+  describe '#perform!' do
+    before do
+      db.stubs(:mkdir)
+      db.stubs(:run)
+    end
+
+    it 'should ensure the directory is available' do
+      db.expects(:mkdir).with(File.join(Backup::TMP_PATH, "myapp", "Riak"))
+      db.perform!
+    end
+
+    it do
+      Backup::Logger.expects(:message).
+          with("Backup::Database::Riak started dumping and archiving 'mydatabase'.")
+      db.perform!
+    end
+  end
+end

data/spec/encryptor/gpg_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::Encryptor::GPG do
 

data/spec/encryptor/open_ssl_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::Encryptor::OpenSSL do
 
@@ -20,34 +20,80 @@ describe Backup::Encryptor::OpenSSL do
     end
 
     it do
-      encryptor.send(:options).should == "aes-256-cbc"
+      encryptor.send(:pass).should == ["-k ''"]
+    end
+
+    it do
+      encryptor.send(:options).should == "aes-256-cbc -k ''"
     end
   end
 
   context "when a block is provided" do
-    let(:encryptor) do
-      Backup::Encryptor::OpenSSL.new do |e|
-        e.password = "my_secret_password"
-        e.salt     = true
-        e.base64   = true
+
+    context "with a password" do
+      let(:encryptor) do
+        Backup::Encryptor::OpenSSL.new do |e|
+          e.password = "my_secret_password"
+          e.salt     = true
+          e.base64   = true
+        end
       end
-    end
 
-    it do
-      encryptor.password.should == "my_secret_password"
-    end
+      it do
+        encryptor.password.should == "my_secret_password"
+      end
 
-    it do
-      encryptor.send(:salt).should == ['-salt']
-    end
+      it do
+        encryptor.send(:salt).should == ['-salt']
+      end
 
-    it do
-      encryptor.send(:base64).should == ['-base64']
+      it do
+        encryptor.send(:base64).should == ['-base64']
+      end
+
+      it do
+        encryptor.send(:pass).should == ["-k 'my_secret_password'"]
+      end
+
+      it do
+        encryptor.send(:options).should == "aes-256-cbc -base64 -salt -k 'my_secret_password'"
+      end
     end
 
-    it do
-      encryptor.send(:options).should == "aes-256-cbc -base64 -salt"
+    context "with a password file" do
+      let(:encryptor) do
+        Backup::Encryptor::OpenSSL.new do |e|
+          e.password_file = "/path/to/password/file"
+          e.salt     = true
+          e.base64   = true
+        end
+      end
+
+      it do
+        encryptor.password.should == nil
+      end
+
+      it do
+        encryptor.password_file.should == "/path/to/password/file"
+      end
+
+      it do
+        encryptor.send(:salt).should == ['-salt']
+      end
+
+      it do
+        encryptor.send(:base64).should == ['-base64']
+      end
+
+      it do
+        encryptor.send(:pass).should == ['-pass file:/path/to/password/file']
+      end
+
+      it do
+        encryptor.send(:options).should == "aes-256-cbc -base64 -salt -pass file:/path/to/password/file"
+      end
     end
+
   end
 
   describe '#perform!' do
@@ -60,7 +106,7 @@ describe Backup::Encryptor::OpenSSL do
     it do
       encryptor = Backup::Encryptor::OpenSSL.new
       encryptor.expects(:utility).returns(:openssl)
-      encryptor.expects(:run).with("openssl aes-256-cbc -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }' -k ''")
+      encryptor.expects(:run).with("openssl aes-256-cbc -k '' -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }'")
       encryptor.perform!
     end
 
@@ -71,7 +117,18 @@ describe Backup::Encryptor::OpenSSL do
         e.base64   = true
       end
       encryptor.stubs(:utility).returns(:openssl)
-      encryptor.expects(:run).with("openssl aes-256-cbc -base64 -salt -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }' -k 'my_secret_password'")
+      encryptor.expects(:run).with("openssl aes-256-cbc -base64 -salt -k 'my_secret_password' -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }'")
+      encryptor.perform!
+    end
+
+    it do
+      encryptor = Backup::Encryptor::OpenSSL.new do |e|
+        e.password_file = "/path/to/password/file"
+        e.salt     = true
+        e.base64   = true
+      end
+      encryptor.stubs(:utility).returns(:openssl)
+      encryptor.expects(:run).with("openssl aes-256-cbc -base64 -salt -pass file:/path/to/password/file -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }'")
       encryptor.perform!
     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