switchman 1.2.10 → 1.2.11

data/spec/lib/active_record/connection_handler_spec.rb

@@ -6,39 +6,39 @@ module Switchman
       include RSpecHelper
 
       it "should use different proxies for different categories" do
-        Shard.connection_pool.should_not == User.connection_pool
+        expect(Shard.connection_pool).not_to eq User.connection_pool
       end
 
       it "should share underlying pools for different categories on the same shard" do
-        Shard.connection_pool.current_pool.should == User.connection_pool.current_pool
+        expect(Shard.connection_pool.current_pool).to eq User.connection_pool.current_pool
       end
 
       it "should insert sharding for connections established after initialization" do
-        User.connection_pool.should == ::ActiveRecord::Base.connection_pool
+        expect(User.connection_pool).to eq ::ActiveRecord::Base.connection_pool
         begin
           config = { :adapter => 'sqlite3', :database => ':memory:', :something_unique_in_the_spec => true }
           User.establish_connection(config)
-          User.connection_pool.should_not == ::ActiveRecord::Base.connection_pool
-          User.connection_pool.spec.config.should == config
-          User.connection_pool.should be_is_a(ConnectionPoolProxy)
+          expect(User.connection_pool).not_to eq ::ActiveRecord::Base.connection_pool
+          expect(User.connection_pool.spec.config).to eq config
+          expect(User.connection_pool).to be_is_a(ConnectionPoolProxy)
           @shard2.activate do
-            User.connection_pool.spec.config.should == ::ActiveRecord::Base.connection_pool.spec.config
-            User.connection_pool.spec.config.should_not == config
+            expect(User.connection_pool.spec.config).to eq ::ActiveRecord::Base.connection_pool.spec.config
+            expect(User.connection_pool.spec.config).not_to eq config
           end
         ensure
           User.remove_connection
-          User.connection_pool.should == ::ActiveRecord::Base.connection_pool
-          User.connection_pool.should be_is_a(ConnectionPoolProxy)
+          expect(User.connection_pool).to eq ::ActiveRecord::Base.connection_pool
+          expect(User.connection_pool).to be_is_a(ConnectionPoolProxy)
         end
       end
 
       it "should set up separate pools for different categories" do
-        User.connection_pool.should_not == MirrorUser.connection_pool
+        expect(User.connection_pool).not_to eq MirrorUser.connection_pool
         mu = MirrorUser.create!
-        MirrorUser.find(mu.local_id).should == mu
+        expect(MirrorUser.find(mu.local_id)).to eq mu
         # didn't activate the :mirror_universe category
-        @shard1.activate { MirrorUser.find(mu.local_id).should == mu }
-        @shard1.activate(:mirror_universe) { MirrorUser.find_by_id(mu.local_id).should == nil }
+        @shard1.activate { expect(MirrorUser.find(mu.local_id)).to eq mu }
+        @shard1.activate(:mirror_universe) { expect(MirrorUser.where(id: mu.local_id).first).to eq nil }
       end
     end
   end

data/spec/lib/active_record/connection_pool_spec.rb

@@ -4,24 +4,24 @@ module Switchman
   module ActiveRecord
     describe ConnectionPool do
       it "should be able to access another shard on a db server after the 'primary' shard is gone" do
-        pending 'A "real" database"' unless Shard.default.database_server.shareable?
+        skip 'A "real" database"' unless Shard.default.database_server.shareable?
         # separate connections
         server = DatabaseServer.create(:config => Shard.default.database_server.config.dup)
         s1 = server.shards.create!(:name => 'non_existent_shard') # don't actually create any schema
         s2 = server.shards.create! # inherit's the default shard's config, which is functional
         s1.activate do
-          lambda { User.count }.should raise_exception
+          expect { User.count }.to raise_exception
         end
         # the config for s1 should not be the permanent default for all new
         # connections now
         s2.activate do
-          lambda { User.count }.should_not raise_exception
+          expect { User.count }.not_to raise_exception
         end
       end
 
       describe "clear_idle_connections!" do
         before do
-          pending 'A "real" database"' unless Shard.default.database_server.shareable?
+          skip 'A "real" database"' unless Shard.default.database_server.shareable?
           @server = DatabaseServer.create(:config => Shard.default.database_server.config.dup)
           @shard = @server.shards.create!
           @conn, @pool = @shard.activate{ [User.connection, User.connection_pool.current_pool] }
