seamless_database_pool 1.0.17 → 1.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87e18b0e58926f6f71bd8f9850020bdcc3ce067f
-  data.tar.gz: 76977bb0e86a07279caff2fcf26a463c64866455
+  metadata.gz: 97df06be58768fd03235c0370d3f6e48a997f720
+  data.tar.gz: 4175c26ce145bc7e429f7b996a72fda489450506
 SHA512:
-  metadata.gz: 2205e7dd760e02835a043464a69e37a5f168261d7d0bde192a6c92bcc4edfc90a4af2612ab6b01524fd7b5b3d570caab7915ea53aff59dcc6904c81a1e9ab091
-  data.tar.gz: 3008995d6ff8d27562fefe1bf2ded47e8ba05a1f8773abca1ad9c242d3846a4fe08ced9564db71faec9ca7ac8bea8d97e3cf1b16d45dae71c9a02efb089f2df0
+  metadata.gz: fab0026bafa0d44e418d1522f0d6ee584b9fcaaa01af1fffe2a3388c93ff52b841656e2e68487d7e7b58ae4bfd757a8532d197157f5e7a677400c37d0bf48092
+  data.tar.gz: cdb1f53c64c9798e252ad7016d04d3fc5c771195cba4a6745a7b31eee5fa8d8c68def54dfc94db7b23e6bb83b287d4546423bbd03916374be85f7092bc6c8f87

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - rbx
+  - jruby

data/HISTORY.txt

@@ -0,0 +1,79 @@
+1.0.18
+
+ActiveRecord 5.0 compatibility (thanks jkowens)
+
+1.0.17
+
+Do not update the HTTP session if there are no changes.
+
+1.0.16
+
+Use shorter to_s output for output on connection.inspect.
+
+1.0.15
+
+Implement less wordy connection to string method so logs don't fill up with long messages on connection errors.
+
+Update specs to remove deprecation warnings
+
+Fix adapter specs to work with ActiveRecord 4.1 configuration changes
+
+1.0.14
+
+Remove custom connection timeout logic; Use the underlying driver's timeouts instead.
+
+Fix to work with query cache.
+
+Make driver less aggressive about overriding methods to proxy to the master connection.
+
+End support for ActiveRecord 2.x
+
+Add support for ActiveRecord 4.0
+
+1.0.13
+
+Fix to work with `rake db:*` Rails tasks by removing the adapter from the configuration when db:* tasks are run.
+
+Fix connection pool issues so checkout/checkins don't interact with the underlying connections (thanks afex)
+
+Ruby 2.0/Rails 4.0 compatibility (thanks t27duck)
+
+1.0.12
+
+Remove excessively long log messages on reconnect attempts.
+
+1.0.11
+
+Remove debug code that prevented recovering from errors.
+
+1.0.10
+
+Compatibility with ActiveRecord 3.1.0
+
+1.0.9
+
+Compatibility with bind variables.
+
+1.0.8
+
+Compatibility with ActiveRecord 3.1.0rc4
+
+1.0.7
+
+Make compatible with ActionController 3.0
+
+Improved handling of down slave instances.
+
+1.0.6
+
+Make compatible with ActiveRecord 3.0.
+
+Make compatible with database adapters other than MySQL including PostgrSQL.
+
+Better test suite to actually hit three different database adapters.
+
+1.0.5
+
+Update docs.
+
+Remove rake dependency on rspec

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'yaml'
+require "bundler/gem_tasks"
 
 desc 'Default: run unit tests.'
 task :default => :test
@@ -59,27 +60,3 @@ rescue LoadError
     STDERR.puts "You must have rspec >= 2.0 to run the tests"
   end
 end
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "seamless_database_pool"
-    gem.summary = "Add support for master/slave database clusters in ActiveRecord to improve performance."
-    gem.email = "bbdurand@gmail.com"
-    gem.homepage = "http://github.com/bdurand/seamless_database_pool"
-    gem.authors = ["Brian Durand"]
-    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile", "MIT-LICENSE"].to_a
-    gem.has_rdoc = true
-    gem.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE"]
-  
-    gem.add_dependency('activerecord', '>= 3.0.20')
-    gem.add_development_dependency('rspec', '>= 2.0')
-    gem.add_development_dependency('jeweler')
-    gem.add_development_dependency('sqlite3')
-    gem.add_development_dependency('mysql')
-    gem.add_development_dependency('pg')
-  end
-
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-end

data/VERSION

@@ -0,0 +1 @@
+1.0.18

