schema_plus 1.5.2 → 1.5.3

data/spec/index_definition_spec.rb

@@ -47,7 +47,7 @@ describe "Index definition" do
     end
 
     it "is included in User.indexes" do
-      @index.should_not be_nil
+      expect(@index).not_to be_nil
     end
 
   end
@@ -55,16 +55,16 @@ describe "Index definition" do
   it "should correctly report supports_partial_indexes?" do
     query = lambda { migration.execute "CREATE INDEX users_login_index ON users(login) WHERE deleted_at IS NULL" }
     if migration.supports_partial_indexes?
-      query.should_not raise_error
+      expect(query).not_to raise_error
     else
-      query.should raise_error
+      expect(query).to raise_error
     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
+    expect(index == nil).to be false
   end
 
 
@@ -85,7 +85,7 @@ describe "Index definition" 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}
+          expect(index.orders).to eq({"login" => :desc, "deleted_at" => :asc})
         end
 
       end
@@ -104,23 +104,23 @@ describe "Index definition" do
       end
 
       it "is included in User.indexes" do
-        @index.should_not be_nil
+        expect(@index).not_to be_nil
       end
 
       it "is not case_sensitive" do
-        @index.should_not be_case_sensitive
+        expect(@index).not_to be_case_sensitive
       end
 
       it "its column should not be case sensitive" do
-        User.columns.find{|column| column.name == "login"}.should_not be_case_sensitive
+        expect(User.columns.find{|column| column.name == "login"}).not_to be_case_sensitive
       end
 
       it "defines expression" do
-        @index.expression.should == "lower((login)::text)"
+        expect(@index.expression).to eq("lower((login)::text)")
       end
 
       it "doesn't define conditions" do
-        @index.conditions.should be_nil
+        expect(@index.conditions).to be_nil
       end
 
     end
@@ -134,19 +134,19 @@ describe "Index definition" do
       end
 
       it "is included in User.indexes" do
-        User.indexes.select { |index| index.columns == ["login"] }.should have(1).item
+        expect(User.indexes.select { |index| index.columns == ["login"] }.size).to eq(1)
       end
 
       it "is case_sensitive" do
-        @index.should be_case_sensitive
+        expect(@index).to be_case_sensitive
       end
 
       it "doesn't define expression" do
-        @index.expression.should be_nil
+        expect(@index.expression).to be_nil
       end
 
       it "defines conditions" do
-        @index.conditions.should == "(deleted_at IS NULL)"
+        expect(@index.conditions).to eq("(deleted_at IS NULL)")
       end
 
     end
@@ -159,23 +159,23 @@ describe "Index definition" do
       end
 
       it "exists" do
-        @index.should_not be_nil
+        expect(@index).not_to be_nil
       end
 
       it "doesnt have columns defined" do
-        @index.columns.should be_empty
+        expect(@index.columns).to be_empty
       end
 
       it "is case_sensitive" do
-        @index.should be_case_sensitive
+        expect(@index).to be_case_sensitive
       end
 
       it "defines expression" do
-        @index.expression.should == "date_part('epoch'::text, deleted_at)"
+        expect(@index.expression).to eq("date_part('epoch'::text, deleted_at)")
       end
 
       it "defines conditions" do
-        @index.conditions.should == "(deleted_at IS NULL)"
+        expect(@index.conditions).to eq("(deleted_at IS NULL)")
       end
 
     end
@@ -188,19 +188,19 @@ describe "Index definition" do
       end
 
       it "exists" do
-        @index.should_not be_nil
+        expect(@index).not_to be_nil
       end
 
       it "defines kind" do
-        @index.kind.should == "hash"
+        expect(@index.kind).to eq("hash")
       end
 
       it "does not define expression" do
-        @index.expression.should be_nil
+        expect(@index.expression).to be_nil
       end
 
       it "does not define order" do
-        @index.orders.should be_blank
+        expect(@index.orders).to be_blank
       end
     end
 

data/spec/index_spec.rb

@@ -42,39 +42,39 @@ describe "index" do
 
     it "should create index when called without additional options" do
       add_index(:users, :login)
