onstomp 1.0.0pre1

data/spec/onstomp/connections/base_spec.rb

@@ -0,0 +1,349 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections
+  describe Base do
+    let(:io) {
+      mock('io', :close => nil)
+    }
+    let(:client) {
+      mock('client', :dispatch_transmitted => nil,
+        :dispatch_received => nil)
+    }
+    let(:serializer) {
+      mock('serializer')
+    }
+    let(:connection) {
+      Base.new(io, client)
+    }
+    let(:frame) {
+      mock('frame')
+    }
+    
+    describe ".method_missing" do
+      it "should raise an unsupported command error if the method ends in _frame" do
+        lambda { connection.lame_frame }.should raise_error(OnStomp::UnsupportedCommandError)
+      end
+      
+      it "should do the regular jazz for other missing methods" do
+        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)
+        connection.should be_connected
+        io.stub(:closed? => true)
+        connection.should_not be_connected
+      end
+    end
+    
+    describe ".close" do
+      it "should close the socket if blocking is true" do
+        io.should_receive(:close)
+        connection.close true
+      end
+      
+      it "should close the socket within single_io_write" do
+        io.should_receive :close
+        connection.close
+        connection.io_process_write
+      end
+    end
+    
+    describe ".io_process" do
+      it "should invoke one io_process_read and one io_process_write" do
+        connection.should_receive :io_process_read
+        connection.should_receive :io_process_write
+        connection.io_process
+      end
+    end
+    
+    describe ".write_frame_nonblock" do
+      before(:each) do
+        connection.stub(:serializer => serializer)
+      end
+      it "should serialize the frame and push it to the buffer" do
+        serializer.stub(:frame_to_bytes).with(frame).and_return('FRAME_SERIALIZED')
+        connection.should_receive(:push_write_buffer).with('FRAME_SERIALIZED', frame)
+        connection.write_frame_nonblock frame
+      end
+    end
+    
+    describe ".(push|shift|unshift)_write_buffer" do
+      it "should not add to the buffer if it's closing" do
+        connection.close
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.should_not_receive :io_process_write
+        connection.close true
+      end
+      it "should shift the first element off the write buffer" do
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.push_write_buffer 'FRAME_SERIALIZED2', frame
+        connection.shift_write_buffer.should == ['FRAME_SERIALIZED', frame]
+      end
+      it "should put the data and frame at the beginning of the buffer" do
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        connection.unshift_write_buffer 'FRAME_SERIALIZED2', frame
+        connection.shift_write_buffer.should == ['FRAME_SERIALIZED2', frame]
+      end
+    end
+    
+    describe ".io_process_write" do
+      it "should not write if the buffer is empty" do
+        io.should_not_receive :write_nonblock
+        connection.io_process_write
+      end
+      it "should not write if the buffer has something but IO.select returns nil" do
+        IO.stub(:select => nil)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_not_receive :write_nonblock
+        connection.io_process_write
+      end
+      it "should write to IO in a non-blocking fashion otherwise" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_return(16)
+        client.should_receive(:dispatch_transmitted).with(frame)
+        connection.io_process_write
+      end
+      it "should put back the remaining data" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_return(5)
+        connection.should_receive(:unshift_write_buffer).with('_SERIALIZED', frame)
+        connection.io_process_write
+      end
+      it "should put all the data back if EINTR is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_raise(Errno::EINTR)
+        connection.should_receive(:unshift_write_buffer).with('FRAME_SERIALIZED', frame)
+        connection.io_process_write
+      end
+      it "should put all the data back if EAGAIN is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_raise(Errno::EAGAIN)
+        connection.should_receive(:unshift_write_buffer).with('FRAME_SERIALIZED', frame)
+        connection.io_process_write
+      end
+      it "should put all the data back if EWOULDBLOCK is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_raise(Errno::EWOULDBLOCK)
+        connection.should_receive(:unshift_write_buffer).with('FRAME_SERIALIZED', frame)
+        connection.io_process_write
+      end
+      it "should close the connection and re-raise if an EOFError is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_raise(EOFError)
+        io.should_receive(:close)
+        lambda { connection.io_process_write }.should raise_error(EOFError)
+      end
+      it "should close the connection and re-raise if an IOError is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_raise(IOError)
+        io.should_receive(:close)
+        lambda { connection.io_process_write }.should raise_error(IOError)
+      end
+      it "should close the connection and re-raise if an EOFError is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_raise(SystemCallError.new('msg', 13))
+        io.should_receive(:close)
+        lambda { connection.io_process_write }.should raise_error(SystemCallError)
+      end
+      it "should re-raise on any other exception" do
+        triggered = false
+        connection.on_terminated { triggered = true }
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        connection.push_write_buffer 'FRAME_SERIALIZED', frame
+        io.should_receive(:close)
+        io.should_receive(:write_nonblock).with('FRAME_SERIALIZED').and_raise(Exception)
+        lambda { connection.io_process_write }.should raise_error(Exception)
+        triggered.should be_true
+      end
+    end
+    describe ".io_process_read" do
+      before(:each) do
+        connection.stub(:serializer => serializer)
+      end
+      it "should not read if the connection is not alive" do
+        connection.stub(:connected? => false)
+        io.should_not_receive :read_nonblock
+        connection.io_process_read
+      end
+      it "should not read if IO.select returns nil" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => nil)
+        io.should_not_receive :read_nonblock
+        connection.io_process_read
+      end
+      it "should read IO in a non-blocking fashion otherwise" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_return('FRAME_SERIALIZED')
+        serializer.should_receive(:bytes_to_frame).with(['FRAME_SERIALIZED'])
+        connection.io_process_read
+      end
+      it "should dispatch and yield a frame if the serializer yields one" do
+        yielded = nil
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_return('FRAME_SERIALIZED')
+        serializer.should_receive(:bytes_to_frame).with(['FRAME_SERIALIZED']).and_yield(frame)
+        client.should_receive(:dispatch_received).with(frame)
+        connection.io_process_read do |f|
+          yielded = f
+        end
+        yielded.should == frame
+      end
+      it "should not raise an error if EINTR is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(Errno::EINTR)
+        lambda { connection.io_process_read }.should_not raise_error
+      end
+      it "should put all the data back if EAGAIN is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(Errno::EAGAIN)
+        lambda { connection.io_process_read }.should_not raise_error
+      end
+      it "should put all the data back if EWOULDBLOCK is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(Errno::EWOULDBLOCK)
+        lambda { connection.io_process_read }.should_not raise_error
+      end
+      it "should close the connection and not raise error if an EOFError is raised?" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(EOFError)
+        io.should_receive(:close)
+        lambda { connection.io_process_read }.should_not raise_error
+      end
+      it "should close the connection and re-raise if an IOError is raised" do
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(IOError)
+        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
+        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))
+        io.should_receive(:close)
+        lambda { connection.io_process_read }.should raise_error(SystemCallError)
+      end
+      it "should re-raise on any other exception" do
+        triggered = false
+        connection.on_terminated { triggered = true }
+        connection.stub(:connected? => true)
+        IO.stub(:select => true)
+        io.should_receive(:close)
+        io.should_receive(:read_nonblock).with(Base::MAX_BYTES_PER_READ).and_raise(Exception)
+        lambda { connection.io_process_read }.should raise_error(Exception)
+        triggered.should be_true
+      end
+    end
+    
+    describe ".connect" do
+      let(:headers) { [] }
+      let(:connect_frame) {
+        OnStomp::Components::Frame.new('CONNECT')
+      }
+      let(:connected_frame) {
+        OnStomp::Components::Frame.new('CONNECTED')
+      }
+      
+      it "should raise an error if the first frame read is not CONNECTED" do
+        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)
+        connected_frame.command = 'NOT CONNECTED'
+        lambda { connection.connect(client, *headers) }.should raise_error(OnStomp::ConnectFailedError)
+      end
+      it "should raise an error if the CONNECTED frame specifies an unsolicited version" do
+        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)
+        connected_frame[:version] = '1.9'
+        client.stub(:versions => [ '1.0', '1.1' ])
+        lambda { connection.connect(client, *headers) }.should raise_error(OnStomp::UnsupportedProtocolVersionError)
+      end
+      it "should assume version 1.0 if no version header is set" do
+        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)
+        client.stub(:versions => [ '1.0', '1.1' ])
+        connection.connect(client, *headers).should == ['1.0', connected_frame]
+      end
+      it "should return the CONNECTED version header if it's included" do
+        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)
+        connected_frame[:version] = '2.3'
+        client.stub(:versions => [ '1.0', '2.3' ])
+        connection.connect(client, *headers).should == ['2.3', connected_frame]
+      end
+      
+      it "should trigger :on_died once, if the connection was up but is no longer connected" do
+        connection.stub(:connect_frame => connect_frame,
+          :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)
+        triggered = 0
+        connection.on_died { |cl, cn| triggered += 1 }
+        connection.connect client
+        connection.stub(:io_process_write => nil, :io_process_read => nil)
+        connection.stub(:connected? => false)
+        connection.io_process
+        connection.io_process
+        triggered.should == 1
+      end
+    end
+    
+    describe ".configure" do
+      let(:client_bindings) {
+        { :died => nil, :established => nil }
+      }
+      it "should set its version parameter based on the supplied CONNECTED frame" do
+        frame.stub(:header?).with(:version).and_return(true)
+        frame.stub(:[]).with(:version).and_return('9.x')
+        connection.should_receive(:install_bindings_from_client).with(client_bindings)
+        connection.configure frame, client_bindings
+        connection.version.should == '9.x'
+      end
+      it "should set its version parameter to 1.0 if the header is not present" do
+        frame.stub(:header?).with(:version).and_return(false)
+        connection.should_receive(:install_bindings_from_client).with(client_bindings)
+        connection.configure frame, client_bindings
+        connection.version.should == '1.0'
+      end
+    end
+  end
+end

