backup_checksum 3.0.23

data/spec/database/mongodb_spec.rb

@@ -0,0 +1,428 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Database::MongoDB do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:db) do
+    Backup::Database::MongoDB.new(model) do |db|
+      db.name      = 'mydatabase'
+      db.username  = 'someuser'
+      db.password  = 'secret'
+      db.host      = 'localhost'
+      db.port      = 123
+
+      db.ipv6               = true
+      db.only_collections   = ['users', 'pirates']
+      db.additional_options = ['--query', '--foo']
+      db.mongodump_utility  = '/path/to/mongodump'
+      db.mongo_utility      = '/path/to/mongo'
+    end
+  end
+
+  describe '#initialize' do
+
+    it 'should read the adapter details correctly' do
+      db.name.should      == 'mydatabase'
+      db.username.should  == 'someuser'
+      db.password.should  == 'secret'
+      db.host.should      == 'localhost'
+      db.port.should      == 123
+
+      db.ipv6.should                == true
+      db.only_collections.should    == ['users', 'pirates']
+      db.additional_options.should  == ['--query', '--foo']
+      db.mongodump_utility.should   == '/path/to/mongodump'
+      db.mongo_utility.should       == '/path/to/mongo'
+      db.lock.should                == false
+    end
+
+    context 'when options are not set' do
+      before do
+        Backup::Database::MongoDB.any_instance.expects(:utility).
+            with(:mongodump).returns('/real/mongodump')
+        Backup::Database::MongoDB.any_instance.expects(:utility).
+            with(:mongo).returns('/real/mongo')
+      end
+
+      it 'should use default values' do
+        db = Backup::Database::MongoDB.new(model)
+
+        db.name.should      be_nil
+        db.username.should  be_nil
+        db.password.should  be_nil
+        db.host.should      be_nil
+        db.port.should      be_nil
+
+        db.ipv6.should                be_false
+        db.only_collections.should    == []
+        db.additional_options.should  == []
+        db.mongodump_utility.should   == '/real/mongodump'
+        db.mongo_utility.should       == '/real/mongo'
+        db.lock.should                be_false
+      end
+    end
+
+    context 'when configuration defaults have been set' do
+      after { Backup::Configuration::Database::MongoDB.clear_defaults! }
+
+      it 'should use configuration defaults' do
+        Backup::Configuration::Database::MongoDB.defaults do |db|
+          db.name       = 'db_name'
+          db.username   = 'db_username'
+          db.password   = 'db_password'
+          db.host       = 'db_host'
+          db.port       = 789
+
+          db.ipv6               = true
+          db.only_collections   = ['collection']
+          db.additional_options = ['--opt']
+          db.mongodump_utility  = '/default/path/to/mongodump'
+          db.mongo_utility      = '/default/path/to/mongo'
+          db.lock               = true
+        end
+
+        db = Backup::Database::MongoDB.new(model)
+        db.name.should      == 'db_name'
+        db.username.should  == 'db_username'
+        db.password.should  == 'db_password'
+        db.host.should      == 'db_host'
+        db.port.should      == 789
+
+        db.ipv6.should                be_true
+        db.only_collections.should    == ['collection']
+        db.additional_options.should  == ['--opt']
+        db.mongodump_utility.should   == '/default/path/to/mongodump'
+        db.mongo_utility.should       == '/default/path/to/mongo'
+        db.lock.should                be_true
+      end
+    end
+  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 #lock is set to false' do
+
+      context 'when #only_collections has not been specified' do
+        before { db.only_collections = [] }
+        it 'should dump everything without locking' do
+          db.expects(:lock_database).never
+          db.expects(:unlock_database).never
+          db.expects(:specific_collection_dump!).never
+
+          db.expects(:dump!).in_sequence(s)
+          db.expects(:package!).in_sequence(s)
+          db.perform!
+        end
+      end
+
+      context 'when #only_collections has been specified' do
+        it 'should dump specific collections without locking' do
+          db.expects(:lock_database).never
+          db.expects(:unlock_database).never
+          db.expects(:dump!).never
+
+          db.expects(:specific_collection_dump!).in_sequence(s)
+          db.expects(:package!).in_sequence(s)
+          db.perform!
+        end
+      end
+
+    end # context 'when #lock is set to false'
+
+    context 'when #lock is set to true' do
+      before { db.lock = true }
+
+      context 'when #only_collections has not been specified' do
+        before { db.only_collections = [] }
+        it 'should dump everything while locking the database' do
+          db.expects(:specific_collection_dump!).never
+
+          db.expects(:lock_database).in_sequence(s)
+          db.expects(:dump!).in_sequence(s)
+          db.expects(:unlock_database).in_sequence(s)
+          db.expects(:package!).in_sequence(s)
+          db.perform!
+        end
+      end
+
+      context 'when #only_collections has been specified' do
+        it 'should dump specific collections without locking' do
+          db.expects(:lock_database).never
+          db.expects(:unlock_database).never
+          db.expects(:dump!).never
+
+          db.expects(:lock_database).in_sequence(s)
+          db.expects(:specific_collection_dump!).in_sequence(s)
+          db.expects(:unlock_database).in_sequence(s)
+          db.expects(:package!).in_sequence(s)
+          db.perform!
+        end
+      end
+
+    end # context 'when #lock is set to true'
+
+    context 'when errors occur' do
+      it 'should re-raise error and skip package!' do
+        db.expects(:specific_collection_dump!).in_sequence(s).
+            raises('Test Error Message')
+        db.expects(:package!).never
+
+        expect do
+          db.perform!
+        end.to raise_error(
+          Backup::Errors::Database::MongoDBError,
+          "Database::MongoDBError: Database Dump Failed!\n" +
+          "  Reason: RuntimeError\n" +
+          "  Test Error Message"
+        )
+      end
+
+      it 'should ensure database is unlocked' do
+        db.lock = true
+
+        db.expects(:lock_database).in_sequence(s)
+        db.expects(:specific_collection_dump!).in_sequence(s).
+            raises('Test Error Message')
+        db.expects(:unlock_database).in_sequence(s)
+        db.expects(:package!).never
+
+        expect do
+          db.perform!
+        end.to raise_error(
+          Backup::Errors::Database::MongoDBError,
+          "Database::MongoDBError: Database Dump Failed!\n" +
+          "  Reason: RuntimeError\n" +
+          "  Test Error Message"
+        )
+      end
+    end
+
+  end # describe '#perform!'
+
+  describe '#dump!' do
+    it 'should run the mongodb dump command' do
+      db.expects(:mongodump).returns(:dump_command)
+      db.expects(:run).with(:dump_command)
+      db.send(:dump!)
+    end
+  end
+
+  describe '#specific_collection_dump!' do
+    it 'should run the mongodb dump command for each collection' do
+      db.expects(:mongodump).twice.returns('dump_command')
+      db.expects(:run).with("dump_command --collection='users'")
+      db.expects(:run).with("dump_command --collection='pirates'")
+      db.send(:specific_collection_dump!)
+    end
+  end
+
+  describe '#mongodump' do
+    before do
+      db.instance_variable_set(:@dump_path, '/path/to/dump/folder')
+    end
+
+    it 'should return the mongodb dump command string' do
+      db.send(:mongodump).should == "/path/to/mongodump " +
+        "--db='mydatabase' --username='someuser' --password='secret' " +
+        "--host='localhost' --port='123' --ipv6 " +
+        "--query --foo --out='/path/to/dump/folder'"
+    end
+  end
+
+  describe '#package!' do
+    let(:compressor) { mock }
+    let(:pipeline) { mock }
+    let(:timestamp) { Time.now.to_i.to_s[-5, 5] }
+    let(:s) { sequence '' }
+
+    context 'when a compressor is configured' do
+      before do
+        Timecop.freeze(Time.now)
+        db.instance_variable_set(:@dump_path, '/path/to/dump/folder')
+        db.expects(:utility).with(:tar).returns('tar')
+        model.expects(:compressor).twice.returns(compressor)
+        compressor.expects(:compress_with).yields('compressor_command', '.gz')
+        Backup::Pipeline.expects(:new).returns(pipeline)
+      end
+
+      context 'when pipeline command succeeds' do
+        it 'should package the dump directory, then remove it' do
+
+          Backup::Logger.expects(:message).in_sequence(s).with(
+            "Database::MongoDB started compressing and packaging:\n" +
+            "  '/path/to/dump/folder'"
+          )
+
+          pipeline.expects(:<<).in_sequence(s).with(
+            "tar -cf - -C '/path/to/dump' 'folder'"
+          )
+          pipeline.expects(:<<).in_sequence(s).with('compressor_command')
+          pipeline.expects(:<<).in_sequence(s).with(
+            "cat > /path/to/dump/folder-#{ timestamp }.tar.gz"
+          )
+
+          pipeline.expects(:run).in_sequence(s)
+          pipeline.expects(:success?).in_sequence(s).returns(true)
+          Backup::Logger.expects(:message).in_sequence(s).with(
+            "Database::MongoDB completed compressing and packaging:\n" +
+            "  '/path/to/dump/folder-#{ timestamp }.tar.gz'"
+          )
+          FileUtils.expects(:rm_rf).in_sequence(s).with('/path/to/dump/folder')
+
+          db.send(:package!)
+        end
+      end #context 'when pipeline command succeeds'
+
+      context 'when pipeline command fails' do
+        before do
+          pipeline.stubs(:<<)
+          pipeline.expects(:run)
+          pipeline.expects(:success?).returns(false)
+          pipeline.expects(:error_messages).returns('pipeline_errors')
+        end
+
+        it 'should raise an error' do
+          expect do
+            db.send(:package!)
+          end.to raise_error(
+            Backup::Errors::Database::PipelineError,
+            "Database::PipelineError: Database::MongoDB " +
+            "Failed to create compressed dump package:\n" +
+            "  '/path/to/dump/folder-#{ timestamp }.tar.gz'\n" +
+            "  pipeline_errors"
+          )
+        end
+      end # context 'when pipeline command fails'
+    end
+
+    context 'when a compressor is not configured' do
+      before do
+        model.expects(:compressor).returns(nil)
+      end
+
+      it 'should return nil' do
+        Backup::Pipeline.expects(:new).never
+        db.send(:package!).should be_nil
+      end
+    end
+  end # describe '#package!'
+
+  describe '#database' do
+    context 'when a database name is given' do
+      it 'should return the command string for the database' do
+        db.send(:database).should == "--db='mydatabase'"
+      end
+    end
+
+    context 'when no database name is given' do
+      it 'should return nil' do
+        db.name = nil
+        db.send(:database).should be_nil
+      end
+    end
+  end
+
+  describe '#credential_options' do
+    it 'should return the command string for the user credentials' do
+      db.send(:credential_options).should ==
+          "--username='someuser' --password='secret'"
+    end
+  end
+
+  describe '#connectivity_options' do
+    it 'should return the command string for the connectivity options' do
+      db.send(:connectivity_options).should == "--host='localhost' --port='123'"
+    end
+  end
+
+  describe '#ipv6_option' do
+    context 'when #ipv6 is set true' do
+      it 'should return the command string for the ipv6 option' do
+        db.send(:ipv6_option).should == '--ipv6'
+      end
+    end
+
+    context 'when #ipv6 is set false' do
+      it 'should return and empty string' do
+        db.ipv6 = false
+        db.send(:ipv6_option).should == ''
+      end
+    end
+  end
+
+  describe '#user_options' do
+    context 'when #additional_options are set' do
+      it 'should return the command string for the options' do
+        db.send(:user_options).should == '--query --foo'
+      end
+    end
+
+    context 'when #additional_options are not set' do
+      it 'should return an empty string' do
+        db.additional_options = []
+        db.send(:user_options).should == ''
+      end
+    end
+  end
+
+  describe '#dump_directory' do
+    it 'should return the command string for the dump path' do
+      db.instance_variable_set(:@dump_path, '/path/to/dump/folder')
+      db.send(:dump_directory).should == "--out='/path/to/dump/folder'"
+    end
+  end
+
+  describe '#lock_database' do
+    it 'should return the command to lock the database' do
+      db.stubs(:mongo_uri).returns(:mongo_uri_output)
+      db.expects(:run).with(
+        " echo 'use admin\n" +
+        ' db.runCommand({"fsync" : 1, "lock" : 1})\' | /path/to/mongo mongo_uri_output' +
+        "\n"
+      )
+      db.send(:lock_database)
+    end
+  end
+
+  describe '#unlock_database' do
+    it 'should return the command to unlock the database' do
+      db.stubs(:mongo_uri).returns(:mongo_uri_output)
+      db.expects(:run).with(
+        " echo 'use admin\n" +
+        ' db.$cmd.sys.unlock.findOne()\' | /path/to/mongo mongo_uri_output' +
+        "\n"
+      )
+      db.send(:unlock_database)
+    end
+  end
+
+  describe '#mongo_uri' do
+    before do
+      db.stubs(:credential_options).returns(:credential_options_output)
+      db.stubs(:ipv6_option).returns(:ipv6_option_output)
+    end
+
+    context 'when a database name is given' do
+      it 'should return the URI specifying the database' do
+        db.send(:mongo_uri).should ==
+          "localhost:123/mydatabase credential_options_output ipv6_option_output"
+      end
+    end
+
+    context 'when no database name is given' do
+      it 'should return the URI without specifying the database' do
+        db.name = nil
+        db.send(:mongo_uri).should ==
+          "localhost:123 credential_options_output ipv6_option_output"
+      end
+    end
+  end
+end