data/lib/active_record/connection_adapters/seamless_database_pool_adapter.rb

@@ -35,7 +35,7 @@ module ActiveRecord
         end if config[:read_pool]
 
         klass = ::ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
-        klass.new(nil, logger, master_connection, read_connections, pool_weights)
+        klass.new(nil, logger, master_connection, read_connections, pool_weights, config)
       end
 
       def establish_adapter(adapter)
@@ -153,12 +153,12 @@ module ActiveRecord
         end
       end
       
-      def initialize(connection, logger, master_connection, read_connections, pool_weights)
+      def initialize(connection, logger, master_connection, read_connections, pool_weights, config)
         @master_connection = master_connection
         @read_connections = read_connections.dup.freeze
         
-        super(connection, logger)
-        
+        super(connection, logger, config)
+
         @weighted_read_connections = []
         pool_weights.each_pair do |conn, weight|
           weight.times{@weighted_read_connections << conn}

data/seamless_database_pool.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |spec|
+  spec.name          = "seamless_database_pool"
+  spec.version       = File.read(File.expand_path("../VERSION", __FILE__)).chomp
+  spec.authors       = ["Brian Durand"]
+  spec.email         = ["bbdurand@gmail.com"]
+  spec.description   = %q{Add support for master/slave database database clusters in ActiveRecord to improve performance.}
+  spec.summary       = %q{Add support for master/slave database clusters in ActiveRecord to improve performance.}
+  spec.homepage      = "https://github.com/bdurand/seamless_database_pool"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency(%q<activerecord>, [">= 3.0.20"])
+  spec.add_development_dependency(%q<rspec>, [">= 2.0"])
+  spec.add_development_dependency(%q<sqlite3>, [">= 0"])
+  spec.add_development_dependency(%q<mysql>, [">= 0"])
+  spec.add_development_dependency(%q<pg>, [">= 0"])
+end

data/spec/connection_statistics_spec.rb

@@ -61,7 +61,7 @@ describe SeamlessDatabasePool::ConnectionStatistics do
   
   it "should increment counts only once within a block" do
     connection = SeamlessDatabasePool::ConnectionStatisticsTester.new
-    connection.should_receive(:execute).with('SQL')
+    expect(connection).to receive(:execute).with('SQL')
     connection.update('SQL')
     connection.connection_statistics.should == {:update => 1}
   end

data/spec/database.yml

@@ -27,6 +27,7 @@ postgresql:
 mysql:
   adapter: seamless_database_pool
   database: seamless_database_pool_test
+  prepared_statements: false
   username: root
   password:
   master:

data/spec/seamless_database_pool_adapter_spec.rb

@@ -58,16 +58,16 @@ describe "SeamlessDatabasePoolAdapter ActiveRecord::Base extension" do
     logger = ActiveRecord::Base.logger
     weights = {master_connection => 1, read_connection_1 => 1, read_connection_2 => 2}
     
-    ActiveRecord::Base.should_receive(:writer_connection).with('adapter' => 'writer', 'host' => 'master_host', 'username' => 'user', 'pool_weight' => 1).and_return(master_connection)
-    ActiveRecord::Base.should_receive(:reader_connection).with('adapter' => 'reader', 'host' => 'read_host_1', 'username' => 'user', 'pool_weight' => 1).and_return(read_connection_1)
-    ActiveRecord::Base.should_receive(:reader_connection).with('adapter' => 'reader', 'host' => 'read_host_2', 'username' => 'user', 'pool_weight' => 2).and_return(read_connection_2)
+    expect(ActiveRecord::Base).to receive(:writer_connection).with('adapter' => 'writer', 'host' => 'master_host', 'username' => 'user', 'pool_weight' => 1).and_return(master_connection)
+    expect(ActiveRecord::Base).to receive(:reader_connection).with('adapter' => 'reader', 'host' => 'read_host_1', 'username' => 'user', 'pool_weight' => 1).and_return(read_connection_1)
+    expect(ActiveRecord::Base).to receive(:reader_connection).with('adapter' => 'reader', 'host' => 'read_host_2', 'username' => 'user', 'pool_weight' => 2).and_return(read_connection_2)
     
     klass = double(:class)
-    ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.should_receive(:adapter_class).with(master_connection).and_return(klass)
-    klass.should_receive(:new).with(nil, logger, master_connection, [read_connection_1, read_connection_2], weights).and_return(pool_connection)
+    expect(ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter).to receive(:adapter_class).with(master_connection).and_return(klass)
+    expect(klass).to receive(:new).with(nil, logger, master_connection, [read_connection_1, read_connection_2], weights, options).and_return(pool_connection)
     