data/spec/onstomp/connections/heartbeating_spec.rb

@@ -0,0 +1,132 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections
+  describe Heartbeating do
+    let(:connection) {
+      mock('connection').tap do |m|
+        m.extend Heartbeating
+      end
+    }
+    
+    describe ".configure_heartbeating" do
+      it "should use 0 for client beats if either side is zero" do
+        connection.configure_heartbeating([0,500], [100, 300])
+        connection.heartbeating.first.should == 0
+        connection.configure_heartbeating([300,500], [100, 0])
+        connection.heartbeating.first.should == 0
+      end
+      it "should use 0 for broker beats if either side is zero" do
+        connection.configure_heartbeating([500,0], [100, 300])
+        connection.heartbeating.last.should == 0
+        connection.configure_heartbeating([300,100], [0, 500])
+        connection.heartbeating.last.should == 0
+      end
+      it "should use the maximums for heartbeating" do
+        connection.configure_heartbeating([500,700], [100, 300])
+        connection.heartbeating.should == [500, 700]
+      end
+    end
+    
+    describe ".pulse?" do
+      it "should not have a pulse if it has no client pulse" do
+        connection.stub(:client_pulse? => false, :broker_pulse? => true)
+        connection.pulse?.should be_false
+      end
+      it "should not have a pulse if it has no broker pulse" do
+        connection.stub(:client_pulse? => true, :broker_pulse? => false)
+        connection.pulse?.should be_false
+      end
+      it "should have a pulse if it has both a client and broker pulse" do
+        connection.stub(:client_pulse? => true, :broker_pulse? => true)
+        connection.pulse?.should be_true
+      end
+    end
+    
+    describe ".heartbeat_client_limit" do
+      it "should be 110% of a positive client heartbeat value" do
+        connection.stub(:heartbeating => [64, 0])
+        connection.heartbeat_client_limit.should == 70.4
+      end
+      it "should be 0 if the client heartbeat value is 0" do
+        connection.stub(:heartbeating => [0, 90])
+        connection.heartbeat_client_limit.should == 0
+      end
+    end
+    
+    describe ".heartbeat_broker_limit" do
+      it "should be 110% of a positive broker heartbeat value" do
+        connection.stub(:heartbeating => [0, 32])
+        connection.heartbeat_broker_limit.should == 35.2
+      end
+      it "should be 0 if the broker heartbeat value is 0" do
+        connection.stub(:heartbeating => [90, 0])
+        connection.heartbeat_broker_limit.should == 0
+      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 ".client_pulse?" do
+      it "should be true if client heartbeating is disabled" do
+        connection.stub(:heartbeat_client_limit => 0)
+        connection.client_pulse?.should be_true
+      end
+      it "should be true if duration since transmitted is at most client limit" do
+        connection.stub(:heartbeat_client_limit => 10)
+        connection.stub(:duration_since_transmitted => 1)
+        connection.client_pulse?.should be_true
+        connection.stub(:heartbeat_client_limit => 10)
+        connection.stub(:duration_since_transmitted => 10)
+        connection.client_pulse?.should be_true
+      end
+      it "should be false if duration since transmitted is greater than client limit" do
+        connection.stub(:heartbeat_client_limit => 10)
+        connection.stub(:duration_since_transmitted => 11)
+        connection.client_pulse?.should be_false
+      end
+    end
+    
+    describe ".broker_pulse?" do
+      it "should be true if broker heartbeating is disabled" do
+        connection.stub(:heartbeat_broker_limit => 0)
+        connection.broker_pulse?.should be_true
+      end
+      it "should be true if duration since transmitted is at most broker limit" do
+        connection.stub(:heartbeat_broker_limit => 10)
+        connection.stub(:duration_since_received => 1)
+        connection.broker_pulse?.should be_true
+        connection.stub(:heartbeat_broker_limit => 10)
+        connection.stub(:duration_since_received => 10)
+        connection.broker_pulse?.should be_true
+      end
+      it "should be false if duration since received is greater than broker limit" do
+        connection.stub(:heartbeat_broker_limit => 10)
+        connection.stub(:duration_since_received => 11)
+        connection.broker_pulse?.should be_false
+      end
+    end
+  end
+end