@@ -36,7 +36,7 @@ module Switchman
         it "should remove idle connections" do
           @pool.checkin(@conn)
           @pool.clear_idle_connections!(@conn.last_query_at + 1)
-          @pool.connections.should be_empty
+          expect(@pool.connections).to be_empty
         end
 
         it "should not affect idle but checked out connections" do
@@ -53,7 +53,7 @@ module Switchman
 
       describe "release_connection" do
         before do
-          pending 'A "real" database"' unless Shard.default.database_server.shareable?
+          skip 'A "real" database"' unless Shard.default.database_server.shareable?
           @server = DatabaseServer.create(:config => Shard.default.database_server.config.dup)
           @shard = @server.shards.create!
           @pool = @shard.activate{ User.connection_pool.current_pool }
@@ -73,7 +73,7 @@ module Switchman
         it "should still work if idle timeout is not configured" do
           @pool.spec.config[:idle_timeout] = nil
           @pool.expects(:clear_idle_connections!).never
-          lambda { @pool.release_connection }.should_not raise_exception
+          expect { @pool.release_connection }.not_to raise_exception
         end
       end
     end

data/spec/lib/active_record/finder_methods_spec.rb

@@ -11,17 +11,17 @@ module Switchman
 
       describe "#find_one" do
         it "should find with a global id" do
-          User.find(@user.global_id).should == @user
+          expect(User.find(@user.global_id)).to eq @user
         end
       end
 
       describe "#find_by_attributes" do
         it "should find with a global id" do
-          User.find_by_id(@user.global_id).should == @user
+          expect(User.find_by_id(@user.global_id)).to eq @user
         end
 
         it "should find with an array of global ids" do
-          User.find_by_id([@user.global_id]).should == @user
+          expect(User.find_by_id([@user.global_id])).to eq @user
         end
       end
 
@@ -29,21 +29,21 @@ module Switchman
         it "should initialize with the shard from the scope" do
           @user.destroy
           u = User.shard(@shard1).where(id: @user).first_or_initialize
-          u.should be_new_record
-          u.shard.should == @shard1
+          expect(u).to be_new_record
+          expect(u.shard).to eq @shard1
         end
       end
 
       describe "#exists?" do
         it "should work for an out-of-shard scope" do
           scope = @shard1.activate { User.where(id: @user) }
-          scope.shard_value.should == @shard1
-          scope.exists?.should be_true
+          expect(scope.shard_value).to eq @shard1
+          expect(scope.exists?).to eq true
         end
 
         it "should work for a multi-shard scope" do
           user2 = @shard2.activate { User.create!(name: "multi-shard exists") }
-          User.where(name: "multi-shard exists").shard(::Rails.version < '4' ? Shard.scoped : Shard.all).exists?.should be_true
+          expect(User.where(name: "multi-shard exists").shard(::Rails.version < '4' ? Shard.scoped : Shard.all).exists?).to eq true
         end
       end
     end

data/spec/lib/active_record/query_cache_spec.rb

@@ -53,27 +53,27 @@ module Switchman
         @shard3.activate do
           User.create!
         end
-        @shard1.activate { User.all.to_a }.should_not == @shard3.activate { User.all.to_a }
+        expect(@shard1.activate { User.all.to_a }).not_to eq @shard3.activate { User.all.to_a }
       end
 
       describe "query_cache_enabled" do
         it "should be shared across shards on the same server" do
           @shard1.activate{ User.connection.query_cache_enabled = true }
           @shard3.activate{ User.connection.query_cache_enabled = false }
-          @shard1.activate{ User.connection.query_cache_enabled.should == false }
+          @shard1.activate{ expect(User.connection.query_cache_enabled).to eq false }
         end
 
         it "should be shared across servers" do
           @shard1.activate{ User.connection.query_cache_enabled = true }
           @shard2.activate{ User.connection.query_cache_enabled = false }
-          @shard1.activate{ User.connection.query_cache_enabled.should == false }
+          @shard1.activate{ expect(User.connection.query_cache_enabled).to eq false }
         end
 
         it "should be distinct across threads" do
           User.connection.query_cache_enabled = true
           threaded(
             lambda{ |cc| User.connection.query_cache_enabled = false; cc.call },
-            lambda{ User.connection.query_cache_enabled.should == true })
+            lambda{ expect(User.connection.query_cache_enabled).to eq true })
         end
       end
 