-      index_for(:login).should_not be_nil
+      expect(index_for(:login)).not_to be_nil
     end
 
     it "should create unique index" do
       add_index(:users, :login, :unique => true)
-      index_for(:login).unique.should == true
+      expect(index_for(:login).unique).to eq(true)
     end
 
     it "should assign given name" do
       add_index(:users, :login, :name => 'users_login_index')
-      index_for(:login).name.should == 'users_login_index'
+      expect(index_for(:login).name).to eq('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}
+        expect(index_for([:login, :deleted_at]).orders).to eq({"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(index_for(:login)).not_to be_nil
+        expect(ActiveRecord::Base.logger).to receive(:warn).with(/login.*Skipping/)
         expect { add_index(:users, :login) }.to_not raise_error
-        index_for(:login).should_not be_nil
+        expect(index_for(:login)).not_to 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(index_for(:login)).not_to be_nil
         expect { add_index(:users, :login) }.to raise_error
-        index_for(:login).should_not be_nil
+        expect(index_for(:login)).not_to be_nil
       end
     end
 
@@ -82,34 +82,34 @@ describe "index" do
 
       it "should assign conditions" do
         add_index(:users, :login, :conditions => 'deleted_at IS NULL')
-        index_for(:login).conditions.should == '(deleted_at IS NULL)'
+        expect(index_for(:login).conditions).to eq('(deleted_at IS NULL)')
       end
 
       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"
+        expect(@index.expression).to eq("upper((login)::text)")
+        expect(@index.conditions).to eq("(deleted_at IS NULL)")
+        expect(@index.kind).to       eq("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"
+        expect(@index.expression).to eq("upper((login)::text)")
+        expect(@index.conditions).to eq("(deleted_at IS NULL)")
+        expect(@index.kind).to       eq("hash")
       end
 
       it "should allow to specify kind" do
         add_index(:users, :login, :kind => "hash")
-        index_for(:login).kind.should == 'hash'
+        expect(index_for(:login).kind).to eq('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.name == 'users_login_index' }
-        @index.expression.should == "upper((login)::text)"
+        expect(@index.expression).to eq("upper((login)::text)")
       end
 
       it "should raise if no column given and expression is missing" do
@@ -151,58 +151,58 @@ describe "index" do
 
     it "removes index by column name (symbols)" do
       add_index :users, :login
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index :users, :login
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "removes index by column name (symbols)" do
       add_index :users, :login
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index 'users', 'login'
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "removes multi-column index by column names (symbols)" do
       add_index :users, [:login, :deleted_at]
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index :users, [:login, :deleted_at]
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "removes multi-column index by column names (strings)" do
       add_index 'users', [:login, :deleted_at]
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index 'users', ['login', 'deleted_at']
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "removes index using column option" do
       add_index :users, :login
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index :users, column: :login
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "removes index if_exists" do
       add_index :users, :login
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index :users, :login, :if_exists => true
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "removes multi-column index if exists" do
       add_index :users, [:login, :deleted_at]
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index :users, [:login, :deleted_at], :if_exists => true
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "removes index if_exists using column option" do
       add_index :users, :login
-      User.indexes.length.should == 1
+      expect(User.indexes.length).to eq(1)
       remove_index :users, column: :login, :if_exists => true
-      User.indexes.length.should == 0
+      expect(User.indexes.length).to eq(0)
     end
 
     it "raises exception if doesn't exist" do

data/spec/migration_spec.rb

@@ -47,126 +47,175 @@ describe ActiveRecord::Migration do
          t.boolean :bool, :default => true
         end
       }.to_not raise_error
-      @model.create.reload.bool.should be_true
+      expect(@model.create.reload.bool).to be true
     end
 
     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)
+      expect(@model).to 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)
+      expect(@model).to 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)
+      expect(@model).to 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)
+      expect(@model).to reference(:users, :id).on(:author_id)
     end
 
     it "should create foreign key with default name" do
       recreate_table @model do |t|
         t.integer :user_id, :foreign_key => true
       end
