activerecord-turntable 1.1.2 → 2.0.0.rc1

data/spec/active_record/turntable/active_record_ext/association_preloader_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe ActiveRecord::Turntable::ActiveRecordExt::Association do
+  before(:all) do
+    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
+  end
+
+  before(:each) do
+    establish_connection_to(:test)
+    truncate_shard
+  end
+
+  let!(:user) do
+    user = User.new({:nickname => 'user1'})
+    user.id = 1
+    user.save
+    user
+  end
+
+  let!(:cards_users) do
+    10.times.map do
+      CardsUser.create(user: user, card_id: 1)
+    end
+  end
+
+  let!(:cards_users_histories) do
+    cards_users.map do |cards_user|
+      CardsUsersHistory.create(cards_user: cards_user, user: user)
+    end
+  end
+
+  let!(:events_users_histories) do
+    cards_users.map do |cards_user|
+      EventsUsersHistory.create(cards_user: cards_user, user: user, events_user_id: user.id)
+    end
+  end
+
+  context "When preloads has_many association" do
+    before do
+      ActiveRecord::Base.turntable_config.instance_variable_get(:@config)[:raise_on_not_specified_shard_query] = true
+    end
+
+    context "associated objects has same turntable_key" do
+      subject { CardsUser.where(user: user).preload(:cards_users_histories).first }
+      it { expect { subject }.to_not raise_error }
+
+      it "its association should be loaded" do
+        expect(subject.association(:cards_users_histories)).to be_loaded
+      end
+
+      it "its has_many targets should be assigned all related object" do
+        expect(subject.cards_users_histories).to include(*cards_users_histories.select { |history| history.cards_user_id == subject.id} )
+      end
+    end
+
+    context "associated objects has different turntable_key" do
+      context "when foreign_shard_key option passed" do
+        subject { CardsUser.where(user: user).preload(:events_users_histories_with_foreign_shard_key).first }
+
+        it { expect { subject }.to_not raise_error }
+
+        it "its association should be loaded" do
+          expect(subject.association(:events_users_histories_with_foreign_shard_key)).to be_loaded
+        end
+
+        it "its has_many targets should be assigned all related object" do
+          expect(subject.events_users_histories_with_foreign_shard_key).to include(*events_users_histories.select { |history| history.cards_user_id == subject.id} )
+        end
+      end
+
+      context "when foreign_shard_key option is not passed" do
+        subject { CardsUser.where(user: user).preload(:events_users_histories).first }
+
+        it { expect { subject }.to raise_error }
+      end
+    end
+  end
+end

data/spec/active_record/turntable/active_record_ext/association_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe ActiveRecord::Turntable::ActiveRecordExt::Association do
+  before(:all) do
+    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
+  end
+
+  before(:each) do
+    establish_connection_to(:test)
+    truncate_shard
+  end
+
+  let!(:user) do
+    user = User.new({:nickname => 'user1'})
+    user.id = 1
+    user.save
+    user
+  end
+
+  let!(:cards_users) do
+    10.times.map do
+      CardsUser.create(user: user, card_id: 1)
+    end
+  end
+
+  let!(:cards_users_histories) do
+    cards_users.map do |cards_user|
+      CardsUsersHistory.create(cards_user: cards_user, user: user)
+    end
+  end
+
+  let!(:events_users_histories) do
+    cards_users.map do |cards_user|
+      EventsUsersHistory.create(cards_user: cards_user, user: user, events_user_id: user.id)
+    end
+  end
+
+  context "When a model with has_one relation" do
+    context "When the has_one associated object doesn't exists" do
+      subject { user.user_status }
+      it { expect { subject }.to_not raise_error }
+    end
+  end
+
+  context "With has_many association" do
+    before do
+      ActiveRecord::Base.turntable_config.instance_variable_get(:@config)[:raise_on_not_specified_shard_query] = true
+    end
+    let(:cards_user) { CardsUser.where(user: user).first }
+
+    context "associated objects has same turntable_key" do
+      subject { cards_user.cards_users_histories }
+      it { expect { subject }.to_not raise_error }
+      it { is_expected.to include(*cards_users_histories.select { |history| history.cards_user_id == cards_user.id }) }
+    end
+
+    context "associated objects has different turntable_key" do
+      context "when foreign_shard_key option passed" do
+        subject { cards_user.events_users_histories_with_foreign_shard_key }
+
+        it { expect { subject }.to_not raise_error }
+        it { is_expected.to include(*events_users_histories.select { |history| history.cards_user_id == cards_user.id }) }
+      end
+
+      context "when foreign_shard_key option is not passed" do
+        subject { CardsUser.where(user: user).events_users_histories }
+
+        it { expect { subject }.to raise_error }
+      end
+    end
+  end
+end

