backup_checksum 3.0.23

data/spec/database/riak_spec.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Database::Riak do
+  let(:model) { Backup::Model.new('foo', 'foo') }
+  let(:db) do
+    Backup::Database::Riak.new(model) do |db|
+      db.name         = 'mydatabase'
+      db.node         = 'riak@localhost'
+      db.cookie       = 'riak'
+      db.riak_admin_utility = '/path/to/riak-admin'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should read the adapter details correctly' do
+      db.name.should      == 'mydatabase'
+      db.node.should      == 'riak@localhost'
+      db.cookie.should    == 'riak'
+      db.riak_admin_utility.should == '/path/to/riak-admin'
+    end
+
+    context 'when options are not set' do
+      before do
+        Backup::Database::Riak.any_instance.expects(:utility).
+            with('riak-admin').returns('/real/riak-admin')
+      end
+
+      it 'should use default values' do
+        db = Backup::Database::Riak.new(model)
+
+        db.name.should        be_nil
+        db.node.should        be_nil
+        db.cookie.should      be_nil
+        db.riak_admin_utility.should == '/real/riak-admin'
+      end
+    end
+
+    context 'when configuration defaults have been set' do
+      after { Backup::Configuration::Database::Riak.clear_defaults! }
+
+      it 'should use configuration defaults' do
+        Backup::Configuration::Database::Riak.defaults do |db|
+          db.name         = 'db_name'
+          db.node         = 'db_node'
+          db.cookie       = 'db_cookie'
+          db.riak_admin_utility = '/default/path/to/riak-admin'
+        end
+
+        db = Backup::Database::Riak.new(model)
+        db.name.should        == 'db_name'
+        db.node.should        == 'db_node'
+        db.cookie.should      == 'db_cookie'
+        db.riak_admin_utility.should == '/default/path/to/riak-admin'
+      end
+    end
+  end # describe '#initialize'
+
+  describe '#perform!' do
+    let(:compressor) { mock }
+    let(:s) { sequence '' }
+    before do
+      # superclass actions
+      db.expects(:prepare!).in_sequence(s)
+      db.expects(:log!).in_sequence(s)
+      db.instance_variable_set(:@dump_path, '/dump/path')
+
+      db.stubs(:riakadmin).returns('riakadmin_command')
+    end
+
+    context 'when no compressor is configured' do
+      it 'should only perform the riak-admin backup command' do
+        FileUtils.expects(:chown_R).with('riak', 'riak', '/dump/path')
+        db.expects(:run).in_sequence(s).
+            with('riakadmin_command /dump/path/mydatabase node')
+
+        db.perform!
+      end
+    end
+
+    context 'when a compressor is configured' do
+      before do
+        model.stubs(:compressor).returns(compressor)
+        compressor.expects(:compress_with).yields('compressor_command', '.gz')
+      end
+
+      it 'should compress the backup file and remove the source file' do
+        FileUtils.expects(:chown_R).with('riak', 'riak', '/dump/path')
+        db.expects(:run).in_sequence(s).
+            with('riakadmin_command /dump/path/mydatabase node')
+        db.expects(:run).in_sequence(s).with(
+          "compressor_command -c /dump/path/mydatabase > /dump/path/mydatabase.gz"
+        )
+        FileUtils.expects(:rm_f).in_sequence(s).with('/dump/path/mydatabase')
+
+        db.perform!
+      end
+    end
+  end
+
+  describe '#riakadmin' do
+    it 'should return the full riakadmin string' do
+      db.send(:riakadmin).should == "/path/to/riak-admin backup riak@localhost riak"
+    end
+  end
+
+end

