onstomp 1.0.3 → 1.0.4

data/lib/onstomp/failover/buffers/written.rb

@@ -4,70 +4,30 @@
 # {OnStomp::Client client}'s {OnStomp::Connections::Base connection} and
 # replays the ones that were not when the
 # {OnStomp::Failover::Client failover} client reconnects.
-class OnStomp::Failover::Buffers::Written
+class OnStomp::Failover::Buffers::Written < OnStomp::Failover::Buffers::Base
   def initialize failover
-    @failover = failover
-    @buffer_mutex = Mutex.new
-    @buffer = []
-    @txs = {}
-
-    failover.before_send &method(:buffer_frame)
-    failover.before_commit &method(:buffer_frame)
-    failover.before_abort &method(:buffer_frame)
-    failover.before_subscribe &method(:buffer_frame)
-    failover.before_begin &method(:buffer_transaction)
-    # We can scrub the subscription before UNSUBSCRIBE is fully written
-    # because if we replay before UNSUBSCRIBE was sent, we still don't
-    # want to be subscribed when we reconnect.
-    failover.before_unsubscribe &method(:debuffer_subscription)
-    # We only want to scrub the transactions if ABORT or COMMIT was
-    # at least written fully to the socket.
-    failover.on_commit &method(:debuffer_transaction)
-    failover.on_abort &method(:debuffer_transaction)
-    failover.on_send &method(:debuffer_non_transactional_frame)
-    
-    failover.on_failover_connected &method(:replay)
-  end
-  
-  # Adds a frame to a buffer so that it may be replayed if the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def buffer_frame f, *_
-    @buffer_mutex.synchronize do
-      unless f.header? :'x-onstomp-failover-replay'
-        @buffer << f 
+    super
+    [:send, :commit, :abort, :subscribe].each do |ev|
+      failover.__send__(:"before_#{ev}") do |f, *_|
+        add_to_buffer f
       end
     end
-  end
-  
-  # Records the start of a transaction so that it may be replayed if the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def buffer_transaction f, *_
-    @txs[f[:transaction]] = true
-    buffer_frame f
-  end
-  
-  # Removes the recorded transaction from the buffer after it has been
-  # written the broker socket so that it will not be replayed when the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def debuffer_transaction f, *_
-    tx = f[:transaction]
-    if @txs.delete tx
-      @buffer_mutex.synchronize do
-        @buffer.reject! { |bf| bf[:transaction] == tx }
+    # We only want to scrub the transactions if ABORT or COMMIT was
+    # at least written fully to the socket.
+    [:commit, :abort].each do |ev|
+      failover.__send__(:"on_#{ev}") do |f,*_|
+        remove_from_transactions f
       end
     end
+    failover.before_begin { |f, *_| add_to_transactions f }
+    # We can scrub the subscription before UNSUBSCRIBE is fully written
+    # because if we replay before UNSUBSCRIBE was sent, we still don't
+    # want to be subscribed when we reconnect.
+    failover.before_unsubscribe { |f, *_| remove_subscribe_from_buffer f }
+    failover.on_send &method(:debuffer_non_transactional_frame)
+    failover.on_failover_connected { |f,c,*_| replay_buffer c }
   end
-  
-  # Removes the matching SUBSCRIBE frame from the buffer after the
-  # UNSUBSCRIBE has been added to the connection's write buffer
-  # so that it will not be replayed when the
-  # {OnStomp::Failover::Client failover} client re-connects
-  def debuffer_subscription f, *_
-    @buffer_mutex.synchronize do
-      @buffer.reject! { |bf| bf.command == 'SUBSCRIBE' && bf[:id] == f[:id] }
-    end
-  end
-  
+
   # Removes a frame that is not part of a transaction from the buffer
   # after it has been written the broker socket so that it will not be
   # replayed when the {OnStomp::Failover::Client failover} client re-connects
@@ -76,16 +36,4 @@ class OnStomp::Failover::Buffers::Written
       @buffer_mutex.synchronize { @buffer.delete f }
     end
   end
-  
-  # Called when the {OnStomp::Failover::Client failover} client triggers
-  # `on_failover_connected` to start replaying any frames in the buffer.
-  def replay fail, client, *_
-    replay_frames = @buffer_mutex.synchronize do
-      @buffer.select { |f| f[:'x-onstomp-failover-replay'] = '1'; true }
-    end
-    
-    replay_frames.each do |f|
-      client.transmit f
-    end
-  end
 end

