backup 3.0.23 → 3.0.24

data/spec/database/base_spec.rb

@@ -6,10 +6,25 @@ describe Backup::Database::Base do
   let(:model) { Backup::Model.new('foo', 'foo') }
   let(:db) { Backup::Database::Base.new(model) }
 
-  it 'should set #utility_path' do
-    db.utility_path.should be_nil
-    db.utility_path = 'utility path'
-    db.utility_path.should == 'utility path'
+  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
@@ -22,12 +37,6 @@ describe Backup::Database::Base do
     end
   end
 
-  context 'since CLI::Helpers are included' do
-    it 'should respond to the #utility method' do
-      db.respond_to?(:utility).should be_true
-    end
-  end
-
   describe '#prepare!' do
     it 'should set and create #dump_path' do
       model = stub(:trigger => 'test_trigger')

data/spec/database/mongodb_spec.rb

@@ -17,86 +17,127 @@ describe Backup::Database::MongoDB do
       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 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
+    it 'should load pre-configured defaults through Base' do
+      Backup::Database::MongoDB.any_instance.expects(:load_defaults!)
+      db
     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 pass the model reference to Base' do
+      db.instance_variable_get(:@model).should == model
+    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
+    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
-    end
 
-    context 'when configuration defaults have been set' do
-      after { Backup::Configuration::Database::MongoDB.clear_defaults! }
+      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'
 
-      it 'should use configuration defaults' do
-        Backup::Configuration::Database::MongoDB.defaults do |db|
+    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               = true
+          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               = true
+          db.lock               = 'default_lock'
         end
+      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
+      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
-    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
@@ -109,6 +150,7 @@ describe Backup::Database::MongoDB do
     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 = [] }
@@ -138,7 +180,6 @@ describe Backup::Database::MongoDB do
     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 = [] }
@@ -171,6 +212,8 @@ describe Backup::Database::MongoDB do
 
     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
@@ -186,8 +229,6 @@ describe Backup::Database::MongoDB do
       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')
@@ -239,6 +280,9 @@ describe Backup::Database::MongoDB do
 
   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
@@ -247,18 +291,62 @@ describe Backup::Database::MongoDB do
         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
 
-      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')
+      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
 
-        db.send(:package!)
-      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
@@ -267,11 +355,11 @@ describe Backup::Database::MongoDB do
       end
 
       it 'should return nil' do
-        db.expects(:run).never
+        Backup::Pipeline.expects(:new).never
         db.send(:package!).should be_nil
       end
     end
-  end
+  end # describe '#package!'
 
   describe '#database' do
     context 'when a database name is given' do
@@ -383,4 +471,41 @@ describe Backup::Database::MongoDB do
       end
     end
   end
+
+  describe 'deprecations' do
+    after do
+      Backup::Database::MongoDB.clear_defaults!
+    end
+
+    describe '#utility_path' do
+      before do
+        Backup::Database::MongoDB.any_instance.stubs(:utility)
+        Backup::Logger.expects(:warn).with(
+          instance_of(Backup::Errors::ConfigurationError)
+        )
+        Backup::Logger.expects(:warn).with(
+          "Backup::Database::MongoDB.mongodump_utility is being set to 'foo'"
+        )
+      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

data/spec/database/mysql_spec.rb

@@ -20,49 +20,66 @@ describe Backup::Database::MySQL do
     end
   end
 
+  it 'should be a subclass of Database::Base' do
+    Backup::Database::MySQL.superclass.
+      should == Backup::Database::Base
+  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'
+
+    it 'should load pre-configured defaults through Base' do
+      Backup::Database::MySQL.any_instance.expects(:load_defaults!)
+      db
     end
 
-    context 'when options are not set' do
-      before do
-        Backup::Database::MySQL.any_instance.expects(:utility).
-            with(:mysqldump).returns('/real/mysqldump')
+    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.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
       end
 
-      it 'should use default values' do
-        db = Backup::Database::MySQL.new(model)
+      context 'when options are not specified' do
+        before do
+          Backup::Database::MySQL.any_instance.expects(:utility).
+              with(:mysqldump).returns('/real/mysqldump')
+        end
 
-        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
+        it 'should provide default values' do
+          db = Backup::Database::MySQL.new(model)
 
-        db.skip_tables.should         == []
-        db.only_tables.should         == []
-        db.additional_options.should  == []
-        db.mysqldump_utility.should  == '/real/mysqldump'
-      end
-    end
+          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
 
