switchman 1.2.10 → 1.2.11

data/spec/lib/active_record/relation_spec.rb

@@ -12,25 +12,25 @@ module Switchman
 
       describe "#exec_queries" do
         it "should activate the correct shard for the query" do
-          User.shard(@shard1).where(:id => @user2.local_id).first.should == @user2
+          expect(User.shard(@shard1).where(:id => @user2.local_id).first).to eq @user2
         end
 
         it "should activate multiple shards if necessary" do
-          User.where(:id => [@user1.id, @user2.id]).sort_by(&:id).should == [@user1, @user2].sort_by(&:id)
+          expect(User.where(:id => [@user1.id, @user2.id]).sort_by(&:id)).to eq [@user1, @user2].sort_by(&:id)
         end
       end
 
       describe "#update_all" do
         it "should activate the correct shard for the query" do
           User.shard(@shard1).where(:id => @user2.local_id).update_all(:name => 'a')
-          @user1.reload.name.should == 'user1'
-          @user2.reload.name.should == 'a'
+          expect(@user1.reload.name).to eq 'user1'
+          expect(@user2.reload.name).to eq 'a'
         end
 
         it "should activate multiple shards if necessary" do
           User.where(:id => [@user1.id, @user2.id]).update_all(:name => 'a')
-          @user1.reload.name.should == 'a'
-          @user2.reload.name.should == 'a'
+          expect(@user1.reload.name).to eq 'a'
+          expect(@user2.reload.name).to eq 'a'
         end
       end
 
@@ -38,8 +38,8 @@ module Switchman
         it "should infer the scope's shard" do
           scope = @shard1.activate { User.where(id: 1) }
           u = scope.new
-          u.shard.should == @shard1
-          u.local_id.should == 1
+          expect(u.shard).to eq @shard1
+          expect(u.local_id).to eq 1
         end
       end
     end

data/spec/lib/active_record/spawn_methods_spec.rb

@@ -8,35 +8,35 @@ module Switchman
       describe "#merge" do
         it "should merge shard_value for multiple explicits" do
           result = User.shard([@shard1, @shard2]).merge(User.shard([Shard.default, @shard1]))
-          result.shard_value.should == @shard1
-          result.shard_source_value.should == :explicit
+          expect(result.shard_value).to eq @shard1
+          expect(result.shard_source_value).to eq :explicit
         end
 
         it "should merge shard_value relations for multiple explicits" do
           result = User.shard(Shard.where("id IN (?)", [@shard1, @shard2])).merge(User.shard(Shard.where(id: [Shard.default, @shard1])))
-          (::ActiveRecord::Relation === result.shard_value).should be_true
-          result.shard_value.to_a.should == [@shard1]
-          result.shard_source_value.should == :explicit
+          expect(::ActiveRecord::Relation === result.shard_value).to eq true
+          expect(result.shard_value.to_a).to eq [@shard1]
+          expect(result.shard_source_value).to eq :explicit
         end
 
         it "should ignore implicit shard value lhs" do
           scope = ::Rails.version < '4' ? User.scoped : User.all
           result = scope.merge(User.shard(@shard1))
-          result.shard_value.should == @shard1
-          result.shard_source_value.should == :explicit
+          expect(result.shard_value).to eq @shard1
+          expect(result.shard_source_value).to eq :explicit
         end
 
         it "should ignore implicit shard value rhs" do
           result = User.shard(@shard1).merge(::Rails.version < '4' ? User.scoped : User.all)
-          result.shard_value.should == @shard1
-          result.shard_source_value.should == :explicit
+          expect(result.shard_value).to eq @shard1
+          expect(result.shard_source_value).to eq :explicit
         end
 
         it "should take lhs shard_value for double implicit" do
           scope1 = @shard2.activate { ::Rails.version < '4' ? User.scoped : User.all }
           result = scope1.merge(::Rails.version < '4' ? User.scoped : User.all)
-          result.shard_value.should == @shard2
-          result.shard_source_value.should == :implicit
+          expect(result.shard_value).to eq @shard2
+          expect(result.shard_source_value).to eq :implicit
         end
       end
     end

data/spec/lib/connection_pool_proxy_spec.rb

@@ -8,8 +8,8 @@ module Switchman
       @db = DatabaseServer.create(:config => { :adapter => 'sqlite3', :database => ':memory:' })
       @sqlite_shard1 = @db.shards.create!
       @sqlite_shard2 = @db.shards.create!