data/lib/onstomp/failover/failover_configurable.rb

@@ -14,13 +14,6 @@ module OnStomp::Failover::FailoverConfigurable
   # Provides attribute methods for {OnStomp::Failover::Client failover}
   # clients.
   module ClassMethods
-    # Creates readable and writeable attributes that are automatically
-    # converted into integers.
-    def attr_configurable_int *args, &block
-      trans = attr_configurable_wrap lambda { |v| v.to_i }, block
-      attr_configurable_single(*args, &trans)
-    end
-    
     # Creates readable and writeable attributes that are automatically
     # converted into boolean values. Assigning the attributes any of
     # `true`, `'true'`, `'1'` or `1` will set the attribute to `true`, all

data/lib/onstomp/failover/uri.rb

@@ -41,7 +41,9 @@ module OnStomp::Failover::URI
       #   @return [FAILOVER]
       def parse uri_str
         if uri_str =~ FAILOVER_REG
-          self.new $1.split(','), $2
+          uris = $1
+          query = $2
+          self.new uris.split(','), query
         else
           raise OnStomp::Failover::InvalidFailoverURIError, uri_str.inspect
         end

data/lib/onstomp/interfaces/client_events.rb

@@ -125,7 +125,7 @@ module OnStomp::Interfaces::ClientEvents
   # @endgroup
 
   # Helpers for setting up connection events through a client
-  [:established, :terminated, :died, :closed].each do |ev|
+  [:established, :terminated, :died, :closed, :blocked].each do |ev|
     module_eval <<-EOS
       def on_connection_#{ev}(&cb)
         if connection

data/lib/onstomp/interfaces/connection_events.rb

@@ -32,6 +32,14 @@ module OnStomp::Interfaces::ConnectionEvents
   #   the event (in general the same as `client.connection`)
   create_event_methods :terminated, :on
   # @api gem:1 STOMP:1.0,1.1
+  # Binds a callback to be invoked when a connection has been blocked
+  # on writing for more than the allowed duration, closing the connection.
+  # @yield [client, connection] callback invoked when event is triggered
+  # @yieldparam [OnStomp::Client] client
+  # @yieldparam [OnStomp::Connections::Base] connection that triggered
+  #   the event (in general the same as `client.connection`)
+  create_event_methods :blocked, :on
+  # @api gem:1 STOMP:1.0,1.1
   # Binds a callback to be invoked when a connection has been closed, either
   # through a graceful disconnect or unexpectedly.
   # @note If connection is closed unexpectedly, {#on_died} is triggered first,

data/lib/onstomp/interfaces/uri_configurable.rb

@@ -70,6 +70,13 @@ module OnStomp::Interfaces::UriConfigurable
       attr_configurable(*args, &trans)
     end
     
+    # Creates readable and writeable attributes that are automatically
+    # converted into integers.
+    def attr_configurable_int *args, &block
+      trans = attr_configurable_wrap lambda { |v| v.to_i }, block
+      attr_configurable_single(*args, &trans)
+    end
+    
     # Creates a group readable and writeable attributes that can be set
     # by a URI query parameter sharing the same name, a property of a URI or
     # a default value. The value of this attribute will be transformed by

data/lib/onstomp/version.rb

@@ -7,7 +7,7 @@ module OnStomp
   # Minor / feature version
   MINOR = 0
   # Patch version
-  PATCH = 3
+  PATCH = 4
   # Complete version
   VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
 end

data/spec/onstomp/client_spec.rb

@@ -34,6 +34,8 @@ module OnStomp
         client.login.should == ''
         client.passcode.should == ''
         client.heartbeats.should == [0, 0]
+        client.write_timeout.should == 120
+        client.read_timeout.should == 120
         client.processor.should == OnStomp::Components::ThreadedProcessor
       end
       it "should be configurable by options" do
@@ -43,6 +45,8 @@ module OnStomp
         client_options[:login] = 'my login'
         client_options[:passcode] = 'sup3r s3cr3t'
         client_options[:processor] = processor_class