-    context 'when configuration defaults have been set' do
-      after { Backup::Configuration::Database::MySQL.clear_defaults! }
+          db.skip_tables.should         == []
+          db.only_tables.should         == []
+          db.additional_options.should  == []
+          db.mysqldump_utility.should  == '/real/mysqldump'
+        end
+      end
+    end # context 'when no pre-configured defaults have been set'
 
-      it 'should use configuration defaults' do
-        Backup::Configuration::Database::MySQL.defaults do |db|
+    context 'when pre-configured defaults have been set' do
+      before do
+        Backup::Database::MySQL.defaults do |db|
           db.name       = 'db_name'
           db.username   = 'db_username'
           db.password   = 'db_password'
@@ -75,25 +92,50 @@ describe Backup::Database::MySQL do
           db.additional_options = ['--add', '--opts']
           db.mysqldump_utility  = '/default/path/to/mysqldump'
         end
+      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'
+      after { Backup::Database::MySQL.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.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
       end
-    end
+
+      context 'when options are not specified' do
+        it 'should use the pre-configured defaults' do
+          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 # context 'when no pre-configured defaults have been set'
   end # describe '#initialize'
 
   describe '#perform!' do
     let(:s) { sequence '' }
+    let(:pipeline) { mock }
+
     before do
       # superclass actions
       db.expects(:prepare!).in_sequence(s)
@@ -102,17 +144,25 @@ describe Backup::Database::MySQL do
 
       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).in_sequence(s).returns(nil)
+        model.expects(:compressor).returns(nil)
       end
 
       it 'should run mysqldump without compression' do
-        db.expects(:run).in_sequence(s).with(
-          "mysqldump_command > '/dump/path/dump_filename.sql'"
+        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
@@ -120,18 +170,46 @@ describe Backup::Database::MySQL do
     context 'when a compressor is configured' do
       before do
         compressor = mock
-        model.expects(:compressor).twice.in_sequence(s).returns(compressor)
-        compressor.expects(:compress_with).in_sequence(s).yields('gzip', '.gz')
+        model.expects(:compressor).twice.returns(compressor)
+        compressor.expects(:compress_with).yields('gzip', '.gz')
       end
 
       it 'should run mysqldump with compression' do
-        db.expects(:run).in_sequence(s).with(
-          "mysqldump_command | gzip > '/dump/path/dump_filename.sql.gz'"
+        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
@@ -261,18 +339,22 @@ describe Backup::Database::MySQL do
         "--ignore-table='mydatabase.logs' --ignore-table='mydatabase.profiles'"
     end
 
-    context 'when #skip_tables is not set' do
-      before { db.skip_tables = [] }
-      it 'should return an empty string' do
-        db.send(:tables_to_skip).should == ''
-      end
+    it 'should return an empty string if #skip_tables is empty' do
+      db.skip_tables = []
+      db.send(:tables_to_skip).should == ''
     end
 
-    context 'when dump_all? is true' do
-      before { db.stubs(:dump_all?).returns(true) }
-      it 'should return nil' do
-        db.send(:tables_to_skip).should be_nil
-      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
 
@@ -290,4 +372,41 @@ describe Backup::Database::MySQL do
       end
     end
   end
+
+  describe 'deprecations' do
+    after do
+      Backup::Database::MySQL.clear_defaults!
+    end
+
+    describe '#utility_path' do
+      before do
+        Backup::Database::MySQL.any_instance.stubs(:utility)
+        Backup::Logger.expects(:warn).with(
+          instance_of(Backup::Errors::ConfigurationError)
+        )
+        Backup::Logger.expects(:warn).with(
+          "Backup::Database::MySQL.mysqldump_utility is being set to 'foo'"
+        )
+      end
+
+      context 'when set directly' do
+        it 'should issue a deprecation warning and set the replacement value' do
+          mysql = Backup::Database::MySQL.new(model) do |db|
+            db.utility_path = 'foo'
+          end
+          mysql.mysqldump_utility.should == 'foo'
+        end
+      end
+
+      context 'when set as a default' do
+        it 'should issue a deprecation warning and set the replacement value' do
+          mysql = Backup::Database::MySQL.defaults do |db|
+            db.utility_path = 'foo'
+          end
+          mysql = Backup::Database::MySQL.new(model)
+          mysql.mysqldump_utility.should == 'foo'
+        end
+      end
+    end # describe '#utility_path'
+  end
 end