backup 3.0.27 → 3.1.0

data/spec/configuration/helpers_spec.rb

@@ -1,247 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../../spec_helper.rb', __FILE__)
-
-describe 'Backup::Configuration::Helpers' do
-
-  before do
-    module Backup
-      class Foo
-        include Backup::Configuration::Helpers
-        attr_accessor :accessor, :accessor_two
-        attr_reader :reader
-
-        attr_deprecate :removed,
-                       :version => '1.1'
-
-        attr_deprecate :removed_with_message,
-                       :version => '1.2',
-                       :message => 'This has no replacement.'
-
-        attr_deprecate :removed_with_action,
-                       :version => '1.3',
-                       :action => lambda {|klass, val|
-                         klass.accessor = val ? '1' : '0'
-                         klass.accessor_two = 'updated'
-                       }
-
-        attr_deprecate :removed_with_action_and_message,
-                       :version => '1.4',
-                       :message => "Updating accessors.",
-                       :action => lambda {|klass, val|
-                         klass.accessor = val ? '1' : '0'
-                         klass.accessor_two = 'updated'
-                       }
-      end
-    end
-  end
-
-  after do
-    Backup.send(:remove_const, 'Foo')
-  end
-
-  describe '.defaults' do
-    let(:configuration) { mock }
-
-    before do
-      Backup::Configuration::Store.expects(:new).once.returns(configuration)
-    end
-
-    it 'should return the Configuration::Store for the class' do
-      Backup::Foo.defaults.should be(configuration)
-    end
-
-    it 'should yield the Configuration::Store for the class' do
-      Backup::Foo.defaults do |config|
-        config.should be(configuration)
-      end
-    end
-
-    it 'should cache the Configuration::Store for the class' do
-      Backup::Foo.instance_variable_get(:@configuration).should be_nil
-      Backup::Foo.defaults.should be(configuration)
-      Backup::Foo.instance_variable_get(
-          :@configuration).should be(configuration)
-      Backup::Foo.defaults.should be(configuration)
-    end
-  end
-
-  describe '.clear_defaults!' do
-    it 'should clear all defaults set' do
-      Backup::Foo.defaults do |config|
-        config.accessor = 'foo'
-      end
-      Backup::Foo.defaults.accessor.should == 'foo'
-
-      Backup::Foo.clear_defaults!
-      Backup::Foo.defaults.accessor.should be_nil
-    end
-  end
-
-  describe '.deprecations' do
-    it 'should return @deprecations' do
-      Backup::Foo.deprecations.should be_a(Hash)
-      Backup::Foo.deprecations.keys.count.should be(4)
-    end
-
-    it 'should set @deprecations to an empty hash if not set' do
-      Backup::Foo.send(:remove_instance_variable, :@deprecations)
-      Backup::Foo.deprecations.should == {}
-    end
-  end
-
-  describe '.attr_deprecate' do
-    before do
-      Backup::Foo.send(:remove_instance_variable, :@deprecations)
-    end
-
-    it 'should add deprected attributes' do
-      Backup::Foo.send(:attr_deprecate, :attr1)
-      Backup::Foo.send(:attr_deprecate, :attr2,
-                       :version => '2')
-      Backup::Foo.send(:attr_deprecate, :attr3,
-                       :version => '3',
-                       :message => 'attr3 message')
-      Backup::Foo.send(:attr_deprecate, :attr4,
-                       :version => '4',
-                       :message => 'attr4 message',
-                       :action  => 'attr4 action')
-
-      Backup::Foo.deprecations.should == {
-        :attr1 => { :version => nil,
-                    :message => nil,
-                    :action  => nil },
-        :attr2 => { :version => '2',
-                    :message => nil,
-                    :action  => nil },
-        :attr3 => { :version => '3',
-                    :message => 'attr3 message',
-                    :action  => nil },
-        :attr4 => { :version => '4',
-                    :message => 'attr4 message',
-                    :action  => 'attr4 action' }
-      }
-    end
-  end
-
-  describe '.log_deprecation_warning' do
-    context 'when no message given' do
-      it 'should log a warning that the attribute has been removed' do
-        Backup::Logger.expects(:warn).with do |err|
-          err.message.should ==
-              "ConfigurationError: [DEPRECATION WARNING]\n" +
-              "  Backup::Foo#removed has been deprecated as of backup v.1.1"
-        end
-
-        deprecation = Backup::Foo.deprecations[:removed]
-        Backup::Foo.log_deprecation_warning(:removed, deprecation)
-      end
-    end
-
-    context 'when a message is given' do
-      it 'should log warning with the message' do
-        Backup::Logger.expects(:warn).with do |err|
-          err.message.should ==
-              "ConfigurationError: [DEPRECATION WARNING]\n" +
-              "  Backup::Foo#removed_with_message has been deprecated " +
-              "as of backup v.1.2\n" +
-              "  This has no replacement."
-        end
-
-        deprecation = Backup::Foo.deprecations[:removed_with_message]
-        Backup::Foo.log_deprecation_warning(:removed_with_message, deprecation)
-
-      end
-    end
-  end # describe '.log_deprecation_warning'
-
-  describe '#load_defaults!' do
-    let(:klass) { Backup::Foo.new }
-
-    it 'should load default values set for the class' do
-      Backup::Foo.defaults do |config|
-        config.accessor = 'foo'
-      end
-
-      klass.send(:load_defaults!)
-      klass.accessor.should == 'foo'
-    end
-
-    it 'should raise an error if defaults are set for attribute readers' do
-      Backup::Foo.defaults do |config|
-        config.reader = 'foo'
-      end
-
-      expect do
-        klass.send(:load_defaults!)
-      end.to raise_error(NoMethodError, /Backup::Foo/)
-    end
-
-    it 'should raise an error if defaults were set for invalid accessors' do
-      Backup::Foo.defaults do |config|
-        config.foobar = 'foo'
-      end
-
-      expect do
-        klass.send(:load_defaults!)
-      end.to raise_error(NoMethodError, /Backup::Foo/)
-    end
-  end
-
-  describe '#method_missing' do
-    context 'when the method is a deprecated method' do
-      before do
-        Backup::Logger.expects(:warn).with(
-          instance_of(Backup::Errors::ConfigurationError)
-        )
-      end
-
-      context 'when an :action is specified' do
-        it 'should call the :action' do
-          value = [true, false].shuffle.first
-          expected_value = value ? '1' : '0'
-
-          klass = Backup::Foo.new
-          klass.removed_with_action = value
-
-          klass.accessor.should == expected_value
-          # lambda additionally sets :accessor_two
-          klass.accessor_two.should == 'updated'
-        end
-      end
-
-      context 'when no :action is specified' do
-        it 'should only log the warning' do
-          Backup::Foo.any_instance.expects(:accessor=).never
-
-          klass = Backup::Foo.new
-          klass.removed = 'foo'
-
-          klass.accessor.should be_nil
-        end
-      end
-    end
-
-    context 'when the method is not a deprecated method' do
-      it 'should raise a NoMethodError' do
-        Backup::Logger.expects(:warn).never
-
-        klass = Backup::Foo.new
-        expect do
-          klass.foobar = 'attr_value'
-        end.to raise_error(NoMethodError)
-      end
-    end
-
-    context 'when the method is not a set operation' do
-      it 'should raise a NoMethodError' do
-        Backup::Logger.expects(:warn).never
-
-        klass = Backup::Foo.new
-        expect do
-          klass.removed
-        end.to raise_error(NoMethodError)
-      end
-    end
-  end # describe '#method_missing'
-end

