dm-migrations 0.9.2 → 0.9.3

data/spec/integration/sql_spec.rb

@@ -1,148 +1,158 @@
 require 'pathname'
 require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
 
-if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
-  describe DataMapper::Migration, "#create_table helper" do
-    before do
-      @creator = DataMapper::Migration::TableCreator.new(repository(:default).adapter, :people) do
-        column :name, String
+[:sqlite3, :mysql, :postgres].each do |adapter|
+  next unless eval("HAS_#{adapter.to_s.upcase}")
+  describe "Using Adapter #{adapter}, " do
+    describe DataMapper::Migration, "#create_table helper" do
+      before do
+        @creator = DataMapper::Migration::TableCreator.new(repository(adapter).adapter, :people) do
+          column :name, String
+          column :long_string, String, :size => 200
+        end
       end
-    end
 
-    it "should have a #create_table helper" do
-      @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
-      @migration.should respond_to(:create_table)
-    end
+      it "should have a #create_table helper" do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+        @migration.should respond_to(:create_table)
+      end
 
-    it "should have a table_name" do
-      @creator.table_name.should == "people"
-    end
+      it "should have a table_name" do
+        @creator.table_name.should == "people"
+      end
 
-    it "should have an adapter" do
-      @creator.instance_eval("@adapter").should == repository(:default).adapter
-    end
+      it "should have an adapter" do
+        @creator.instance_eval("@adapter").should == repository(adapter).adapter
+      end
 
-    it "should have an options hash" do
-      @creator.opts.should be_kind_of(Hash)
-      @creator.opts.should == {}
-    end
+      it "should have an options hash" do
+        @creator.opts.should be_kind_of(Hash)
+        @creator.opts.should == {}
+      end
 
-    it "should have an array of columns" do
-      @creator.instance_eval("@columns").should be_kind_of(Array)
-      @creator.instance_eval("@columns").should have(1).item
-      @creator.instance_eval("@columns").first.should be_kind_of(DataMapper::Migration::TableCreator::Column)
-    end
+      it "should have an array of columns" do
+        @creator.instance_eval("@columns").should be_kind_of(Array)
+        @creator.instance_eval("@columns").should have(2).items
+        @creator.instance_eval("@columns").first.should be_kind_of(DataMapper::Migration::TableCreator::Column)
+      end
+
+      it "should quote the table name for the adapter" do
+        @creator.quoted_table_name.should == (adapter == :mysql ? '`people`' : '"people"')
+      end
+      
+      it "should allow for custom options" do
+        columns = @creator.instance_eval("@columns")
+        col = columns.detect{|c| c.name == "long_string"}
+        col.instance_eval("@type").should include("200") 
+      end
 
-    it "should quote the table name for the adapter" do
-      @creator.quoted_table_name.should == '"people"'
     end
 
-  end
+    describe DataMapper::Migration, "#modify_table helper" do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+      end
 
-  describe DataMapper::Migration, "#modify_table helper" do
-    before do
-      @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
-    end
+      it "should have a #modify_table helper" do
+        @migration.should respond_to(:modify_table)
+      end
 
-    it "should have a #modify_table helper" do
-      @migration.should respond_to(:modify_table)
     end
 
-  end
+    describe DataMapper::Migration, "other helpers" do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+      end
 
-  describe DataMapper::Migration, "other helpers" do
-    before do
-      @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
-    end
+      it "should have a #drop_table helper" do
+        @migration.should respond_to(:drop_table)
+      end
 
-    it "should have a #drop_table helper" do
-      @migration.should respond_to(:drop_table)
     end
 
-  end
+    describe DataMapper::Migration, "version tracking" do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) do
+          up   { :ran_up }
+          down { :ran_down }
+        end
 
-  describe DataMapper::Migration, "version tracking" do
-    before do
-      @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) do
-        up   { :ran_up }
-        down { :ran_down }
+        @migration.send(:create_migration_info_table_if_needed)
       end
 
-      @migration.send(:create_migration_info_table_if_needed)
-    end
-
-    def insert_migration_record
-      DataMapper.repository.adapter.execute("INSERT INTO migration_info (migration_name) VALUES ('create_people_table')")
-    end
+      def insert_migration_record
+        DataMapper.repository.adapter.execute("INSERT INTO migration_info (migration_name) VALUES ('create_people_table')")
+      end
 
