schema_plus 1.5.1 → 1.5.3

data/spec/column_spec.rb

@@ -14,7 +14,7 @@ describe "Column" do
       @login = User.columns.find{|column| column.name == "login"}
     end
     it "works properly" do
-      JSON.parse(@login.to_json).should include("name" => "login", "type" => "string")
+      expect(JSON.parse(@login.to_json)).to include("name" => "login", "type" => "string")
     end
   end
 
@@ -28,12 +28,12 @@ describe "Column" do
       end
 
       it "should report not unique" do
-        @login.should_not be_unique
+        expect(@login).not_to be_unique
       end
 
       it "should report nil unique scope" do
         create_table(User, :login => { :index => true})
-        @login.unique_scope.should be_nil
+        expect(@login.unique_scope).to be_nil
       end
     end
 
@@ -44,11 +44,11 @@ describe "Column" do
       end
 
       it "should report unique" do
-        @login.should be_unique
+        expect(@login).to be_unique
       end
 
       it "should report an empty unique scope" do
-        @login.unique_scope.should == []
+        expect(@login.unique_scope).to eq([])
       end
     end
 
@@ -62,15 +62,15 @@ describe "Column" do
       end
 
       it "should report unique for each" do
-        @first.should be_unique
-        @middle.should be_unique
-        @last.should be_unique
+        expect(@first).to be_unique
+        expect(@middle).to be_unique
+        expect(@last).to be_unique
       end
 
       it "should report unique scope for each" do
-        @first.unique_scope.should =~ %W[middle last]
-        @middle.unique_scope.should =~ %W[first last]
-        @last.unique_scope.should =~ %W[first middle]
+        expect(@first.unique_scope).to match_array(%W[middle last])
+        expect(@middle.unique_scope).to match_array(%W[first last])
+        expect(@last.unique_scope).to match_array(%W[first middle])
       end
     end
 
@@ -80,17 +80,17 @@ describe "Column" do
 
     it "not required if the column can be null" do
       create_table(User, :login => { :null => true})
-      User.columns.find{|column| column.name == "login"}.required_on.should be_nil
+      expect(User.columns.find{|column| column.name == "login"}.required_on).to be_nil
     end
 
     it "must have a value on :save if there's no default" do
       create_table(User, :login => { :null => false })
-      User.columns.find{|column| column.name == "login"}.required_on.should == :save
+      expect(User.columns.find{|column| column.name == "login"}.required_on).to eq(:save)
     end
 
     it "must have a value on :update if there's default" do
       create_table(User, :login => { :null => false, :default => "foo" })
-      User.columns.find{|column| column.name == "login"}.required_on.should == :update
+      expect(User.columns.find{|column| column.name == "login"}.required_on).to eq(:update)
     end
 
   end
@@ -113,19 +113,19 @@ describe "Column" do
 
       it "creating a record should respect default expression" do
         User.create!(:alpha => ActiveRecord::DB_DEFAULT, :beta => "hello")
-        User.last.alpha.should == "gabba"
-        User.last.beta.should == "hello"
+        expect(User.last.alpha).to eq("gabba")
+        expect(User.last.beta).to eq("hello")
       end
 
       it "updating a record should respect default expression" do
         u = User.create!(:alpha => "hey", :beta => "hello")
         u.reload
-        u.alpha.should == "hey"
-        u.beta.should == "hello"
+        expect(u.alpha).to eq("hey")
+        expect(u.beta).to eq("hello")
         u.update_attributes(:alpha => ActiveRecord::DB_DEFAULT, :beta => "goodbye")
         u.reload
-        u.alpha.should == "gabba"
-        u.beta.should == "goodbye"
+        expect(u.alpha).to eq("gabba")
+        expect(u.beta).to eq("goodbye")
       end
     end
   end

data/spec/connection_spec.rb

@@ -4,7 +4,7 @@ describe "Connection" do
 
   it "should re-open without failure" do
     expect {
-      ActiveRecord::Base.establish_connection "schema_plus"
+      ActiveRecord::Base.establish_connection :schema_plus
     }.to_not raise_error
   end
 end

data/spec/foreign_key_definition_spec.rb

@@ -5,17 +5,17 @@ describe "Foreign Key definition" do
   let(:definition) { SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id) }
 
   it "dumps to sql with quoted values" do