-      @model.should reference(:users, :id).with_name("fk_#{@model.table_name}_user_id")
+      expect(@model).to reference(:users, :id).with_name("fk_#{@model.table_name}_user_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")
+      expect(@model).to 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)
+      expect(@model).not_to 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)
+      expect(@model).not_to reference.on(:member_id)
     end
 
     it "should create foreign key using t.belongs_to" do
       recreate_table(@model) do |t|
         t.belongs_to :user
       end
-      @model.should reference(:users, :id).on(:user_id)
+      expect(@model).to reference(:users, :id).on(:user_id)
     end
 
     it "should not create foreign key using t.belongs_to with :polymorphic => true" do
       recreate_table(@model) do |t|
         t.belongs_to :user, :polymorphic => true
       end
-      @model.should_not reference(:users, :id).on(:user_id)
+      expect(@model).not_to reference(:users, :id).on(:user_id)
     end
 
     it "should create foreign key using t.references" do
       recreate_table(@model) do |t|
         t.references :user
       end
-      @model.should reference(:users, :id).on(:user_id)
+      expect(@model).to reference(:users, :id).on(:user_id)
     end
 
     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)
+      expect(@model).not_to reference(:users, :id).on(:user_id)
     end
 
     it "should not create foreign key using t.references with :polymorphic => true" do
       recreate_table(@model) do |t|
         t.references :user, :polymorphic => true
       end
-      @model.should_not reference(:users, :id).on(:user_id)
+      expect(@model).not_to reference(:users, :id).on(:user_id)
     end
 
     it "should create foreign key to the same table on parent_id" do
       recreate_table(@model) do |t|
         t.integer :parent_id
       end
-      @model.should reference(@model.table_name, :id).on(:parent_id)
+      expect(@model).to reference(@model.table_name, :id).on(:parent_id)
     end
 
     it "should create an index if specified on column" do
       recreate_table(@model) do |t|
         t.integer :state, :index => true
       end
-      @model.should have_index.on(:state)
+      expect(@model).to have_index.on(:state)
     end
 
     it "should create a unique index if specified on column" do
       recreate_table(@model) do |t|
         t.integer :state, :index => { :unique => true }
       end
-      @model.should have_unique_index.on(:state)
+      expect(@model).to have_unique_index.on(:state)
     end
 
     it "should create a unique index if specified on column using shorthand" do
       recreate_table(@model) do |t|
         t.integer :state, :index => :unique
       end
-      @model.should have_unique_index.on(:state)
+      expect(@model).to have_unique_index.on(:state)
+    end
+
+    [:references, :belongs_to].each do |reftype|
+
+      context "when define #{reftype}" do
+
+        before(:each) do
+          @model = Comment
+        end
+
+        it "should create foreign key" do
+          create_reference(reftype, :post)
+          expect(@model).to reference(:posts, :id).on(:post_id)
+        end
+
+        it "should not create a foreign_key if polymorphic" do
+          create_reference(reftype, :post, :polymorphic => true)
+          expect(@model).not_to reference(:posts, :id).on(:post_id)
+        end
+
+        it "should create an index implicitly" do
+          create_reference(reftype, :post)
+          expect(@model).to have_index.on(:post_id)
+        end
+
+        it "should create exactly one index explicitly (#157)" do
+          create_reference(reftype, :post, :index => true)
+          expect(@model).to have_index.on(:post_id)
+        end
+
+        it "should respect :unique (#157)" do
+          create_reference(reftype, :post, :index => :unique)
+          expect(@model).to have_unique_index.on(:post_id)
+        end
+
+        it "should create a two-column index if polymophic and index requested" do
+          create_reference(reftype, :post, :polymorphic => true, :index => true)
+          expect(@model).to have_index.on([:post_id, :post_type])
+        end unless ::ActiveRecord::VERSION::MAJOR.to_i < 4
+
+        protected
+
+        def create_reference(reftype, column_name, *args)
+          recreate_table(@model) do |t|
+            t.send reftype, column_name, *args
+          end
+        end
+
+      end
     end
 
     if SchemaPlusHelpers.mysql?
@@ -176,7 +225,7 @@ describe ActiveRecord::Migration do
           t.string :bar, :index => { :with => :foo, :length => { :foo => 8, :bar => 12 }}
         end
         index = @model.indexes.first