data/spec/configuration/store_spec.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../../spec_helper.rb', __FILE__)
-
-describe 'Backup::Configuration::Store' do
-  let(:store) { Backup::Configuration::Store.new }
-
-  before do
-    store.foo = 'one'
-    store.bar = 'two'
-  end
-
-  it 'should be a subclass of OpenStruct' do
-    Backup::Configuration::Store.superclass.should == OpenStruct
-  end
-
-  it 'should return nil for unset attributes' do
-    store.foobar.should be_nil
-  end
-
-  describe '#_attribues' do
-    it 'should return an array of attribute names' do
-      store._attributes.should be_an Array
-      store._attributes.count.should be(2)
-      store._attributes.should include(:foo, :bar)
-    end
-  end
-
-  describe '#reset!' do
-    it 'should clear all attributes set' do
-      store.reset!
-      store._attributes.should be_an Array
-      store._attributes.should be_empty
-      store.foo.should be_nil
-      store.bar.should be_nil
-    end
-  end
-
-end

data/spec/configuration_spec.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../spec_helper.rb', __FILE__)
-
-describe 'Backup::Configuration' do
-
-  after do
-    Backup::Configuration.send(:remove_const, 'Foo')
-  end
-
-  it 'should create modules for missing constants' do
-    Backup::Configuration::Foo.class.should == Module
-  end
-
-  describe 'a generated module' do
-
-    before do
-      module Backup
-        class Foo; end
-      end
-    end
-
-    after do
-      Backup.send(:remove_const, 'Foo')
-    end
-
-    it 'should create modules for missing constants' do
-      Backup::Configuration::Foo::A::B.class.should == Module
-    end
-
-    it 'should pass calls to .defaults to the proper class' do
-      Backup::Logger.expects(:warn)
-      Backup::Foo.expects(:defaults)
-      Backup::Configuration::Foo.defaults
-    end
-
-    it 'should pass a given block to .defaults to the proper class' do
-      Backup::Logger.expects(:warn)
-      configuration = mock
-      Backup::Foo.expects(:defaults).yields(configuration)
-      configuration.expects(:foo=).with('bar')
-
-      Backup::Configuration::Foo.defaults do |config|
-        config.foo = 'bar'
-      end
-    end
-
-    it 'should log a deprecation warning' do
-      Backup::Foo.stubs(:defaults)
-      Backup::Logger.expects(:warn).with do |err|
-        err.message.should ==
-        "ConfigurationError: [DEPRECATION WARNING]\n" +
-        "  Backup::Configuration::Foo.defaults is being deprecated.\n" +
-        "  To set pre-configured defaults for Backup::Foo, use:\n" +
-        "  Backup::Foo.defaults"
-      end
-      Backup::Configuration::Foo.defaults
-    end
-
-  end
-
-end

