backup 3.0.20 → 3.0.21

data/spec/configuration/storage/s3_spec.rb

@@ -12,6 +12,7 @@ describe Backup::Configuration::Storage::S3 do
       s3.path               = 'my_backups'
     end
   end
+  after { Backup::Configuration::Storage::S3.clear_defaults! }
 
   it 'should set the default S3 configuration' do
     s3 = Backup::Configuration::Storage::S3

data/spec/configuration/storage/scp_spec.rb

@@ -13,6 +13,7 @@ describe Backup::Configuration::Storage::SCP do
       scp.keep      = 20
     end
   end
+  after { Backup::Configuration::Storage::SCP.clear_defaults! }
 
   it 'should set the default scp configuration' do
     scp = Backup::Configuration::Storage::SCP

data/spec/configuration/storage/sftp_spec.rb

@@ -13,6 +13,7 @@ describe Backup::Configuration::Storage::SFTP do
       sftp.keep      = 20
     end
   end
+  after { Backup::Configuration::Storage::SFTP.clear_defaults! }
 
   it 'should set the default sftp configuration' do
     sftp = Backup::Configuration::Storage::SFTP

data/spec/configuration/syncer/rsync/base_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require File.expand_path('../../../../spec_helper.rb', __FILE__)
+
+describe Backup::Configuration::Syncer::RSync::Base do
+  before do
+    Backup::Configuration::Syncer::RSync::Base.defaults do |rsync|
+      #rsync.directories         = 'cannot_have_a_default_value'
+      rsync.path                = '~/backups/'
+      rsync.mirror              = true
+      rsync.additional_options  = []
+    end
+  end
+  after { Backup::Configuration::Syncer::RSync::Base.clear_defaults! }
+
+  it 'should set the default rsync configuration' do
+    rsync = Backup::Configuration::Syncer::RSync::Base
+    rsync.path.should               == '~/backups/'
+    rsync.mirror.should             == true
+    rsync.additional_options.should == []
+  end
+
+  describe '#clear_defaults!' do
+    it 'should clear all the defaults, resetting them to nil' do
+      Backup::Configuration::Syncer::RSync::Base.clear_defaults!
+
+      rsync = Backup::Configuration::Syncer::RSync::Base
+      rsync.path.should               == nil
+      rsync.mirror.should             == nil
+      rsync.additional_options.should == nil
+    end
+  end
+end

data/spec/configuration/syncer/rsync/local_spec.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require File.expand_path('../../../../spec_helper.rb', __FILE__)
+
+describe Backup::Configuration::Syncer::RSync::Local do
+  it 'should be a subclass of RSync::Base' do
+    rsync = Backup::Configuration::Syncer::RSync::Local
+    rsync.superclass.should == Backup::Configuration::Syncer::RSync::Base
+  end
+end

data/spec/configuration/syncer/rsync/pull_spec.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require File.expand_path('../../../../spec_helper.rb', __FILE__)
+
+describe Backup::Configuration::Syncer::RSync::Pull do
+  it 'should be a subclass of RSync::Push' do
+    rsync = Backup::Configuration::Syncer::RSync::Pull
+    rsync.superclass.should == Backup::Configuration::Syncer::RSync::Push
+  end
+end

data/spec/configuration/syncer/{rsync_spec.rb → rsync/push_spec.rb}

@@ -1,46 +1,43 @@
 # encoding: utf-8
 
-require File.expand_path('../../../spec_helper.rb', __FILE__)
+require File.expand_path('../../../../spec_helper.rb', __FILE__)
 
-describe Backup::Configuration::Syncer::RSync do
+describe Backup::Configuration::Syncer::RSync::Push do
   before do
-    Backup::Configuration::Syncer::RSync.defaults do |rsync|
+    Backup::Configuration::Syncer::RSync::Push.defaults do |rsync|
       rsync.username  = 'my_username'
       rsync.password  = 'my_password'
       rsync.ip        = '123.45.678.90'
       rsync.port      = 22
