schema_plus 0.4.1 → 1.0.0

data/spec/foreign_key_definition_spec.rb

@@ -2,10 +2,6 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Foreign Key definition" do
 
-  before(:all) do
-    load_core_schema
-  end
-
   let(:definition) { SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id) }
 
   it "it is dumped to sql with quoted values" do

data/spec/foreign_key_spec.rb

@@ -1,16 +1,22 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-require 'models/user'
-require 'models/post'
-require 'models/comment'
-
 describe "Foreign Key" do
-  
+
   let(:migration) { ::ActiveRecord::Migration }
 
   context "created with table" do
     before(:all) do
-      load_auto_schema
+      define_schema(:auto_create => true) do
+        create_table :users, :force => true do |t|
+          t.string :login
+        end
+        create_table :comments, :force => true do |t|
+          t.integer :user_id
+          t.foreign_key :user_id, :users, :id
+        end
+      end
+      class User < ::ActiveRecord::Base ; end
+      class Comment < ::ActiveRecord::Base ; end
     end
 
     it "should report foreign key constraints" do
@@ -26,7 +32,27 @@ describe "Foreign Key" do
   context "modification" do
 
     before(:all) do
-      load_core_schema
+      define_schema(:auto_create => false) do
+        create_table :users, :force => true do |t|
+          t.string :login
+          t.datetime :deleted_at
+        end
+
+        create_table :posts, :force => true do |t|
+          t.text :body
+          t.integer :user_id
+          t.integer :author_id
+        end
+
+        create_table :comments, :force => true do |t|
+          t.text :body
+          t.integer :post_id
+          t.foreign_key :post_id, :posts, :id
+        end
+      end
+      class User < ::ActiveRecord::Base ; end
+      class Post < ::ActiveRecord::Base ; end
+      class Comment < ::ActiveRecord::Base ; end
     end
 
     if SchemaPlusHelpers.sqlite3?
@@ -34,13 +60,13 @@ describe "Foreign Key" do
       it "raises an exception when attempting to add" do
         expect { 
           add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
-        }.should raise_error(NotImplementedError)
+        }.to raise_error(NotImplementedError)
       end
 
       it "raises an exception when attempting to remove" do
         expect { 
           remove_foreign_key(:posts, "dummy")
-        }.should raise_error(NotImplementedError)
+        }.to raise_error(NotImplementedError)
       end
 
     else
@@ -102,8 +128,6 @@ describe "Foreign Key" do
           Post.reverse_foreign_keys.collect(&:column_names).should_not include(%w[post_id])
         end
 
-        it "removes auto-generated index"
-
       end
 
       context "when referencing column and column is removed" do
@@ -117,7 +141,7 @@ describe "Foreign Key" do
 
       end
 
-      context "when table name is a rerved word" do
+      context "when table name is a reserved word" do
         before(:each) do
           migration.suppress_messages do
             migration.create_table :references, :force => true do |t|
@@ -132,7 +156,7 @@ describe "Foreign Key" do
               migration.add_foreign_key(:references, :post_id, :posts, :id)
               foreign_key = migration.foreign_keys(:references).detect{|definition| definition.column_names == ["post_id"]}
               migration.remove_foreign_key(:references, foreign_key.name)
-            }.should_not raise_error
+            }.to_not raise_error
           end
         end
       end

data/spec/index_definition_spec.rb

@@ -6,7 +6,27 @@ describe "Index definition" do
   let(:migration) { ::ActiveRecord::Migration }
   
   before(:all) do
-    load_core_schema
+    define_schema(:auto_create => false) do
+      create_table :users, :force => true do |t|
+        t.string :login
+        t.datetime :deleted_at
+      end
+
+      create_table :posts, :force => true do |t|
+        t.text :body
+        t.integer :user_id
+        t.integer :author_id
+      end
+
+      create_table :comments, :force => true do |t|
+        t.text :body
+        t.integer :post_id
+        t.foreign_key :post_id, :posts, :id
+      end
+    end
+    class User < ::ActiveRecord::Base ; end
+    class Post < ::ActiveRecord::Base ; end
+    class Comment < ::ActiveRecord::Base ; end
   end
 
   around(:each) do |example|