-    definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')})}
+    expect(definition.to_sql).to eq(%Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')})})
   end
 
   it "dumps to sql with deferrable values" do
     deferred_definition = SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id, nil, nil, true)
-    deferred_definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE}
+    expect(deferred_definition.to_sql).to eq(%Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE})
   end
 
   it "dumps to sql with initially deferrable values" do
     initially_deferred_definition = SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new("posts_user_fkey", :posts, :user, :users, :id, nil, nil, :initially_deferred)
-    initially_deferred_definition.to_sql.should == %Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE INITIALLY DEFERRED}
+    expect(initially_deferred_definition.to_sql).to eq(%Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE INITIALLY DEFERRED})
   end
 
   def quote_table_name(table)

data/spec/foreign_key_spec.rb

@@ -20,11 +20,11 @@ describe "Foreign Key" do
     end
 
     it "should report foreign key constraints" do
-      Comment.foreign_keys.collect(&:column_names).flatten.should == [ "user_id" ]
+      expect(Comment.foreign_keys.collect(&:column_names).flatten).to eq([ "user_id" ])
     end
 
     it "should report reverse foreign key constraints" do
-      User.reverse_foreign_keys.collect(&:column_names).flatten.should == [ "user_id" ]
+      expect(User.reverse_foreign_keys.collect(&:column_names).flatten).to eq([ "user_id" ])
     end
 
   end
@@ -32,7 +32,9 @@ describe "Foreign Key" do
   if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
     context "with modifications to SQL generated by upstream visit_TableDefinition" do
       before(:each) do
-        ActiveRecord::Base.connection.class.const_get(:SchemaCreation).any_instance.stub :visit_TableDefinition_without_schema_plus => "this is unexpected"
+        allow_any_instance_of(ActiveRecord::Base.connection.class.const_get(:SchemaCreation))
+          .to receive(:visit_TableDefinition_without_schema_plus)
+          .and_return('this is unexpected')
       end
 
       it "raises an exception when attempting to create a table" do
@@ -105,23 +107,23 @@ describe "Foreign Key" do
         end
 
         it "references users(id)" do
-          Post.should reference(:users, :id).on(:author_id)
+          expect(Post).to reference(:users, :id).on(:author_id)
         end
 
         it "cascades on update" do
-          Post.should reference(:users).on_update(:cascade)
+          expect(Post).to reference(:users).on_update(:cascade)
         end
 
         it "restricts on delete" do
-          Post.should reference(:users).on_delete(:restrict)
+          expect(Post).to reference(:users).on_delete(:restrict)
         end
 
         it "is available in Post.foreign_keys" do
-          Post.foreign_keys.collect(&:column_names).should include(%w[author_id])
+          expect(Post.foreign_keys.collect(&:column_names)).to include(%w[author_id])
         end
 
         it "is available in User.reverse_foreign_keys" do
-          User.reverse_foreign_keys.collect(&:column_names).should include(%w[author_id])
+          expect(User.reverse_foreign_keys.collect(&:column_names)).to include(%w[author_id])
         end
 
       end
@@ -139,15 +141,15 @@ describe "Foreign Key" do
         end
 
         it "doesn't reference posts(id)" do
-          Comment.should_not reference(:posts).on(:post_id)
+          expect(Comment).not_to reference(:posts).on(:post_id)
         end
 
         it "is no longer available in Post.foreign_keys" do
-          Comment.foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+          expect(Comment.foreign_keys.collect(&:column_names)).not_to include(%w[post_id])
         end
 
         it "is no longer available in User.reverse_foreign_keys" do
-          Post.reverse_foreign_keys.collect(&:column_names).should_not include(%w[post_id])
+          expect(Post.reverse_foreign_keys.collect(&:column_names)).not_to include(%w[post_id])
         end
 
       end
@@ -158,7 +160,7 @@ describe "Foreign Key" do
 
         it "should remove foreign keys" do
           remove_foreign_key(:comments, foreign_key_name)
-          Post.reverse_foreign_keys.collect { |fk| fk.column_names == %w[post_id] && fk.table_name == "comments" }.should be_empty
+          expect(Post.reverse_foreign_keys.collect { |fk| fk.column_names == %w[post_id] && fk.table_name == "comments" }).to be_empty
         end
 
       end

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