-      rsync.path      = '~/backups/'
-      rsync.mirror    = true
       rsync.compress  = true
-      rsync.additional_options = []
     end
   end
+  after { Backup::Configuration::Syncer::RSync::Push.clear_defaults! }
+
+  it 'should be a subclass of RSync::Base' do
+    rsync = Backup::Configuration::Syncer::RSync::Push
+    rsync.superclass.should == Backup::Configuration::Syncer::RSync::Base
+  end
 
   it 'should set the default rsync configuration' do
-    rsync = Backup::Configuration::Syncer::RSync
+    rsync = Backup::Configuration::Syncer::RSync::Push
     rsync.username.should  == 'my_username'
     rsync.password.should  == 'my_password'
     rsync.ip.should        == '123.45.678.90'
     rsync.port.should      == 22
-    rsync.path.should      == '~/backups/'
-    rsync.mirror.should    == true
     rsync.compress.should  == true
-    rsync.additional_options.should == []
   end
 
   describe '#clear_defaults!' do
     it 'should clear all the defaults, resetting them to nil' do
-      Backup::Configuration::Syncer::RSync.clear_defaults!
+      Backup::Configuration::Syncer::RSync::Push.clear_defaults!
 
-      rsync = Backup::Configuration::Syncer::RSync
+      rsync = Backup::Configuration::Syncer::RSync::Push
       rsync.username.should  == nil
       rsync.password.should  == nil
       rsync.ip.should        == nil
       rsync.port.should      == nil
-      rsync.path.should      == nil
-      rsync.mirror.should    == nil
       rsync.compress.should  == nil
-      rsync.additional_options.should == nil
     end
   end
 end

data/spec/configuration/syncer/s3_spec.rb

@@ -9,11 +9,12 @@ describe Backup::Configuration::Syncer::S3 do
       s3.secret_access_key   = 'my_secret_access_key'
       s3.bucket              = 'my-bucket'
       s3.path                = '/backups/'
-      s3.directories         = '/directories/to/backup/'
+      #s3.directories         = 'cannot_have_a_default_value'
       s3.mirror              = true
       s3.additional_options  = ['--exclude="*.rb"']
     end
   end
+  after { Backup::Configuration::Syncer::S3.clear_defaults! }
 
   it 'should set the default s3 configuration' do
     s3 = Backup::Configuration::Syncer::S3
@@ -21,7 +22,6 @@ describe Backup::Configuration::Syncer::S3 do
     s3.secret_access_key.should   == 'my_secret_access_key'
     s3.bucket.should              == 'my-bucket'
     s3.path.should                == '/backups/'
-    s3.directories.should         == '/directories/to/backup/'
     s3.mirror.should              == true
     s3.additional_options.should  == ['--exclude="*.rb"']
   end
@@ -35,7 +35,6 @@ describe Backup::Configuration::Syncer::S3 do
       s3.secret_access_key.should   == nil
       s3.bucket.should              == nil
       s3.path.should                == nil
-      s3.directories.should         == nil
       s3.mirror.should              == nil
       s3.additional_options.should  == nil
     end

data/spec/database/base_spec.rb

@@ -3,37 +3,52 @@
 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) }
 
-  before do
-    class Backup::Database::Base
-      def initialize(&block)
-        instance_eval(&block) if block_given?
-      end
-    end
+  it 'should set #utility_path' do
+    db.utility_path.should be_nil
+    db.utility_path = 'utility path'
+    db.utility_path.should == 'utility path'
   end
 
-  let(:db) do
-    Backup::Database::Base.new do |db|
-      db.utility_path = '/var/usr/my_util'
+  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
 
-  it 'should return the utility path instead of auto-detecting it' do
-    db.utility(:my_database_util).should == '/var/usr/my_util'
+  context 'since CLI::Helpers are included' do
+    it 'should respond to the #utility method' do
+      db.respond_to?(:utility).should be_true
+    end
   end
 
