stomper 1.0.0 → 2.0.0

data/spec/stomper/extensions/common_spec.rb

@@ -0,0 +1,187 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Extensions
+  describe Common do
+    before(:each) do
+      @common = mock("common", :version => '1.0')
+      @common.extend Common
+      @subscription_manager = mock('subscription manager')
+      @common.stub!(:subscription_manager).and_return(@subscription_manager)
+    end
+    
+    describe "Shared default interface" do
+      before(:each) do
+        @common.stub!(:is_a?).with(::Stomper::Connection).and_return(true)
+      end
+      it "should transmit an ABORT frame" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'transaction' => 'tx-1234'}, 'ABORT'))
+        @common.abort('tx-1234')
+      end
+    
+      it "should transmit a BEGIN frame" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'transaction' => 'tx-3124'}, 'BEGIN'))
+        @common.begin('tx-3124')
+      end
+    
+      it "should transmit a COMMIT frame" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'transaction' => 'tx-4321'}, 'COMMIT'))
+        @common.commit('tx-4321')
+      end
+    
+      it "should transmit a SEND frame with :send" do
+        @common.should_receive(:transmit).with(stomper_frame('testing :send', {'destination' => '/queue/test_send'}, 'SEND'))
+        @common.send('/queue/test_send', 'testing :send')
+      end
+    
+      it "should transmit a SEND frame with :puts" do
+        @common.should_receive(:transmit).with(stomper_frame('testing :puts', {'destination' => '/queue/test_puts'}, 'SEND'))
+        @common.puts('/queue/test_puts', 'testing :puts')
+      end
+    
+      it "should transmit a SUBSCRIBE frame" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'destination' => '/queue/test_subscribe'}, 'SUBSCRIBE'))
+        @common.subscribe('/queue/test_subscribe')
+      end
+    
+      it "should transmit an UNSUBSCRIBE frame for a given subscription ID" do
+        @subscription_manager.should_receive(:subscribed_id?).with('subscription-1234').and_return(true)
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'id' => 'subscription-1234'}, 'UNSUBSCRIBE'))
+        @common.unsubscribe('subscription-1234')
+      end
+    
+      it "should transmit an UNSUBSCRIBE frame for a given SUBSCRIBE frame" do
+        @subscription_manager.should_receive(:subscribed_id?).with('id-in-frame-4321').and_return(true)
+        subscribe = ::Stomper::Frame.new('SUBSCRIBE', { :id => 'id-in-frame-4321' })
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'id' => 'id-in-frame-4321'}, 'UNSUBSCRIBE'))
+        @common.unsubscribe(subscribe)
+      end
+    
+      it "should raise an error on :nack" do
+        lambda { @common.nack("msg-001", "sub-001") }.should raise_error
+      end
+    
+      it "should transmit an ACK for a message-id given MESSAGE frame" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-001'}, 'ACK'))
+        @common.ack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-001' }, 'some body'))
+      end
+    
+      it "should transmit an ACK for a message-id given a message-id" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-123'}, 'ACK'))
+        @common.ack('msg-123')
+      end
+    
+      it "should raise an error when the message-id cannot be inferred" do
+        lambda { @common.ack('') }.should raise_error(ArgumentError)
+        lambda { @common.ack(Stomper::Frame.new('MESSAGE', { :id => '' }, 'some body')) }.should raise_error(ArgumentError)
+        lambda { @common.ack(nil) }.should raise_error(ArgumentError)
+        lambda { @common.ack(Stomper::Frame.new('MESSAGE', {}, 'some body')) }.should raise_error(ArgumentError)
+      end
+    end
+    
+    describe "subscription handling" do
+      it "should add a callback to the subscription manager on :subscribe" do
+        # In this tests, we do not care about the particulars of the generated
+        # frame. Our only interest is the interaction with the subscription
+        # manager
+        @common.stub!(:transmit).and_return { |f| f }
+        @subscription_manager.should_receive(:add).with(stomper_frame_with_headers({}, 'SUBSCRIBE'), an_instance_of(Proc))
+        @common.subscribe('/queue/test') { |m| true }
+      end
+      it "should unsubscribe by destination" do
+        # As this invocation of unsubscribe will result in multiple UNSUBSCRIBE
+        # frames being generated, we do care about the actual frames generated
+        # as well.
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({:id => '1234'}, 'UNSUBSCRIBE'))
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({:id => '4567'}, 'UNSUBSCRIBE'))
+        @subscription_manager.should_receive(:subscribed_id?).with('/queue/test').and_return(false)
+        @subscription_manager.should_receive(:subscribed_destination?).with('/queue/test').and_return(true)
+        @subscription_manager.should_receive(:ids_for_destination).with('/queue/test').and_return(['1234', '4567'])
+        @common.unsubscribe("/queue/test")
+      end
+    end
+    
+    describe "SEND receipt handling" do
+      it "should build a receipt scope when a block is passed to :send" do
+        receipt_scope = mock('receipt scope')
+        @common.should_receive(:with_receipt).and_return(receipt_scope)
+        receipt_scope.should_receive(:transmit).with(stomper_frame('my message', { :destination => '/topic/testing' }, 'SEND'))
+        @common.send('/topic/testing', 'my message') { |r| true }
+      end
+      
+      it "should build a receipt scope when a block is passed to :puts" do
+        receipt_scope = mock('receipt scope')
+        @common.should_receive(:with_receipt).and_return(receipt_scope)
+        receipt_scope.should_receive(:transmit).with(stomper_frame('my message', { :destination => '/topic/testing' }, 'SEND'))
+        @common.puts('/topic/testing', 'my message') { |r| true }
+      end
+    end
+    
+    describe "1.1 Protocol Extensions" do
+      before(:each) do
+        @common.stub!(:version).and_return('1.1')
+        Common.extend_by_protocol_version(@common, '1.1')
+      end
+      it "should include V1_1 module" do
+        @common.should be_a_kind_of(Common::V1_1)
+      end
+      
+      it "should transmit a NACK for a message-id and subscription given MESSAGE frame" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-456', 'subscription' => 'sub-123'}, 'NACK'))
+        @common.nack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456', :subscription => 'sub-123' }, 'some body'))
+      end
+      it "should transmit a NACK for a message-id and subscription given MESSAGE frame w/o subscription and subscription-id" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-456', 'subscription' => 'sub-123'}, 'NACK'))
+        @common.nack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456', :subscription => '' }, 'some body'), 'sub-123')
+      end
+      it "should transmit a NACK for a message-id and subscription given message-id and subscription-id" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-456', 'subscription' => 'sub-123'}, 'NACK'))
+        @common.nack('msg-456', 'sub-123')
+      end
+      it "should raise an error when the subscription ID cannot be inferred" do
+        lambda { @common.nack('msg-456') }.should raise_error(ArgumentError)
+        lambda { @common.nack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456' }, 'some body')) }.should raise_error(ArgumentError)
+        lambda { @common.nack('msg-456', '') }.should raise_error(ArgumentError)
+        lambda { @common.nack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456' }, 'some body'), '') }.should raise_error(ArgumentError)
+        lambda { @common.nack('msg-456', { :subscription => ''}) }.should raise_error(ArgumentError)
+        lambda { @common.nack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456' }, 'some body'), '', { :subscription => nil }) }.should raise_error(ArgumentError)
+        lambda { @common.nack('msg-456', { :subscription => 'sub-123'}) }.should raise_error(ArgumentError)
+      end
+      it "should raise an error when the message-id cannot be inferred" do
+        lambda { @common.nack('', 'sub-123') }.should raise_error(ArgumentError)
+        lambda { @common.nack(Stomper::Frame.new('MESSAGE', { :'message-id' => '' }, 'some body'), 'sub-123') }.should raise_error(ArgumentError)
+        lambda { @common.nack(nil, 'sub-123') }.should raise_error(ArgumentError)
+        lambda { @common.nack(Stomper::Frame.new('MESSAGE', {}, 'some body'), 'sub-123') }.should raise_error(ArgumentError)
+      end
+
+      it "should transmit an ACK for a message-id and subscription given MESSAGE frame" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-456', 'subscription' => 'sub-123'}, 'ACK'))
+        @common.ack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456', :subscription => 'sub-123' }, 'some body'))
+      end    
+      it "should transmit an ACK for a message-id and subscription given MESSAGE frame w/o subscription and subscription-id" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-456', 'subscription' => 'sub-123'}, 'ACK'))
+        @common.ack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456', :subscription => '' }, 'some body'), 'sub-123')
+      end
+      it "should transmit an ACK for a message-id and subscription given message-id and subscription-id" do
+        @common.should_receive(:transmit).with(stomper_frame_with_headers({'message-id' => 'msg-456', 'subscription' => 'sub-123'}, 'ACK'))
+        @common.ack('msg-456', 'sub-123')
+      end
+      it "should raise an error when the subscription ID cannot be inferred" do
+        lambda { @common.ack('msg-456') }.should raise_error(ArgumentError)
+        lambda { @common.ack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456' }, 'some body')) }.should raise_error(ArgumentError)
+        lambda { @common.ack('msg-456', '') }.should raise_error(ArgumentError)
+        lambda { @common.ack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456' }, 'some body'), '') }.should raise_error(ArgumentError)
+        lambda { @common.ack('msg-456', { :subscription => ''}) }.should raise_error(ArgumentError)
+        lambda { @common.ack(Stomper::Frame.new('MESSAGE', { :'message-id' => 'msg-456' }, 'some body'), '', { :subscription => nil }) }.should raise_error(ArgumentError)
+        lambda { @common.ack('msg-456', { :subscription => 'sub-123'}) }.should raise_error(ArgumentError)
+      end
+      it "should raise an error when the message-id cannot be inferred" do
+        lambda { @common.ack('', 'sub-123') }.should raise_error(ArgumentError)
+        lambda { @common.ack(Stomper::Frame.new('MESSAGE', { :'message-id' => '' }, 'some body'), 'sub-123') }.should raise_error(ArgumentError)
+        lambda { @common.ack(nil, 'sub-123') }.should raise_error(ArgumentError)
+        lambda { @common.ack(Stomper::Frame.new('MESSAGE', {}, 'some body'), 'sub-123') }.should raise_error(ArgumentError)
+        lambda { @common.ack('', { :'message-id' => 'msg-456', :subscription => 'sub-123'}) }.should raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/stomper/extensions/events_spec.rb

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Extensions
+  describe Events do
+    before(:each) do
+      @events = mock('events')
+      @events.extend Events
+    end
+    
+    describe "basic event callbacks" do
+      [:on_abort, :on_ack, :on_begin, :on_commit, :on_connect, :on_stomp,
+        :on_connected, :on_disconnect, :on_error, :on_message, :on_nack,
+        :on_receipt, :on_send, :on_subscribe, :on_unsubscribe, :on_client_beat,
+        :on_broker_beat, :on_connection_established, :on_connection_closed,
+        :on_connection_terminated, :on_connection_disconnected,
+        :on_connection_died, :before_transmitting, :after_transmitting,
+        :before_receiving, :after_receiving].each do |event_name|
+        
+        it "should register a callback for #{event_name} and trigger appropriately" do
+          triggered = false
+          @events.__send__(event_name) do
+            triggered = true
+          end
+          @events.__send__(:trigger_event, event_name)
+          triggered.should be_true
+        end
+      end
+    end
+    
+    describe "frame event callbacks" do
+      [ :on_connected, :on_error, :on_message, :on_receipt].each do |event_name|
+
+        it "should register a callback for #{event_name} and trigger when the frame is received" do
+          command_name = event_name.to_s.split('_').last.upcase
+          triggered = false
+          @events.__send__(event_name) do
+            triggered = true
+          end
+          @events.__send__(:trigger_received_frame, ::Stomper::Frame.new(command_name))
+          triggered.should be_true
+        end
+      end
+      
+      [:on_abort, :on_ack, :on_begin, :on_commit, :on_connect, :on_stomp,
+        :on_disconnect, :on_nack, :on_send, :on_subscribe, :on_unsubscribe].each do |event_name|
+
+        it "should register a callback for #{event_name} and trigger when the frame is transmitted" do
+          command_name = event_name.to_s.split('_').last.upcase
+          triggered = false
+          @events.__send__(event_name) do
+            triggered = true
+          end
+          @events.__send__(:trigger_transmitted_frame, ::Stomper::Frame.new(command_name))
+          triggered.should be_true
+        end
+      end
+      
+      it "should trigger a broker beat when receiving a frame with no command" do
+        triggered = false
+        @events.on_broker_beat do
+          triggered = true
+        end
+        @events.__send__(:trigger_received_frame, ::Stomper::Frame.new)
+        triggered.should be_true
+      end
+      
+      it "should trigger a client beat when receiving a frame with no command" do
+        triggered = false
+        @events.on_client_beat do
+          triggered = true
+        end
+        @events.__send__(:trigger_transmitted_frame, ::Stomper::Frame.new)
+        triggered.should be_true
+      end
+    end
+  end
+end

data/spec/stomper/extensions/heartbeat_spec.rb

@@ -0,0 +1,103 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Extensions
+  describe Heartbeat do
+    before(:each) do
+      @heartbeats = mock('heartbeats')
+      @heartbeats.extend Heartbeat
+    end
+    
+    describe "Shared default interface" do
+      it "should be dead? when it is not alive?" do
+        @heartbeats.stub(:alive? => true)
+        @heartbeats.dead?.should be_false
+
+        @heartbeats.stub(:alive? => false)
+        @heartbeats.dead?.should be_true
+      end
+
+      it "should do nothing when :beat is called" do
+        @heartbeats.beat.should be_nil
+      end
+
+      it "should be alive if the connection is connected?" do
+        @heartbeats.should_receive(:connected?).and_return(true)
+        @heartbeats.alive?.should be_true
+        @heartbeats.should_receive(:connected?).and_return(false)
+        @heartbeats.alive?.should be_false
+      end
+    end
+    
+    describe "1.1 Protocol Extensions" do
+      before(:each) do
+        Heartbeat.extend_by_protocol_version(@heartbeats, '1.1')
+      end
+      
+      it "should include the 1.1 extensions" do
+        @heartbeats.should be_a_kind_of(Heartbeat::V1_1)
+      end
+      
+      it "should transmit a heartbeat frame through :beat" do
+        @heartbeats.should_receive(:transmit).with(stomper_heartbeat_frame)
+        @heartbeats.beat
+      end
+
+      it "should be alive if client and broker are alive and connected" do
+        @heartbeats.stub(:client_alive? => true, :broker_alive? => true, :connected? => true)
+        @heartbeats.alive?.should be_true
+        @heartbeats.stub(:connected? => false)
+        @heartbeats.alive?.should be_false
+      end
+
+
+      it "should be dead if connected and broker is alive but client is not" do
+        @heartbeats.stub(:client_alive? => false, :broker_alive? => true, :connected? => true)
+        @heartbeats.alive?.should be_false
+        @heartbeats.stub(:client_alive? => true)
+        @heartbeats.alive?.should be_true
+      end
+
+      it "should be dead if connected and client is alive but broker is not" do
+        @heartbeats.stub(:client_alive? => true, :broker_alive? => false, :connected? => true)
+        @heartbeats.alive?.should be_false
+        @heartbeats.stub(:broker_alive? => true)
+        @heartbeats.alive?.should be_true
+      end
+
+      it "should have a living client if client beats are disabled" do
+        @heartbeats.stub(:heartbeating => [0, 10], :connected? => true)
+        @heartbeats.client_alive?.should be_true
+      end
+
+      it "should have a living broker if broker beats are disabled" do
+        @heartbeats.stub(:heartbeating => [10, 0], :connected? => true)
+        @heartbeats.broker_alive?.should be_true
+      end
+
+      it "should have a living client if beating is enabled and transmitted within a marin of error" do
+        @heartbeats.stub(:heartbeating => [1_000, 0], :connected? => true)
+        @heartbeats.stub(:duration_since_transmitted => 50)
+        @heartbeats.client_alive?.should be_true
+        @heartbeats.stub(:duration_since_transmitted => 1_000)
+        @heartbeats.client_alive?.should be_true
+        @heartbeats.stub(:duration_since_transmitted => 1_100)
+        @heartbeats.client_alive?.should be_true
+        @heartbeats.stub(:duration_since_transmitted => 1_200)
+        @heartbeats.client_alive?.should be_false
+      end
+
+      it "should have a living broker if beating is enabled and received within a marin of error" do
+        @heartbeats.stub(:heartbeating => [0, 5_000], :connected? => true)
+        @heartbeats.stub(:duration_since_received => 100)
+        @heartbeats.broker_alive?.should be_true
+        @heartbeats.stub(:duration_since_received => 5_000)
+        @heartbeats.broker_alive?.should be_true
+        @heartbeats.stub(:duration_since_received => 5_500)
+        @heartbeats.broker_alive?.should be_true
+        @heartbeats.stub(:duration_since_received => 5_600)
+        @heartbeats.broker_alive?.should be_false
+      end
+    end
+  end
+end

data/spec/stomper/extensions/scoping_spec.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper::Extensions
+  describe Scoping do
+    before(:each) do
+      @scoping = mock("scoping", :version => '1.0')
+      @scoping.extend Scoping
+    end
+    
+    it "should return a new HeaderScope" do
+      @scoping.with_headers({}).should be_an_instance_of(::Stomper::Scopes::HeaderScope)
+    end
+    it "should return a new TransactionScope" do
+      @scoping.with_transaction.should be_an_instance_of(::Stomper::Scopes::TransactionScope)
+    end
+    it "should return a new ReceiptScope" do
+      @scoping.with_receipt.should be_an_instance_of(::Stomper::Scopes::ReceiptScope)
+    end
+  end
+end

data/spec/stomper/frame_serializer_1.8_spec.rb

@@ -0,0 +1,318 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper
+  if RUBY_VERSION < '1.9'
+    describe FrameSerializer do
+      before(:each) do
+        @messages = {
+          :content_type_and_charset => "MESSAGE\ncontent-type:text/plain; charset=ISO-8859-1\ncontent-length:6\na-header: padded \n\nh\xEBllo!\000",
+          :escaped_headers => "MESSAGE\ncontent-type:text/plain;charset=UTF-8\ncontent-length:7\na\\nspecial\\chead\\\\cer: padded\\c and using\\nspecial\\\\\\\\\\\\ncharacters \n\nh\xC3\xABllo!\000",
+          :no_content_length => "MESSAGE\ncontent-type:text/plain\n\nh\xC3\xABllo!\000",
+          :repeated_headers => "MESSAGE\ncontent-type:text/plain\nrepeated header:a value\nrepeated header:alternate value\n\nh\xC3\xABllo!\000",
+          :non_text_content_type => "MESSAGE\ncontent-type:not-text/other\n\nh\xC3\xABllo!\000",
+          :no_content_type => "MESSAGE\n\nh\xC3\xABllo!\000",
+          :invalid_content_length => "MESSAGE\ncontent-length:4\n\n12345\000",
+          :invalid_header_character => "MESSAGE\ngrandpa:he was:anti\n\n12345\000",
+          :invalid_header_sequence => "MESSAGE\ngrandpa:he was\\ranti\n\n12345\000",
+          :malformed_header => "MESSAGE\nearth_below_us\nfloating:weightless\n\n12345\000",
+          :dangling_header_sequence => "MESSAGE\ngrandpa:he was anti\\\n\n12345\000",
+        }
+      
+        @frames = {
+          :common => ::Stomper::Frame.new('FRAME', {}, 'body of message'),
+          :no_headers => ::Stomper::Frame.new('FRAME', {}, 'body of message'),
+          :no_body => ::Stomper::Frame.new('FRAME'),
+          :no_command => ::Stomper::Frame.new,
+          :header_name_with_linefeed => ::Stomper::Frame.new('FRAME', { "a\ntest\nheader" => "va\\lue : is\n\nme"}),
+          :header_name_with_colon => ::Stomper::Frame.new('FRAME', { "a:test:header" => "va\\lue : is\n\nme"}),
+          :header_name_with_backslash => ::Stomper::Frame.new('FRAME', { "a\\test\\header" => "va\\lue : is\n\nme"}),
+          :binary_body_no_content_type => ::Stomper::Frame.new('FRAME', {}, 'body of message'),
+          :charset_header_text_body => ::Stomper::Frame.new('FRAME', {:'content-type' => 'text/plain; param="value";charset=ISO-8859-1'}, 'body of message'),
+          :charset_header_binary_body => ::Stomper::Frame.new('FRAME', {:'content-type' => 'application/pdf; param="value";charset=ISO-8859-1'}, 'body of message')
+        }
+        #{ :header_1 => 'value 1', :header_2 => '3', :header_3 => '', :'content-type' => 'text/plain'}
+        @frames[:common][:header_1] = 'value 1'
+        @frames[:common][:header_2] = '3'
+        @frames[:common][:header_3] = ''
+        @frames[:common][:'content-type'] = 'text/plain'
+        # :header_1 => 'val', :musical => '', :offering => '4'
+        @frames[:no_body][:header_1] = 'val'
+        @frames[:no_body][:musical] = ''
+        @frames[:no_body][:offering] = '4'
+        @frame_io = StringIO.new
+        @frame_serializer = FrameSerializer.new(@frame_io)
+      end
+    
+      describe "thread safety" do
+        before(:each) do
+          @frame_serializer = FrameSerializer.new(mock('frame io'))
+        end
+        it "should synchronize writing to the underlying IO" do
+          first_called = false
+          call_next = false
+          ordered = []
+          @frame_serializer.stub!(:__write_frame__).and_return do |f|
+            first_called = true
+            ordered << 1
+            Thread.stop
+            ordered << 2
+            f
+          end
+        
+          thread_1 = Thread.new do
+            @frame_serializer.write_frame(mock('frame'))
+          end
+          thread_2 = Thread.new do
+            Thread.pass until call_next
+            Thread.pass
+            thread_1.run
+          end
+          Thread.pass until first_called
+          call_next = true
+        
+          @frame_serializer.stub!(:__write_frame__).and_return do |f|
+            ordered << 3
+            f
+          end
+          @frame_serializer.write_frame(mock('frame'))
+          thread_1.join
+          thread_2.join
+          ordered.should == [1, 2, 3]
+        end
+      
+        it "should synchronize reading from the underlying IO" do
+          first_called = false
+          call_next = false
+          ordered = []
+          @frame_serializer.stub!(:__read_frame__).and_return do
+            first_called = true
+            ordered << 1
+            Thread.stop
+            ordered << 2
+            mock('frame 1')
+          end
+        
+          thread_1 = Thread.new do
+            @frame_serializer.read_frame
+          end
+          thread_2 = Thread.new do
+            Thread.pass until call_next
+            Thread.pass
+            thread_1.run
+          end
+          Thread.pass until first_called
+          call_next = true
+        
+          @frame_serializer.stub!(:__read_frame__).and_return do
+            ordered << 3
+            mock('frame 2')
+          end
+          @frame_serializer.read_frame
+          thread_1.join
+          thread_2.join
+          ordered.should == [1, 2, 3]
+        end
+      
+        it "should not make reading and writing mutually exclusive" do
+          first_called = false
+          call_next = false
+          ordered = []
+          @frame_serializer.stub!(:__write_frame__).and_return do |f|
+            first_called = true
+            ordered << 1
+            Thread.stop
+            ordered << 2
+            f
+          end
+          @frame_serializer.stub!(:__read_frame__).and_return do
+            ordered << 3
+            mock('frame 2')
+          end
+        
+          thread_1 = Thread.new do
+            @frame_serializer.write_frame(mock('frame'))
+          end
+          thread_2 = Thread.new do
+            Thread.pass until call_next
+            Thread.pass
+            thread_1.run
+          end
+          Thread.pass until first_called
+          call_next = true
+          @frame_serializer.read_frame
+          thread_1.join
+          thread_2.join
+          ordered.should == [1, 3, 2]
+        end
+      end
+    
+      describe "Protocol 1.0" do
+        it "should not have extended the V1_1 mixin" do
+          ::Stomper::FrameSerializer::EXTEND_BY_VERSION['1.1'].each do |mod|
+            @frame_serializer.should_not be_a_kind_of(mod)
+          end
+        end
+      
+        describe "writing frames" do
+          it "should properly serialize a common frame" do
+            @frame_serializer.write_frame(@frames[:common])
+            @frame_io.string.should == "FRAME\nheader_1:value 1\nheader_2:3\nheader_3:\ncontent-type:text/plain;charset=UTF-8\ncontent-length:15\n\nbody of message\000"
+          end
+      
+          it "should properly serialize a frame without headers - content type cannot be inferred in Ruby 1.8.7" do
+            @frame_serializer.write_frame(@frames[:no_headers])
+            @frame_io.string.should == "FRAME\ncontent-length:15\n\nbody of message\000"
+          end
+      
+          it "should properly serialize a frame without a body" do
+            @frame_serializer.write_frame(@frames[:no_body])
+            @frame_io.string.should == "FRAME\nheader_1:val\nmusical:\noffering:4\n\n\000"
+          end
+      
+          it "should properly serialize a frame without a command as a new line" do
+            @frame_serializer.write_frame(@frames[:no_command])
+            @frame_io.string.should == "\n"
+          end
+      
+          it "should properly drop LF from header names and values" do
+            @frame_serializer.write_frame(@frames[:header_name_with_linefeed])
+            @frame_io.string.should == "FRAME\natestheader:va\\lue : isme\n\n\000"
+          end
+        
+          it "should not escape backslash characters in header names or values" do
+            @frame_serializer.write_frame(@frames[:header_name_with_backslash])
+            @frame_io.string.should == "FRAME\na\\test\\header:va\\lue : isme\n\n\000"
+          end
+        
+          it "should drop colons in header names, but leave them alone in values" do
+            @frame_serializer.write_frame(@frames[:header_name_with_colon])
+            @frame_io.string.should == "FRAME\natestheader:va\\lue : isme\n\n\000"
+          end
+        
+          it "should not generate a content-type header if the encoding is binary" do
+            @frame_serializer.write_frame(@frames[:binary_body_no_content_type])
+            @frame_io.string.should == "FRAME\ncontent-length:15\n\nbody of message\000"
+          end
+        
+          it "should preserve the charset parameter of text bodies, because we have nothing else to work with in Ruby 1.8.7" do
+            @frame_serializer.write_frame(@frames[:charset_header_text_body])
+            @frame_io.string.should == "FRAME\ncontent-type:text/plain; param=\"value\";charset=ISO-8859-1\ncontent-length:15\n\nbody of message\000"
+          end
+        
+          it "should preserve the charset parameter of binary bodies, because we have nothing else to work with in Ruby 1.8.7" do
+            @frame_serializer.write_frame(@frames[:charset_header_binary_body])
+            @frame_io.string.should == "FRAME\ncontent-type:application/pdf; param=\"value\";charset=ISO-8859-1\ncontent-length:15\n\nbody of message\000"
+          end
+        end
+      end
+    
+      describe "Protocol 1.1" do
+        before(:each) do
+          @frame_serializer.extend_for_protocol '1.1'
+        end
+      
+        it "should have extended the V1_1 mixin" do
+          ::Stomper::FrameSerializer::EXTEND_BY_VERSION['1.1'].each do |mod|
+            @frame_serializer.should be_a_kind_of(mod)
+          end
+        end
+  
+        describe "writing frames" do
+          it "should properly serialize a common frame" do
+            @frame_serializer.write_frame(@frames[:common])
+            @frame_io.string.should == "FRAME\nheader_1:value 1\nheader_2:3\nheader_3:\ncontent-type:text/plain;charset=UTF-8\ncontent-length:15\n\nbody of message\000"
+          end
+      
+          it "should properly serialize a frame without headers - content type cannot be inferred in Ruby 1.8.7" do
+            @frame_serializer.write_frame(@frames[:no_headers])
+            @frame_io.string.should == "FRAME\ncontent-length:15\n\nbody of message\000"
+          end
+      
+          it "should properly serialize a frame without a body" do
+            @frame_serializer.write_frame(@frames[:no_body])
+            @frame_io.string.should == "FRAME\nheader_1:val\nmusical:\noffering:4\n\n\000"
+          end
+      
+          it "should properly serialize a frame without a command as a new line" do
+            @frame_serializer.write_frame(@frames[:no_command])
+            @frame_io.string.should == "\n"
+          end
+        
+          it "should escape LF in header names and values" do
+            @frame_serializer.write_frame(@frames[:header_name_with_linefeed])
+            @frame_io.string.should == "FRAME\na\\ntest\\nheader:va\\\\lue \\c is\\n\\nme\n\n\000"
+          end
+        
+          it "should escape backslashes in header names and values" do
+            @frame_serializer.write_frame(@frames[:header_name_with_backslash])
+            @frame_io.string.should == "FRAME\na\\\\test\\\\header:va\\\\lue \\c is\\n\\nme\n\n\000"
+          end
+        
+          it "should escape colons in header names and values" do
+            @frame_serializer.write_frame(@frames[:header_name_with_colon])
+            @frame_io.string.should == "FRAME\na\\ctest\\cheader:va\\\\lue \\c is\\n\\nme\n\n\000"
+          end
+        end
+  
+        describe "reading frames" do
+          it "should properly de-serialize a simple frame" do
+            @frame_io.string = @messages[:content_type_and_charset]
+            frame = @frame_serializer.read_frame
+            frame.command.should == "MESSAGE"
+            frame.headers.sort { |a, b| a.first <=> b.first }.should == [
+              ['a-header', ' padded '], ['content-length', '6'],
+              ['content-type', 'text/plain; charset=ISO-8859-1']
+            ]
+            frame.body.should == "h\xEBllo!"
+          end
+          it "should properly read a frame with special characters in its header" do
+            @frame_io.string = @messages[:escaped_headers]
+            frame = @frame_serializer.read_frame
+            frame["a\nspecial:head\\cer"].should == " padded: and using\nspecial\\\\\\ncharacters "
+          end
+          it "should properly read a frame with a body and no content-length" do
+            @frame_io.string = @messages[:no_content_length]
+            frame = @frame_serializer.read_frame
+            frame.body.should == "hëllo!"
+          end
+          it "should assume a binary charset if none is set and the content-type does not match text/*" do
+            @frame_io.string = @messages[:non_text_content_type]
+            frame = @frame_serializer.read_frame
+          end
+          it "should assume a binary charset if the content-type header is not specified" do
+            @frame_io.string = @messages[:no_content_type]
+            frame = @frame_serializer.read_frame
+          end
+          it "should set the value of a header to the first occurrence" do
+            @frame_io.string = @messages[:repeated_headers]
+            frame = @frame_serializer.read_frame
+          end
+          it "should raise a malformed frame error if the frame is not properly terminated" do
+            @frame_io.string = @messages[:invalid_content_length]
+            lambda { @frame_serializer.read_frame }.should raise_error(::Stomper::Errors::MalformedFrameError)
+          end
+          # While the spec suggests that all ":" chars be replaced with "\c", ActiveMQ 5.3.2 sends
+          # a "session" header with a value that contains ":" chars.  So, we are NOT going to
+          # freak out if we receive more than one ":" on a header line.
+          it "should not raise an error if the frame contains a header value with a raw ':'" do
+            @frame_io.string = @messages[:invalid_header_character]
+            lambda { @frame_serializer.read_frame }.should_not raise_error
+          end
+          it "should raise an invalid header esacape sequence error if the frame contains a header with an invalid escape sequence" do
+            @frame_io.string = @messages[:invalid_header_sequence]
+            lambda { @frame_serializer.read_frame }.should raise_error(::Stomper::Errors::InvalidHeaderEscapeSequenceError)
+          end
+          it "should raise an malfored header error if the frame contains an incomplete header" do
+            @frame_io.string = @messages[:malformed_header]
+            lambda { @frame_serializer.read_frame }.should raise_error(::Stomper::Errors::MalformedHeaderError)
+          end
+          it "should raise an invalid header esacape sequence error if the frame contains a header with a dangling escape sequence" do
+            @frame_io.string = @messages[:dangling_header_sequence]
+            lambda { @frame_serializer.read_frame }.should raise_error(::Stomper::Errors::InvalidHeaderEscapeSequenceError)
+          end
+        end
+      end
+    end
+  end
+end