@@ -84,10 +84,10 @@ module Switchman
             lambda{ |cc|
               User.connection.query_cache_enabled = false
               User.connection.enable_query_cache!
-              User.connection.query_cache_enabled.should == true
+              expect(User.connection.query_cache_enabled).to eq true
               cc.call
             },
-            lambda{ User.connection.query_cache_enabled.should == false })
+            lambda{ expect(User.connection.query_cache_enabled).to eq false })
         end
       end
 
@@ -98,10 +98,10 @@ module Switchman
             lambda{ |cc|
               User.connection.query_cache_enabled = true
               User.connection.disable_query_cache!
-              User.connection.query_cache_enabled.should == false
+              expect(User.connection.query_cache_enabled).to eq false
               cc.call
             },
-            lambda{ User.connection.query_cache_enabled.should == true })
+            lambda{ expect(User.connection.query_cache_enabled).to eq true })
         end
       end
 
@@ -112,15 +112,15 @@ module Switchman
           User.connection.disable_query_cache!
           threaded(
             lambda{ |cc| User.connection.cache{ cc.call } },
-            lambda{ User.connection.query_cache_enabled.should == false })
+            lambda{ expect(User.connection.query_cache_enabled).to eq false })
         end
 
         it "should only enable for the duration of the block" do
           User.connection.disable_query_cache!
           User.connection.cache do
-            User.connection.query_cache_enabled.should == true
+            expect(User.connection.query_cache_enabled).to eq true
           end
-          User.connection.query_cache_enabled.should == false
+          expect(User.connection.query_cache_enabled).to eq false
         end
 
         it "should clear query cache if disabling query cache after block" do
@@ -128,7 +128,7 @@ module Switchman
           User.connection.cache do
             User.connection.query_cache[:key][:binds] = :value
           end
-          User.connection.query_cache[:key][:binds].should be_nil
+          expect(User.connection.query_cache[:key][:binds]).to be_nil
         end
 
         it "should not clear query cache if the cache was already enabled" do
@@ -136,7 +136,7 @@ module Switchman
           User.connection.cache do
             User.connection.query_cache[:key][:binds] = :value
           end
-          User.connection.query_cache[:key][:binds].should == :value
+          expect(User.connection.query_cache[:key][:binds]).to eq :value
         end
       end
 
@@ -147,21 +147,21 @@ module Switchman
           User.connection.enable_query_cache!
           threaded(
             lambda{ |cc| User.connection.uncached{ cc.call } },
-            lambda{ User.connection.query_cache_enabled.should == true })
+            lambda{ expect(User.connection.query_cache_enabled).to eq true })
         end
 
         it "should only disable for the duration of the block" do
           User.connection.enable_query_cache!
           User.connection.uncached do
-            User.connection.query_cache_enabled.should == false
+            expect(User.connection.query_cache_enabled).to eq false
           end
-          User.connection.query_cache_enabled.should == true
+          expect(User.connection.query_cache_enabled).to eq true
         end
 
         it "should not clear query cache" do
           User.connection.query_cache[:key][:binds] = :value
           User.connection.uncached{}
-          User.connection.query_cache[:key][:binds].should == :value
+          expect(User.connection.query_cache[:key][:binds]).to eq :value
         end
       end
 
@@ -169,26 +169,26 @@ module Switchman
         it "should cache when query cache enabled" do
           User.connection.enable_query_cache!
           User.all.to_a
-          User.connection.query_cache.should_not be_empty
+          expect(User.connection.query_cache).not_to be_empty
         end
 
         it "should not cache when query cache disabled" do
           User.connection.disable_query_cache!
           User.all.to_a
-          User.connection.query_cache.should be_empty
+          expect(User.connection.query_cache).to be_empty
         end
 
         it "should not cache when query cache disabled but other thread's enabled" do
           User.connection.disable_query_cache!
           threaded(
             lambda{ |cc| User.connection.cache{ cc.call } },
-            lambda{ User.all.to_a; User.connection.query_cache.should be_empty })
+            lambda{ User.all.to_a; expect(User.connection.query_cache).to be_empty })
         end
 
         it "should not cache when query is locked" do
           User.connection.enable_query_cache!
           User.lock.to_a
-          User.connection.query_cache.should be_empty
+          expect(User.connection.query_cache).to be_empty
         end
       end
 
@@ -197,7 +197,7 @@ module Switchman
           User.connection.enable_query_cache!
           User.all.to_a
           User.create!
