seamless_database_pool 1.0.5 → 1.0.6

data/spec/seamless_database_pool_adapter_spec.rb

@@ -48,9 +48,9 @@ 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)
+    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)
     
     klass = mock(:class)
     ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.should_receive(:adapter_class).with(master_connection).and_return(klass)
@@ -78,303 +78,281 @@ describe "SeamlessDatabasePoolAdapter" do
     @pool_connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1, @read_connection_2], weights)
   end
   
-  it "should initialize the connection pool" do
-    @pool_connection.master_connection.should == @master_connection
-    @pool_connection.read_connections.should == [@read_connection_1, @read_connection_2]
-    @pool_connection.all_connections.should == [@master_connection, @read_connection_1, @read_connection_2]
-    @pool_connection.pool_weight(@master_connection).should == 1
-    @pool_connection.pool_weight(@read_connection_1).should == 1
-    @pool_connection.pool_weight(@read_connection_2).should == 2
-  end
+  context "selecting a connection from the pool" do
+    it "should initialize the connection pool" do
+      @pool_connection.master_connection.should == @master_connection
+      @pool_connection.read_connections.should == [@read_connection_1, @read_connection_2]
+      @pool_connection.all_connections.should == [@master_connection, @read_connection_1, @read_connection_2]
+      @pool_connection.pool_weight(@master_connection).should == 1
+      @pool_connection.pool_weight(@read_connection_1).should == 1
+      @pool_connection.pool_weight(@read_connection_2).should == 2
+    end
   
-  it "should return the current read connection" do
-    SeamlessDatabasePool.should_receive(:read_only_connection).with(@pool_connection).and_return(:current)
-    @pool_connection.current_read_connection.should == :current
-  end
+    it "should return the current read connection" do
+      SeamlessDatabasePool.should_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 = stub(:connection, :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)
-    @pool_connection.random_read_connection.should == mock_connection
-  end
+    it "should select a random read connection" do
+      mock_connection = stub(:connection, :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)
+      @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([])
-    @pool_connection.random_read_connection.should == @master_connection
-  end
+    it "should select the master connection if the read pool is empty" do
+      @pool_connection.should_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, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
-    connection.random_read_connection.should == @read_connection_1
-    connection.use_master_connection do
-      connection.random_read_connection.should == @master_connection
+    it "should use the master connection in a block" do
+      connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(@master_connection)
+      connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
+      connection.random_read_connection.should == @read_connection_1
+      connection.use_master_connection do
+        connection.random_read_connection.should == @master_connection
+      end
+      connection.random_read_connection.should == @read_connection_1
     end
-    connection.random_read_connection.should == @read_connection_1
-  end
   
-  it "should use the master connection inside a transaction" do
-    connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(@master_connection)
-    connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
-    @master_connection.should_receive(:transaction).with(true).and_yield
-    @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)
+    it "should use the master connection inside a transaction" do
+      connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(@master_connection)
+      connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
+      @master_connection.should_receive(:transaction).and_yield
+      @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)
     
-    SeamlessDatabasePool.use_persistent_read_connection do
-      connection.send(:select, 'SQL 1', nil)
-      connection.transaction do
-        connection.send(:select, 'Transaction SQL', nil)
+      SeamlessDatabasePool.use_persistent_read_connection do
+        connection.send(:select, 'SQL 1', nil)
+        connection.transaction do
+          connection.send(:select, 'Transaction SQL', nil)
+        end
+        connection.send(:select, 'SQL 2', nil)
       end
-      connection.send(:select, 'SQL 2', nil)
     end
   end
-
-  # Read methods
-  
-  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)
-    @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)
-    @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)
-    @pool_connection.select_rows('SQL').should == :retval
-  end
   
-  # Master connection methods
-  
-  it "should proxy insert method to the master connection" do
-    @master_connection.should_receive(:insert).with('SQL', nil, nil, nil, nil).and_return(:retval)
-    @pool_connection.insert('SQL').should == :retval
-  end
+  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)
+      @pool_connection.send(:select, 'SQL').should == :retval
+    end
   
-  it "should proxy update method to the master connection" do
-    @master_connection.should_receive(:update).with('SQL', nil).and_return(:retval)
-    @pool_connection.update('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)
+      @pool_connection.execute('SQL').should == :retval
+    end
   
-  it "should proxy columns method to the master connection" do
-    @master_connection.should_receive(:columns).with(:table).and_return(:retval)
-    @pool_connection.columns(:table).should == :retval
+    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)
+      @pool_connection.select_rows('SQL').should == :retval
+    end
   end
   