-    ActiveRecord::Base.should_receive(:establish_adapter).with('writer')
-    ActiveRecord::Base.should_receive(:establish_adapter).with('reader').twice
+    expect(ActiveRecord::Base).to receive(:establish_adapter).with('writer')
+    expect(ActiveRecord::Base).to receive(:establish_adapter).with('reader').twice
     
     ActiveRecord::Base.seamless_database_pool_connection(options).should == pool_connection
   end
@@ -82,10 +82,11 @@ describe "SeamlessDatabasePoolAdapter" do
   let(:master_connection){ SeamlessDatabasePool::MockMasterConnection.new("master") }
   let(:read_connection_1){ SeamlessDatabasePool::MockConnection.new("read_1") }
   let(:read_connection_2){ SeamlessDatabasePool::MockConnection.new("read_2") }
+  let(:config){ {} }
   let(:pool_connection) do
     weights = {master_connection => 1, read_connection_1 => 1, read_connection_2 => 2}
     connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
-    connection_class.new(nil, nil, master_connection, [read_connection_1, read_connection_2], weights)
+    connection_class.new(nil, nil, master_connection, [read_connection_1, read_connection_2], weights, config)
   end
   
   it "should be able to be converted to a string" do
@@ -104,26 +105,26 @@ describe "SeamlessDatabasePoolAdapter" do
     end
   
     it "should return the current read connection" do
-      SeamlessDatabasePool.should_receive(:read_only_connection).with(pool_connection).and_return(:current)
+      expect(SeamlessDatabasePool).to receive(:read_only_connection).with(pool_connection).and_return(:current)
       pool_connection.current_read_connection.should == :current
     end
   
     it "should select a random read connection" do
       mock_connection = double(:connection)
       mock_connection.stub(:active? => true)
-      pool_connection.should_receive(:available_read_connections).and_return([:fake1, :fake2, mock_connection])
-      pool_connection.should_receive(:rand).with(3).and_return(2)
+      expect(pool_connection).to receive(:available_read_connections).and_return([:fake1, :fake2, mock_connection])
+      expect(pool_connection).to receive(:rand).with(3).and_return(2)
       pool_connection.random_read_connection.should == mock_connection
     end
   
     it "should select the master connection if the read pool is empty" do
-      pool_connection.should_receive(:available_read_connections).and_return([])
+      expect(pool_connection).to receive(:available_read_connections).and_return([])
       pool_connection.random_read_connection.should == master_connection
     end
   
     it "should use the master connection in a block" do
       connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
-      connection = connection_class.new(nil, double(:logger), master_connection, [read_connection_1], {read_connection_1 => 1})
+      connection = connection_class.new(nil, double(:logger), master_connection, [read_connection_1], {read_connection_1 => 1}, config)
       connection.random_read_connection.should == read_connection_1
       connection.use_master_connection do
         connection.random_read_connection.should == master_connection
@@ -133,12 +134,12 @@ describe "SeamlessDatabasePoolAdapter" do
   
     it "should use the master connection inside a transaction" do
       connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
-      connection = connection_class.new(nil, double(:logger), master_connection, [read_connection_1], {read_connection_1 => 1})
-      master_connection.should_receive(:begin_db_transaction)
-      master_connection.should_receive(:commit_db_transaction)
-      master_connection.should_receive(:select).with('Transaction SQL', nil)
-      read_connection_1.should_receive(:select).with('SQL 1', nil)
-      read_connection_1.should_receive(:select).with('SQL 2', nil)
+      connection = connection_class.new(nil, double(:logger), master_connection, [read_connection_1], {read_connection_1 => 1}, config)
+      expect(master_connection).to receive(:begin_db_transaction)
+      expect(master_connection).to receive(:commit_db_transaction)
+      expect(master_connection).to receive(:select).with('Transaction SQL', nil)
+      expect(read_connection_1).to receive(:select).with('SQL 1', nil)
+      expect(read_connection_1).to receive(:select).with('SQL 2', nil)
     
       SeamlessDatabasePool.use_persistent_read_connection do
         connection.send(:select, 'SQL 1', nil)
@@ -152,81 +153,81 @@ describe "SeamlessDatabasePoolAdapter" do
   
   context "read connection methods" do
     it "should proxy select methods to a read connection" do