@@ -27,7 +47,7 @@ describe "Index definition" do
     end
 
     it "is included in User.indexes" do
-      User.indexes.select { |index| index.columns == %w[login deleted_at] }.should have(1).item
+      @index.should_not be_nil
     end
 
   end
@@ -41,6 +61,38 @@ describe "Index definition" do
     end
   end
 
+  it "should not crash on equality test with nil" do
+    index = ActiveRecord::ConnectionAdapters::IndexDefinition.new(:table, :column)
+    expect{index == nil}.to_not raise_error
+    (index == nil).should be_false
+  end
+
+
+  unless SchemaPlusHelpers.mysql?
+    context "when index is ordered" do
+
+      quotes = [
+        ["unquoted", ''],
+        ["double-quoted", '"'],
+      ]
+      quotes += [
+        ["single-quoted", "'"],
+        ["back-quoted", '`']
+      ] if SchemaPlusHelpers.sqlite3?
+
+      quotes.each do |quotename, quote|
+        it "index definition includes orders for #{quotename} columns" do
+          migration.execute "CREATE INDEX users_login_index ON users (#{quote}login#{quote} DESC, #{quote}deleted_at#{quote} ASC)"
+          User.reset_column_information
+          index = index_definition(%w[login deleted_at])
+          index.orders.should == {"login" => :desc, "deleted_at" => :asc}
+        end
+
+      end
+    end
+  end
+
+
   if SchemaPlusHelpers.postgresql?
 
     context "when case insensitive is added" do

data/spec/index_spec.rb

@@ -1,11 +1,29 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-require 'models/user'
-
 describe "add_index" do
-  
+
   before(:all) do
-    load_core_schema
+    define_schema(:auto_create => false) do
+      create_table :users, :force => true do |t|
+        t.string :login
+        t.datetime :deleted_at
+      end
+
+      create_table :posts, :force => true do |t|
+        t.text :body
+        t.integer :user_id
+        t.integer :author_id
+      end
+
+      create_table :comments, :force => true do |t|
+        t.text :body
+        t.integer :post_id
+        t.foreign_key :post_id, :posts, :id
+      end
+    end
+    class User < ::ActiveRecord::Base ; end
+    class Post < ::ActiveRecord::Base ; end
+    class Comment < ::ActiveRecord::Base ; end
   end
 
   let(:migration) { ::ActiveRecord::Migration }
@@ -31,21 +49,27 @@ describe "add_index" do
     index_for(:login).name.should == 'users_login_index'
   end
 
+  unless SchemaPlusHelpers.mysql?
+    it "should assign order" do
+      add_index(:users, [:login, :deleted_at], :order => {:login => :desc, :deleted_at => :asc})
+      index_for([:login, :deleted_at]).orders.should == {"login" => :desc, "deleted_at" => :asc}
+    end
+  end
+
+
   context "for duplicate index" do
     it "should not complain if the index is the same" do
       add_index(:users, :login)
       index_for(:login).should_not be_nil
       ActiveRecord::Base.logger.should_receive(:warn).with(/login.*Skipping/)
-      expect { add_index(:users, :login) }.should_not raise_error
+      expect { add_index(:users, :login) }.to_not raise_error
       index_for(:login).should_not be_nil
     end
-    if ActiveRecord::VERSION::STRING >= "3.0"
-      it "should complain if the index is different" do
-        add_index(:users, :login, :unique => true)
-        index_for(:login).should_not be_nil
-        expect { add_index(:users, :login) }.should raise_error
-        index_for(:login).should_not be_nil
-      end
+    it "should complain if the index is different" do
+      add_index(:users, :login, :unique => true)
+      index_for(:login).should_not be_nil
+      expect { add_index(:users, :login) }.to raise_error
+      index_for(:login).should_not be_nil
     end
   end
 
@@ -56,19 +80,39 @@ describe "add_index" do
       index_for(:login).conditions.should == '(deleted_at IS NULL)'
     end
 