-      ::ActiveRecord::Base.connection.should_not == @sqlite_shard2.activate { ::ActiveRecord::Base.connection }
-      @sqlite_shard1.activate { ::ActiveRecord::Base.connection }.should_not == @sqlite_shard2.activate { ::ActiveRecord::Base.connection }
+      expect(::ActiveRecord::Base.connection).not_to eq @sqlite_shard2.activate { ::ActiveRecord::Base.connection }
+      expect(@sqlite_shard1.activate { ::ActiveRecord::Base.connection }).not_to eq @sqlite_shard2.activate { ::ActiveRecord::Base.connection }
     end
 
     it "should forward clear_idle_connections! to each of its pools" do

data/spec/lib/database_server_spec.rb

@@ -5,37 +5,37 @@ module Switchman
     describe "shareable?" do
       it "should be false for sqlite" do
         db = DatabaseServer.new(config: { adapter: 'sqlite3', database: '%{shard_name}' })
-        db.shareable?.should be_false
+        expect(db.shareable?).to eq false
       end
 
       it "should be true for mysql" do
         db = DatabaseServer.new(config: { adapter: 'mysql' })
-        db.shareable?.should be_true
+        expect(db.shareable?).to eq true
 
         db = DatabaseServer.new(config: { adapter: 'mysql2' })
-        db.shareable?.should be_true
+        expect(db.shareable?).to eq true
       end
 
       it "should be true for postgres with a non-variable username" do
         db = DatabaseServer.new(config: { adapter: 'postgresql' })
-        db.shareable?.should be_true
+        expect(db.shareable?).to eq true
       end
 
       it "should be false for postgres with variable username" do
         db = DatabaseServer.new(config: { adapter: 'postgresql', username: '%{schema_search_path}' })
-        db.shareable?.should be_false
+        expect(db.shareable?).to eq false
       end
 
       it "should depend on the database environment" do
         db = DatabaseServer.new(config: { adapter: 'postgresql', username: '%{schema_search_path}', deploy: { username: 'deploy' }})
-        db.shareable?.should be_false
-        ::Shackles.activate(:deploy) { db.shareable? }.should be_true
+        expect(db.shareable?).to eq false
+        expect(::Shackles.activate(:deploy) { db.shareable? }).to eq true
       end
 
       it "should handle string keys" do
         db = DatabaseServer.new(config: { adapter: 'postgresql', username: '%{schema_search_path}', deploy: { 'username' => 'deploy' }})
-        db.shareable?.should be_false
-        ::Shackles.activate(:deploy) { db.shareable? }.should be_true
+        expect(db.shareable?).to eq false
+        expect(::Shackles.activate(:deploy) { db.shareable? }).to eq true
       end
     end
 
@@ -50,19 +50,19 @@ module Switchman
       adapter = ::ActiveRecord::Base.connection.adapter_name
       def create_shard(server)
         new_shard = server.create_new_shard
-        new_shard.should_not be_new_record
-        new_shard.name.should match /shard_#{new_shard.id}/
+        expect(new_shard).not_to be_new_record
+        expect(new_shard.name).to match /shard_#{new_shard.id}/
         # They should share a connection pool
         if server == Shard.default.database_server
-          User.connection_pool.current_pool.should == new_shard.activate { User.connection_pool.current_pool }
-          User.connection_pool.current_pool.should == Shard.connection_pool.current_pool
+          expect(User.connection_pool.current_pool).to eq new_shard.activate { User.connection_pool.current_pool }
+          expect(User.connection_pool.current_pool).to eq Shard.connection_pool.current_pool
         else
-          User.connection_pool.current_pool.should_not == new_shard.activate { User.connection_pool.current_pool }
+          expect(User.connection_pool.current_pool).not_to eq new_shard.activate { User.connection_pool.current_pool }
         end
         # The tables should be created, ready to use
         new_shard.activate {
           a = User.create!
-          a.should_not be_new_record
+          expect(a).not_to be_new_record
         }
       ensure
         if new_shard
@@ -90,7 +90,7 @@ module Switchman
 
       it "should be able to create a new shard from a db server that doesn't have any shards" do
         # otherwise it's a repeat of the sqlite spec above