-  # Fork to all connection methods
+  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)
+      @pool_connection.insert('SQL').should == :retval
+    end
   
-  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)
-    @pool_connection.active?.should == true
-  end
+    it "should proxy update method to the master connection" do
+      @master_connection.should_receive(:update).with('SQL').and_return(:retval)
+      @pool_connection.update('SQL').should == :retval
+    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)
-    @pool_connection.active?.should == false
+    it "should proxy columns method to the master connection" do
+      @master_connection.should_receive(:columns).with(:table).and_return(:retval)
+      @pool_connection.columns(:table).should == :retval
+    end
   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)
-    @pool_connection.verify!(5)
-  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)
+      @pool_connection.active?.should == true
+    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!)
-    @pool_connection.disconnect!
-  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)
+      @pool_connection.active?.should == false
+    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!)
-    @pool_connection.reconnect!
-  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)
+      @pool_connection.verify!(5)
+    end
   
-  it "should timeout reconnect! calls to dead servers" do
-    @read_connection_1.connect_timeout = 0.1
-    lambda{@pool_connection.reconnect!}.should raise_error("reconnect timed out")
-  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!)
+      @pool_connection.disconnect!
+    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)
-    @pool_connection.reset_runtime.should == 6
-  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!)
+      @pool_connection.reconnect!
+    end
   
-  # Reconnection logic
+    it "should timeout reconnect! calls to dead servers" do
+      @read_connection_1.connect_timeout = 0.1
+      lambda{@pool_connection.reconnect!}.should raise_error("reconnect timed out")
+    end
   
-  it "should proxy requests to a connection" do
-    args = [:arg1, :arg2]
-    block = Proc.new{}
-    @master_connection.should_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)
+    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)
+      @pool_connection.reset_runtime.should == 6
+    end
   end
+
+  context "reconnection" do
+    it "should proxy requests to a connection" do
+      args = [:arg1, :arg2]
+      block = Proc.new{}
+      @master_connection.should_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" do
-    args = [:arg1, :arg2]
-    block = Proc.new{}
-    @master_connection.should_receive(:select_value).with(*args, &block).and_raise("SQL ERROR")
-    @master_connection.should_receive(:active?).and_return(false)
-    @master_connection.should_receive(:reconnect!)
-    lambda{@pool_connection.send(:proxy_connection_method, @master_connection, :select_value, :master, *args, &block)}.should raise_error(ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError)
-  end
+    it "should try to reconnect dead connections when they become available again" do
+      @master_connection.stub!(:select_value).and_raise("SQL ERROR")
+      @master_connection.should_receive(:active?).and_return(false, false, true)
+      @master_connection.should_receive(:reconnect!)
+      now = Time.now
+      lambda{@pool_connection.select_value("SQL")}.should raise_error("SQL ERROR")
+      Time.stub!(:now).and_return(now + 31)
+      lambda{@pool_connection.select_value("SQL")}.should raise_error("SQL ERROR")
+    end
   
-  it "should not try to reconnect live connections" do
-    args = [:arg1, :arg2]
-    block = Proc.new{}
-    @master_connection.should_receive(:select_value).with(*args, &block).and_raise("SQL ERROR")
-    @master_connection.should_receive(:active?).and_return(true)
-    @master_connection.should_not_receive(:reconnect!)
-    lambda{@pool_connection.send(:proxy_connection_method, @master_connection, :select_value, :master, *args, &block)}.should raise_error("SQL ERROR")
-  end
+    it "should not try to reconnect live connections" do
+      args = [:arg1, :arg2]
+      block = Proc.new{}
+      @master_connection.should_receive(:select_value).with(*args, &block).twice.and_raise("SQL ERROR")
+      @master_connection.should_receive(:active?).and_return(true)
+      @master_connection.should_not_receive(:reconnect!)
+      lambda{@pool_connection.send(:proxy_connection_method, @master_connection, :select_value, :read, *args, &block)}.should raise_error("SQL ERROR")
+    end
   
-  it "should not try to reconnect a connection during a retry" do
-    args = [:arg1, :arg2]
-    block = Proc.new{}
-    @master_connection.should_receive(:select_value).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_value, :retry, *args, &block)}.should raise_error("SQL ERROR")
-  end
+    it "should not try to reconnect a connection during a retry" do
+      args = [:arg1, :arg2]
+      block = Proc.new{}
+      @master_connection.should_receive(:select_value).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_value, :retry, *args, &block)}.should raise_error("SQL ERROR")
+    end
   