-    it "should assign expression" do
+    it "should assign expression, conditions and kind" do
       add_index(:users, :expression => "USING hash (upper(login)) WHERE deleted_at IS NULL", :name => 'users_login_index')
       @index = User.indexes.detect { |i| i.expression.present? }
       @index.expression.should == "upper((login)::text)"
       @index.conditions.should == "(deleted_at IS NULL)"
+      @index.kind.should       == "hash"
+    end
+
+    it "should allow to specify expression, conditions and kind separately" do
+      add_index(:users, :kind => "hash", :expression => "upper(login)", :conditions => "deleted_at IS NULL", :name => 'users_login_index')
+      @index = User.indexes.detect { |i| i.expression.present? }
+      @index.expression.should == "upper((login)::text)"
+      @index.conditions.should == "(deleted_at IS NULL)"
+      @index.kind.should       == "hash"
+    end
+
+    it "should allow to specify kind" do
+      add_index(:users, :login, :kind => "hash")
+      index_for(:login).kind.should == 'hash'
+    end
+
+    it "should allow to specify actual expression only" do
+      add_index(:users, :expression => "upper(login)", :name => 'users_login_index')
+      @index = User.indexes.detect { |i| i.expression.present? }
+      @index.expression.should == "upper((login)::text)"
     end
 
     it "should raise if no column given and expression is missing" do
-      expect { add_index(:users, :name => 'users_login_index') }.should raise_error(ArgumentError)
+      expect { add_index(:users, :name => 'users_login_index') }.to raise_error(ArgumentError)
     end
 
     it "should raise if expression without name is given" do
-      expect { add_index(:users, :expression => "USING btree (login)") }.should raise_error(ArgumentError)
+      expect { add_index(:users, :expression => "USING btree (login)") }.to raise_error(ArgumentError)
     end
 
   end # of postgresql specific examples

data/spec/migration_spec.rb

@@ -5,7 +5,34 @@ describe ActiveRecord::Migration do
   include SchemaPlusHelpers
 
   before(:all) do
-    load_auto_schema
+    define_schema(:auto_create => true) do
+
+      create_table :users, :force => true do |t|
+        t.string :login, :index => { :unique => true }
+      end
+
+      create_table :members, :force => true do |t|
+        t.string :login
+      end
+
+      create_table :comments, :force => true do |t|
+        t.string :content
+        t.integer :user
+        t.integer :user_id
+        t.foreign_key :user_id, :users, :id
+      end
+
+      create_table :posts, :force => true do |t|
+        t.string :content
+      end
+    end
+    class User < ::ActiveRecord::Base ; end
+    class Post < ::ActiveRecord::Base ; end
+    class Comment < ::ActiveRecord::Base ; end
+  end
+
+  around(:each) do |example|
+    with_fk_config(:auto_create => true, :auto_index => true) { example.run }
   end
 
   context "when table is created" do
@@ -15,107 +42,184 @@ describe ActiveRecord::Migration do
     end
 
     it "should properly handle default values for booleans" do
-      expect { create_table(@model,  :bool => { :METHOD => :boolean, :default => true }) }.should_not raise_error
+      expect {
+        recreate_table(@model) do |t|
+         t.boolean :bool, :default => true
+        end
+      }.to_not raise_error
       @model.create.reload.bool.should be_true
     end
 
-    it "should create foreign keys" do
-      create_table(@model,  :user_id => {}, 
-                          :author_id => { :references => :users },
-                          :member_id => { :references => nil } )
+    it "should create auto foreign keys" do
+      recreate_table(@model) do |t|
+        t.integer :user_id
+      end
       @model.should reference(:users, :id).on(:user_id)
+    end
+
+    it "should create explicit foreign key with default reference" do
+      recreate_table(@model) do |t|
+        t.integer :user, :foreign_key => true
+      end
+      @model.should reference(:users, :id).on(:user)
+    end
+
+    it "should create foreign key with different reference" do
+      recreate_table(@model) do |t|
+        t.integer :author_id, :foreign_key => { :references => :users }
+      end
+      @model.should reference(:users, :id).on(:author_id)
+    end
+
+    it "should create foreign key with different reference using shortcut" do
+      recreate_table(@model) do |t|
+        t.integer :author_id, :references => :users
+      end
       @model.should reference(:users, :id).on(:author_id)