-  it 'should ignore the utility_path when not defined' do
-    db = Backup::Database::Base.new
-    db.utility(:my_database_util).should == :my_database_util
+  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 '#perform!' do
-    it 'should invoke prepare! and log!' do
-      db.expects(:prepare!)
-      db.expects(:log!)
+  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.perform!
+      db.send(:log!)
     end
   end
-
 end

data/spec/database/mongodb_spec.rb

@@ -3,13 +3,9 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Database::MongoDB do
-
-  before do
-    Backup::Database::MongoDB.any_instance.stubs(:load_defaults!)
-  end
-
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
   let(:db) do
-    Backup::Database::MongoDB.new do |db|
+    Backup::Database::MongoDB.new(model) do |db|
       db.name      = 'mydatabase'
       db.username  = 'someuser'
       db.password  = 'secret'
@@ -18,11 +14,14 @@ describe Backup::Database::MongoDB do
 
       db.ipv6               = true
       db.only_collections   = ['users', 'pirates']
-      db.additional_options = ['--query']
+      db.additional_options = ['--query', '--foo']
+      db.mongodump_utility  = '/path/to/mongodump'
+      db.mongo_utility      = '/path/to/mongo'
     end
   end
 
-  describe '#new' do
+  describe '#initialize' do
+
     it 'should read the adapter details correctly' do
       db.name.should      == 'mydatabase'
       db.username.should  == 'someuser'
@@ -30,178 +29,358 @@ describe Backup::Database::MongoDB do
       db.host.should      == 'localhost'
       db.port.should      == 123
 
-      db.only_collections.should == ['users', 'pirates']
-      db.additional_options.should == '--query'
+      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
 
-    it 'arrays should default to empty arrays when not specified' do
-      db = Backup::Database::MongoDB.new do |db|
-        db.name     = 'mydatabase'
-        db.username = 'someuser'
-        db.password = 'secret'
+    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
 
-      db.only_collections.should   == []
-      db.additional_options.should == ""
+      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
-  end
 
-  describe '#only_collections' do
-    it 'should return a string for the mongodump selected table to dump option' do
-      db.collections_to_dump.should == %w[users pirates]
+    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
+  end # describe '#initialize'
 
-  describe '#credential_options' do
-    it 'should return the mongo syntax for the credential options' do
-      db.credential_options.should == "--username='someuser' --password='secret'"
+  describe '#perform!' do
+    let(:s) { sequence '' }
+
+    before do
+      # superclass actions
+      db.expects(:prepare!).in_sequence(s)
+      db.expects(:log!).in_sequence(s)
     end
 
-    it 'should only return the mongo syntax for the user' do
-      db = Backup::Database::MongoDB.new do |db|
-        db.username = 'someuser'
+    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
 
-      db.credential_options.should == "--username='someuser'"
-    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
 
-  describe '#connectivity_options' do
-    it 'should return the mongo syntax for the connectivity options' do
-      db.connectivity_options.should == "--host='localhost' --port='123'"
-    end
+          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'
 
-    it 'should return only the socket' do
-      db = Backup::Database::MongoDB.new do |db|
-        db.host   = ''
-        db.port   = 123
+    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
 
-      db.connectivity_options.should == "--port='123'"
-    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
 
-  describe '#ipv6' do
-    it 'should return a mongodb syntax compatible ipv6 flag' do
-      db.ipv6 = true
-      db.ipv6.should == '--ipv6'
+      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
 
-    it 'should return an empty string' do
-      db.ipv6 = nil
-      db.ipv6.should == ''
+  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 '#mongodump_string' do
-    it 'should return the full mongodump string' do
-      db.expects(:utility).with(:mongodump).returns('mongodump')
-      db.prepare!
-      db.mongodump.should ==
-      "mongodump --db='mydatabase' --username='someuser' --password='secret' " +
-      "--host='localhost' --port='123' --ipv6 --query --out='#{ File.join(Backup::TMP_PATH, Backup::TRIGGER, 'MongoDB') }'"
+  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 '#perform!' do
+  describe '#mongodump' do
     before do