-      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
-      read_connection_1.should_receive(:select).with('SQL').and_return(:retval)
+      expect(pool_connection).to receive(:current_read_connection).and_return(read_connection_1)
+      expect(read_connection_1).to receive(:select).with('SQL').and_return(:retval)
       pool_connection.send(:select, 'SQL').should == :retval
     end
   
     it "should proxy execute methods to a read connection" do
-      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
-      read_connection_1.should_receive(:execute).with('SQL').and_return(:retval)
+      expect(pool_connection).to receive(:current_read_connection).and_return(read_connection_1)
+      expect(read_connection_1).to receive(:execute).with('SQL').and_return(:retval)
       pool_connection.execute('SQL').should == :retval
     end
   
     it "should proxy select_rows methods to a read connection" do
-      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
-      read_connection_1.should_receive(:select_rows).with('SQL').and_return(:retval)
+      expect(pool_connection).to receive(:current_read_connection).and_return(read_connection_1)
+      expect(read_connection_1).to receive(:select_rows).with('SQL').and_return(:retval)
       pool_connection.select_rows('SQL').should == :retval
     end
   end
   
   context "master connection methods" do
     it "should proxy insert method to the master connection" do
-      master_connection.should_receive(:insert).with('SQL').and_return(:retval)
+      expect(master_connection).to receive(:insert).with('SQL').and_return(:retval)
       pool_connection.insert('SQL').should == :retval
     end
   
     it "should proxy update method to the master connection" do
-      master_connection.should_receive(:update).with('SQL').and_return(:retval)
+      expect(master_connection).to receive(:update).with('SQL').and_return(:retval)
       pool_connection.update('SQL').should == :retval
     end
   
     it "should proxy columns method to the master connection" do
-      master_connection.should_receive(:columns).with(:table).and_return(:retval)
+      expect(master_connection).to receive(:columns).with(:table).and_return(:retval)
       pool_connection.columns(:table).should == :retval
     end
   end
   
   context "fork to all connections" do
     it "should fork active? to all connections and return true if all are up" do
-      master_connection.should_receive(:active?).and_return(true)
-      read_connection_1.should_receive(:active?).and_return(true)
-      read_connection_2.should_receive(:active?).and_return(true)
+      expect(master_connection).to receive(:active?).and_return(true)
+      expect(read_connection_1).to receive(:active?).and_return(true)
+      expect(read_connection_2).to receive(:active?).and_return(true)
       pool_connection.active?.should == true
     end
   
     it "should fork active? to all connections and return false if one is down" do
-      master_connection.should_receive(:active?).and_return(true)
-      read_connection_1.should_receive(:active?).and_return(true)
-      read_connection_2.should_receive(:active?).and_return(false)
+      expect(master_connection).to receive(:active?).and_return(true)
+      expect(read_connection_1).to receive(:active?).and_return(true)
+      expect(read_connection_2).to receive(:active?).and_return(false)
       pool_connection.active?.should == false
     end
   
     it "should fork verify! to all connections" do
-      master_connection.should_receive(:verify!).with(5)
-      read_connection_1.should_receive(:verify!).with(5)
-      read_connection_2.should_receive(:verify!).with(5)
+      expect(master_connection).to receive(:verify!).with(5)
+      expect(read_connection_1).to receive(:verify!).with(5)
+      expect(read_connection_2).to receive(:verify!).with(5)
       pool_connection.verify!(5)
     end
   
     it "should fork disconnect! to all connections" do
-      master_connection.should_receive(:disconnect!)
-      read_connection_1.should_receive(:disconnect!)
-      read_connection_2.should_receive(:disconnect!)
+      expect(master_connection).to receive(:disconnect!)
+      expect(read_connection_1).to receive(:disconnect!)
+      expect(read_connection_2).to receive(:disconnect!)
       pool_connection.disconnect!
     end
   
     it "should fork reconnect! to all connections" do
-      master_connection.should_receive(:reconnect!)
-      read_connection_1.should_receive(:reconnect!)
-      read_connection_2.should_receive(:reconnect!)
+      expect(master_connection).to receive(:reconnect!)
+      expect(read_connection_1).to receive(:reconnect!)
+      expect(read_connection_2).to receive(:reconnect!)
       pool_connection.reconnect!
     end
     
     it "should fork reset_runtime to all connections" do