-        Hash[index.columns.zip(index.lengths.map(&:to_i))].should == { "foo" => 8, "bar" => 12}
+        expect(Hash[index.columns.zip(index.lengths.map(&:to_i))]).to eq({ "foo" => 8, "bar" => 12})
       end
     end
 
@@ -185,7 +234,7 @@ describe ActiveRecord::Migration do
         t.integer :state
         t.index :state
       end
-      @model.should have_index.on(:state)
+      expect(@model).to have_index.on(:state)
     end
 
     it "should create a unique index if specified explicitly" do
@@ -193,7 +242,7 @@ describe ActiveRecord::Migration do
         t.integer :state
         t.index :state, :unique => true
       end
-      @model.should have_unique_index.on(:state)
+      expect(@model).to have_unique_index.on(:state)
     end
 
     it "should create a multiple-column index if specified" do
@@ -201,7 +250,7 @@ describe ActiveRecord::Migration do
         t.integer :city
         t.integer :state,       :index => { :with => :city }
       end
-      @model.should have_index.on([:state, :city])
+      expect(@model).to have_index.on([:state, :city])
     end
 
     it "should auto-index foreign keys only" do
@@ -210,9 +259,9 @@ describe ActiveRecord::Migration do
         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)
+      expect(@model).to have_index.on(:user_id)
+      expect(@model).not_to have_index.on(:application_id)
+      expect(@model).not_to have_index.on(:state)
     end
 
     it "should override foreign key auto_create positively" do
@@ -220,7 +269,7 @@ describe ActiveRecord::Migration do
         recreate_table @model, :foreign_keys => {:auto_create => true} do |t|
           t.integer :user_id
         end
-        @model.should reference(:users, :id).on(:user_id)
+        expect(@model).to reference(:users, :id).on(:user_id)
       end
     end
 
@@ -229,7 +278,7 @@ describe ActiveRecord::Migration do
         recreate_table @model, :foreign_keys => {:auto_create => false} do |t|
           t.integer :user_id
         end
-        @model.should_not reference.on(:user_id)
+        expect(@model).not_to reference.on(:user_id)
       end
     end
 
@@ -238,7 +287,7 @@ describe ActiveRecord::Migration do
         recreate_table @model, :foreign_keys => {:auto_index => true} do |t|
           t.integer :user_id
         end
-        @model.should have_index.on(:user_id)
+        expect(@model).to have_index.on(:user_id)
       end
     end
 
@@ -268,28 +317,28 @@ describe ActiveRecord::Migration do
         recreate_table @model do |t|
           t.integer :user_id,   :foreign_key => { :on_update => action }
         end
-        @model.should reference.on(:user_id).on_update(action)
+        expect(@model).to 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)
+        expect(@model).to reference.on(:user_id).on_update(action)
       end
 
       it "should create and detect on_delete #{action.inspect}" do
         recreate_table @model do |t|
           t.integer :user_id,   :foreign_key => { :on_delete => action }
         end
-        @model.should reference.on(:user_id).on_delete(action)
+        expect(@model).to 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)
+        expect(@model).to reference.on(:user_id).on_delete(action)
       end
     end
 
@@ -298,7 +347,7 @@ describe ActiveRecord::Migration do
         recreate_table @model do |t|
           t.integer :user_id,   :on_delete => :cascade, :deferrable => status
         end
-        @model.should reference.on(:user_id).deferrable(status)
+        expect(@model).to reference.on(:user_id).deferrable(status)
       end
     end unless SchemaPlusHelpers.mysql?
 
@@ -307,7 +356,7 @@ describe ActiveRecord::Migration do
         recreate_table @model do |t|
           t.integer :user_id
         end
-        @model.should reference.on(:user_id).on_delete(:cascade)
+        expect(@model).to reference.on(:user_id).on_delete(:cascade)
       end
     end
 
@@ -316,7 +365,7 @@ describe ActiveRecord::Migration do
         recreate_table @model, :foreign_keys => {:on_update => :restrict} do |t|
           t.integer :user_id
         end