+        client_options[:write_timeout] = 50
+        client_options[:read_timeout] = 70
         client_options[:ssl] = { :cert_path => '/path/to/certs' }
         client.versions.should == ['1.1']
         client.heartbeats.should == [90, 110]
@@ -50,6 +54,8 @@ module OnStomp
         client.login.should == 'my login'
         client.passcode.should == 'sup3r s3cr3t'
         client.processor.should == processor_class
+        client.write_timeout.should == 50
+        client.read_timeout.should == 70
         client.ssl.should == { :cert_path => '/path/to/certs' }
       end
       it "should be configurable by query" do
@@ -59,11 +65,15 @@ module OnStomp
         client_uri << '&login=query%20login'
         client_uri << '&passcode=qu3ry%20s3cr3t'
         client_uri << '&processor=OnStomp::Connections'
+        client_uri << '&write_timeout=30'
+        client_uri << '&read_timeout=50'
         client.versions.should == ['1.0']
         client.heartbeats.should == [80, 210]
         client.host.should == 'query host'
         client.login.should == 'query login'
         client.passcode.should == 'qu3ry s3cr3t'
+        client.write_timeout.should == 30
+        client.read_timeout.should == 50
         client.processor.should == OnStomp::Connections
       end
       it "should be configurable through parts of the URI" do
@@ -106,7 +116,7 @@ module OnStomp
         OnStomp::Connections.should_receive(:connect).with(client, headers,
           { :'accept-version' => '1.1', :host => 'my host',
             :'heart-beat' => '30,110', :login => 'my login',
-            :passcode => 's3cr3t' }, pending_events).and_return(connection)
+            :passcode => 's3cr3t' }, pending_events, 30, 50).and_return(connection)
         processor.should_receive(:start)
         client.stub(:pending_connection_events => pending_events)
         client.versions = '1.1'
@@ -114,6 +124,8 @@ module OnStomp
         client.login = 'my login'
         client.passcode = 's3cr3t'
         client.heartbeats = [30,110]
+        client.read_timeout = 30
+        client.write_timeout = 50
         client.connect(headers)
         client.connection.should == connection
       end

data/spec/onstomp/components/scopes/transaction_scope_spec.rb

@@ -136,7 +136,7 @@ module OnStomp::Components::Scopes
           :transaction => 't-1234')).and_return { |f| f }
         client.should_receive(:transmit).with(an_onstomp_frame('SEND',
           {:destination => '/queue/test', :transaction => 't-1234'},
-          'my body'), an_instance_of(Hash)).and_return { |f| f }
+          'my body'), an_instance_of(Hash)).and_return { |f,*_| f }
 
         scope.perform { |t| t.send("/queue/test", "my body") }
       end
@@ -146,7 +146,7 @@ module OnStomp::Components::Scopes
           :transaction => 't-1234')).and_return { |f| f }
         client.should_receive(:transmit).with(an_onstomp_frame('SEND',
           {:destination => '/queue/test', :transaction => 't-1234'},
-          'my body'), an_instance_of(Hash)).and_return { |f| f }
+          'my body'), an_instance_of(Hash)).and_return { |f,*_| f }
 
         scope.perform { |t| t.send("/queue/test", "my body") }
       end
@@ -157,7 +157,7 @@ module OnStomp::Components::Scopes
           :transaction => 't-1234')).and_return { |f| f }
         client.should_receive(:transmit).with(an_onstomp_frame('SEND',
           {:destination => '/queue/test', :transaction => 't-1234'},
-          'my body'), an_instance_of(Hash)).and_return { |f| f }
+          'my body'), an_instance_of(Hash)).and_return { |f,*_| f }
 
         scope.perform { |t| t.send("/queue/test", "my body"); t.commit }
       end
@@ -168,7 +168,7 @@ module OnStomp::Components::Scopes
           :transaction => 't-1234')).and_return { |f| f }
         client.should_receive(:transmit).with(an_onstomp_frame('SEND',
           {:destination => '/queue/test', :transaction => 't-1234'},
-          'my body'), an_instance_of(Hash)).and_return { |f| f }
+          'my body'), an_instance_of(Hash)).and_return { |f,*_| f }
 
         scope.perform { |t| t.send("/queue/test", "my body"); t.abort }
       end