+    end
+
+    it "should create foreign key with specified name" do
+      recreate_table @model do |t|
+        t.integer :user_id, :foreign_key => { :name => "wugga" }
+      end
+      @model.should reference(:users, :id).with_name("wugga")
+    end
+
+    it "should suppress foreign key" do
+      recreate_table(@model) do |t|
+        t.integer :member_id, :foreign_key => false
+      end
+      @model.should_not reference.on(:member_id)
+    end
+
+    it "should suppress foreign key using shortcut" do
+      recreate_table(@model) do |t|
+        t.integer :member_id, :references => nil
+      end
       @model.should_not reference.on(:member_id)
     end
 
     it "should create foreign key using t.belongs_to" do
-      create_table(@model,  :user => {:METHOD => :belongs_to})
+      recreate_table(@model) do |t|
+        t.belongs_to :user
+      end
       @model.should reference(:users, :id).on(:user_id)
     end
 
     it "should not create foreign key using t.belongs_to with :polymorphic => true" do
-      create_table(@model,  :user => {:METHOD => :belongs_to, :polymorphic => true})
+      recreate_table(@model) do |t|
+        t.belongs_to :user, :polymorphic => true
+      end
       @model.should_not reference(:users, :id).on(:user_id)
     end
 
     it "should create foreign key using t.references" do
-      create_table(@model,  :user => {:METHOD => :references})
+      recreate_table(@model) do |t|
+        t.references :user
+      end
       @model.should reference(:users, :id).on(:user_id)
     end
 
-    it "should not create foreign key using t.references with :references => nil" do
-      create_table(@model,  :user => {:METHOD => :references, :references => nil})
+    it "should not create foreign key using t.references with :foreign_key => false" do
+      recreate_table(@model) do |t|
+        t.references :user, :foreign_key => false
+      end
       @model.should_not reference(:users, :id).on(:user_id)
     end
 
     it "should not create foreign key using t.references with :polymorphic => true" do
-      create_table(@model,  :user => {:METHOD => :references, :polymorphic => true})
+      recreate_table(@model) do |t|
+        t.references :user, :polymorphic => true
+      end
       @model.should_not reference(:users, :id).on(:user_id)
     end
 
     it "should create foreign key to the same table on parent_id" do
-      create_table(@model,  :parent_id => {})
+      recreate_table(@model) do |t|
+        t.integer :parent_id
+      end
       @model.should reference(@model.table_name, :id).on(:parent_id)
     end
 
     it "should create an index if specified on column" do
-      create_table(@model, :state => { :index => true }) 
+      recreate_table(@model) do |t|
+        t.integer :state, :index => true 
+      end
       @model.should have_index.on(:state)
     end
 
     it "should create a unique index if specified on column" do
-      create_table(@model, :state => { :index => {:unique => true} }) 
+      recreate_table(@model) do |t|
+        t.integer :state, :index => { :unique => true }
+      end
       @model.should have_unique_index.on(:state)
     end
+
     it "should create a unique index if specified on column using shorthand" do
-      create_table(@model, :state => { :index => :unique }) 
+      recreate_table(@model) do |t|
+        t.integer :state, :index => :unique
+      end
       @model.should have_unique_index.on(:state)
     end
 
     it "should create an index if specified explicitly" do
-      create_table_opts(@model, {}, {:state => {}}, {:state => {}}) 
+      recreate_table(@model) do |t|
+        t.integer :state
+        t.index :state
+      end
       @model.should have_index.on(:state)
     end
 
     it "should create a unique index if specified explicitly" do
-      create_table_opts(@model, {}, {:state => {}}, {:state => {:unique => true}}) 
+      recreate_table(@model) do |t|
+        t.integer :state
+        t.index :state, :unique => true
+      end
       @model.should have_unique_index.on(:state)
     end
 
     it "should create a multiple-column index if specified" do