data/spec/onstomp/connections/serializers/stomp_1_0_spec.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections::Serializers
+  describe Stomp_1_0 do
+    let(:serializer) { Stomp_1_0.new }
+    describe "ancestors" do
+      it "should be a kind of Stomp_1 serializer" do
+        serializer.should be_a_kind_of(OnStomp::Connections::Serializers::Stomp_1)
+      end
+    end
+    describe ".frame_to_string" do
+      # So tests pass with Ruby 1.8.7, we need to get the headers in order
+      let(:frame_without_body) {
+        OnStomp::Components::Frame.new('COMMAND').tap do |f|
+          f[:header1] = 'value 1'
+          f[:header2] = 'value 2'
+          f["header\nwith:specials"] = "value\nwith\nspecials"
+        end
+      }
+      let(:frame_with_body) {
+        OnStomp::Components::Frame.new('COMMAND',{},"body of message").tap do |f|
+          f[:header1] = 'value 1'
+          f[:header2] = 'value 2'
+          f["header\nwith:specials"] = "value\nwith\nspecials"
+        end
+      }
+      it "should convert a frame to a string with escaped headers" do
+        serializer.frame_to_string(frame_without_body).should ==
+          "COMMAND\nheader1:value 1\nheader2:value 2\nheaderwithspecials:valuewithspecials\n\n\000"
+      end
+      it "should generate a content-length" do
+        serializer.frame_to_string(frame_with_body).should ==
+          "COMMAND\nheader1:value 1\nheader2:value 2\nheaderwithspecials:valuewithspecials\ncontent-length:15\n\nbody of message\000"
+      end
+    end
+    
+    describe ".split_header" do
+      it "should raise a malformed header error if the header line has no ':'" do
+        lambda {
+          serializer.split_header('header-name')
+        }.should raise_error(OnStomp::MalformedHeaderError)
+      end
+      it "should return a header name / value pair" do
+        serializer.split_header('header-name: some : value ').should ==
+          ['header-name', ' some : value ']
+      end
+    end
+  end
+end