-        pending 'A "real" database"' unless %w{MySQL Mysql2 PostgreSQL}.include?(adapter)
+        skip 'A "real" database"' unless %w{MySQL Mysql2 PostgreSQL}.include?(adapter)
 
         # So, it's really the same server, but we want separate connections
         db = DatabaseServer.create(:config => Shard.default.database_server.config)
@@ -105,7 +105,7 @@ module Switchman
       it "should use the connection's db name as temp db name" do
         db = DatabaseServer.new(config: { adapter: 'postgresql' })
         Shard.expects(:create!).with(:name => Shard.default.name, :database_server => db).raises(MyException.new)
-        lambda { db.create_new_shard }.should raise_error(MyException)
+        expect { db.create_new_shard }.to raise_error(MyException)
       end
     end
 
@@ -115,38 +115,38 @@ module Switchman
                         slave: [nil, { database: 'slave' }],
                         deploy: { username: 'deploy' }}
         ds = DatabaseServer.new(config: base_config)
-        ds.config.should == base_config
-        ds.config(:slave).should == [{ database: 'db', deploy: base_config[:deploy] },
+        expect(ds.config).to eq base_config
+        expect(ds.config(:slave)).to eq [{ database: 'db', deploy: base_config[:deploy] },
                                      { database: 'slave', deploy: base_config[:deploy] }]
-        ds.config(:deploy).should == { database: 'db', username: 'deploy', slave: base_config[:slave], deploy: base_config[:deploy] }
+        expect(ds.config(:deploy)).to eq({ database: 'db', username: 'deploy', slave: base_config[:slave], deploy: base_config[:deploy] })
       end
     end
 
     describe "#shackles_environment" do
       it "should inherit from Shackles.environment" do
         ds = DatabaseServer.new
-        ds.shackles_environment.should == :master
+        expect(ds.shackles_environment).to eq :master
         ::Shackles.activate(:slave) do
-          ds.shackles_environment.should == :slave
+          expect(ds.shackles_environment).to eq :slave
         end
       end
 
       it "should override Shackles.environment when explicitly set" do
         ds = DatabaseServer.new
         ds.shackle!
-        ds.shackles_environment.should == :slave
+        expect(ds.shackles_environment).to eq :slave
         ds.unshackle do
-          ds.shackles_environment.should == :master
+          expect(ds.shackles_environment).to eq :master
         end
-        ds.shackles_environment.should == :slave
+        expect(ds.shackles_environment).to eq :slave
         ::Shackles.activate(:slave) do
-          ds.shackles_environment.should == :slave
+          expect(ds.shackles_environment).to eq :slave
           ds.unshackle do
-            ds.shackles_environment.should == :slave
+            expect(ds.shackles_environment).to eq :slave
           end
-          ds.shackles_environment.should == :slave
+          expect(ds.shackles_environment).to eq :slave
         end
-        ds.shackles_environment.should == :slave
+        expect(ds.shackles_environment).to eq :slave
       end
     end
 
@@ -164,12 +164,12 @@ module Switchman
       end
 
       it "should prefer the cache specific to the database" do
-        @db.cache_store.object_id.should == @db_store.object_id
+        expect(@db.cache_store.object_id).to eq @db_store.object_id
       end
 
       it "should fallback to Rails.cache_without_sharding if no specific cache" do
         Switchman.config[:cache_map].delete(@db.id)
-        @db.cache_store.object_id.should == @default_store.object_id
+        expect(@db.cache_store.object_id).to eq @default_store.object_id
       end
     end
 
@@ -200,20 +200,20 @@ module Switchman
       end
 
       it "should return the default server if that's the only one around" do
-        DatabaseServer.server_for_new_shard.should == @db1
+        expect(DatabaseServer.server_for_new_shard).to eq @db1
       end
 
       it "should return on open server" do
         @db1.config[:open] = true
-        DatabaseServer.server_for_new_shard.should == @db1
+        expect(DatabaseServer.server_for_new_shard).to eq @db1
       end
 
       it "should return another server if it's the only one open" do
         @db2 = DatabaseServer.create(:config => { :open => true})
-        4.times { DatabaseServer.server_for_new_shard.should == @db2 }
+        4.times { expect(DatabaseServer.server_for_new_shard).to eq @db2 }
         @db2.config.delete(:open)
         @db1.config[:open] = true
-        4.times { DatabaseServer.server_for_new_shard.should == @db1 }
+        4.times { expect(DatabaseServer.server_for_new_shard).to eq @db1 }
       end
 
       it "should return multiple open servers" do
@@ -223,8 +223,8 @@ module Switchman
         20.times do
           dbs << DatabaseServer.server_for_new_shard
         end
-        dbs.should include(@db1)
-        dbs.should include(@db2)
+        expect(dbs).to include(@db1)
+        expect(dbs).to include(@db2)
       end
     end
   end

data/spec/lib/default_shard_spec.rb

@@ -6,13 +6,13 @@ module Switchman
       include RSpecHelper
 
       it "should be equivalent to a real default shard" do
-        Shard.default.should be_is_a(Shard)
-        DefaultShard.send(:new).should == Shard.default
+        expect(Shard.default).to be_is_a(Shard)
+        expect(DefaultShard.send(:new)).to eq Shard.default
       end
     end
 
     it "all defaultshards should be equivalent to each other" do
-      DefaultShard.send(:new).should == DefaultShard.send(:new)
+      expect(DefaultShard.send(:new)).to eq DefaultShard.send(:new)
     end
   end
 end

data/spec/lib/r_spec_helper_spec.rb

@@ -2,20 +2,46 @@ require "spec_helper"
 
 module Switchman
   describe RSpecHelper do
+    context "unsharded" do
+      it "doesn't make shards accessible" do
+        # by virtue of including RSpecHelper somewhere, test shards will
+        # always already be set up by this point (though not accessible),
+        # but only if we are running a sharding spec
+        expect(Shard.count).to eq 0
+        expect(Shard.default).to be_a(DefaultShard)
+      end
+
+      it "doesn't set up sharding at all if no sharded specs are run" do
+        run_groups = RSpec.world.filtered_examples.select{ |k, v| v.present? }.map(&:first)
+        pending "run without other sharding specs" if run_groups.any?{ |group| RSpecHelper.included_in?(group) }
+
+        expect(RSpecHelper.class_variable_defined?(:@@default_shard)).to eq false
+        expect(RSpecHelper.class_variable_get(:@@shard1)).to be_nil
+      end
+
+      it "sets up sharding but hides it if other sharding specs are run" do
+        run_groups = RSpec.world.filtered_examples.select{ |k, v| v.present? }.map(&:first)
+        pending "run alongside sharding specs" unless run_groups.any?{ |group| RSpecHelper.included_in?(group) }
+
+        expect(RSpecHelper.class_variable_get(:@@default_shard)).to be_a(Shard)
+        expect(RSpecHelper.class_variable_get(:@@shard1)).to be_a(Shard)
+      end
+    end
+
     context "sharding" do
       # strategically place these before we include the module
       before(:all) do
-        Shard.default.should be_a(DefaultShard)
+        expect(Shard.default).to be_a(DefaultShard)
       end
 
       after(:all) do
-        Shard.default.should be_a(DefaultShard)
+        expect(Shard.default).to be_a(DefaultShard)
       end
 
       include RSpecHelper
 
       it "should make the default shard a real shard" do
-        Shard.default.should be_a(Shard)
+        expect(Shard.default).to be_a(Shard)
       end
     end
 
@@ -54,18 +80,18 @@ module Switchman
 
       it "should support nested transactions" do
         @shard2.activate do |shard|
-          User.count.should == 1 # we get the user from the before :all
+          expect(User.count).to eq 1 # we get the user from the before :all
           User.create! # should only last for the duration of this spec
           conn = ::ActiveRecord::Base.connection
-          conn.open_transactions.should eql 2
+          expect(conn.open_transactions).to eql 2
         end
       end
 
       prepend_after :all do
         @shard2.activate do
-          User.count.should == 1
+          expect(User.count).to eq 1
           conn = ::ActiveRecord::Base.connection
-          conn.open_transactions.should eql 1 # RSpecHelper shouldn't have rolled back the before :all one above
+          expect(conn.open_transactions).to eql 1 # RSpecHelper shouldn't have rolled back the before :all one above
           rollback_transaction(::ActiveRecord::Base.connection)
         end
       end

data/spec/lib/rails_spec.rb

@@ -9,19 +9,19 @@ module Switchman
       s1 = db.shards.create!
       s2 = db.shards.create!
 
-      s1.activate { ::Rails.cache }.should == s2.activate { ::Rails.cache }
+      expect(s1.activate { ::Rails.cache }).to eq s2.activate { ::Rails.cache }
 
       from_1 = s1.activate { ::Rails.cache.fetch('key') { 1 } }
-      from_1.should == 1
+      expect(from_1).to eq 1
       from_2 = s2.activate do
         ::Rails.cache.fetch('key') { 2 }
       end
-      from_2.should == 2
+      expect(from_2).to eq 2
 
       from_1 = s1.activate { ::Rails.cache.fetch('key') }
-      from_1.should == 1
+      expect(from_1).to eq 1
       from_2 = s2.activate { ::Rails.cache.fetch('key') }
-      from_2.should == 2
+      expect(from_2).to eq 2
     end
 
     it "should not be assignable" do

data/spec/lib/shackles_spec.rb

@@ -18,7 +18,7 @@ module Switchman
         @current_pool = ::Shackles.activate(:slave) { ::ActiveRecord::Base.connection_pool.current_pool }
       end
       ::Shackles.activate(:slave) do
-        ::ActiveRecord::Base.connection_pool.default_pool.should_not == @current_pool
+        expect(::ActiveRecord::Base.connection_pool.default_pool).not_to eq @current_pool
       end
     end
 
@@ -30,9 +30,9 @@ module Switchman
         models = ::ActiveRecord::Base.connection_handler.send(:class_to_pool)
         pools = {}
         models.each_pair { |k, v| pools[k] = v.current_pool }
-        default_pools.keys.sort.should == pools.keys.sort
+        expect(default_pools.keys.sort).to eq pools.keys.sort
         default_pools.keys.each do |model|
-          default_pools[model].should_not == pools[model]
+          expect(default_pools[model]).not_to eq pools[model]
         end
       end
     end
@@ -47,7 +47,7 @@ module Switchman
       s = ds.shards.create!
       s.activate do
         User.connection
-        User.connection_pool.spec.config[:host].should_not == 'some.postgres.server'
+        expect(User.connection_pool.spec.config[:host]).not_to eq 'some.postgres.server'
       end
     end
 
@@ -55,8 +55,8 @@ module Switchman
       begin
         Shard.default.database_server.shackle!
         @shard2.activate do
-          Shard.default.database_server.shackles_environment.should == :slave
-          ::Shackles.environment.should == :master
+          expect(Shard.default.database_server.shackles_environment).to eq :slave
+          expect(::Shackles.environment).to eq :master
 
           Shard.default.database_server.expects(:unshackle).once
           User.shard(Shard.default).update_all(updated_at: nil)
@@ -69,13 +69,13 @@ module Switchman
     it "should deshackle for FOR UPDATE queries" do
       begin
         Shard.default.database_server.shackle!
-        Shard.default.database_server.shackles_environment.should == :slave
+        expect(Shard.default.database_server.shackles_environment).to eq :slave
 
         u = User.create!
         Shard.default.database_server.expects(:unshackle).once.returns([])
         User.lock.first
         Shard.default.database_server.expects(:unshackle).once.returns([])
-        lambda { u.lock! }.should raise_error(::ActiveRecord::RecordNotFound)
+        expect { u.lock! }.to raise_error(::ActiveRecord::RecordNotFound)
       ensure
         Shard.default.database_server.unshackle!
       end
@@ -90,7 +90,7 @@ module Switchman
         ::Rails.env.stubs(:test?).returns(false)
         s = ds.shards.create!
         s.activate do
-          User.connection_pool.spec.config[:host].should == 'notshackled'
+          expect(User.connection_pool.spec.config[:host]).to eq 'notshackled'
         end
       ensure
         Shard.default.database_server.unshackle!
@@ -102,44 +102,44 @@ module Switchman
 
       it "should really disconnect all envs" do
         ::ActiveRecord::Base.connection
-        ::ActiveRecord::Base.connection_pool.should be_connected
+        expect(::ActiveRecord::Base.connection_pool).to be_connected
         @shard1.activate do
           ::ActiveRecord::Base.connection
-          ::ActiveRecord::Base.connection_pool.should be_connected
+          expect(::ActiveRecord::Base.connection_pool).to be_connected
         end
         @shard2.activate do
           ::ActiveRecord::Base.connection
-          ::ActiveRecord::Base.connection_pool.should be_connected
+          expect(::ActiveRecord::Base.connection_pool).to be_connected
         end
 
         ::Shackles.activate(:slave) do
           ::ActiveRecord::Base.connection
-          ::ActiveRecord::Base.connection_pool.should be_connected
+          expect(::ActiveRecord::Base.connection_pool).to be_connected
           @shard1.activate do
             ::ActiveRecord::Base.connection
-            ::ActiveRecord::Base.connection_pool.should be_connected
+            expect(::ActiveRecord::Base.connection_pool).to be_connected
           end
           @shard2.activate do
             ::ActiveRecord::Base.connection
-            ::ActiveRecord::Base.connection_pool.should be_connected
+            expect(::ActiveRecord::Base.connection_pool).to be_connected
           end
         end
 
         ::ActiveRecord::Base.clear_all_connections!
-        ::ActiveRecord::Base.connection_pool.should_not be_connected
+        expect(::ActiveRecord::Base.connection_pool).not_to be_connected
         @shard1.activate do
-          ::ActiveRecord::Base.connection_pool.should_not be_connected
+          expect(::ActiveRecord::Base.connection_pool).not_to be_connected
         end
         @shard2.activate do
-          ::ActiveRecord::Base.connection_pool.should_not be_connected
+          expect(::ActiveRecord::Base.connection_pool).not_to be_connected
         end
         ::Shackles.activate(:slave) do
-          ::ActiveRecord::Base.connection_pool.should_not be_connected
+          expect(::ActiveRecord::Base.connection_pool).not_to be_connected
           @shard1.activate do
-            ::ActiveRecord::Base.connection_pool.should_not be_connected
+            expect(::ActiveRecord::Base.connection_pool).not_to be_connected
           end
           @shard2.activate do
-            ::ActiveRecord::Base.connection_pool.should_not be_connected
+            expect(::ActiveRecord::Base.connection_pool).not_to be_connected
           end
         end
       end
@@ -150,53 +150,53 @@ module Switchman
 
       it "should really return active connections to the pool in all envs" do
         ::ActiveRecord::Base.connection
-        actual_connection_count.should_not == 0
+        expect(actual_connection_count).not_to eq 0
         @shard1.activate do
           ::ActiveRecord::Base.connection
-          actual_connection_count.should_not == 0
+          expect(actual_connection_count).not_to eq 0
         end
         @shard2.activate do
           ::ActiveRecord::Base.connection
-          actual_connection_count.should_not == 0
+          expect(actual_connection_count).not_to eq 0
         end
 
         ::Shackles.activate(:slave) do
           ::ActiveRecord::Base.connection
-          actual_connection_count.should_not == 0
+          expect(actual_connection_count).not_to eq 0
           @shard1.activate do
             ::ActiveRecord::Base.connection
-            actual_connection_count.should_not == 0
+            expect(actual_connection_count).not_to eq 0
           end
           @shard2.activate do
             ::ActiveRecord::Base.connection
-            actual_connection_count.should_not == 0
+            expect(actual_connection_count).not_to eq 0
           end
         end
 
         ::ActiveRecord::Base.clear_active_connections!
-        actual_connection_count.should == 0
+        expect(actual_connection_count).to eq 0
         @shard1.activate do
-          actual_connection_count.should == 0
+          expect(actual_connection_count).to eq 0
         end
         @shard2.activate do
-          actual_connection_count.should == 0
+          expect(actual_connection_count).to eq 0
         end
         ::Shackles.activate(:slave) do
-          actual_connection_count.should == 0
+          expect(actual_connection_count).to eq 0
           @shard1.activate do
-            actual_connection_count.should == 0
+            expect(actual_connection_count).to eq 0
           end
           @shard2.activate do
-            actual_connection_count.should == 0
+            expect(actual_connection_count).to eq 0
           end
         end
       end
 
       it "should not establish connections when switching environments" do
         ::ActiveRecord::Base.clear_all_connections!
-        ::ActiveRecord::Base.connection_pool.should_not be_connected
+        expect(::ActiveRecord::Base.connection_pool).not_to be_connected
         ::Shackles.activate(:slave) {}
-        ::ActiveRecord::Base.connection_pool.should_not be_connected
+        expect(::ActiveRecord::Base.connection_pool).not_to be_connected
       end
     end
   end