-        @model.should reference.on(:user_id).on_update(:restrict)
+        expect(@model).to reference.on(:user_id).on_update(:restrict)
       end
     end
 
@@ -325,7 +374,7 @@ describe ActiveRecord::Migration do
         recreate_table @model, :foreign_keys => {:on_delete => :restrict} do |t|
           t.integer :user_id
         end
-        @model.should reference.on(:user_id).on_delete(:restrict)
+        expect(@model).to reference.on(:user_id).on_delete(:restrict)
       end
     end
 
@@ -334,7 +383,7 @@ describe ActiveRecord::Migration do
         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)
+        expect(@model).to reference.on(:user_id).on_update(:set_null)
       end
     end
 
@@ -343,7 +392,7 @@ describe ActiveRecord::Migration do
         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)
+        expect(@model).to reference.on(:user_id).on_delete(:set_null)
       end
     end
 
@@ -369,7 +418,7 @@ describe ActiveRecord::Migration do
           recreate_table @model, :foreign_keys => {:auto_index => false} do |t|
             t.integer :user_id
           end
-          @model.should_not have_index.on(:user_id)
+          expect(@model).not_to have_index.on(:user_id)
         end
       end
 
@@ -378,7 +427,7 @@ describe ActiveRecord::Migration do
           recreate_table @model do |t|
             t.integer :user_id, :index => false
           end
-          @model.should_not have_index.on(:user_id)
+          expect(@model).not_to have_index.on(:user_id)
         end
       end
 
@@ -397,7 +446,7 @@ describe ActiveRecord::Migration do
         change_table(@model, :bulk => bulk) do |t|
           t.integer :state, :index => true
         end
-        @model.should have_index.on(:state)
+        expect(@model).to have_index.on(:state)
       end
 
       unless SchemaPlusHelpers.sqlite3?
@@ -406,13 +455,13 @@ describe ActiveRecord::Migration do
           change_table(@model, :bulk => bulk) do |t|
             t.integer :user_id
           end
-          @model.should reference(:users, :id).on(:user_id)
+          expect(@model).to reference(:users, :id).on(:user_id)
         end
 
         context "migrate down" do
           it "should remove a foreign key constraint"+suffix do
             Comment.reset_column_information
-            Comment.should reference(:users, :id).on(:user_id)
+            expect(Comment).to reference(:users, :id).on(:user_id)
             migration = Class.new ::ActiveRecord::Migration do
               define_method(:change) {
                 change_table("comments", :bulk => bulk) do |t|
@@ -424,7 +473,7 @@ describe ActiveRecord::Migration do
               migration.migrate(:down)
             end
             Comment.reset_column_information
-            Comment.should_not reference(:users, :id).on(:user_id)
+            expect(Comment).not_to reference(:users, :id).on(:user_id)
           end
         end if ActiveRecord::VERSION::MAJOR >= 4
 
@@ -432,14 +481,14 @@ describe ActiveRecord::Migration do
           change_table(@model, :bulk => bulk) do |t|
             t.references :user
           end
-          @model.should reference(:users, :id).on(:user_id)
+          expect(@model).to reference(:users, :id).on(:user_id)
         end
 
         it "should create a foreign key constraint using :belongs_to"+suffix do
           change_table(@model, :bulk => bulk) do |t|
             t.belongs_to :user
           end
-          @model.should reference(:users, :id).on(:user_id)
+          expect(@model).to reference(:users, :id).on(:user_id)
         end
       end
     end
@@ -456,87 +505,87 @@ describe ActiveRecord::Migration do
 
       it "should create an index" do
         add_column(:slug, :string, :index => true) do
-          @model.should have_index.on(:slug)
+          expect(@model).to have_index.on(:slug)
         end
       end
 
       it "should create foreign key" do
         add_column(:post_id, :integer) do
-          @model.should reference(:posts, :id).on(:post_id)
+          expect(@model).to reference(:posts, :id).on(:post_id)
         end
       end
 
       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)
+          expect(@model).to 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)
+          expect(@model).to reference(:users, :id).on(:author_id)
         end
       end
 
       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)