data/spec/onstomp/connections/serializers/stomp_1_1_spec.rb

@@ -0,0 +1,99 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections::Serializers
+  describe Stomp_1_1 do
+    let(:serializer) { Stomp_1_1.new }
+    describe "ancestors" do
+      it "should be a kind of Stomp_1 serializer" do
+        serializer.should be_a_kind_of(OnStomp::Connections::Serializers::Stomp_1)
+      end
+    end
+    
+    describe ".frame_to_string" do
+      # So tests pass with Ruby 1.8.7, we need to get the headers in order
+      let(:frame_without_body) {
+        OnStomp::Components::Frame.new('COMMAND').tap do |f|
+          f[:header1] = 'value 1'
+          f[:header2] = 'value 2'
+          f["header\nwith:special \\characters"] = "value:with\\special\ncharacters"
+        end
+      }
+      let(:frame_with_body) {
+        OnStomp::Components::Frame.new('COMMAND',{},'body of message').tap do |f|
+          f[:header1] = 'value 1'
+          f[:header2] = 'value 2'
+          f["header\nwith:special \\characters"] = "value:with\\special\ncharacters"
+        end
+      }
+      it "should convert a frame to a string with escaped headers" do
+        serializer.frame_to_string(frame_without_body).should ==
+          "COMMAND\nheader1:value 1\nheader2:value 2\nheader\\nwith\\cspecial \\\\characters:value\\cwith\\\\special\\ncharacters\n\n\000"
+      end
+      it "should generate a content-length and content-type" do
+        expected_str = if RUBY_VERSION >= '1.9'
+          frame_with_body.body = frame_with_body.body.encode('ISO-8859-1')
+          "COMMAND\nheader1:value 1\nheader2:value 2\nheader\\nwith\\cspecial \\\\characters:value\\cwith\\\\special\\ncharacters\ncontent-type:text/plain;charset=ISO-8859-1\ncontent-length:15\n\nbody of message\000"
+        else
+          "COMMAND\nheader1:value 1\nheader2:value 2\nheader\\nwith\\cspecial \\\\characters:value\\cwith\\\\special\\ncharacters\ncontent-length:15\n\nbody of message\000"
+        end
+        serializer.frame_to_string(frame_with_body).should == expected_str
+      end
+    end
+    
+    describe ".split_header" do
+      it "should raise a malformed header error if the header line has no ':'" do
+        lambda {
+          serializer.split_header('header-name')
+        }.should raise_error(OnStomp::MalformedHeaderError)
+      end
+      it "should raise an invalid escape sequence error given a bad escape sequence" do
+        lambda {
+          serializer.split_header('header-name:header\\rvalue')
+        }.should raise_error(OnStomp::InvalidHeaderEscapeSequenceError)
+      end
+      it "should raise an invalid escape sequence error given an incomplete escape sequence" do
+        lambda {
+          serializer.split_header('header-name\\:header\\cvalue')
+        }.should raise_error(OnStomp::InvalidHeaderEscapeSequenceError)
+      end
+      it "should return an unescaped header name/value pair" do
+        serializer.split_header('header\\cname\\\\is\\nme:value\\\\is\\nthis\\cguy').should == 
+          ["header:name\\is\nme", "value\\is\nthis:guy"]
+      end
+    end
+    
+    describe ".prepare_parsed_frame" do
+      let(:iso8859_frame) {
+        OnStomp::Components::Frame.new('COMMAND', {
+          :header1 => 'value 1',
+          :header2 => 'value 2',
+          :'content-length' => '5',
+          :'content-type' => 'text/plain;charset=ISO-8859-1',
+          "header\nwith:special \\characters" => "value:with\\special\ncharacters"
+        }, "h\xEBllo")
+      }
+      let(:utf8_frame) {
+        OnStomp::Components::Frame.new('COMMAND', {
+          :header1 => 'value 1',
+          :header2 => 'value 2',
+          :'content-length' => '6',
+          :'content-type' => 'text/plain',
+          "header\nwith:special \\characters" => "value:with\\special\ncharacters"
+        }, "h\xC3\xABllo")
+      }
+      before(:each) do
+        if RUBY_VERSION > '1.9'
+          iso8859_frame.body.force_encoding('ASCII-8BIT')
+          utf8_frame.body.force_encoding('ASCII-8BIT')
+        end
+      end
+      it "should force a body encoding on the frame" do
+        serializer.prepare_parsed_frame(iso8859_frame)
+        serializer.prepare_parsed_frame(utf8_frame)
+        iso8859_frame.should have_body_encoding('ISO-8859-1')
+        utf8_frame.should have_body_encoding('UTF-8')
+      end
+    end
+  end
+end