data/spec/active_record/turntable/active_record_ext/clever_load_spec.rb

@@ -7,7 +7,7 @@ describe ActiveRecord::Turntable::ActiveRecordExt::CleverLoad do
   end
 
   before(:each) do
-    establish_connection_to("test")
+    establish_connection_to(:test)
     truncate_shard
 
     @user1 = User.new({:nickname => 'user1'})
@@ -18,76 +18,55 @@ describe ActiveRecord::Turntable::ActiveRecordExt::CleverLoad do
     @user2.id = 2
     @user2.save
     @user2_status = @user2.create_user_status(:hp => 20, :mp => 10)
-    ActiveRecord::Base.logger = Logger.new(STDOUT)
   end
 
   context "When a model has has_one relation" do
     context "When call clever_load!" do
-      before(:each) do
-        @strio = StringIO.new
-        ActiveRecord::Base.logger = Logger.new(@strio)
-        @users = User.clever_load!(:user_status)
-        puts @strio.string
-      end
-      it "should send merged user_status select query" do
-        @strio.string.should =~ //
-      end
+      let(:users) { User.all.clever_load!(:user_status) }
+
+      context "With their associations" do
+        subject { users.map { |u| u.association(:user_status) } }
 
-      it "should target loaded" do
-        if ActiveRecord::VERSION::STRING < "3.1"
-          @users.each do |user|
-            user.loaded_user_status?.should be_true
-          end
-        else
-          @users.each do |user|
-            user.association(:user_status).loaded?.should be_true
-          end
+        it "should be association target loaded" do
+          is_expected.to all(be_loaded)
         end
       end
 
-      it "should assigned reverse relation" do
-        pending "should be implemented"
+      context "With their targets" do
+        subject { users.map { |u| u.association(:user_status).target } }
+
+        it "should be loaded target object" do
+          is_expected.to all(be_instance_of(UserStatus))
+        end
       end
     end
   end
 
   context "When a model has belongs_to relation" do
     context "When call clever_load!" do
-      before(:each) do
-        @strio = StringIO.new
-        @strio = StringIO.new
-        ActiveRecord::Base.logger = Logger.new(@strio)
-        @user_statuses = UserStatus.clever_load!(:user)
-        puts @strio.string
-      end
+      let(:user_statuses) { UserStatus.all.clever_load!(:user) }
 
-      it "should send merged user_status select query" do
-        @strio.string.should =~ //
-      end
+      context "With their associations" do
+        subject { user_statuses.map { |us| us.association(:user) } }
 
-      it "should target loaded" do
-        if ActiveRecord::VERSION::STRING < "3.1"
-          @user_statuses.each do |user_status|
-            user_status.loaded_user?.should be_true
-          end
-        else
-          @user_statuses.each do |user_status|
-            user_status.association(:user).loaded?.should be_true
-          end
+        it "should target loaded" do
+          is_expected.to all(be_loaded)
         end
       end
 
-      it "should assigned reverse relation" do
-        pending "should be implemented"
+      context "With their targets" do
+        subject { user_statuses.map { |us| us.association(:user).target } }
+
+        it "should be loaded target object" do
+          is_expected.to all(be_instance_of(User))
+        end
       end
     end
   end
 
   context "When a model has has_many relation" do
     it "should send query only 2 times." do