-  it "should try to execute a read statement again after a connection error" do
-    connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
-    connection_error.wrapped_exception = StandardError.new("Error")
-    @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(connection_error)
-    @read_connection_1.should_receive(:active?).and_return(true)
-    @pool_connection.should_not_receive(:suppress_read_connection)
-    SeamlessDatabasePool.should_not_receive(:set_persistent_read_connection)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :retry, 'SQL').and_return(:results)
-    @pool_connection.send(:select, 'SQL').should == :results
-  end
+    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)
+      @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)
+      @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
-    connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
-    connection_error.wrapped_exception = StandardError.new("Error")
-    @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(connection_error)
-    @pool_connection.use_master_connection do
-      lambda{@pool_connection.send(:select, 'SQL')}.should raise_error("Error")
+    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")
+      @pool_connection.use_master_connection do
+        lambda{@pool_connection.send(:select, 'SQL')}.should raise_error("Fail")
+      end
     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")
-    lambda{@pool_connection.send(:select, 'SQL')}.should raise_error("SQL Error")
-  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")
+      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
-    connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
-    connection_error.wrapped_exception = StandardError.new("Error")
-    @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1, @read_connection_2)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :read, 'SQL').and_raise(connection_error)
-    @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)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_2, :select, :retry, 'SQL').and_return(:results)
-    @pool_connection.send(:select, 'SQL').should == :results
-  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)
+      @pool_connection.send(:select, 'SQL').should == :results
+    end
   
-  it "should keep track of read connections that can't be reconnected for a set period" do
-    @pool_connection.available_read_connections.should include(@read_connection_1)
-    @pool_connection.suppress_read_connection(@read_connection_1, 30)
-    @pool_connection.available_read_connections.should_not include(@read_connection_1)
-  end
+    it "should keep track of read connections that can't be reconnected for a set period" do
+      @pool_connection.available_read_connections.should include(@read_connection_1)
+      @pool_connection.suppress_read_connection(@read_connection_1, 30)
+      @pool_connection.available_read_connections.should_not include(@read_connection_1)
+    end
   
-  it "should return dead connections to the pool after the timeout has expired" do
-    @pool_connection.available_read_connections.should include(@read_connection_1)
-    @pool_connection.suppress_read_connection(@read_connection_1, 0.2)
-    @pool_connection.available_read_connections.should_not include(@read_connection_1)
-    sleep(0.3)
-    @pool_connection.available_read_connections.should include(@read_connection_1)
-  end
+    it "should return dead connections to the pool after the timeout has expired" do
+      @pool_connection.available_read_connections.should include(@read_connection_1)
+      @pool_connection.suppress_read_connection(@read_connection_1, 0.2)
+      @pool_connection.available_read_connections.should_not include(@read_connection_1)
+      sleep(0.3)
+      @pool_connection.available_read_connections.should include(@read_connection_1)
+    end
   
-  it "should not return a connection to the pool until it can be reconnected" do
-    @pool_connection.available_read_connections.should include(@read_connection_1)
-    @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)
-    @pool_connection.available_read_connections.should_not include(@read_connection_1)
-  end
+    it "should not return a connection to the pool until it can be reconnected" do
+      @pool_connection.available_read_connections.should include(@read_connection_1)
+      @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)
+      @pool_connection.available_read_connections.should_not include(@read_connection_1)
+    end
   
-  it "should try all connections again if none of them can be reconnected" do
-    stack = @pool_connection.instance_variable_get(:@available_read_connections)
+    it "should try all connections again if none of them can be reconnected" do
+      stack = @pool_connection.instance_variable_get(:@available_read_connections)
     
-    available = @pool_connection.available_read_connections
-    available.should include(@read_connection_1)
-    available.should include(@read_connection_2)
-    available.should include(@master_connection)
-    stack.size.should == 1
+      available = @pool_connection.available_read_connections
+      available.should include(@read_connection_1)
+      available.should include(@read_connection_2)
+      available.should include(@master_connection)
+      stack.size.should == 1
     
-    @pool_connection.suppress_read_connection(@read_connection_1, 30)
-    available = @pool_connection.available_read_connections
-    available.should_not include(@read_connection_1)
-    available.should include(@read_connection_2)
-    available.should include(@master_connection)
-    stack.size.should == 2
+      @pool_connection.suppress_read_connection(@read_connection_1, 30)
+      available = @pool_connection.available_read_connections
+      available.should_not include(@read_connection_1)
+      available.should include(@read_connection_2)
+      available.should include(@master_connection)
+      stack.size.should == 2
     