-    it "should know if the migration_info table exists" do
-      @migration.send(:migration_info_table_exists?).should be_true
-    end
+      it "should know if the migration_info table exists" do
+        @migration.send(:migration_info_table_exists?).should be_true
+      end
 
-    it "should know if the migration_info table does not exist" do
-      repository.adapter.execute("DROP TABLE migration_info") rescue nil
-      @migration.send(:migration_info_table_exists?).should be_false
-    end
+      it "should know if the migration_info table does not exist" do
+        repository.adapter.execute("DROP TABLE migration_info") rescue nil
+        @migration.send(:migration_info_table_exists?).should be_false
+      end
 
-    it "should be able to find the migration_info record for itself" do
-      insert_migration_record
-      @migration.send(:migration_record).should_not be_empty
-    end
+      it "should be able to find the migration_info record for itself" do
+        insert_migration_record
+        @migration.send(:migration_record).should_not be_empty
+      end
 
-    it "should know if a migration needs_up?" do
-      @migration.send(:needs_up?).should be_true
-      insert_migration_record
-      @migration.send(:needs_up?).should be_false
-    end
+      it "should know if a migration needs_up?" do
+        @migration.send(:needs_up?).should be_true
+        insert_migration_record
+        @migration.send(:needs_up?).should be_false
+      end
 
-    it "should know if a migration needs_down?" do
-      @migration.send(:needs_down?).should be_false
-      insert_migration_record
-      @migration.send(:needs_down?).should be_true
-    end
+      it "should know if a migration needs_down?" do
+        @migration.send(:needs_down?).should be_false
+        insert_migration_record
+        @migration.send(:needs_down?).should be_true
+      end
 
-    it "should properly quote the migration_info table for use in queries" do
-      @migration.send(:migration_info_table).should == '"migration_info"'
-    end
+      it "should properly quote the migration_info table for use in queries" do
+        @migration.send(:migration_info_table).should == '"migration_info"'
+      end
 
-    it "should properly quote the migration_info.migration_name column for use in queries" do
-      @migration.send(:migration_name_column).should == '"migration_name"'
-    end
+      it "should properly quote the migration_info.migration_name column for use in queries" do
+        @migration.send(:migration_name_column).should == '"migration_name"'
+      end
 
-    it "should properly quote the migration's name for use in queries"
-    # TODO how to i call the adapter's #escape_sql method?
+      it "should properly quote the migration's name for use in queries"
+      # TODO how to i call the adapter's #escape_sql method?
 
-    it "should create the migration_info table if it doesn't exist" do
-      repository.adapter.execute("DROP TABLE migration_info")
-      @migration.send(:migration_info_table_exists?).should be_false
-      @migration.send(:create_migration_info_table_if_needed)
-      @migration.send(:migration_info_table_exists?).should be_true
-    end
+      it "should create the migration_info table if it doesn't exist" do
+        repository.adapter.execute("DROP TABLE migration_info")
+        @migration.send(:migration_info_table_exists?).should be_false
+        @migration.send(:create_migration_info_table_if_needed)
+        @migration.send(:migration_info_table_exists?).should be_true
+      end
 
-    it "should insert a record into the migration_info table on up" do
-      @migration.send(:migration_record).should be_empty
-      @migration.perform_up.should == :ran_up
-      @migration.send(:migration_record).should_not be_empty
-    end
+      it "should insert a record into the migration_info table on up" do
+        @migration.send(:migration_record).should be_empty
+        @migration.perform_up.should == :ran_up
+        @migration.send(:migration_record).should_not be_empty
+      end
 
-    it "should remove a record from the migration_info table on down" do
-      insert_migration_record
-      @migration.send(:migration_record).should_not be_empty
-      @migration.perform_down.should == :ran_down
-      @migration.send(:migration_record).should be_empty
-    end
+      it "should remove a record from the migration_info table on down" do
+        insert_migration_record
+        @migration.send(:migration_record).should_not be_empty
+        @migration.perform_down.should == :ran_down
+        @migration.send(:migration_record).should be_empty
+      end
 