-      create_table(@model, :city => {},
-                   :state => { :index => {:with => :city} } ) 
+      recreate_table(@model) do |t|
+        t.integer :city
+        t.integer :state,       :index => { :with => :city }
+      end
       @model.should have_index.on([:state, :city])
     end
     
     it "should auto-index foreign keys only" do
-      with_fk_config(:auto_index => true) do
-        create_table(@model,  :user_id => {},
-                     :application_id => { :references => nil },
-                     :state => {})
-        @model.should have_index.on(:user_id)
-        @model.should_not have_index.on(:application_id)
-        @model.should_not have_index.on(:state)
+      recreate_table(@model) do |t|
+        t.integer :user_id
+        t.integer :application_id, :references => nil
+        t.integer :state
       end
+      @model.should have_index.on(:user_id)
+      @model.should_not have_index.on(:application_id)
+      @model.should_not have_index.on(:state)
     end
 
     it "should override foreign key auto_create positively" do
       with_fk_config(:auto_create => false) do
-        create_table_opts(@model, {:foreign_keys => {:auto_create => true}}, :user_id => {})
+        recreate_table @model, :foreign_keys => {:auto_create => true} do |t|
+          t.integer :user_id
+        end
         @model.should reference(:users, :id).on(:user_id)
       end
     end
 
     it "should override foreign key auto_create negatively" do
       with_fk_config(:auto_create => true) do
-        create_table_opts(@model, {:foreign_keys => {:auto_create => false}}, :user_id => {})
+        recreate_table @model, :foreign_keys => {:auto_create => false} do |t|
+          t.integer :user_id
+        end
         @model.should_not reference.on(:user_id)
       end
     end
 
     it "should override foreign key auto_index positively" do
       with_fk_config(:auto_index => false) do 
-        create_table_opts(@model, {:foreign_keys => {:auto_index => true}}, :user_id => {})
+        recreate_table @model, :foreign_keys => {:auto_index => true} do |t|
+          t.integer :user_id
+        end
         @model.should have_index.on(:user_id)
       end
     end
@@ -125,87 +229,137 @@ describe ActiveRecord::Migration do
     if SchemaPlusHelpers.mysql?
       actions.delete(:set_default)
       it "should raise a not-implemented error for on_update => :set_default" do
-        expect { create_table(@model, :user_id => {:on_update => :set_default}) }.should raise_error(NotImplementedError)
+        expect {
+          recreate_table @model do |t|
+            t.integer :user_id, :foreign_key => { :on_update => :set_default }
+          end
+        }.to raise_error(NotImplementedError)
       end
 
       it "should raise a not-implemented error for on_delete => :set_default" do
-        expect { create_table(@model, :user_id => {:on_delete => :set_default}) }.should raise_error(NotImplementedError)
+        expect {
+          recreate_table @model do |t|
+            t.integer :user_id, :foreign_key => { :on_delete => :set_default }
+          end
+        }.to raise_error(NotImplementedError)
       end
     end
 
     actions.each do |action|
       it "should create and detect on_update #{action.inspect}" do
-        create_table(@model, :user_id => {:on_update => action})
+        recreate_table @model do |t|
+          t.integer :user_id,   :foreign_key => { :on_update => action }
+        end
+        @model.should reference.on(:user_id).on_update(action)
+      end
+
+      it "should create and detect on_update #{action.inspect} using shortcut" do
+        recreate_table @model do |t|
+          t.integer :user_id,   :on_update => action
+        end
         @model.should reference.on(:user_id).on_update(action)
       end
 
       it "should create and detect on_delete #{action.inspect}" do
-        create_table(@model, :user_id => {:on_delete => action})
+        recreate_table @model do |t|
+          t.integer :user_id,   :foreign_key => { :on_delete => action }
+        end
+        @model.should reference.on(:user_id).on_delete(action)
+      end
+
+      it "should create and detect on_delete #{action.inspect} using shortcut" do
+        recreate_table @model do |t|
+          t.integer :user_id,   :on_delete => action
+        end
         @model.should reference.on(:user_id).on_delete(action)
       end
     end
 
     it "should use default on_update action" do
       with_fk_config(:on_update => :cascade) do