-    @pool_connection.suppress_read_connection(@master_connection, 30)
-    available = @pool_connection.available_read_connections
-    available.should_not include(@read_connection_1)
-    available.should include(@read_connection_2)
-    available.should_not include(@master_connection)
-    stack.size.should == 3
-    
-    @pool_connection.suppress_read_connection(@read_connection_2, 30)
-    available = @pool_connection.available_read_connections
-    available.should include(@read_connection_1)
-    available.should include(@read_connection_2)
-    available.should include(@master_connection)
-    stack.size.should == 1
-  end
-  
-  it "should not try to suppress a read connection that wasn't available in the read pool" do
-    stack = @pool_connection.instance_variable_get(:@available_read_connections)
-    stack.size.should == 1
-    @pool_connection.suppress_read_connection(@read_connection_1, 30)
-    stack.size.should == 2
-    @pool_connection.suppress_read_connection(@read_connection_1, 30)
-    stack.size.should == 2
-  end
+      @pool_connection.suppress_read_connection(@master_connection, 30)
+      available = @pool_connection.available_read_connections
+      available.should_not include(@read_connection_1)
+      available.should include(@read_connection_2)
+      available.should_not include(@master_connection)
+      stack.size.should == 3
     
-end
-
-describe "Reload extensions" do
-  before(:all) do
-    SeamlessDatabasePool::Test.create_tables
-    @record =  SeamlessDatabasePool::Test::Model.create(:name => 'test')
-    @thing = SeamlessDatabasePool::Test::Thing.create(:name => 'thing', :model_id => @record.id)
-  end
-  
-  after(:all) do
-    SeamlessDatabasePool::Test.drop_tables
-  end
+      @pool_connection.suppress_read_connection(@read_connection_2, 30)
+      available = @pool_connection.available_read_connections
+      available.should include(@read_connection_1)
+      available.should include(@read_connection_2)
+      available.should include(@master_connection)
+      stack.size.should == 1
+    end
   
-  it "should force the master connection on reload" do
-    SeamlessDatabasePool.should_receive(:use_master_connection).and_yield
-    @record.should_receive(:reload_without_seamless_database_pool).with(:options)
-    @record.reload(:options)
+    it "should not try to suppress a read connection that wasn't available in the read pool" do
+      stack = @pool_connection.instance_variable_get(:@available_read_connections)
+      stack.size.should == 1
+      @pool_connection.suppress_read_connection(@read_connection_1, 30)
+      stack.size.should == 2
+      @pool_connection.suppress_read_connection(@read_connection_1, 30)
+      stack.size.should == 2
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,12 +1,13 @@
 require 'rubygems'
 
-active_record_version = ENV["ACTIVE_RECORD_VERSION"] || [">= 2.2.2", "< 3.0"]
+active_record_version = ENV["ACTIVE_RECORD_VERSION"] || [">= 2.2.2"]
 active_record_version = [active_record_version] unless active_record_version.is_a?(Array)
 gem 'activerecord', *active_record_version
 
-require 'spec'
 require 'active_record'
 puts "Testing Against ActiveRecord #{ActiveRecord::VERSION::STRING}" if defined?(ActiveRecord::VERSION)
 
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'seamless_database_pool'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'test_models'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_model'))
+
+$LOAD_PATH << File.expand_path("../test_adapter", __FILE__)

data/spec/test_adapter/active_record/connection_adapters/read_only_adapter.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  class Base
+    def self.read_only_connection (config)
+      real_adapter = config.delete("real_adapter")
+      connection = send("#{real_adapter}_connection", config.merge("adapter" => real_adapter))
+      ConnectionAdapters::ReadOnlyAdapter.new(connection)
+    end
+  end
+  
+  module ConnectionAdapters
+    class ReadOnlyAdapter < AbstractAdapter
+      %w(select_one select_all select_value select_values select select_rows execute tables columns).each do |read_method|
+        class_eval <<-EOS
+          def #{read_method} (*args, &block)
+            raise "Not Connected" unless @connected
+            result = @connection.send(:#{read_method}, *args, &block)
+            def result.read_only?
+              true
+            end
+            result
+          end
+        EOS
+        
+        %w(update insert delete reload create_table drop_table add_index remove_index transaction).each do |write_method|
+          class_eval <<-EOS
+            def #{write_method} (*args, &block)
+              raise NotImplementedError.new("Master method '#{write_method}' called on read only connection")
+            end
+          EOS
+        end
+      end
+    
+      def initialize (connection)
+        @connection = connection
+        @connected = true
+      end
+    
+      def reconnect!
+        @connected = true
+      end
+    
+      def disconnect!
+        @connected = false
+      end
+      
+      def active?
+        @connected
+      end
+    end
+  end
+end