data/spec/database/base_spec.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../../spec_helper.rb', __FILE__)
-
-describe Backup::Database::Base do
-  let(:model) { Backup::Model.new('foo', 'foo') }
-  let(:db) { Backup::Database::Base.new(model) }
-
-  it 'should include CLI::Helpers' do
-    Backup::Database::Base.
-      include?(Backup::CLI::Helpers).should be_true
-  end
-
-  it 'should include Configuration::Helpers' do
-    Backup::Database::Base.
-      include?(Backup::Configuration::Helpers).should be_true
-  end
-
-  describe '#initialize' do
-    it 'should load pre-configured defaults' do
-      Backup::Database::Base.any_instance.expects(:load_defaults!)
-      db
-    end
-
-    it 'should set a reference to the model' do
-      db.instance_variable_get(:@model).should == model
-    end
-  end
-
-  describe '#perform!' do
-    it 'should invoke prepare! and log!' do
-      s = sequence ''
-      db.expects(:prepare!).in_sequence(s)
-      db.expects(:log!).in_sequence(s)
-
-      db.perform!
-    end
-  end
-
-  describe '#prepare!' do
-    it 'should set and create #dump_path' do
-      model = stub(:trigger => 'test_trigger')
-      db.instance_variable_set(:@model, model)
-      FileUtils.expects(:mkdir_p).with(
-        File.join(Backup::Config.tmp_path, 'test_trigger', 'databases', 'Base')
-      )
-      db.send(:prepare!)
-      db.instance_variable_get(:@dump_path).should ==
-        File.join(Backup::Config.tmp_path, 'test_trigger', 'databases', 'Base')
-    end
-  end
-
-  describe '#log!' do
-    it 'should use #database_name' do
-      db.stubs(:name).returns('database_name')
-      Backup::Logger.expects(:message).with(
-        "Database::Base started dumping and archiving 'database_name'."
-      )
-
-      db.send(:log!)
-    end
-  end
-end

data/spec/database/mongodb_spec.rb

@@ -1,510 +0,0 @@
-# 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'
-      db.lock               = true
-    end
-  end
-
-  it 'should be a subclass of Database::Base' do
-    Backup::Database::MongoDB.superclass.
-      should == Backup::Database::Base
-  end
-
-  describe '#initialize' do
-
-    it 'should load pre-configured defaults through Base' do
-      Backup::Database::MongoDB.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.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                == true
-        end
-      end
-
-      context 'when options are not specified' 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 provide 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
-    end # context 'when no pre-configured defaults have been set'
-
-    context 'when pre-configured defaults have been set' do
-      before do
-        Backup::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               = 'default_ipv6'
-          db.only_collections   = ['collection']
-          db.additional_options = ['--opt']
-          db.mongodump_utility  = '/default/path/to/mongodump'
-          db.mongo_utility      = '/default/path/to/mongo'
-          db.lock               = 'default_lock'
-        end
-      end
-
-      after { Backup::Database::MongoDB.clear_defaults! }
-
-      context 'when options are specified' do
-        it 'should override the pre-configured defaults' 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                == true
-        end
-      end
-
-      context 'when options are not specified' do
-        it 'should use the pre-configured defaults' do
-          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                == 'default_ipv6'
-          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                == 'default_lock'
-        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 #lock is set to false' do
-      before { db.lock = false }
-
-      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
-
-      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.lock = false
-
-        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.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
-          Backup::Logger.expects(:message).with(
-            "Database::MongoDB started compressing and packaging:\n" +
-            "  '/path/to/dump/folder'"
-          )
-
-          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
-
-  describe 'deprecations' do
-    describe '#utility_path' do
-      before do
-        Backup::Database::MongoDB.any_instance.stubs(:utility)
-        Backup::Logger.expects(:warn).with {|err|
-          err.should be_an_instance_of Backup::Errors::ConfigurationError
-          err.message.should match(
-            /Use MongoDB#mongodump_utility instead/
-          )
-        }
-      end
-      after do
-        Backup::Database::MongoDB.clear_defaults!
-      end
-
-      context 'when set directly' do
-        it 'should issue a deprecation warning and set the replacement value' do
-          mongodb = Backup::Database::MongoDB.new(model) do |db|
-            db.utility_path = 'foo'
-          end
-          mongodb.mongodump_utility.should == 'foo'
-        end
-      end
-
-      context 'when set as a default' do
-        it 'should issue a deprecation warning and set the replacement value' do
-          mongodb = Backup::Database::MongoDB.defaults do |db|
-            db.utility_path = 'foo'
-          end
-          mongodb = Backup::Database::MongoDB.new(model)
-          mongodb.mongodump_utility.should == 'foo'
-        end
-      end
-    end # describe '#utility_path'
-  end
-end