-        create_table_opts(@model, {:foreign_keys => {}}, :user_id => {})
+        recreate_table @model do |t|
+          t.integer :user_id
+        end
         @model.should reference.on(:user_id).on_update(:cascade)
       end
     end
 
     it "should use default on_delete action" do
       with_fk_config(:on_delete => :cascade) do
-        create_table_opts(@model, {:foreign_keys => {}}, :user_id => {})
+        recreate_table @model do |t|
+          t.integer :user_id
+        end
         @model.should reference.on(:user_id).on_delete(:cascade)
       end
     end
 
     it "should override on_update action per table" do
       with_fk_config(:on_update => :cascade) do
-        create_table_opts(@model, {:foreign_keys => {:on_update => :restrict}}, :user_id => {})
+        recreate_table @model, :foreign_keys => {:on_update => :restrict} do |t|
+          t.integer :user_id
+        end
         @model.should reference.on(:user_id).on_update(:restrict)
       end
     end
 
     it "should override on_delete action per table" do
       with_fk_config(:on_delete => :cascade) do
-        create_table_opts(@model, {:foreign_keys => {:on_delete => :restrict}}, :user_id => {})
+        recreate_table @model, :foreign_keys => {:on_delete => :restrict} do |t|
+          t.integer :user_id
+        end
         @model.should reference.on(:user_id).on_delete(:restrict)
       end
     end
 
     it "should override on_update action per column" do
       with_fk_config(:on_update => :cascade) do
-        create_table_opts(@model, {:foreign_keys => {:on_update => :restruct}}, :user_id => {:on_update => :set_null})
+        recreate_table @model, :foreign_keys => {:on_update => :restrict} do |t|
+          t.integer :user_id, :foreign_key => { :on_update => :set_null }
+        end
         @model.should reference.on(:user_id).on_update(:set_null)
       end
     end
 
     it "should override on_delete action per column" do
       with_fk_config(:on_delete => :cascade) do
-        create_table_opts(@model, {:foreign_keys => {:on_delete => :restrict}}, :user_id => {:on_delete => :set_null})
+        recreate_table @model, :foreign_keys => {:on_delete => :restrict} do |t|
+          t.integer :user_id, :foreign_key => { :on_delete => :set_null }
+        end
         @model.should reference.on(:user_id).on_delete(:set_null)
       end
     end
 
     it "should raise an error for an invalid on_update action" do
-        expect { create_table(@model, :user_id => {:on_update => :invalid}) }.should raise_error(ArgumentError)
+      expect {
+        recreate_table @model do |t|
+          t.integer :user_id, :foreign_key => { :on_update => :invalid }
+        end
+      }.to raise_error(ArgumentError)
     end
 
     it "should raise an error for an invalid on_delete action" do
-        expect { create_table(@model, :user_id => {:on_delete => :invalid}) }.should raise_error(ArgumentError)
+      expect {
+        recreate_table @model do |t|
+        t.integer :user_id, :foreign_key => { :on_delete => :invalid }
+        end
+      }.to raise_error(ArgumentError)
     end
 
     unless SchemaPlusHelpers.mysql?
       it "should override foreign key auto_index negatively" do
         with_fk_config(:auto_index => true) do 
-          create_table_opts(@model, {:foreign_keys => {:auto_index => false}}, :user_id => {})
+          recreate_table @model, :foreign_keys => {:auto_index => false} do |t|
+            t.integer :user_id
+          end
           @model.should_not have_index.on(:user_id)
         end
       end
 
       it "should disable auto-index for a column" do
         with_fk_config(:auto_index => true) do
-          create_table(@model,  :user_id => { :index => false })
+          recreate_table @model do |t|
+            t.integer :user_id, :index => false
+          end
           @model.should_not have_index.on(:user_id)
         end
       end
@@ -234,14 +388,20 @@ describe ActiveRecord::Migration do
         end
       end
 