+          expect(@model).to reference(:users, :login).on(:author_login)
         end
       end
 
       it "should create foreign key to the same table on parent_id" do
         add_column(:parent_id, :integer) do
-          @model.should reference(@model.table_name, :id).on(:parent_id)
+          expect(@model).to reference(@model.table_name, :id).on(:parent_id)
         end
       end
 
       it "shouldn't create foreign key if column doesn't look like foreign key" do
         add_column(:views_count, :integer) do
-          @model.should_not reference.on(:views_count)
+          expect(@model).not_to reference.on(:views_count)
         end
       end
 
       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)
+          expect(@model).not_to 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)
+          expect(@model).not_to reference.on(:post_id)
         end
       end
 
       it "should create an index if specified" do
         add_column(:post_id, :integer, :index => true) do
-          @model.should have_index.on(:post_id)
+          expect(@model).to have_index.on(:post_id)
         end
       end
 
       it "should create a unique index if specified" do
         add_column(:post_id, :integer, :index => { :unique => true }) do
-          @model.should have_unique_index.on(:post_id)
+          expect(@model).to have_unique_index.on(:post_id)
         end
       end
 
       it "should create a unique index if specified by shorthand" do
         add_column(:post_id, :integer, :index => :unique) do
-          @model.should have_unique_index.on(:post_id)
+          expect(@model).to have_unique_index.on(:post_id)
         end
       end
 
       it "should allow custom name for index" do
         index_name = 'comments_post_id_unique_index'
         add_column(:post_id, :integer, :index => { :unique => true, :name => index_name }) do
-          @model.should have_unique_index(:name => index_name).on(:post_id)
+          expect(@model).to have_unique_index(:name => index_name).on(:post_id)
         end
       end
 
       it "should auto-index if specified in global options" do
         SchemaPlus.config.foreign_keys.auto_index = true
         add_column(:post_id, :integer) do
-          @model.should have_index.on(:post_id)
+          expect(@model).to have_index.on(:post_id)
         end
         SchemaPlus.config.foreign_keys.auto_index = false
       end
@@ -544,7 +593,7 @@ describe ActiveRecord::Migration do
       it "should auto-index foreign keys only" do
         SchemaPlus.config.foreign_keys.auto_index = true
         add_column(:state, :integer) do
-          @model.should_not have_index.on(:state)
+          expect(@model).not_to have_index.on(:state)
         end
         SchemaPlus.config.foreign_keys.auto_index = false
       end
@@ -555,7 +604,7 @@ describe ActiveRecord::Migration do
           # MySQL creates an index on foreign by default
           # and we can do nothing with that
           unless SchemaPlusHelpers.mysql?
-            @model.should_not have_index.on(:post_id)
+            expect(@model).not_to have_index.on(:post_id)
           end
         end
         SchemaPlus.config.foreign_keys.auto_index = false
@@ -564,7 +613,7 @@ describe ActiveRecord::Migration do
       it "should use default on_update action" do
         SchemaPlus.config.foreign_keys.on_update = :cascade
         add_column(:post_id, :integer) do
-          @model.should reference.on(:post_id).on_update(:cascade)
+          expect(@model).to reference.on(:post_id).on_update(:cascade)
         end
         SchemaPlus.config.foreign_keys.on_update = nil
       end
@@ -572,7 +621,7 @@ describe ActiveRecord::Migration do
       it "should use default on_delete action" do
         SchemaPlus.config.foreign_keys.on_delete = :cascade
         add_column(:post_id, :integer) do
-          @model.should reference.on(:post_id).on_delete(:cascade)
+          expect(@model).to reference.on(:post_id).on_delete(:cascade)
         end
         SchemaPlus.config.foreign_keys.on_delete = nil
       end
@@ -581,7 +630,7 @@ describe ActiveRecord::Migration do
         SchemaPlus.config.foreign_keys.on_delete = :cascade
         SchemaPlus.config.foreign_keys.on_update = :restrict
         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)
+          expect(@model).to reference.on(:post_id).on_delete(:set_null).on_update(:set_null)
         end
         SchemaPlus.config.foreign_keys.on_delete = nil
       end