data/spec/dependency_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Dependency do
+  before do
+    Backup::Dependency.stubs(:all).returns(
+      'net-sftp' => {
+        :require => 'net/sftp',
+        :version => '~> 2.0.5',
+        :for     => 'SFTP Protocol (SFTP Storage)'
+    })
+  end
+
+  describe ".load" do
+    it "should load and require given dependency" do
+      Backup::Dependency.expects(:gem).with("net-sftp", "~> 2.0.5")
+      Backup::Dependency.expects(:require).with("net/sftp")
+      Backup::Dependency.load("net-sftp")
+    end
+
+    context "on a missing dependency" do
+      before do
+        Backup::Dependency.stubs(:gem).raises(LoadError)
+      end
+
+      it "should display error message" do
+        Backup::Logger.expects(:error).with do |exception|
+          exception.message.should == "Dependency::LoadError: Dependency missing
+  Dependency required for:
+  SFTP Protocol (SFTP Storage)
+  To install the gem, issue the following command:
+  > gem install net-sftp -v '~> 2.0.5'
+  Please try again after installing the missing dependency."
+        end
+
+        expect do
+          Backup::Dependency.load("net-sftp")
+        end.to raise_error(SystemExit)
+      end
+
+      it "should exit with status code 1" do
+        expect do
+          Backup::Dependency.load("net-sftp")
+        end.to raise_error { |exit| exit.status.should be(1) }
+      end
+    end
+  end
+end

data/spec/encryptor/base_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Encryptor::Base do
+  let(:base) { Backup::Encryptor::Base.new }
+
+  describe '#initialize' do
+    it 'should load defaults' do
+      Backup::Encryptor::Base.any_instance.expects(:load_defaults!)
+      base
+    end
+  end
+
+  describe '#encryptor_name' do
+    it 'should return class name with Backup namespace removed' do
+      base.send(:encryptor_name).should == 'Encryptor::Base'
+    end
+  end
+
+  describe '#log!' do
+    it 'should log a message' do
+      base.expects(:encryptor_name).returns('Encryptor Name')
+      Backup::Logger.expects(:message).with(
+        'Using Encryptor Name to encrypt the archive.'
+      )
+      base.send(:log!)
+    end
+  end
+end