-      pending "not implemented yet"
+      skip "not implemented yet"
     end
   end
-
-
 end

data/spec/active_record/turntable/active_record_ext/locking_optimistic_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ActiveRecord::Turntable::ActiveRecordExt::LockingOptimistic do
+  before(:all) do
+    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
+  end
+
+  before(:each) do
+    establish_connection_to(:test)
+    truncate_shard
+  end
+
+  before do
+    ActiveRecord::Base.turntable_config.instance_variable_get(:@config)[:raise_on_not_specified_shard_update] = true
+  end
+
+  let!(:user_status) do
+    user_status = UserStatus.new(user_id: 1)
+    user_status.id = 10
+    user_status.save
+    user_status
+  end
+
+  describe "optimistic locking" do
+    subject { user_status.update_attributes(hp: 20) }
+    it { expect { subject }.to change(user_status, :lock_version).by(1) }
+  end
+end

data/spec/active_record/turntable/active_record_ext/persistence_spec.rb

@@ -7,9 +7,15 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
   end
 
   before(:each) do
-    establish_connection_to("test")
+    establish_connection_to(:test)
     truncate_shard
+  end
+
+  around(:each) do |example|
+    old = ActiveRecord::Base.logger
     ActiveRecord::Base.logger = Logger.new(STDOUT)
