backup 3.0.27 → 3.1.0

data/spec/database/redis_spec.rb

@@ -1,334 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../../spec_helper.rb', __FILE__)
-
-describe Backup::Database::Redis do
-  let(:model) { Backup::Model.new('foo', 'foo') }
-  let(:db) do
-    Backup::Database::Redis.new(model) do |db|
-      db.name         = 'mydatabase'
-      db.path         = '/var/lib/redis/db/'
-      db.password     = 'secret'
-      db.host         = 'localhost'
-      db.port         = '123'
-      db.socket       = '/redis.sock'
-      db.invoke_save  = true
-
-      db.additional_options = ['--query', '--foo']
-      db.redis_cli_utility  = '/path/to/redis-cli'
-    end
-  end
-
-  it 'should be a subclass of Database::Base' do
-    Backup::Database::Redis.superclass.
-      should == Backup::Database::Base
-  end
-
-  describe '#initialize' do
-
-    it 'should load pre-configured defaults through Base' do
-      Backup::Database::Redis.any_instance.expects(:load_defaults!)
-      db
-    end
-
-    it 'should pass the model reference to Base' do
-      db.instance_variable_get(:@model).should == model
-    end
-
-    context 'when no pre-configured defaults have been set' do
-      context 'when options are specified' do
-        it 'should use the given values' do
-          db.name.should        == 'mydatabase'
-          db.path.should        == '/var/lib/redis/db/'
-          db.password.should    == 'secret'
-          db.host.should        == 'localhost'
-          db.port.should        == '123'
-          db.socket.should      == '/redis.sock'
-          db.invoke_save.should == true
-
-          db.additional_options.should == ['--query', '--foo']
-          db.redis_cli_utility.should  == '/path/to/redis-cli'
-        end
-      end
-
-      context 'when options are not specified' do
-        before do
-          Backup::Database::Redis.any_instance.expects(:utility).
-              with('redis-cli').returns('/real/redis-cli')
-        end
-
-        it 'should provide default values' do
-          db = Backup::Database::Redis.new(model)
-
-          db.name.should        == 'dump'
-          db.path.should        be_nil
-          db.password.should    be_nil
-          db.host.should        be_nil
-          db.port.should        be_nil
-          db.socket.should      be_nil
-          db.invoke_save.should be_nil
-
-          db.additional_options.should  == []
-          db.redis_cli_utility.should   == '/real/redis-cli'
-        end
-      end
-    end # context 'when no pre-configured defaults have been set'
-
-    context 'when pre-configured defaults have been set' do
-      before do
-        Backup::Database::Redis.defaults do |db|
-          db.name         = 'db_name'
-          db.path         = 'db_path'
-          db.password     = 'db_password'
-          db.host         = 'db_host'
-          db.port         = 789
-          db.socket       = '/foo.sock'
-          db.invoke_save  = true
-
-          db.additional_options = ['--add', '--opts']
-          db.redis_cli_utility  = '/default/path/to/redis-cli'
-        end
-      end
-
-      after { Backup::Database::Redis.clear_defaults! }
-
-      context 'when options are specified' do
-        it 'should override the pre-configured defaults' do
-          db.name.should        == 'mydatabase'
-          db.path.should        == '/var/lib/redis/db/'
-          db.password.should    == 'secret'
-          db.host.should        == 'localhost'
-          db.port.should        == '123'
-          db.socket.should      == '/redis.sock'
-          db.invoke_save.should == true
-
-          db.additional_options.should == ['--query', '--foo']
-          db.redis_cli_utility.should  == '/path/to/redis-cli'
-        end
-      end
-
-      context 'when options are not specified' do
-        it 'should use the pre-configured defaults' do
-          db = Backup::Database::Redis.new(model)
-
-          db.name.should        == 'db_name'
-          db.path.should        == 'db_path'
-          db.password.should    == 'db_password'
-          db.host.should        == 'db_host'
-          db.port.should        == 789
-          db.socket.should      == '/foo.sock'
-          db.invoke_save.should == true
-
-          db.additional_options.should  == ['--add', '--opts']
-          db.redis_cli_utility.should   == '/default/path/to/redis-cli'
-        end
-      end
-    end # context 'when no pre-configured defaults have been set'
-  end # describe '#initialize'
-
-  describe '#perform!' do
-    let(:s) { sequence '' }
-    before do
-      # superclass actions
-      db.expects(:prepare!).in_sequence(s)
-      db.expects(:log!).in_sequence(s)
-    end
-
-    context 'when #invoke_save is true' do
-      before { db.invoke_save = true }
-      it 'should copy over after persisting (saving) the most recent updates' do
-        db.expects(:invoke_save!).in_sequence(s)
-        db.expects(:copy!).in_sequence(s)
-
-        db.perform!
-      end
-    end
-
-    context 'when #invoke_save is not true' do
-      before { db.invoke_save = nil }
-      it 'should copy over without persisting (saving) first' do
-        db.expects(:invoke_save!).never
-        db.expects(:copy!).in_sequence(s)
-
-        db.perform!
-      end
-    end
-
-  end # describe '#perform!'
-
-  describe '#invoke_save!' do
-    before do
-      db.stubs(:credential_options).returns(:credential_options_output)
-      db.stubs(:connectivity_options).returns(:connectivity_options_output)
-      db.stubs(:user_options).returns(:user_options_output)
-    end
-
-    context 'when response is OK' do
-      it 'should run the redis-cli command string' do
-        db.expects(:run).with(
-          '/path/to/redis-cli credential_options_output ' +
-          'connectivity_options_output user_options_output SAVE'
-        ).returns('result OK for command')
-
-        expect do
-          db.send(:invoke_save!)
-        end.not_to raise_error
-      end
-    end
-
-    context 'when response is not OK' do
-      it 'should raise an error' do
-        db.stubs(:run).returns('result not ok for command')
-        db.stubs(:database).returns('database_filename')
-
-        expect do
-          db.send(:invoke_save!)
-        end.to raise_error {|err|
-          err.should be_an_instance_of Backup::Errors::Database::Redis::CommandError
-          err.message.should match(/Could not invoke the Redis SAVE command/)
-          err.message.should match(/The database_filename file/)
-          err.message.should match(/Redis CLI response: result not ok/)
-        }
-      end
-    end
-
-  end # describe '#invoke_save!'
-
-  describe '#copy!' do
-    let(:src_path)    { '/var/lib/redis/db/mydatabase.rdb' }
-    let(:dst_path)    { '/dump/path/mydatabase.rdb' }
-    let(:compressor)  { mock }
-
-    context 'when the database exists' do
-      before do
-        db.instance_variable_set(:@dump_path, '/dump/path')
-        File.expects(:exist?).with(src_path).returns(true)
-      end
-
-      context 'when no compressor is configured' do
-        it 'should copy the database' do
-          db.expects(:run).never
-
-          FileUtils.expects(:cp).with(src_path, dst_path)
-          db.send(:copy!)
-        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 copy the database using the compressor' do
-          FileUtils.expects(:cp).never
-
-          db.expects(:run).with(
-            "compressor_command -c #{ src_path } > #{ dst_path }.gz"
-          )
-          db.send(:copy!)
-        end
-      end
-    end
-
-    context 'when the database does not exist' do
-      it 'should raise an error if the database dump file is not found' do
-        File.expects(:exist?).returns(false)
-        expect do
-          db.send(:copy!)
-        end.to raise_error {|err|
-          err.should be_an_instance_of Backup::Errors::Database::Redis::NotFoundError
-          err.message.should match(/Redis database dump not found/)
-          err.message.should match(/File path was #{src_path}/)
-        }
-      end
-    end
-  end # describe '#copy!'
-
-  describe '#database' do
-    it 'should return the database name with the extension added' do
-      db.send(:database).should == 'mydatabase.rdb'
-    end
-  end
-
-  describe '#credential_options' do
-    context 'when #password is set' do
-      it 'should return the redis-cli syntax for the credential options' do
-        db.send(:credential_options).should == "-a 'secret'"
-      end
-    end
-
-    context 'when password is not set' do
-      it 'should return an empty string' do
-        db.password = nil
-        db.send(:credential_options).should == ''
-      end
-    end
-  end
-
-  describe '#connectivity_options' do
-    it 'should return the redis syntax for the connectivity options' do
-      db.send(:connectivity_options).should ==
-        "-h 'localhost' -p '123' -s '/redis.sock'"
-    end
-
-    context 'when only the #port is set' do
-      it 'should return only the port' do
-        db.host   = nil
-        db.socket = nil
-        db.send(:connectivity_options).should == "-p '123'"
-      end
-    end
-  end
-
-  describe '#user_options' do
-    context 'when #additional_options are set' do
-      it 'should return the options' do
-        db.send(:user_options).should == '--query --foo'
-      end
-    end
-
-    context 'when #additional_options is not set' do
-      it 'should return an empty string' do
-        db.additional_options = []
-        db.send(:user_options).should == ''
-      end
-    end
-  end
-
-  describe 'deprecations' do
-    describe '#utility_path' do
-      before do
-        Backup::Database::Redis.any_instance.stubs(:utility)
-        Backup::Logger.expects(:warn).with {|err|
-          err.should be_an_instance_of Backup::Errors::ConfigurationError
-          err.message.should match(
-            /Use Redis#redis_cli_utility instead/
-          )
-        }
-      end
-      after do
-        Backup::Database::Redis.clear_defaults!
-      end
-
-      context 'when set directly' do
-        it 'should issue a deprecation warning and set the replacement value' do
-          redis = Backup::Database::Redis.new(model) do |db|
-            db.utility_path = 'foo'
-          end
-          redis.redis_cli_utility.should == 'foo'
-        end
-      end
-
-      context 'when set as a default' do
-        it 'should issue a deprecation warning and set the replacement value' do
-          redis = Backup::Database::Redis.defaults do |db|
-            db.utility_path = 'foo'
-          end
-          redis = Backup::Database::Redis.new(model)
-          redis.redis_cli_utility.should == 'foo'
-        end
-      end
-    end # describe '#utility_path'
-  end
-end

data/spec/database/riak_spec.rb

@@ -1,176 +0,0 @@
-# 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
-
-  it 'should be a subclass of Database::Base' do
-    Backup::Database::Riak.superclass.
-      should == Backup::Database::Base
-  end
-
-  describe '#initialize' do
-
-    it 'should load pre-configured defaults through Base' do
-      Backup::Database::Riak.any_instance.expects(:load_defaults!)
-      db
-    end
-
-    it 'should pass the model reference to Base' do
-      db.instance_variable_get(:@model).should == model
-    end
-
-    context 'when no pre-configured defaults have been set' do
-      context 'when options are specified' do
-        it 'should use the given values' do
-          db.name.should      == 'mydatabase'
-          db.node.should      == 'riak@localhost'
-          db.cookie.should    == 'riak'
-          db.riak_admin_utility.should == '/path/to/riak-admin'
-        end
-      end
-
-      context 'when options are not specified' do
-        before do
-          Backup::Database::Riak.any_instance.expects(:utility).
-              with('riak-admin').returns('/real/riak-admin')
-        end
-
-        it 'should provide 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
-    end # context 'when no pre-configured defaults have been set'
-
-    context 'when pre-configured defaults have been set' do
-      before do
-        Backup::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
-      end
-
-      after { Backup::Database::Riak.clear_defaults! }
-
-      context 'when options are specified' do
-        it 'should override the pre-configured defaults' do
-          db.name.should      == 'mydatabase'
-          db.node.should      == 'riak@localhost'
-          db.cookie.should    == 'riak'
-          db.riak_admin_utility.should == '/path/to/riak-admin'
-        end
-      end
-
-      context 'when options are not specified' do
-        it 'should use the pre-configured defaults' do
-          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 # context 'when no pre-configured defaults have been set'
-  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
-
-  describe 'deprecations' do
-    describe '#utility_path' do
-      before do
-        Backup::Database::Riak.any_instance.stubs(:utility)
-        Backup::Logger.expects(:warn).with {|err|
-          err.should be_an_instance_of Backup::Errors::ConfigurationError
-          err.message.should match(
-            /Use Riak#riak_admin_utility instead/
-          )
-        }
-      end
-      after do
-        Backup::Database::Riak.clear_defaults!
-      end
-
-      context 'when set directly' do
-        it 'should issue a deprecation warning and set the replacement value' do
-          riak = Backup::Database::Riak.new(model) do |db|
-            db.utility_path = 'foo'
-          end
-          riak.riak_admin_utility.should == 'foo'
-        end
-      end
-
-      context 'when set as a default' do
-        it 'should issue a deprecation warning and set the replacement value' do
-          riak = Backup::Database::Riak.defaults do |db|
-            db.utility_path = 'foo'
-          end
-          riak = Backup::Database::Riak.new(model)
-          riak.riak_admin_utility.should == 'foo'
-        end
-      end
-    end # describe '#utility_path'
-  end
-end