@@ -179,7 +179,7 @@ module OnStomp::Components::Scopes
           :transaction => 't-1234')).and_return { |f| f }
         client.should_receive(:transmit).with(an_onstomp_frame('SEND',
           {:destination => '/queue/test', :transaction => 't-1234'},
-          'my body'), an_instance_of(Hash)).and_return { |f| f }
+          'my body'), an_instance_of(Hash)).and_return { |f,*_| f }
 
         lambda {
           scope.perform { |t|
@@ -195,7 +195,7 @@ module OnStomp::Components::Scopes
           :transaction => 't-1234')).and_return { |f| f }
         client.should_receive(:transmit).with(an_onstomp_frame('SEND',
           {:destination => '/queue/test', :transaction => 't-1234'},
-          'my body'), an_instance_of(Hash)).and_return { |f| f }
+          'my body'), an_instance_of(Hash)).and_return { |f,*_| f }
 
         lambda {
           scope.perform { |t|
@@ -212,7 +212,7 @@ module OnStomp::Components::Scopes
           :transaction => 't-1234')).and_return { |f| f }
         client.should_receive(:transmit).with(an_onstomp_frame('SEND',
           {:destination => '/queue/test', :transaction => 't-1234'},
-          'my body'), an_instance_of(Hash)).and_return { |f| f }
+          'my body'), an_instance_of(Hash)).and_return { |f,*_| f }
 
         lambda {
           scope.perform { |t|

data/spec/onstomp/connections/base_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 module OnStomp::Connections
   describe Base do
     let(:io) {
-      mock('io', :close => nil)
+      mock('io', :close => nil, :read_nonblock => nil, :write_nonblock => nil)
     }
     let(:client) {
       mock('client', :dispatch_transmitted => nil,
@@ -29,11 +29,7 @@ module OnStomp::Connections
         lambda { connection.lame_lame }.should raise_error(NameError)
       end
     end
-    
-    describe ".configure" do
-      
-    end
-    
+
     describe ".connected?" do
       it "should be connected if io is not closed" do
         io.stub(:closed? => false)
@@ -43,6 +39,30 @@ module OnStomp::Connections
       end
     end
     
+    describe ".duration_since_transmitted" do
+      it "should be nil if last_transmitted_at is nil" do
+        connection.stub(:last_transmitted_at => nil)
+        connection.duration_since_transmitted.should be_nil
+      end
+      it "should be the difference between now and the last_transmitted_at in milliseconds" do
+        Time.stub(:now => 10)
+        connection.stub(:last_transmitted_at => 8.5)
+        connection.duration_since_transmitted.should == 1500
+      end
+    end
+    
+    describe ".duration_since_received" do
+      it "should be nil if last_received_at is nil" do
+        connection.stub(:last_received_at => nil)
+        connection.duration_since_received.should be_nil
+      end
+      it "should be the difference between now and the last_received_at in milliseconds" do
+        Time.stub(:now => 10)
+        connection.stub(:last_received_at => 6)
+        connection.duration_since_received.should == 4000
+      end
+    end
+    
     describe ".close" do
       it "should close the socket if blocking is true" do
         io.should_receive(:close)
@@ -195,6 +215,18 @@ module OnStomp::Connections
         lambda { connection.io_process_write }.should raise_error(Exception)
         triggered.should be_true
       end
+      it "should trigger a blocked close if the write timeout is exceeded" do
+        triggered = false
+        connection.on_blocked { triggered = true }
+        connection.write_timeout = 10
+        Time.stub(:now => 31)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        Time.stub(:now => 77)
+        IO.stub(:select => false)
+        io.should_receive(:close)
+        connection.io_process_write
+        triggered.should be_true
+      end
     end
     describe ".io_process_read" do
       before(:each) do
@@ -262,7 +294,7 @@ module OnStomp::Connections
         io.should_receive(:close)
         lambda { connection.io_process_read }.should raise_error(IOError)
       end
-      it "should close the connection and re-raise if an EOFError is raised" do
+      it "should close the connection and re-raise if an SystemCallError is raised" do
         connection.stub(:connected? => true)
         IO.stub(:select => true)
         io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(SystemCallError.new('msg', 13))
@@ -279,6 +311,122 @@ module OnStomp::Connections
         lambda { connection.io_process_read }.should raise_error(Exception)
         triggered.should be_true
       end
+      it "should trigger a blocked close if checking timeout and it is exceeded" do
+        triggered = false
+        connection.on_blocked { triggered = true }
+        IO.stub(:select => false)
+        connection.stub(:read_timeout_exceeded? => true, :connected? => true)
+        io.should_receive(:close)
+        connection.io_process_read(true)
+        triggered.should be_true
+      end
+    end
+    
+    describe "read helpers" do
+      it "should not be ready for read if not connected" do
+        IO.stub(:select => true)
+        connection.stub(:connected? => false)
+        connection.__send__(:ready_for_read?).should be_false
+      end
+      it "should not be ready for read if IO.select is nil" do
+        IO.stub(:select => nil)
+        connection.stub(:connected? => true)
+        connection.__send__(:ready_for_read?).should be_false
+      end
+      it "should be ready for read if connected and selectable" do
+        IO.stub(:select => true)
+        connection.stub(:connected? => true)
+        connection.__send__(:ready_for_read?).should be_true
+      end
+      it "should close and trigger terminated event if error is raised" do
+        triggered = false
+        connection.on_terminated { triggered = true }
+        IO.stub(:select).and_raise(IOError)
+        connection.stub(:connected? => true)
+        lambda {
+          connection.__send__(:ready_for_read?)
+        }.should raise_error(IOError)
+        triggered.should be_true
+      end
+      it "should not exceed the timeout if no timeout is set" do
+        connection.read_timeout = nil
+        connection.__send__(:read_timeout_exceeded?).should be_false
+      end
+      it "should not exceed the timeout if duration is less than timeout" do
+        connection.read_timeout = 10
+        connection.stub(:duration_since_received => 9000)
+        connection.__send__(:read_timeout_exceeded?).should be_false
+      end
+      it "should not exceed the timeout if duration is equal to timeout" do
+        connection.read_timeout = 10
+        connection.stub(:duration_since_received => 10000)
+        connection.__send__(:read_timeout_exceeded?).should be_false
+      end
+      it "should exceed the timeout if duration is greater than timeout" do
+        connection.read_timeout = 10
+        connection.stub(:duration_since_received => 10001)
+        connection.__send__(:read_timeout_exceeded?).should be_true
+      end
+    end
+    
+    describe "write helpers" do
+      it "should not be ready for write if buffer is empty" do
+        IO.stub(:select => true)
+        connection.__send__(:ready_for_write?).should be_false
+      end
+      it "should not be ready for write if IO.select is nil" do
+        IO.stub(:select => nil)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.__send__(:ready_for_write?).should be_false
+      end
+      it "should be ready for write if there's buffer data and selectable" do
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.__send__(:ready_for_write?).should be_true
+      end
+      it "should close and trigger terminated event if error is raised" do
+        triggered = false
+        connection.on_terminated { triggered = true }
+        IO.stub(:select).and_raise(IOError)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        lambda {
+          connection.__send__(:ready_for_write?)
+        }.should raise_error(IOError)
+        triggered.should be_true
+      end
+      it "should not exceed the timeout if no timeout is set" do
+        connection.write_timeout = nil
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.__send__(:write_timeout_exceeded?).should be_false
+      end
+      it "should not exceed the timeout if duration is less than timeout" do
+        connection.write_timeout = 10
+        Time.stub(:now => 59)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        Time.stub(:now => 61)
+        connection.__send__(:write_timeout_exceeded?).should be_false
+      end
+      it "should not exceed the timeout if duration is equal to timeout" do
+        connection.write_timeout = 10
+        Time.stub(:now => 59)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        Time.stub(:now => 69)
+        connection.__send__(:write_timeout_exceeded?).should be_false
+      end
+      it "should not exceed the timeout if the duratio is greater but there's no buffered data" do
+        connection.write_timeout = 1
+        connection.stub(:duration_since_transmitted => 5000)
+        connection.__send__(:write_timeout_exceeded?).should be_false
+      end
+      it "should exceed the timeout if buffered and duration is greater than timeout" do
+        Time.stub(:now => 59)
+        connection.write_timeout = 10
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        # This proves that not all calls to push_write_buffer reset the clock.
+        Time.stub(:now => 70)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.__send__(:write_timeout_exceeded?).should be_true
+      end
     end
     
     describe ".connect" do
@@ -294,7 +442,7 @@ module OnStomp::Connections
         connection.should_receive(:connect_frame).and_return(connect_frame)
         connection.should_receive(:write_frame_nonblock).with(connect_frame)
         connection.should_receive(:io_process_write).and_yield(connect_frame)
-        connection.should_receive(:io_process_read).and_yield(connected_frame)
+        connection.should_receive(:io_process_read).with(true).and_yield(connected_frame)
         connected_frame.command = 'NOT CONNECTED'
         lambda { connection.connect(client, *headers) }.should raise_error(OnStomp::ConnectFailedError)
       end
@@ -302,7 +450,7 @@ module OnStomp::Connections
         connection.should_receive(:connect_frame).and_return(connect_frame)
         connection.should_receive(:write_frame_nonblock).with(connect_frame)
         connection.should_receive(:io_process_write).and_yield(connect_frame)
-        connection.should_receive(:io_process_read).and_yield(connected_frame)
+        connection.should_receive(:io_process_read).with(true).and_yield(connected_frame)
         connected_frame[:version] = '1.9'
         client.stub(:versions => [ '1.0', '1.1' ])
         lambda { connection.connect(client, *headers) }.should raise_error(OnStomp::UnsupportedProtocolVersionError)
@@ -311,7 +459,7 @@ module OnStomp::Connections
         connection.should_receive(:connect_frame).and_return(connect_frame)
         connection.should_receive(:write_frame_nonblock).with(connect_frame)
         connection.should_receive(:io_process_write).and_yield(connect_frame)
-        connection.should_receive(:io_process_read).and_yield(connected_frame)
+        connection.should_receive(:io_process_read).with(true).and_yield(connected_frame)
         client.stub(:versions => [ '1.0', '1.1' ])
         connection.connect(client, *headers).should == ['1.0', connected_frame]
       end
@@ -319,7 +467,7 @@ module OnStomp::Connections
         connection.should_receive(:connect_frame).and_return(connect_frame)
         connection.should_receive(:write_frame_nonblock).with(connect_frame)
         connection.should_receive(:io_process_write).and_yield(connect_frame)
-        connection.should_receive(:io_process_read).and_yield(connected_frame)
+        connection.should_receive(:io_process_read).with(true).and_yield(connected_frame)
         connected_frame[:version] = '2.3'
         client.stub(:versions => [ '1.0', '2.3' ])
         connection.connect(client, *headers).should == ['2.3', connected_frame]
@@ -330,7 +478,7 @@ module OnStomp::Connections
           :write_frame_nonblock => connect_frame)
         client.stub(:versions => ['1.0', '1.1'])
         connection.stub(:io_process_write).and_yield(connect_frame)
-        connection.stub(:io_process_read).and_yield(connected_frame)
+        connection.stub(:io_process_read).with(true).and_yield(connected_frame)
         triggered = 0
         connection.on_died { |cl, cn| triggered += 1 }
         connection.connect client
@@ -360,5 +508,39 @@ module OnStomp::Connections
         connection.version.should == '1.0'
       end
     end
+    
+    describe "non-blocking IO wrappers" do
+      before(:each) do
+        io.stub(:closed? => false)
+        io.stub(:read_nonblock => nil, :write_nonblock => 16)
+      end
+      
+      it "should use read_nonblock if IO responds to read_nonblock" do
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ)
+        connection.stub(:ready_for_read? => true)
+        connection.io_process_read
+      end
+      it "should use readpartial if IO does not respond to read_nonblock" do
+        io.unstub(:read_nonblock)
+        io.should_receive(:readpartial).with(Base::MAX_BYTES_PER_READ)
+        connection.stub(:ready_for_read? => true)
+        connection.io_process_read
+      end
+      
+      it "should use write_nonblock if IO responds to write_nonblock" do
+        io.should_receive(:write_nonblock).with("FRAME_SERIALIZED")
+        connection.stub(:ready_for_write? => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.io_process_write
+      end
+      it "should use readpartial if IO does not respond to read_nonblock" do
+        io.unstub(:write_nonblock)
+        io.should_not respond_to(:write_nonblock)
+        io.should_receive(:write).with("FRAME_SERIALIZED") { 16 }
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.stub(:ready_for_write? => true)
+        connection.io_process_write
+      end
+    end
   end
 end