+    example.run
+    ActiveRecord::Base.logger = old
   end
 
   let(:user) {
@@ -37,24 +43,24 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
       expect {
         user.save!
       }.to_not raise_error
-      strio.string.should =~ /WHERE `users`\.`id` = #{user.id}[^\s]*$/
+      expect(strio.string).to match(/WHERE `users`\.`id` = #{user.id}[^\s]*$/)
+    end
+
+    it "should be saved to target_shard" do
+      expect(user).to be_saved_to(user.turntable_shard)
     end
 
     it "should change updated_at when updating" do
       user.nickname = "fizzbuzz"
 
-      lambda {
-        user.save!
-      }.should change(user, :updated_at)
+      expect { user.save! }.to change(user, :updated_at)
     end
 
     it "should not changed from normal operation when destroying" do
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
-      expect {
-        user.destroy
-      }.to_not raise_error
-      strio.string.should =~ /WHERE `users`\.`id` = #{user.id}[^\s]*$/
+      expect { user.destroy }.to_not raise_error
+      expect(strio.string).to match(/WHERE `users`\.`id` = #{user.id}[^\s]*$/)
     end
   end
 
@@ -74,13 +80,13 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
 
     context "on update once" do
       it "callback should be called once" do
-        mock(user).on_update.times(1)
+        expect(user).to receive(:on_update).once
         user.save
       end
     end
     context "on destroy once" do
       it "callback should be called once" do
-        mock(user).on_destroy.times(1)
+        expect(user).to receive(:on_destroy).once
         user.destroy
       end
     end
@@ -95,15 +101,15 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
       expect {
         user_status.save!
       }.to_not raise_error
-      strio.string.should =~ /WHERE `user_statuses`\.`id` = #{user_status.id} AND `user_statuses`\.`user_id` = #{user_status.user_id}[^\s]*$/
+      expect(strio.string).to match(/`user_statuses`\.`user_id` = #{user_status.user_id}[^\s]*($|\s)/)
     end
 
     it "should change updated_at when updating" do
       user_status.hp = 20
 
-      lambda {
+      expect {
         user_status.save!
-      }.should change(user_status, :updated_at)
+      }.to change(user_status, :updated_at)
     end
 
     it "should send shard_key condition when destroying" do
@@ -112,11 +118,11 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
       expect {
         user_status.destroy
       }.to_not raise_error
-      strio.string.should =~ /WHERE `user_statuses`\.`id` = #{user_status.id} AND `user_statuses`\.`user_id` = #{user_status.user_id}[^\s]*$/
+      expect(strio.string).to match(/`user_statuses`\.`user_id` = #{user_status.user_id}[^\s]*($|\s)/)
     end
 
     it "should warn when creating without shard_key" do
-      pending "doesn't need to implemented soon"
+      skip "doesn't need to implemented soon"
     end
 
     it "should execute one query when reloading" do
@@ -124,12 +130,27 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
       strio = StringIO.new
       ActiveRecord::Base.logger = Logger.new(strio)
 
-      expect {
-        user_status.reload
-      }.to_not raise_error
-      puts strio.string
+      expect { user_status.reload }.to_not raise_error
+
+      expect(strio.string.split("\n").select {|stmt| stmt =~ /SELECT/ and stmt !~ /Turntable/ }).to have(1).items
+    end
+
+    it "should execute one query when touching" do
+      user; user_status
+      strio = StringIO.new
+      ActiveRecord::Base.logger = Logger.new(strio)
+
+      expect { user_status.touch }.to_not raise_error
+      expect(strio.string.split("\n").select {|stmt| stmt =~ /UPDATE/ and stmt !~ /Turntable/ }).to have(1).items
+    end
+
+    it "should execute one query when locking" do
+      user; user_status
+      strio = StringIO.new
+      ActiveRecord::Base.logger = Logger.new(strio)
 
-      strio.string.split("\n").select {|stmt| stmt =~ /SELECT/ and stmt !~ /Turntable/ }.should have(1).items
+      expect { user_status.lock! }.to_not raise_error
+      expect(strio.string.split("\n").select {|stmt| stmt =~ /SELECT/ and stmt !~ /Turntable/ }).to have(1).items
     end
   end
 
@@ -141,7 +162,7 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
       expect {
         card.save!
       }.to_not raise_error
-      strio.string.should =~ /WHERE `cards`\.`id` = #{card.id}[^\s]*$/
+      expect(strio.string).to match(/WHERE `cards`\.`id` = #{card.id}[^\s]*$/)
     end
 
     it "should not send shard_key condition when destroying" do
@@ -150,14 +171,14 @@ describe ActiveRecord::Turntable::ActiveRecordExt::Persistence do
       expect {
         card.destroy
       }.to_not raise_error
-      strio.string.should =~ /WHERE `cards`\.`id` = #{card.id}[^\s]*$/
+      expect(strio.string).to match(/WHERE `cards`\.`id` = #{card.id}[^\s]*$/)
     end
   end
 
   context "When call reload" do
     subject { user_status.reload }
-    it { should be_instance_of(UserStatus)}
-    it { should == user_status }
+    it { is_expected.to be_instance_of(UserStatus)}
+    it { is_expected.to eq(user_status) }
   end
 
 end

data/spec/active_record/turntable/algorithm/range_algorithm_spec.rb

@@ -12,22 +12,22 @@ describe ActiveRecord::Turntable::Algorithm::RangeAlgorithm do
 
     context "#calculate with 1" do
       subject { @alg.calculate(1) }
-      it { should == ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection] }
+      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
     end
 
     context "#calculate with 19999" do
       subject { @alg.calculate(19999) }
-      it { should == ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection] }
+      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
     end
 
     context "#calculate with 20000" do
       subject { @alg.calculate(20000) }
-      it { should == ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][1][:connection] }
+      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][1][:connection]) }
     end
 
     context "#calculate with 10000000" do
       it "raises ActiveRecord::Turntable::CannotSpecifyShardError" do
-        lambda { @alg.calculate(10000000) }.should raise_error(ActiveRecord::Turntable::CannotSpecifyShardError)
+        expect { @alg.calculate(10000000) }.to raise_error(ActiveRecord::Turntable::CannotSpecifyShardError)
       end
     end
   end

data/spec/active_record/turntable/algorithm/range_bsearch_algorithm_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ActiveRecord::Turntable::Algorithm::RangeBsearchAlgorithm do
+  before(:all) do
+    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
+  end
+
+  context "When initialized" do
+    before do
+      @alg = ActiveRecord::Turntable::Algorithm::RangeBsearchAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster])
+    end
+
+    context "#calculate with 1" do
+      subject { @alg.calculate(1) }
+      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
+    end
+
+    context "#calculate with 19999" do
+      subject { @alg.calculate(19999) }
+      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
+    end
+
+    context "#calculate with 20000" do
+      subject { @alg.calculate(20000) }
+      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][1][:connection]) }
+    end
+
+    context "#calculate with 10000000" do
+      it "raises ActiveRecord::Turntable::CannotSpecifyShardError" do
+        expect { @alg.calculate(10000000) }.to raise_error(ActiveRecord::Turntable::CannotSpecifyShardError)
+      end
+    end
+  end
+
+end