-    it "should not run the up action if the record exists in the table" do
-      insert_migration_record
-      @migration.perform_up.should_not == :ran_up
-    end
+      it "should not run the up action if the record exists in the table" do
+        insert_migration_record
+        @migration.perform_up.should_not == :ran_up
+      end
 
-    it "should not run the down action if the record does not exist in the table" do
-      @migration.perform_down.should_not == :ran_down
-    end
+      it "should not run the down action if the record does not exist in the table" do
+        @migration.perform_down.should_not == :ran_down
+      end
 
-    after do
-      repository.adapter.execute("DELETE FROM migration_info") rescue Sqlite3Error
+      after do
+        repository.adapter.execute("DELETE FROM migration_info") if @migration.send(:migration_info_table_exists?)
+      end
     end
   end
 end

data/spec/spec.opts

@@ -1,2 +1,3 @@
---format specdoc
 --colour
+--format progress
+

data/spec/spec_helper.rb

@@ -5,24 +5,17 @@ require 'pathname'
 require Pathname(__FILE__).dirname.parent.expand_path + 'lib/dm-migrations'
 require Pathname(__FILE__).dirname.parent.expand_path + 'lib/migration_runner'
 
-#require 'fileutils'
-
-#DB_FILE = "#{Dir.pwd}/migration_test.db"
-#FileUtils.touch DB_FILE
-
-#DataMapper.setup(:default, "sqlite3://#{DB_FILE}")
-#DataMapper::Logger.new(nil, :debug)
-
 def load_driver(name, default_uri)
-  return false if ENV['ADAPTER'] != name.to_s
+  #return false if ENV['ADAPTER'] != name.to_s
 
   lib = "do_#{name}"
 
   begin
-    gem lib, '=0.9.2'
+    gem lib, '=0.9.3'
     require lib
-    DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+    DataMapper.setup(name, default_uri)
     DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]
+    puts "Loaded #{name}"
     true
   rescue Gem::LoadError => e
     warn "Could not load #{lib}: #{e}"

data/spec/unit/migration_spec.rb