-          User.connection.query_cache.should be_empty
+          expect(User.connection.query_cache).to be_empty
         end
 
         it "should not clear thread's query cache if disabled" do
@@ -205,7 +205,7 @@ module Switchman
           User.all.to_a
           User.connection.disable_query_cache!
           User.create!
-          User.connection.query_cache.should_not be_empty
+          expect(User.connection.query_cache).not_to be_empty
         end
 
         it "should not clear thread's query cache if disabled but other thread's enabled" do
@@ -214,7 +214,7 @@ module Switchman
           User.connection.disable_query_cache!
           threaded(
             lambda{ |cc| User.create!; cc.call },
-            lambda{ User.connection.query_cache.should_not be_empty })
+            lambda{ expect(User.connection.query_cache).not_to be_empty })
         end
 
         it "should not clear other thread's query cache" do
@@ -223,7 +223,7 @@ module Switchman
           User.connection.disable_query_cache!
           threaded(
             lambda{ |cc| User.create!; cc.call },
-            lambda{ User.connection.query_cache.should_not be_empty })
+            lambda{ expect(User.connection.query_cache).not_to be_empty })
         end
       end
 
@@ -236,7 +236,7 @@ module Switchman
           User.connection.enable_query_cache!
           User.all.to_a
           User.update_all(updated_at: Time.now)
-          User.connection.query_cache.should be_empty
+          expect(User.connection.query_cache).to be_empty
         end
 
         it "should not clear thread's query cache if disabled" do
@@ -244,7 +244,7 @@ module Switchman
           User.all.to_a
           User.connection.disable_query_cache!
           User.update_all(updated_at: Time.now)
-          User.connection.query_cache.should_not be_empty
+          expect(User.connection.query_cache).not_to be_empty
         end
 
         context "non-transactional" do
@@ -262,7 +262,7 @@ module Switchman
             User.connection.disable_query_cache!
             threaded(
               lambda{ |cc| User.update_all(updated_at: Time.now); cc.call },
-              lambda{ User.connection.query_cache.should_not be_empty })
+              lambda{ expect(User.connection.query_cache).not_to be_empty })
           end
 
           it "should not clear other thread's query cache" do
@@ -271,7 +271,7 @@ module Switchman
             User.connection.disable_query_cache!
             threaded(
               lambda{ |cc| User.update_all(updated_at: Time.now); cc.call },
-              lambda{ User.connection.query_cache.should_not be_empty })
+              lambda{ expect(User.connection.query_cache).not_to be_empty })
           end
         end
       end
@@ -285,7 +285,7 @@ module Switchman
           User.connection.enable_query_cache!
           User.all.to_a
           User.delete_all
-          User.connection.query_cache.should be_empty
+          expect(User.connection.query_cache).to be_empty
         end
 
         it "should not clear thread's query cache if disabled" do
@@ -293,7 +293,7 @@ module Switchman
           User.all.to_a
           User.connection.disable_query_cache!
           User.delete_all
-          User.connection.query_cache.should_not be_empty
+          expect(User.connection.query_cache).not_to be_empty
         end
 
         context "non-transactional" do
@@ -311,7 +311,7 @@ module Switchman
             User.connection.disable_query_cache!
             threaded(
               lambda{ |cc| User.delete_all; cc.call },
-              lambda{ User.connection.query_cache.should_not be_empty })
+              lambda{ expect(User.connection.query_cache).not_to be_empty })
           end
 
           it "should not clear other thread's query cache" do
@@ -320,22 +320,22 @@ module Switchman
             User.connection.disable_query_cache!
             threaded(
               lambda{ |cc| User.delete_all; cc.call },
-              lambda{ User.connection.query_cache.should_not be_empty })
+              lambda{ expect(User.connection.query_cache).not_to be_empty })
           end
 
           it "should clear cache for all connections" do
             u = User.create!(name: 'a')
             User.connection.cache do
-              u.reload.name.should == 'a'
+              expect(u.reload.name).to eq 'a'
               ::Shackles.activate(:slave) do
-                u.reload.name.should == 'a'
+                expect(u.reload.name).to eq 'a'
               end
-              u.reload.name.should == 'a'
+              expect(u.reload.name).to eq 'a'
               u.name = 'b'
               u.save!
-              u.reload.name.should == 'b'
+              expect(u.reload.name).to eq 'b'
               ::Shackles.activate(:slave) do
-                u.reload.name.should == 'b'
+                expect(u.reload.name).to eq 'b'
               end
             end
           end