data/spec/active_record/turntable/algorithm_spec.rb

@@ -9,29 +9,37 @@ describe ActiveRecord::Turntable::Algorithm do
     let(:algorithm) { ActiveRecord::Turntable::Algorithm::RangeBsearchAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
     context "#calculate" do
       it "called with 1 returns user_shard_1" do
-        algorithm.calculate(1).should == "user_shard_1"
+        expect(algorithm.calculate(1)).to eq("user_shard_1")
+      end
+
+      it "called with 19999 returns user_shard_1" do
+        expect(algorithm.calculate(19999)).to eq("user_shard_1")
+      end
+
+      it "called with 20000 returns user_shard_2" do
+        expect(algorithm.calculate(20000)).to eq("user_shard_2")
       end
 
       it "called with 100000 returns user_shard_3" do
-        algorithm.calculate(100000).should == "user_shard_3"
+        expect(algorithm.calculate(100000)).to eq("user_shard_3")
       end
     end
 
     context "#calculate_used_shards_with_weight" do
       it "called with 10 returns 1 item" do
-        algorithm.calculate_used_shards_with_weight(10).should have(1).items
+        expect(algorithm.calculate_used_shards_with_weight(10)).to have(1).items
       end
 
       it "called with 10 returns {\"user_shard_1\" => 10}" do
-        algorithm.calculate_used_shards_with_weight(10).should == {"user_shard_1" => 10}
+        expect(algorithm.calculate_used_shards_with_weight(10)).to eq({"user_shard_1" => 10})
       end
 
       it "called with 65000 returns 2 items" do
-        algorithm.calculate_used_shards_with_weight(65000).should have(2).items
+        expect(algorithm.calculate_used_shards_with_weight(65000)).to have(2).items
       end
 
       it "called with 65000 returns {\"user_shard_1\" => 39999, \"user_shard_2\" => 25001}" do
-        algorithm.calculate_used_shards_with_weight(65000).should == {"user_shard_1" => 39999, "user_shard_2" => 25001}
+        expect(algorithm.calculate_used_shards_with_weight(65000)).to eq({"user_shard_1" => 39999, "user_shard_2" => 25001})
       end
     end
   end
@@ -40,29 +48,37 @@ describe ActiveRecord::Turntable::Algorithm do
     let(:algorithm) { ActiveRecord::Turntable::Algorithm::RangeAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
     context "#calculate" do
       it "called with 1 returns user_shard_1" do
-        algorithm.calculate(1).should == "user_shard_1"
+        expect(algorithm.calculate(1)).to eq("user_shard_1")
+      end
+
+      it "called with 19999 returns user_shard_1" do
+        expect(algorithm.calculate(19999)).to eq("user_shard_1")
+      end
+
+      it "called with 20000 returns user_shard_2" do
+        expect(algorithm.calculate(20000)).to eq("user_shard_2")
       end
 
       it "called with 100000 returns user_shard_3" do
-        algorithm.calculate(100000).should == "user_shard_3"
+        expect(algorithm.calculate(100000)).to eq("user_shard_3")
       end
     end
 
     context "#calculate_used_shards_with_weight" do
       it "called with 10 returns 1 item" do
-        algorithm.calculate_used_shards_with_weight(10).should have(1).items
+        expect(algorithm.calculate_used_shards_with_weight(10)).to have(1).items
       end
 
       it "called with 10 returns {\"user_shard_1\" => 10}" do
-        algorithm.calculate_used_shards_with_weight(10).should == {"user_shard_1" => 10}
+        expect(algorithm.calculate_used_shards_with_weight(10)).to eq({"user_shard_1" => 10})
       end
 
       it "called with 65000 returns 2 items" do
-        algorithm.calculate_used_shards_with_weight(65000).should have(2).items
+        expect(algorithm.calculate_used_shards_with_weight(65000)).to have(2).items
       end
 
       it "called with 65000 returns {\"user_shard_1\" => 39999, \"user_shard_2\" => 25001}" do
-        algorithm.calculate_used_shards_with_weight(65000).should == {"user_shard_1" => 39999, "user_shard_2" => 25001}
+        expect(algorithm.calculate_used_shards_with_weight(65000)).to eq({"user_shard_1" => 39999, "user_shard_2" => 25001})
       end
     end
   end

data/spec/active_record/turntable/base_spec.rb

@@ -7,7 +7,7 @@ describe ActiveRecord::Turntable::Base do
 
   context "When installed to ActiveRecord::Base" do
     it "ActiveRecord::Base respond_to 'turntable'" do
-      ActiveRecord::Base.should respond_to(:turntable)
+      expect(ActiveRecord::Base).to respond_to(:turntable)
     end
   end
 end

data/spec/active_record/turntable/cluster_spec.rb

@@ -5,14 +5,36 @@ describe ActiveRecord::Turntable::Cluster do
     reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
   end
 
+  before do
+    establish_connection_to(:test)
+    truncate_shard
+  end
+  let(:cluster_config) { ActiveRecord::Base.turntable_config[:clusters][:user_cluster] }
+  let(:cluster) { ActiveRecord::Turntable::Cluster.new(User, cluster_config) }
+  let(:in_range_shard_key_value) { cluster_config[:shards].last[:less_than] - 1 }
+  let(:out_of_range_shard_key_value) { cluster_config[:shards].last[:less_than] }
+
   context "When initialized" do
-    before do
-      establish_connection_to("test")
-      truncate_shard
-    end
+    subject { cluster }
 
-    subject { ActiveRecord::Turntable::Cluster.new(User, ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
     its(:klass) { should == User }
     its(:shards) { should have(3).items }
   end
+
+  describe "#shard_for" do
+    subject { cluster.shard_for(value) }
+
+    context "with argument in shard range value" do
+      let(:value) { in_range_shard_key_value }
+      let(:expected_shard_name) { cluster_config[:shards].last[:connection] }
+
+      it { is_expected.to be_instance_of(ActiveRecord::Turntable::Shard) }
+      its(:name) { is_expected.to eq expected_shard_name }
+    end
+
+    context "with argument out of shard range value" do
+      let(:value) { out_of_range_shard_key_value }
+      it { expect { subject }.to raise_error(ActiveRecord::Turntable::CannotSpecifyShardError) }
+    end
+  end
 end

data/spec/active_record/turntable/config_spec.rb

@@ -8,10 +8,10 @@ describe ActiveRecord::Turntable::Config do
   subject { ActiveRecord::Turntable::Config }
 
   it "has config hash" do
-    subject.instance.instance_variable_get(:@config).should be_an_kind_of(Hash)
+    expect(subject.instance.instance_variable_get(:@config)).to be_an_kind_of(Hash)
   end
 
   it "has cluster setting" do
-    subject[:clusters][:user_cluster].should be_instance_of(ActiveSupport::HashWithIndifferentAccess)
+    expect(subject[:clusters][:user_cluster]).to be_instance_of(ActiveSupport::HashWithIndifferentAccess)
   end
 end