@@ -0,0 +1,447 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require Pathname(__FILE__).dirname + '../../lib/migration'
+
+describe 'Migration' do
+
+  before do
+    @adapter = mock('adapter', :class => DataMapper::Adapters::Sqlite3Adapter)
+    @repo = mock('DataMapper.repository', :adapter => @adapter)
+    DataMapper.stub!(:repository).and_return(@repo)
+    @m = DataMapper::Migration.new(1, :do_nothing, {}) {}
+    @m.stub!(:write) # silence any output
+  end
+
+  [:position, :name, :database, :adapter].each do |meth|
+    it "should respond to ##{meth}" do
+      @m.should respond_to(meth)
+    end
+  end
+
+  describe 'initialization' do
+    it 'should set @position from the given position' do
+      @m.instance_variable_get(:@position).should == 1
+    end
+
+    it 'should set @name from the given name' do
+      @m.instance_variable_get(:@name).should == :do_nothing
+    end
+
+    it 'should set @options from the options hash' do
+      @m.instance_variable_get(:@options).should == {}
+    end
+
+    it 'should set @database from the default repository if no :database option is given' do
+      DataMapper.should_receive(:repository).with(:default).and_return(@repo)
+      DataMapper::Migration.new(1, :do_nothing, {}) {}
+    end
+
+    it 'should set @database to the repository specified with the :database option' do
+      DataMapper.should_receive(:repository).with(:foobar).and_return(@repo)
+      DataMapper::Migration.new(1, :do_nothing, :database => :foobar) {}
+    end
+
+    it 'should determine the class of the adapter to be extended' do
+      @adapter.should_receive(:class).and_return(DataMapper::Adapters::Sqlite3Adapter)
+      DataMapper::Migration.new(1, :do_nothing, {}) {}
+    end
+    
+    it 'should extend the adapter with the right module' do
+      @adapter.should_receive(:extend).with(SQL::Sqlite3)
+      DataMapper::Migration.new(1, :do_nothing, {}) {}
+    end
+
+    it 'should raise "Unsupported adapter" on an unknown adapter' do
+      @adapter.should_receive(:class).any_number_of_times.and_return("InvalidAdapter")
+      lambda {
+        DataMapper::Migration.new(1, :do_nothing, {}) {}
+      }.should raise_error
+    end
+
+    it 'should set @verbose from the options hash' do
+      m = DataMapper::Migration.new(1, :do_nothing, :verbose => false) {}
+      m.instance_variable_get(:@verbose).should be_false
+    end
+
+    it 'should set @verbose to true by default' do 
+      @m.instance_variable_get(:@verbose).should be_true
+    end
+  
+    it 'should set the @up_action to an empty block' do
+      @m.instance_variable_get(:@up_action).should be_kind_of(Proc)
+    end
+
+    it 'should set the @down_action to an empty block' do
+      @m.instance_variable_get(:@down_action).should be_kind_of(Proc)
+    end
+
+    it 'should evaluate the given block'
+      
+  end
+
+  it 'should set the @up_action when #up is called with a block' do
+    action = lambda {}
+    @m.up(&action)
+    @m.instance_variable_get(:@up_action).should == action
+  end
+
+  it 'should set the @up_action when #up is called with a block' do
+    action = lambda {}
+    @m.down(&action)
+    @m.instance_variable_get(:@down_action).should == action
+  end
+
+  describe 'perform_up' do
+    before do
+      @up_action = mock('proc', :call => true)
+      @m.instance_variable_set(:@up_action, @up_action)
+      @m.stub!(:needs_up?).and_return(true)
+      @m.stub!(:update_migration_info)
+    end
+
+    it 'should call the action assigned to @up_action and return the result' do
+      @up_action.should_receive(:call).and_return(:result)
+      @m.perform_up.should == :result
+    end
+
+    it 'should output a status message with the position and name of the migration' do
+      @m.should_receive(:write).with(/Performing Up Migration #1: do_nothing/)
+      @m.perform_up
+    end
+
+    it 'should not run if it doesnt need to be' do
+      @m.should_receive(:needs_up?).and_return(false)
+      @up_action.should_not_receive(:call)
+      @m.perform_up
+    end
+
+    it 'should update the migration info table' do
+      @m.should_receive(:update_migration_info).with(:up)
+      @m.perform_up
+    end
+
+    it 'should not update the migration info table if the migration does not need run' do
+      @m.should_receive(:needs_up?).and_return(false)
+      @m.should_not_receive(:update_migration_info)
+      @m.perform_up
+    end
+
+  end
+
+  describe 'perform_down' do
+    before do
+      @down_action = mock('proc', :call => true)
+      @m.instance_variable_set(:@down_action, @down_action)
+      @m.stub!(:needs_down?).and_return(true)
+      @m.stub!(:update_migration_info)
+    end
+
+    it 'should call the action assigned to @down_action and return the result' do
+      @down_action.should_receive(:call).and_return(:result)
+      @m.perform_down.should == :result
+    end
+
+    it 'should output a status message with the position and name of the migration' do
+      @m.should_receive(:write).with(/Performing Down Migration #1: do_nothing/)
+      @m.perform_down
+    end
+
+    it 'should not run if it doesnt need to be' do
+      @m.should_receive(:needs_down?).and_return(false)
+      @down_action.should_not_receive(:call)
+      @m.perform_down
+    end
+
+    it 'should update the migration info table' do
+      @m.should_receive(:update_migration_info).with(:down)
+      @m.perform_down
+    end
+
+    it 'should not update the migration info table if the migration does not need run' do
+      @m.should_receive(:needs_down?).and_return(false)
+      @m.should_not_receive(:update_migration_info)
+      @m.perform_down
+    end
+
+  end
+
+  describe 'methods used in the action blocks' do 
+
+    describe '#execute' do
+      before do
+        @adapter.stub!(:execute)
+      end
+
+      it 'should send the SQL it its executing to the adapter execute method' do
+        @adapter.should_receive(:execute).with('SELECT SOME SQL')
+        @m.execute('SELECT SOME SQL')
+      end
+
+      it 'should output the SQL it is executing' do
+        @m.should_receive(:write).with(/SELECT SOME SQL/)
+        @m.execute('SELECT SOME SQL')
+      end
+    end
+
+    describe 'helpers' do
+      before do
+        @m.stub!(:execute) # don't actually run anything
+      end
+
+      describe '#create_table' do
+        before do
+          @tc = mock('TableCreator', :to_sql => 'CREATE TABLE')
+          SQL::TableCreator.stub!(:new).and_return(@tc)
+        end
+
+        it 'should create a new TableCreator object' do
+          SQL::TableCreator.should_receive(:new).with(@adapter, :users, {}).and_return(@tc)
+          @m.create_table(:users) { }
+        end
+        
+        it 'should convert the TableCreator object to an sql statement' do
+          @tc.should_receive(:to_sql).and_return('CREATE TABLE')
+          @m.create_table(:users) { }
+        end
+
+        it 'should execute the create table sql' do
+          @m.should_receive(:execute).with('CREATE TABLE')
+          @m.create_table(:users) { }
+        end
+
+      end
+
+      describe '#drop_table' do
+        it 'should quote the table name' do
+          @adapter.should_receive(:quote_table_name).with('users')
+          @m.drop_table :users
+        end
+
+        it 'should execute the DROP TABLE sql for the table' do
+          @adapter.stub!(:quote_table_name).and_return("'users'")
+          @m.should_receive(:execute).with(%{DROP TABLE 'users'})
+          @m.drop_table :users
+        end
+
+      end
+
+      describe '#modify_table' do
+        before do
+          @tm = mock('TableModifier', :statements => [])
+          SQL::TableModifier.stub!(:new).and_return(@tm)
+        end
+
+        it 'should create a new TableModifier object' do
+          SQL::TableModifier.should_receive(:new).with(@adapter, :users, {}).and_return(@tm)
+          @m.modify_table(:users){ }
+        end
+
+        it 'should get the statements from the TableModifier object' do
+          @tm.should_receive(:statements).and_return([])
+          @m.modify_table(:users){ }
+        end
+
+        it 'should iterate over the statements and execute each one' do
+          @tm.should_receive(:statements).and_return(['SELECT 1', 'SELECT 2'])
+          @m.should_receive(:execute).with('SELECT 1')
+          @m.should_receive(:execute).with('SELECT 2')
+          @m.modify_table(:users){ }
+        end
+
+      end
+
+      describe 'sorting' do
+        it 'should order things by position' do
+          m1 = DataMapper::Migration.new(1, :do_nothing){}
+          m2 = DataMapper::Migration.new(2, :do_nothing_else){}
+
+          (m1 <=> m2).should == -1
+        end
+
+        it 'should order things by name when they have the same position' do
+          m1 = DataMapper::Migration.new(1, :do_nothing_a){}
+          m2 = DataMapper::Migration.new(1, :do_nothing_b){}
+
+          (m1 <=> m2).should == -1
+        end
+
+      end
+
+      describe 'formatting output' do
+        describe '#say' do
+          it 'should output the message' do
+            @m.should_receive(:write).with(/Paul/)
+            @m.say("Paul")
+          end
+
+          it 'should indent the message with 4 spaces by default' do
+            @m.should_receive(:write).with(/^\s{4}/)
+            @m.say("Paul")
+          end
+
+          it 'should indext the message with a given number of spaces' do
+            @m.should_receive(:write).with(/^\s{3}/)
+            @m.say("Paul", 3)
+          end
+        end
+
+        describe '#say_with_time' do
+          before do
+            @m.stub!(:say)
+          end
+
+          it 'should say the message with an indent of 2' do
+            @m.should_receive(:say).with("Paul", 2)
+            @m.say_with_time("Paul"){}
+          end
+
+          it 'should output the time it took' do
+            @m.should_receive(:say).with(/\d+/, 2)
+            @m.say_with_time("Paul"){}
+          end
+        end
+
+        describe '#write' do
+          before do
+            # need a new migration object, because the main one had #write stubbed to silence output
+            @m = DataMapper::Migration.new(1, :do_nothing) {}
+          end
+
+          it 'should puts the message' do
+            @m.should_receive(:puts).with("Paul")
+            @m.write("Paul")
+          end
+
+          it 'should not puts the message if @verbose is false' do
+            @m.instance_variable_set(:@verbose, false)
+            @m.should_not_receive(:puts)
+            @m.write("Paul")
+          end
+
+        end
+
+      end
+
+      describe 'working with the migration_info table' do
+        before do
+          @adapter.stub!(:storage_exists?).and_return(true)
+          @adapter.stub!(:quote_table_name).and_return(%{'users'})
+          @adapter.stub!(:quote_column_name).and_return(%{'migration_name'})
+        end
+
+        describe '#update_migration_info' do
+          it 'should add a record of the migration' do
+            @m.should_receive(:execute).with(
+              %Q{INSERT INTO 'users' ('migration_name') VALUES ('do_nothing')}
+            )
+            @m.update_migration_info(:up)
+          end
+
+          it 'should remove the record of the migration' do
+            @m.should_receive(:execute).with(
+              %Q{DELETE FROM 'users' WHERE 'migration_name' = 'do_nothing'}
+            )
+            @m.update_migration_info(:down)
+          end
+
+          it 'should try to create the migration_info table' do
+            @m.should_receive(:create_migration_info_table_if_needed)
+            @m.update_migration_info(:up)
+          end
+        end
+
+        describe '#create_migration_info_table_if_needed' do
+          it 'should create the migration info table' do
+            @m.should_receive(:migration_info_table_exists?).and_return(false)
+            @m.should_receive(:execute).with(
+              %Q{CREATE TABLE 'users' ('migration_name' VARCHAR(255) UNIQUE)}
+            )
+            @m.create_migration_info_table_if_needed
+          end
+
+          it 'should not try to create the migration info table if it already exists' do
+            @m.should_receive(:migration_info_table_exists?).and_return(true)
+            @m.should_not_receive(:execute)
+            @m.create_migration_info_table_if_needed
+          end
+        end
+
+        it 'should quote the name of the migration for use in sql' do
+          @m.quoted_name.should == %{'do_nothing'}
+        end
+
+        it 'should query the adapter to see if the migration_info table exists' do
+          @adapter.should_receive(:storage_exists?).with('migration_info').and_return(true)
+          @m.migration_info_table_exists?.should == true
+        end
+
+        describe '#migration_record' do
+          it 'should query for the migration' do
+            @adapter.should_receive(:query).with(
+              %Q{SELECT 'migration_name' FROM 'users' WHERE 'migration_name' = 'do_nothing'}
+            )
+            @m.migration_record
+          end
+
+          it 'should not try to query if the table does not exist' do
+            @m.stub!(:migration_info_table_exists?).and_return(false)
+            @adapter.should_not_receive(:query)
+            @m.migration_record
+          end
+
+        end
+
+        describe '#needs_up?' do
+          it 'should be true if there is no record' do
+            @m.should_receive(:migration_record).and_return([])
+            @m.needs_up?.should == true
+          end
+
+          it 'should be false if the record exists' do
+            @m.should_receive(:migration_record).and_return([:not_empty])
+            @m.needs_up?.should == false
+          end
+
+          it 'should be true if there is no migration_info table' do
+            @m.should_receive(:migration_info_table_exists?).and_return(false)
+            @m.needs_up?.should == true
+          end
+
+        end
+
+        describe '#needs_down?' do
+          it 'should be false if there is no record' do
+            @m.should_receive(:migration_record).and_return([])
+            @m.needs_down?.should == false
+          end
+
+          it 'should be true if the record exists' do
+            @m.should_receive(:migration_record).and_return([:not_empty])
+            @m.needs_down?.should == true
+          end
+
+          it 'should be false if there is no migration_info table' do
+            @m.should_receive(:migration_info_table_exists?).and_return(false)
+            @m.needs_down?.should == false
+          end
+
+        end
+
+        it 'should have the adapter quote the migration_info table' do
+          @adapter.should_receive(:quote_table_name).with('migration_info').and_return("'migration_info'")
+          @m.migration_info_table.should == "'migration_info'"
+        end
+
+        it 'should have a quoted migration_name_column' do
+          @adapter.should_receive(:quote_column_name).with('migration_name').and_return("'migration_name'")
+          @m.migration_name_column.should == "'migration_name'"
+        end
+
+      end
+
+    end
+
+  end
+end
+