@@ -599,43 +648,6 @@ describe ActiveRecord::Migration do
 
     end
 
-    context "when add reference" do
-
-      before(:each) do
-        @model = Comment
-      end
-
-      it "should create foreign key" do
-        add_reference(:post) do
-          @model.should reference(:posts, :id).on(:post_id)
-        end
-      end
-
-      it "should not create a foreign_key if polymorphic" do
-        add_reference(:post, :polymorphic => true) do
-          @model.should_not reference(:posts, :id).on(:post_id)
-        end
-      end
-
-      it "should create a two-column index if polymophic and index requested" do
-        add_reference(:post, :polymorphic => true, :index => true) do
-          @model.should have_index.on([:post_id, :post_type])
-        end
-      end
-
-
-      protected
-      def add_reference(column_name, *args)
-        table = @model.table_name
-        ActiveRecord::Migration.suppress_messages do
-          ActiveRecord::Migration.add_reference(table, column_name, *args)
-          @model.reset_column_information
-          yield if block_given?
-          ActiveRecord::Migration.remove_column(table, "#{column_name}_id")
-        end
-      end
-
-    end unless ::ActiveRecord::VERSION::MAJOR.to_i < 4
 
     context "when column is changed" do
 
@@ -645,7 +657,7 @@ describe ActiveRecord::Migration do
 
       it "should create foreign key" do
         change_column :user, :string, :foreign_key => { :references => [:users, :login] }
-        @model.should reference(:users, :login).on(:user)
+        expect(@model).to reference(:users, :login).on(:user)
       end
 
       context "and initially references to users table" do
@@ -657,39 +669,39 @@ describe ActiveRecord::Migration do
         end
 
         it "should have foreign key" do
-          @model.should reference(:users)
+          expect(@model).to reference(:users)
         end
 
         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)
+          expect(@model).not_to reference(:users)
         end
 
         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)
+          expect(@model).not_to 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
+          expect(@model).to 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)
+          expect(@model).not_to 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)
+          expect(@model).to 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)
+          expect(@model).to 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)
+            expect(@model).to reference(:users)
           end
         end
 
@@ -703,7 +715,7 @@ describe ActiveRecord::Migration do
         end
 
         it "should create the index" do
-          @model.should have_index.on(:user_id)
+          expect(@model).to have_index.on(:user_id)
         end
 
         it "adding foreign key should not fail due to attempt to auto-create existing index" do
@@ -731,15 +743,15 @@ describe ActiveRecord::Migration do
       end
 
       it "should remove a foreign key" do
-        @model.should reference(:posts)
+        expect(@model).to reference(:posts)
         remove_column(:post_id)
-        @model.should_not reference(:posts)
+        expect(@model).not_to reference(:posts)
       end
 
       it "should remove an index" do
-        @model.should have_index.on(:post_id)
+        expect(@model).to have_index.on(:post_id)
         remove_column(:post_id)
-        @model.should_not have_index.on(:post_id)
+        expect(@model).not_to have_index.on(:post_id)
       end
 
       protected
@@ -779,17 +791,17 @@ describe ActiveRecord::Migration do
 
     it "should rename rails-named indexes" do
       index = ActiveRecord::Base.connection.indexes(:newname).find{|index| index.columns == ['xyz']}
-      index.name.should =~ /^index_newname_on/
+      expect(index.name).to match(/^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_/
+      expect(index.name).to match(/^fk__newname_/)
     end
 
     unless SchemaPlusHelpers.sqlite3?
       it "should rename foreign key constraints" do
-        ActiveRecord::Base.connection.foreign_keys(:newname).first.name.should =~ /newname/
+        expect(ActiveRecord::Base.connection.foreign_keys(:newname).first.name).to match(/newname/)
       end
     end
 
@@ -821,7 +833,7 @@ describe ActiveRecord::Migration do
       end
       it "should rename foreign key constraints" do
         names = ActiveRecord::Base.connection.foreign_keys(:newname).map(&:name)
-        names.grep(/newname/).should == names
+        expect(names.grep(/newname/)).to eq(names)
       end
     end