-      master_connection.should_receive(:reset_runtime).and_return(1)
-      read_connection_1.should_receive(:reset_runtime).and_return(2)
-      read_connection_2.should_receive(:reset_runtime).and_return(3)
+      expect(master_connection).to receive(:reset_runtime).and_return(1)
+      expect(read_connection_1).to receive(:reset_runtime).and_return(2)
+      expect(read_connection_2).to receive(:reset_runtime).and_return(3)
       pool_connection.reset_runtime.should == 6
     end
   end
@@ -235,16 +236,17 @@ describe "SeamlessDatabasePoolAdapter" do
     it "should proxy requests to a connection" do
       args = [:arg1, :arg2]
       block = Proc.new{}
-      master_connection.should_receive(:select_value).with(*args, &block)
+      expect(master_connection).to receive(:select_value).with(*args, &block)
       master_connection.should_not_receive(:active?)
       master_connection.should_not_receive(:reconnect!)
       pool_connection.send(:proxy_connection_method, master_connection, :select_value, :master, *args, &block)
     end
   
     it "should try to reconnect dead connections when they become available again" do
-      master_connection.stub(:select).and_raise("SQL ERROR")
-      master_connection.should_receive(:active?).and_return(false, false, true)
-      master_connection.should_receive(:reconnect!)
+      master_connection.stub(:select).and_raise("SQL ERROR")      # Rails 3, 4
+      master_connection.stub(:select_rows).and_raise("SQL ERROR") # Rails 5
+      expect(master_connection).to receive(:active?).and_return(false, false, true)
+      expect(master_connection).to receive(:reconnect!)
       now = Time.now
       lambda{pool_connection.select_value("SQL")}.should raise_error("SQL ERROR")
       Time.stub(:now => now + 31)
@@ -254,8 +256,8 @@ describe "SeamlessDatabasePoolAdapter" do
     it "should not try to reconnect live connections" do
       args = [:arg1, :arg2]
       block = Proc.new{}
-      master_connection.should_receive(:select).with(*args, &block).twice.and_raise("SQL ERROR")
-      master_connection.should_receive(:active?).and_return(true)
+      expect(master_connection).to receive(:select).with(*args, &block).twice.and_raise("SQL ERROR")
+      expect(master_connection).to receive(:active?).and_return(true)
       master_connection.should_not_receive(:reconnect!)
       lambda{pool_connection.send(:proxy_connection_method, master_connection, :select, :read, *args, &block)}.should raise_error("SQL ERROR")
     end
@@ -263,7 +265,7 @@ describe "SeamlessDatabasePoolAdapter" do
     it "should not try to reconnect a connection during a retry" do
       args = [:arg1, :arg2]
       block = Proc.new{}
-      master_connection.should_receive(:select).with(*args, &block).and_raise("SQL ERROR")
+      expect(master_connection).to receive(:select).with(*args, &block).and_raise("SQL ERROR")
       master_connection.should_not_receive(:active?)
       master_connection.should_not_receive(:reconnect!)
       lambda{pool_connection.send(:proxy_connection_method, master_connection, :select, :retry, *args, &block)}.should raise_error("SQL ERROR")
@@ -271,35 +273,35 @@ describe "SeamlessDatabasePoolAdapter" do
   
     it "should try to execute a read statement again after a connection error" do
       connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
-      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
-      read_connection_1.should_receive(:select).with('SQL').and_raise(connection_error)
-      read_connection_1.should_receive(:active?).and_return(true)
+      expect(pool_connection).to receive(:current_read_connection).and_return(read_connection_1)
+      expect(read_connection_1).to receive(:select).with('SQL').and_raise(connection_error)
+      expect(read_connection_1).to receive(:active?).and_return(true)
       pool_connection.should_not_receive(:suppress_read_connection)
       SeamlessDatabasePool.should_not_receive(:set_persistent_read_connection)
-      read_connection_1.should_receive(:select).with('SQL').and_return(:results)
+      expect(read_connection_1).to receive(:select).with('SQL').and_return(:results)
       pool_connection.send(:select, 'SQL').should == :results
     end
   
     it "should not try to execute a read statement again after a connection error if the master connection must be used" do
-      master_connection.should_receive(:select).with('SQL').and_raise("Fail")
+      expect(master_connection).to receive(:select).with('SQL').and_raise("Fail")
       pool_connection.use_master_connection do
         lambda{pool_connection.send(:select, 'SQL')}.should raise_error("Fail")
       end
     end
   
     it "should not try to execute a read statement again after a non-connection error" do