-      it "should create foreign key to explicity given table" do
+      it "should create foreign key to explicitly given table" do
+        add_column(:author_id, :integer, :foreign_key => { :references => :users }) do
+          @model.should reference(:users, :id).on(:author_id)
+        end
+      end
+
+      it "should create foreign key to explicitly given table using shortcut" do
         add_column(:author_id, :integer, :references => :users) do
           @model.should reference(:users, :id).on(:author_id)
         end
       end
 
-      it "should create foreign key to explicity given table and column name" do
-        add_column(:author_login, :string, :references => [:users, :login]) do 
+      it "should create foreign key to explicitly given table and column name" do
+        add_column(:author_login, :string, :foreign_key => { :references => [:users, :login]}) do 
           @model.should reference(:users, :login).on(:author_login) 
         end
       end
@@ -258,7 +418,13 @@ describe ActiveRecord::Migration do
         end
       end
 
-      it "shouldnt't create foreign key if specified explicity" do
+      it "shouldn't create foreign key if specified explicitly" do
+        add_column(:post_id, :integer, :foreign_key => false) do
+          @model.should_not reference.on(:post_id)
+        end
+      end
+
+      it "shouldn't create foreign key if specified explicitly by shorthand" do
         add_column(:post_id, :integer, :references => nil) do
           @model.should_not reference.on(:post_id)
         end
@@ -317,10 +483,6 @@ describe ActiveRecord::Migration do
         SchemaPlus.config.foreign_keys.auto_index = false
       end
 
-      it "should not auto-index if column already has an index"
-
-      it "should remove auto-created index when removing foreign key"
-
       it "should use default on_update action" do
         SchemaPlus.config.foreign_keys.on_update = :cascade
         add_column(:post_id, :integer) do
@@ -340,7 +502,7 @@ describe ActiveRecord::Migration do
       it "should allow to overwrite default actions" do
         SchemaPlus.config.foreign_keys.on_delete = :cascade
         SchemaPlus.config.foreign_keys.on_update = :restrict
-        add_column(:post_id, :integer, :on_update => :set_null, :on_delete => :set_null) do
+        add_column(:post_id, :integer, :foreign_key => { :on_update => :set_null, :on_delete => :set_null}) do
           @model.should reference.on(:post_id).on_delete(:set_null).on_update(:set_null)
         end
         SchemaPlus.config.foreign_keys.on_delete = nil
@@ -366,28 +528,71 @@ describe ActiveRecord::Migration do
       end
 
       it "should create foreign key" do
-        change_column :user, :string, :references => [:users, :login]
+        change_column :user, :string, :foreign_key => { :references => [:users, :login] }
         @model.should reference(:users, :login).on(:user)
-        change_column :user, :string, :references => nil
       end
 
       context "and initially references to users table" do
 
+        before(:each) do
+          recreate_table @model do |t|
+            t.integer :user_id
+          end
+        end
+
         it "should have foreign key" do
           @model.should reference(:users)
         end
 
-        it "should drop foreign key afterwards" do
-          change_column :user_id, :integer, :references => :members
+        it "should drop foreign key if it is no longer valid" do
+          change_column :user_id, :integer, :foreign_key => { :references => :members }
           @model.should_not reference(:users)
-          change_column :user_id, :integer, :references => :users
         end
 
-        it "should reference pointed table afterwards" do
-          change_column :user_id, :integer, :references => :members
+        it "should drop foreign key if requested to do so" do
+          change_column :user_id, :integer, :foreign_key => { :references => nil }
+          @model.should_not reference(:users)
+        end
+
+        it "should remove auto-created index if foreign key is removed" do
+          @model.should have_index.on(:user_id)  # sanity check that index was auto-created
+          change_column :user_id, :integer, :foreign_key => { :references => nil }
+          @model.should_not have_index.on(:user_id)
+        end
+
+        it "should reference pointed table afterwards if new one is created" do
+          change_column :user_id, :integer, :foreign_key => { :references => :members }
           @model.should reference(:members)
         end
 