data/spec/database/mysql_spec.rb

@@ -0,0 +1,335 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Database::MySQL do
+  let(:model) { Backup::Model.new('foo', 'foo') }
+  let(:db) do
+    Backup::Database::MySQL.new(model) do |db|
+      db.name      = 'mydatabase'
+      db.username  = 'someuser'
+      db.password  = 'secret'
+      db.host      = 'localhost'
+      db.port      = '123'
+      db.socket    = '/mysql.sock'
+
+      db.skip_tables = ['logs', 'profiles']
+      db.only_tables = ['users', 'pirates']
+      db.additional_options = ['--single-transaction', '--quick']
+      db.mysqldump_utility  = '/path/to/mysqldump'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should read the adapter details correctly' do
+      db.name.should      == 'mydatabase'
+      db.username.should  == 'someuser'
+      db.password.should  == 'secret'
+      db.host.should      == 'localhost'
+      db.port.should      == '123'
+      db.socket.should    == '/mysql.sock'
+
+      db.skip_tables.should == ['logs', 'profiles']
+      db.only_tables.should == ['users', 'pirates']
+      db.additional_options.should == ['--single-transaction', '--quick']
+      db.mysqldump_utility.should  == '/path/to/mysqldump'
+    end
+
+    context 'when options are not set' do
+      before do
+        Backup::Database::MySQL.any_instance.expects(:utility).
+            with(:mysqldump).returns('/real/mysqldump')
+      end
+
+      it 'should use default values' do
+        db = Backup::Database::MySQL.new(model)
+
+        db.name.should      == :all
+        db.username.should  be_nil
+        db.password.should  be_nil
+        db.host.should      be_nil
+        db.port.should      be_nil
+        db.socket.should    be_nil
+
+        db.skip_tables.should         == []
+        db.only_tables.should         == []
+        db.additional_options.should  == []
+        db.mysqldump_utility.should  == '/real/mysqldump'
+      end
+    end
+
+    context 'when configuration defaults have been set' do
+      after { Backup::Configuration::Database::MySQL.clear_defaults! }
+
+      it 'should use configuration defaults' do
+        Backup::Configuration::Database::MySQL.defaults do |db|
+          db.name       = 'db_name'
+          db.username   = 'db_username'
+          db.password   = 'db_password'
+          db.host       = 'db_host'
+          db.port       = 789
+          db.socket     = '/foo.sock'
+
+          db.skip_tables = ['skip', 'tables']
+          db.only_tables = ['only', 'tables']
+          db.additional_options = ['--add', '--opts']
+          db.mysqldump_utility  = '/default/path/to/mysqldump'
+        end
+
+        db = Backup::Database::MySQL.new(model)
+        db.name.should      == 'db_name'
+        db.username.should  == 'db_username'
+        db.password.should  == 'db_password'
+        db.host.should      == 'db_host'
+        db.port.should      == 789
+        db.socket.should    == '/foo.sock'
+
+        db.skip_tables.should         == ['skip', 'tables']
+        db.only_tables.should         == ['only', 'tables']
+        db.additional_options.should  == ['--add', '--opts']
+        db.mysqldump_utility.should   == '/default/path/to/mysqldump'
+      end
+    end
+  end # describe '#initialize'
+
+  describe '#perform!' do
+    let(:s) { sequence '' }
+    let(:pipeline) { mock }
+
+    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(:mysqldump).returns('mysqldump_command')
+      db.stubs(:dump_filename).returns('dump_filename')
+      Backup::Pipeline.expects(:new).returns(pipeline)
+    end
+
+    context 'when no compressor is configured' do
+      before do
+        model.expects(:compressor).returns(nil)
+      end
+
+      it 'should run mysqldump without compression' do
+        pipeline.expects(:<<).in_sequence(s).with('mysqldump_command')
+        pipeline.expects(:<<).in_sequence(s).with(
+          "cat > '/dump/path/dump_filename.sql'"
+        )
+        pipeline.expects(:run).in_sequence(s)
+        pipeline.expects(:success?).in_sequence(s).returns(true)
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          'Database::MySQL Complete!'
+        )
+
+        db.perform!
+      end
+    end
+
+    context 'when a compressor is configured' do
+      before do
+        compressor = mock
+        model.expects(:compressor).twice.returns(compressor)
+        compressor.expects(:compress_with).yields('gzip', '.gz')
+      end
+
+      it 'should run mysqldump with compression' do
+        pipeline.expects(:<<).in_sequence(s).with('mysqldump_command')
+        pipeline.expects(:<<).in_sequence(s).with('gzip')
+        pipeline.expects(:<<).in_sequence(s).with(
+          "cat > '/dump/path/dump_filename.sql.gz'"
+        )
+        pipeline.expects(:run).in_sequence(s)
+        pipeline.expects(:success?).in_sequence(s).returns(true)
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          'Database::MySQL Complete!'
+        )
+
+        db.perform!
+      end
+    end
+
+    context 'when pipeline command fails' do
+      before do
+        model.expects(:compressor).returns(nil)
+        pipeline.stubs(:<<)
+        pipeline.expects(:run)
+        pipeline.expects(:success?).returns(false)
+        pipeline.expects(:error_messages).returns('pipeline_errors')
+      end
+
+      it 'should raise an error' do
+        expect do
+          db.perform!
+        end.to raise_error(
+          Backup::Errors::Database::PipelineError,
+          "Database::PipelineError: Database::MySQL Dump Failed!\n" +
+          "  pipeline_errors"
+        )
+      end
+    end # context 'when pipeline command fails'
+
+  end # describe '#perform!'
+
+  describe '#mysqldump' do
+    before do
+      db.stubs(:mysqldump_utility).returns(:mysqldump_utility)
+      db.stubs(:credential_options).returns(:credential_options)
+      db.stubs(:connectivity_options).returns(:connectivity_options)
+      db.stubs(:user_options).returns(:user_options)
+      db.stubs(:db_name).returns(:db_name)
+      db.stubs(:tables_to_dump).returns(:tables_to_dump)
+      db.stubs(:tables_to_skip).returns(:tables_to_skip)
+    end
+
+    it 'should return the mysqldump command string' do
+      db.send(:mysqldump).should ==
+        "mysqldump_utility credential_options connectivity_options " +
+        "user_options db_name tables_to_dump tables_to_skip"
+    end
+  end
+
+  describe '#dump_filename' do
+    context 'when @name is set to :all' do
+      before { db.name = :all }
+      it 'should set the filename to "all-databases"' do
+        db.send(:dump_filename).should == 'all-databases'
+      end
+    end
+
+    context 'when @name is not set to :all' do
+      it 'should return @name' do
+        db.send(:dump_filename).should == 'mydatabase'
+      end
+    end
+  end
+
+  describe '#credential_options' do
+    context 'when a password is set' do
+      it 'should return the command string for the user credentials' do
+        db.send(:credential_options).should ==
+          "--user='someuser' --password='secret'"
+      end
+    end
+
+    context 'when no password is set' do
+      before { db.password = nil }
+      it 'should return the command string for the user credentials' do
+        db.send(:credential_options).should ==
+          "--user='someuser'"
+      end
+    end
+  end
+
+  describe '#connectivity_options' do
+    it 'should return the mysql syntax for the connectivity options' do
+      db.send(:connectivity_options).should ==
+        "--host='localhost' --port='123' --socket='/mysql.sock'"
+    end
+
+    context 'when only the socket is set' do
+      it 'should return only the socket' do
+        db.host   = ''
+        db.port   = nil
+        db.send(:connectivity_options).should == "--socket='/mysql.sock'"
+      end
+    end
+
+    context 'when only the host and port are set' do
+      it 'should return only the host and port' do
+        db.socket = nil
+        db.send(:connectivity_options).should ==
+          "--host='localhost' --port='123'"
+      end
+    end
+  end
+
+  describe '#user_options' do
+    it 'should return a string of additional options specified by the user' do
+      db.send(:user_options).should == '--single-transaction --quick'
+    end
+
+    context 'when #additional_options is not set' do
+      before { db.additional_options = [] }
+      it 'should return an empty string' do
+        db.send(:user_options).should == ''
+      end
+    end
+  end
+
+  describe '#db_name' do
+    context 'when @name is set to :all' do
+      before { db.name = :all }
+      it 'should return the mysqldump flag to dump all databases' do
+        db.send(:db_name).should == '--all-databases'
+      end
+    end
+
+    context 'when @name is not set to :all' do
+      it 'should return @name' do
+        db.send(:db_name).should == 'mydatabase'
+      end
+    end
+  end
+
+  describe '#tables_to_dump' do
+    it 'should return a string for the mysqldump selected table to dump option' do
+      db.send(:tables_to_dump).should == 'users pirates'
+    end
+
+    context 'when #only_tables is not set' do
+      before { db.only_tables = [] }
+      it 'should return an empty string' do
+        db.send(:tables_to_dump).should == ''
+      end
+    end
+
+    context 'when dump_all? is true' do
+      before { db.stubs(:dump_all?).returns(true) }
+      it 'should return nil' do
+        db.send(:tables_to_dump).should be_nil
+      end
+    end
+  end
+
+  describe '#tables_to_skip' do
+    it 'should return a string for the mysqldump --ignore-tables option' do
+      db.send(:tables_to_skip).should ==
+        "--ignore-table='mydatabase.logs' --ignore-table='mydatabase.profiles'"
+    end
+
+    it 'should return an empty string if #skip_tables is empty' do
+      db.skip_tables = []
+      db.send(:tables_to_skip).should == ''
+    end
+
+    it 'should accept table names prefixed with the database name' do
+      db.skip_tables = ['table_name', 'db_name.table_name']
+      db.send(:tables_to_skip).should ==
+        "--ignore-table='mydatabase.table_name' --ignore-table='db_name.table_name'"
+    end
+
+    it 'should not prefix table name if dump_all? is true' do
+      db.name = :all
+      db.skip_tables = ['table_name', 'db_name.table_name']
+      db.send(:tables_to_skip).should ==
+        "--ignore-table='table_name' --ignore-table='db_name.table_name'"
+    end
+  end
+
+  describe '#dump_all?' do
+    context 'when @name is set to :all' do
+      before { db.name = :all }
+      it 'should return true' do
+        db.send(:dump_all?).should be_true
+      end
+    end
+
+    context 'when @name is not set to :all' do
+      it 'should return false' do
+        db.send(:dump_all?).should be_false
+      end
+    end
+  end
+end