-      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1)
-      pool_connection.should_receive(:proxy_connection_method).with(read_connection_1, :select, :read, 'SQL').and_raise("SQL Error")
+      expect(pool_connection).to receive(:current_read_connection).and_return(read_connection_1)
+      expect(pool_connection).to receive(:proxy_connection_method).with(read_connection_1, :select, :read, 'SQL').and_raise("SQL Error")
       lambda{pool_connection.send(:select, 'SQL')}.should raise_error("SQL Error")
     end
   
     it "should use a different connection on a retry if the original connection could not be reconnected" do
-      pool_connection.should_receive(:current_read_connection).and_return(read_connection_1, read_connection_2)
-      read_connection_1.should_receive(:select).with('SQL').and_raise("Fail")
-      read_connection_1.should_receive(:active?).and_return(false)
-      pool_connection.should_receive(:suppress_read_connection).with(read_connection_1, 30)
-      SeamlessDatabasePool.should_receive(:set_persistent_read_connection).with(pool_connection, read_connection_2)
-      read_connection_2.should_receive(:select).with('SQL').and_return(:results)
+      expect(pool_connection).to receive(:current_read_connection).and_return(read_connection_1, read_connection_2)
+      expect(read_connection_1).to receive(:select).with('SQL').and_raise("Fail")
+      expect(read_connection_1).to receive(:active?).and_return(false)
+      expect(pool_connection).to receive(:suppress_read_connection).with(read_connection_1, 30)
+      expect(SeamlessDatabasePool).to receive(:set_persistent_read_connection).with(pool_connection, read_connection_2)
+      expect(read_connection_2).to receive(:select).with('SQL').and_return(:results)
       pool_connection.send(:select, 'SQL').should == :results
     end
   
@@ -322,8 +324,8 @@ describe "SeamlessDatabasePoolAdapter" do
       pool_connection.suppress_read_connection(read_connection_1, 0.2)
       pool_connection.available_read_connections.should_not include(read_connection_1)
       sleep(0.3)
-      read_connection_1.should_receive(:reconnect!)
-      read_connection_1.should_receive(:active?).and_return(false)
+      expect(read_connection_1).to receive(:reconnect!)
+      expect(read_connection_1).to receive(:active?).and_return(false)
       pool_connection.available_read_connections.should_not include(read_connection_1)
     end
   

data/spec/spec_helper.rb

@@ -11,3 +11,15 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'seamles
 require File.expand_path(File.join(File.dirname(__FILE__), 'test_model'))
 
 $LOAD_PATH << File.expand_path("../test_adapter", __FILE__)
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+  config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seamless_database_pool
 version: !ruby/object:Gem::Version
-  version: 1.0.17
+  version: 1.0.18
 platform: ruby
 authors:
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-14 00:00:00.000000000 Z
+date: 2016-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: jeweler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -94,23 +80,28 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
-email: bbdurand@gmail.com
+description: Add support for master/slave database database clusters in ActiveRecord
+  to improve performance.
+email:
+- bbdurand@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- MIT-LICENSE
-- README.rdoc
+extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".travis.yml"
+- HISTORY.txt
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
+- VERSION
 - lib/active_record/connection_adapters/seamless_database_pool_adapter.rb
 - lib/seamless_database_pool.rb
 - lib/seamless_database_pool/arel_compiler.rb
 - lib/seamless_database_pool/connection_statistics.rb
 - lib/seamless_database_pool/controller_filter.rb
 - lib/seamless_database_pool/railtie.rb
+- seamless_database_pool.gemspec
 - spec/connection_adapters_spec.rb
 - spec/connection_statistics_spec.rb
 - spec/controller_filter_spec.rb
@@ -120,8 +111,9 @@ files:
 - spec/spec_helper.rb
 - spec/test_adapter/active_record/connection_adapters/read_only_adapter.rb
 - spec/test_model.rb
-homepage: http://github.com/bdurand/seamless_database_pool
-licenses: []
+homepage: https://github.com/bdurand/seamless_database_pool
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -139,9 +131,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.3.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Add support for master/slave database clusters in ActiveRecord to improve
   performance.
-test_files: []
+test_files:
+- spec/connection_adapters_spec.rb
+- spec/connection_statistics_spec.rb
+- spec/controller_filter_spec.rb
+- spec/database.yml
+- spec/seamless_database_pool_adapter_spec.rb
+- spec/seamless_database_pool_spec.rb
+- spec/spec_helper.rb
+- spec/test_adapter/active_record/connection_adapters/read_only_adapter.rb
+- spec/test_model.rb