+        it "should maintain foreign key if it's unaffected by change" do
+          change_column :user_id, :integer, :default => 0
+          @model.should reference(:users)
+        end
+
+        it "should maintain foreign key if it's unaffected by change, even if auto_index is off" do
+          with_fk_config(:auto_create => false) do
+            change_column :user_id, :integer, :default => 0
+            @model.should reference(:users)
+          end
+        end
+
+      end
+
+      context "if column defined without foreign key but with index" do
+        before(:each) do
+          recreate_table @model do |t|
+            t.integer :user_id, :foreign_key => false, :index => true
+          end
+        end
+
+        it "should create the index" do
+          @model.should have_index.on(:user_id)
+        end
+
+        it "adding foreign key should not fail due to attempt to auto-create existing index" do
+          expect { change_column :user_id, :integer, :foreign_key => true }.to_not raise_error
+        end
       end
 
       protected
@@ -400,41 +605,87 @@ describe ActiveRecord::Migration do
       end
 
     end
-  end
-    
-  def foreign_key(model, column)
-    columns = Array(column).collect(&:to_s)
-    model.foreign_keys.detect { |fk| fk.table_name == model.table_name && fk.column_names == columns } 
-  end
 
-  def create_table_opts(model, table_options, columns_with_options, indexes={})
-    ActiveRecord::Migration.suppress_messages do
-      ActiveRecord::Migration.create_table model.table_name, table_options.merge(:force => true) do |t|
-        columns_with_options.each_pair do |column, options|
-          method = options.delete(:METHOD) || :integer
-          t.send method, column, options
+    context "when column is removed" do
+      before(:each) do
+        @model = Comment
+        recreate_table @model do |t|
+          t.integer :post_id
         end
-        indexes.each_pair do |column, options|
-          t.index column, options
+      end
+
+      it "should remove a foreign key" do
+        @model.should reference(:posts)
+        remove_column(:post_id)
+        @model.should_not reference(:posts)
+      end
+
+      it "should remove an index" do
+        @model.should have_index.on(:post_id)
+        remove_column(:post_id)
+        @model.should_not have_index.on(:post_id)
+      end
+      
+      protected
+      def remove_column(column_name)
+        table = @model.table_name
+        ActiveRecord::Migration.suppress_messages do
+          ActiveRecord::Migration.remove_column(table, column_name)
+          @model.reset_column_information
         end
       end
-      model.reset_column_information
     end
-  end
 
-  def create_table(model, columns_with_options)
-    create_table_opts(model, {}, columns_with_options)
   end
 
-  def with_fk_config(opts, &block)
-    save = Hash[opts.keys.collect{|key| [key, SchemaPlus.config.foreign_keys.send(key)]}]
-    begin
-      SchemaPlus.config.foreign_keys.update_attributes(opts)
-      yield
-    ensure
-      SchemaPlus.config.foreign_keys.update_attributes(save)
+  context "when table is renamed" do
+
+    before(:each) do
+      @model = Comment
+      recreate_table @model do |t|
+        t.integer :user_id
+        t.integer :xyz, :index => true
+      end
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.rename_table @model.table_name, :newname
+      end
+    end
+
+    around(:each) do |example|
+      begin
+        example.run
+      ensure
+        ActiveRecord::Migration.suppress_messages do
+          ActiveRecord::Migration.rename_table :newname, :comments
+        end
+      end
+    end
+
+    it "should rename rails-named indexes" do
+      index = ActiveRecord::Base.connection.indexes(:newname).find{|index| index.columns == ['xyz']}
+      index.name.should =~ /^index_newname_on/
+    end
+
+    it "should rename fk indexes" do
+      index = ActiveRecord::Base.connection.indexes(:newname).find{|index| index.columns == ['user_id']}
+      index.name.should =~ /^fk__newname_/
     end
+
+    unless SchemaPlusHelpers.sqlite3?
+      it "should rename foreign key definitions" do
+        ActiveRecord::Base.connection.foreign_keys(:newname).first.name.should =~ /newname/
+      end
+    end
+
   end
+    
+  def recreate_table(model, opts={}, &block)
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.create_table model.table_name, opts.merge(:force => true), &block
+    end
+    model.reset_column_information
+  end
+
 
 
 end