data/spec/encryptor/gpg_spec.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Encryptor::GPG do
+  let(:encryptor) do
+    Backup::Encryptor::GPG.new do |e|
+      e.key = 'gpg_key'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should read the adapter details correctly' do
+      encryptor.key.should == 'gpg_key'
+    end
+
+    context 'when options are not set' do
+      it 'should use default values' do
+        encryptor = Backup::Encryptor::GPG.new
+        encryptor.key.should be_nil
+      end
+    end
+
+    context 'when configuration defaults have been set' do
+      after { Backup::Configuration::Encryptor::GPG.clear_defaults! }
+
+      it 'should use configuration defaults' do
+        Backup::Configuration::Encryptor::GPG.defaults do |encryptor|
+          encryptor.key = 'my_key'
+        end
+
+        encryptor = Backup::Encryptor::GPG.new
+        encryptor.key.should == 'my_key'
+      end
+    end
+  end # describe '#initialize'
+
+  describe '#encrypt_with' do
+    it 'should yield the encryption command and extension' do
+      encryptor.expects(:log!)
+      encryptor.expects(:extract_encryption_key_email!)
+      encryptor.expects(:utility).with(:gpg).returns('gpg')
+      encryptor.expects(:options).returns('command options')
+
+      encryptor.encrypt_with do |command, ext|
+        command.should == 'gpg command options'
+        ext.should == '.gpg'
+      end
+    end
+  end
+
+  describe '#extract_encryption_key_email!' do
+    it 'should extract the encryption_key_email' do
+      encryptor.expects(:utility).with(:gpg).returns('gpg')
+      encryptor.expects(:with_tmp_key_file).yields('/path/to/tmpfile')
+      encryptor.expects(:run).with("gpg --import '/path/to/tmpfile' 2>&1").
+        returns('gpg: key A1B2C3D4: "User Name (Comment) <user@host>" not changed')
+
+      encryptor.send(:extract_encryption_key_email!)
+      encryptor.instance_variable_get(:@encryption_key_email).should == 'user@host'
+    end
+
+    it 'should use the cached key email if already extracted' do
+      encryptor.instance_variable_set(:@encryption_key_email, 'foo@host')
+      encryptor.expects(:utility).never
+      encryptor.expects(:with_tmp_key_file).never
+      encryptor.expects(:run).never
+
+      encryptor.send(:extract_encryption_key_email!)
+    end
+  end
+
+  describe '#options' do
+    it 'should return the option string for the gpg command' do
+      encryptor.instance_variable_set(:@encryption_key_email, 'user@host')
+      encryptor.send(:options).should == "-e --trust-model always -r 'user@host'"
+    end
+  end
+
+  describe '#with_tmp_key_file' do
+    let(:tmp_file) { mock }
+    let(:s) { sequence '' }
+
+    before do
+      tmp_file.stubs(:path).returns('/path/to/tmp_file')
+      encryptor.stubs(:encryption_key).returns('provided key')
+    end
+
+    it 'should provide a tempfile with the provided key' do
+      Tempfile.expects(:new).in_sequence(s).
+          with('backup.pub').
+          returns(tmp_file)
+      FileUtils.expects(:chown).in_sequence(s).
+          with(Backup::Config.user, nil, '/path/to/tmp_file')
+      FileUtils.expects(:chmod).in_sequence(s).
+          with(0600, '/path/to/tmp_file')
+      tmp_file.expects(:write).in_sequence(s).
+          with('provided key')
+      tmp_file.expects(:close).in_sequence(s)
+      tmp_file.expects(:delete).in_sequence(s)
+
+      encryptor.send(:with_tmp_key_file) do |tmp_file|
+        tmp_file.should == '/path/to/tmp_file'
+      end
+    end
+  end
+
+  describe '#encryption_key' do
+    it 'should strip leading whitespace from the given key' do
+      encryptor.key = <<-KEY
+        -----BEGIN PGP PUBLIC KEY BLOCK-----
+        \tVersion: GnuPG v1.4.11 (Darwin)
+
+        mQENBE12G/8BCAC4mnlSMYMBwBYTHe5zURcnYYNCORPWOr0iXGiLWuKxYtrDQyLm
+        X2Nws44Iz7Wp7AuJRAjkitf1cRBgXyDu8wuogXO7JqPmtsUdBCABz9w5NH6IQjgR
+        WNa3g2n0nokA7Zr5FA4GXoEaYivfbvGiyNpd6P4okH+//G2p+3FIryu5xz+89D1b
+        =Yvhg
+        -----END PGP PUBLIC KEY BLOCK-----
+      KEY
+
+      encryptor.send(:encryption_key).should == <<-KEY
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.4.11 (Darwin)
+
+mQENBE12G/8BCAC4mnlSMYMBwBYTHe5zURcnYYNCORPWOr0iXGiLWuKxYtrDQyLm
+X2Nws44Iz7Wp7AuJRAjkitf1cRBgXyDu8wuogXO7JqPmtsUdBCABz9w5NH6IQjgR
+WNa3g2n0nokA7Zr5FA4GXoEaYivfbvGiyNpd6P4okH+//G2p+3FIryu5xz+89D1b
+=Yvhg
+-----END PGP PUBLIC KEY BLOCK-----
+      KEY
+    end
+  end
+
+end

data/spec/encryptor/open_ssl_spec.rb

@@ -0,0 +1,129 @@
+# 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
+
+  describe '#initialize' do
+    it 'should read the adapter details correctly' do
+      encryptor.password.should       == 'mypassword'
+      encryptor.password_file.should  == '/my/password/file'
+      encryptor.base64.should         == true
+      encryptor.salt.should           == true
+    end
+
+    context 'when options are not set' do
+      it 'should use default values' 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 configuration defaults have been set' do
+      after { Backup::Configuration::Encryptor::OpenSSL.clear_defaults! }
+
+      it 'should use configuration defaults' do
+        Backup::Configuration::Encryptor::OpenSSL.defaults do |encryptor|
+          encryptor.password      = 'my_password'
+          encryptor.password_file = '/my_password/file'
+          encryptor.base64        = true
+          encryptor.salt          = true
+        end
+
+        encryptor = Backup::Encryptor::OpenSSL.new
+        encryptor.password.should       == 'my_password'
+        encryptor.password_file.should  == '/my_password/file'
+        encryptor.base64.should         == true
+        encryptor.salt.should           == true
+      end
+    end
+  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