data/spec/lib/active_record/query_methods_spec.rb

@@ -16,88 +16,88 @@ module Switchman
 
       describe "#primary_shard" do
         it "should be the shard if it's a shard" do
-          User.shard(Shard.default).primary_shard.should == Shard.default
-          User.shard(@shard1).primary_shard.should == @shard1
+          expect(User.shard(Shard.default).primary_shard).to eq Shard.default
+          expect(User.shard(@shard1).primary_shard).to eq @shard1
         end
 
         it "should be the first shard of an array of shards" do
-          User.shard([Shard.default, @shard1]).primary_shard.should == Shard.default
-          User.shard([@shard1, Shard.default]).primary_shard.should == @shard1
+          expect(User.shard([Shard.default, @shard1]).primary_shard).to eq Shard.default
+          expect(User.shard([@shard1, Shard.default]).primary_shard).to eq @shard1
         end
 
         it "should be the object's shard if it's a model" do
-          User.shard(@user1).primary_shard.should == Shard.default
-          User.shard(@user2).primary_shard.should == @shard1
+          expect(User.shard(@user1).primary_shard).to eq Shard.default
+          expect(User.shard(@user2).primary_shard).to eq @shard1
         end
 
         it "should be the default shard if it's a scope of Shard" do
-          User.shard(::Rails.version < '4' ? Shard.scoped : Shard.all).primary_shard.should == Shard.default
+          expect(User.shard(::Rails.version < '4' ? Shard.scoped : Shard.all).primary_shard).to eq Shard.default
           @shard1.activate do
-            User.shard(::Rails.version < '4' ? Shard.scoped : Shard.all).primary_shard.should == Shard.default
+            expect(User.shard(::Rails.version < '4' ? Shard.scoped : Shard.all).primary_shard).to eq Shard.default
           end
         end
       end
 
       it "should default to the current shard" do
         relation = ::Rails.version < '4' ? User.scoped : User.all
-        relation.shard_value.should == Shard.default
-        relation.shard_source_value.should == :implicit
+        expect(relation.shard_value).to eq Shard.default
+        expect(relation.shard_source_value).to eq :implicit
 
         @shard1.activate do
-          relation.shard_value.should == Shard.default
+          expect(relation.shard_value).to eq Shard.default
 
           relation = ::Rails.version < '4' ? User.scoped : User.all
-          relation.shard_value.should == @shard1
-          relation.shard_source_value.should == :implicit
+          expect(relation.shard_value).to eq @shard1
+          expect(relation.shard_source_value).to eq :implicit
         end
-        relation.shard_value.should == @shard1
+        expect(relation.shard_value).to eq @shard1
       end
 
       describe "with primary key conditions" do
         it "should be changeable, and change conditions when it is changed" do
           relation = User.where(:id => @user1).shard(@shard1)
-          relation.shard_value.should == @shard1
-          relation.shard_source_value.should == :explicit
-          relation.where_values.first.right.should == @user1.global_id
+          expect(relation.shard_value).to eq @shard1
+          expect(relation.shard_source_value).to eq :explicit
+          expect(relation.where_values.first.right).to eq @user1.global_id
         end
 
         it "should infer the shard from a single argument" do
           relation = User.where(:id => @user2)
           # execute on @shard1, with id local to that shard
-          relation.shard_value.should == @shard1
-          relation.where_values.first.right.should == @user2.local_id
+          expect(relation.shard_value).to eq @shard1
+          expect(relation.where_values.first.right).to eq @user2.local_id
         end
 
         it "should infer the shard from multiple arguments" do
           relation = User.where(:id => [@user2, @user2])
           # execute on @shard1, with id local to that shard
-          relation.shard_value.should == @shard1
-          relation.where_values.first.right.should == [@user2.local_id, @user2.local_id]
+          expect(relation.shard_value).to eq @shard1
+          expect(relation.where_values.first.right).to eq [@user2.local_id, @user2.local_id]
         end
 
         it "should infer the correct shard from an array of 1" do
           relation = User.where(:id => [@user2])
           # execute on @shard1, with id local to that shard
-          relation.shard_value.should == @shard1
-          relation.where_values.first.right.should == [@user2.local_id]
+          expect(relation.shard_value).to eq @shard1
+          expect(relation.where_values.first.right).to eq [@user2.local_id]
         end
 
         it "should do nothing when it's an array of 0" do
           relation = User.where(:id => [])
           # execute on @shard1, with id local to that shard