-      db.stubs(:utility).returns('mongodump')
-      db.stubs(:mkdir)
-      db.stubs(:run)
+      db.instance_variable_set(:@dump_path, '/path/to/dump/folder')
     end
 
-    it 'should ensure the directory is available' do
-      db.expects(:mkdir).with(File.join(Backup::TMP_PATH, "myapp", "MongoDB"))
-      db.perform!
+    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
 
-    it 'should run the mongodump command and dump all collections' do
-      db.only_collections = []
-      db.expects(:dump!)
+  describe '#package!' do
+    let(:compressor) { mock }
 
-      db.perform!
-    end
+    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')
+      end
 
-    it 'should run the mongodump command and dump all collections' do
-      db.only_collections = nil
-      db.expects(:dump!)
+      it 'should package the dump directory, then remove it' do
+        timestamp = Time.now.to_i.to_s[-5, 5]
+        db.expects(:run).with(
+          "tar -cf - -C '/path/to/dump' 'folder' | compressor_command" +
+          " > /path/to/dump/folder-#{ timestamp }.tar.gz"
+        )
+        FileUtils.expects(:rm_rf).with('/path/to/dump/folder')
 
-      db.perform!
+        db.send(:package!)
+      end
     end
 
-    it 'should lock database before dump if lock mode is enabled' do
-      db.lock = true
-      db.expects(:lock_database)
+    context 'when a compressor is not configured' do
+      before do
+        model.expects(:compressor).returns(nil)
+      end
 
-      db.perform!
+      it 'should return nil' do
+        db.expects(:run).never
+        db.send(:package!).should be_nil
+      end
     end
+  end
 
-    it 'should not lock database before dump if lock mode is disabled' do
-      db.lock = false
-      db.expects(:lock_database).never
-
-      db.perform!
+  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
 
-    it 'should unlock database after dump if lock mode is enabled' do
-      db.lock = true
-      db.expects(:unlock_database)
+    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
 
-      db.perform!
+  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
 
-    it 'should unlock the database if an exception is raised after it was locked' do
-      db.lock = true
-      db.expects(:unlock_database)
-      db.expects(:lock_database).raises(RuntimeError, 'something went wrong')
-      db.expects(:raise)
+  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
 
-      db.perform!
+  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
 
-    it 'should not unlock database after dump if lock mode is disabled' do
-      db.lock = false
-      db.expects(:unlock_database).never
+    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
 
-      db.perform!
+  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
 
-    it 'should dump only the provided collections' do
-      db.only_collections = %w[users admins profiles]
-      db.expects(:specific_collection_dump!)
+    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
 
-      db.perform!
+  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
 
-    it do
-      Backup::Logger.expects(:message).
-          with("Backup::Database::MongoDB started dumping and archiving 'mydatabase'.")
-      db.perform!
+  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 "#mongo_uri" do
-    before do
-      db.host     = "flame.mongohq.com"
-      db.port     = 12345
-      db.username = "sample_username"
-      db.password = "sample_password"
-      db.ipv6     = nil
+  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
 
-    it "should return URI without database" do
-      db.name = nil
-      db.mongo_uri.should == "flame.mongohq.com:12345 --username='sample_username' --password='sample_password'"
+  describe '#mongo_uri' do
+    before do
+      db.stubs(:credential_options).returns(:credential_options_output)
+      db.stubs(:ipv6_option).returns(:ipv6_option_output)
     end
 
-    it "should return URI without database" do
-      db.name = ""
-      db.mongo_uri.should == "flame.mongohq.com:12345 --username='sample_username' --password='sample_password'"
+    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
 
-    it "should return URI without database" do
-      db.name = "sample_db"
-      db.mongo_uri.should == "flame.mongohq.com:12345/sample_db --username='sample_username' --password='sample_password'"
+    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