-          relation.shard_value.should == Shard.default
-          relation.where_values.first.right.should == []
+          expect(relation.shard_value).to eq Shard.default
+          expect(relation.where_values.first.right).to eq []
         end
 
         it "should order the shards preferring the shard it already had as primary" do
           relation = User.where(:id => [@user1, @user2])
-          relation.shard_value.should == [Shard.default, @shard1]
-          relation.where_values.first.right.should == [@user1.local_id, @user2.global_id]
+          expect(relation.shard_value).to eq [Shard.default, @shard1]
+          expect(relation.where_values.first.right).to eq [@user1.local_id, @user2.global_id]
 
           @shard1.activate do
             relation = User.where(:id => [@user1, @user2])
-            relation.shard_value.should == [@shard1, Shard.default]
-            relation.where_values.first.right.should == [@user1.global_id, @user2.local_id]
+            expect(relation.shard_value).to eq [@shard1, Shard.default]
+            expect(relation.where_values.first.right).to eq [@user1.global_id, @user2.local_id]
           end
         end
       end
@@ -105,36 +105,36 @@ module Switchman
       describe "with foreign key conditions" do
         it "should be changeable, and change conditions when it is changed" do
           relation = Appendage.where(:user_id => @user1)
-          relation.shard_value.should == Shard.default
-          relation.shard_source_value.should == :implicit
-          relation.where_values.first.right.should == @user1.local_id
+          expect(relation.shard_value).to eq Shard.default
+          expect(relation.shard_source_value).to eq :implicit
+          expect(relation.where_values.first.right).to eq @user1.local_id
 
           relation = relation.shard(@shard1)
-          relation.shard_value.should == @shard1
-          relation.shard_source_value.should == :explicit
-          relation.where_values.first.right.should == @user1.global_id
+          expect(relation.shard_value).to eq @shard1
+          expect(relation.shard_source_value).to eq :explicit
+          expect(relation.where_values.first.right).to eq @user1.global_id
         end
 
         it "should translate ids based on current shard" do
           relation = Appendage.where(:user_id => [@user1, @user2])
-          relation.where_values.first.right.should == [@user1.local_id, @user2.global_id]
+          expect(relation.where_values.first.right).to eq [@user1.local_id, @user2.global_id]
 
           @shard1.activate do
             relation = Appendage.where(:user_id => [@user1, @user2])
-            relation.where_values.first.right.should == [@user1.global_id, @user2.local_id]
+            expect(relation.where_values.first.right).to eq [@user1.global_id, @user2.local_id]
           end
         end
 
         it "should translate ids in joins" do
           relation = User.joins(:appendage).where(appendages: { user_id: [@user1, @user2]})
-          relation.where_values.first.right.should == [@user1.local_id, @user2.global_id]
+          expect(relation.where_values.first.right).to eq [@user1.local_id, @user2.global_id]
         end
 
         it "should translate ids according to the current shard of the foreign type" do
           @shard1.activate(:mirror_universe) do
             mirror_user = MirrorUser.create!
             relation = User.where(mirror_user_id: mirror_user)
-            relation.where_values.first.right.should == mirror_user.global_id
+            expect(relation.where_values.first.right).to eq mirror_user.global_id
           end
         end
       end
@@ -143,20 +143,20 @@ module Switchman
         it "should properly construct the query" do
           child = @user1.children.create!
           grandchild = child.children.create!
-          child.reload.parent.should == @user1
+          expect(child.reload.parent).to eq @user1
 
           relation = @user1.association(:grandchildren)
           relation = ::Rails.version < '4' ? relation.scoped : relation.scope
 
           attribute = relation.where_values.first.left
-          attribute.name.to_s.should == 'parent_id'
-          attribute.relation.class.should == Arel::Nodes::TableAlias
+          expect(attribute.name.to_s).to eq 'parent_id'
+          expect(attribute.relation.class).to eq Arel::Nodes::TableAlias
 
           rel, column = relation.send(:relation_and_column, attribute)
-          relation.send(:sharded_primary_key?, rel, column).should == false
-          relation.send(:sharded_foreign_key?, rel, column).should == true
+          expect(relation.send(:sharded_primary_key?, rel, column)).to eq false
+          expect(relation.send(:sharded_foreign_key?, rel, column)).to eq true
 
-          @user1.grandchildren.should == [grandchild]
+          expect(@user1.grandchildren).to eq [grandchild]
         end
       end
     end