onstomp 1.0.0pre1

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

@@ -0,0 +1,104 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections::Serializers
+  describe Stomp_1 do
+    let(:serializer) {
+      mock('serializer').tap do |m|
+        m.extend Stomp_1
+      end
+    }
+    describe ".frame_to_bytes" do
+      let(:frame) {
+        mock('frame')
+      }
+      it "should call frame_to_string and encode the result to ASCII-8BIT" do
+        serializer.stub(:frame_to_string).with(frame).and_return('SERIALIZED FRAME')
+        ser = serializer.frame_to_bytes(frame)
+        ser.should == 'SERIALIZED FRAME'
+        if RUBY_VERSION >= '1.9'
+          ser.encoding.name.should == 'ASCII-8BIT'
+        end
+      end
+    end
+    
+    describe ".frame_to_string_base" do
+      let(:frame) {
+        OnStomp::Components::Frame.new('COMMAND', {}, 'body of frame').tap do |f|
+          f[:heaDer1] = 'Value 1'
+          f[:headeR2] = 'Value 2'
+          f['HEADER3'] = 'Value 3'
+        end
+      }
+      it "should treat a frame with no command as a heartbeat" do
+        frame.command = nil
+        serializer.frame_to_string_base(frame).should == "\n"
+      end
+      it "should serialize a frame as a string, yielding headers to the supplied block" do
+        serializer.frame_to_string_base(frame) do |k,v|
+          "#{k.downcase}:#{v.upcase}\n"
+        end.should == "COMMAND\nheader1:VALUE 1\nheader2:VALUE 2\nheader3:VALUE 3\ncontent-length:13\n\nbody of frame\000"
+      end
+    end
+    
+    describe ".bytes_to_frame" do
+      let(:buffer) {
+        [ "COMMAND1\nheader", " 1:Test value 1", "\nHeader 2:",
+          "Test value 2\n", "content-leng", "th:1",
+          "6\n\ntesting \000his guy", "\000\n\nCOMMAND4",
+          "\nNext Header: some value \nMore headers:another value\n",
+          "\nbody of the frame without content-length\000\nCOMMAND6",
+          "\nheader:and its value\n\n\000", "COMMAND7\nheader",
+          " for command 7:another value\n\nyet another body\000",
+          "\n\nCOMMAND10\nlast Header:last Header ValuE!\n\nthis is a",
+          "nother body for yet another ", "frame", "\000" ]
+      }
+      
+      before(:each) do
+        serializer.reset_parser
+        if RUBY_VERSION >= '1.9'
+          buffer.each do |b|
+            b.force_encoding('ASCII-8BIT')
+          end
+        end
+      end
+      it "should parse and yield the frames contained in the buffers" do
+        serializer.should_receive(:split_header).exactly(8).times.and_return do |str|
+          str.split(':')
+        end
+        serializer.should_receive(:prepare_parsed_frame).exactly(5).times
+        yielded = []
+        serializer.bytes_to_frame(buffer) { |f| yielded << f }
+        yielded.size.should == 10
+        yielded[0].should be_an_onstomp_frame('COMMAND1', {
+          :'header 1' => 'Test value 1', :'Header 2' => 'Test value 2',
+          :'content-length' => '16'
+        }, "testing \000his guy")
+        yielded[1].should be_an_onstomp_frame(nil, {}, nil)
+        yielded[2].should be_an_onstomp_frame(nil, {}, nil)
+        yielded[3].should be_an_onstomp_frame('COMMAND4', {
+          :'Next Header' => ' some value ', :'More headers' => 'another value',
+        }, 'body of the frame without content-length')
+        yielded[4].should be_an_onstomp_frame(nil, {}, nil)
+        # Is this what you really want?
+        yielded[5].should be_an_onstomp_frame('COMMAND6', {
+          :header => 'and its value' }, '')
+        yielded[6].should be_an_onstomp_frame('COMMAND7', {
+          :'header for command 7' => 'another value' }, 'yet another body')
+        yielded[7].should be_an_onstomp_frame(nil, {}, nil)
+        yielded[8].should be_an_onstomp_frame(nil, {}, nil)
+        yielded[9].should be_an_onstomp_frame('COMMAND10', {
+          :'last Header' => 'last Header ValuE!'
+        }, 'this is another body for yet another frame')
+      end
+      it "should raise a malformed frame error if the content-length is a lie" do
+        serializer.stub(:split_header).and_return do |str|
+          str.split(':')
+        end
+        lambda {
+          serializer.bytes_to_frame(["COMMAND\ncontent-length:5\n\nmore than 5\000"])
+        }.should raise_error(OnStomp::MalformedFrameError)
+      end
+    end
+  end
+end

data/spec/onstomp/connections/stomp_1_0_spec.rb

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections
+  describe Stomp_1_0 do
+    let(:io) {
+      mock('io')
+    }
+    let(:client) {
+      mock('client')
+    }
+    let(:connection) {
+      Stomp_1_0.new(io, client)
+    }
+    describe "ancestors" do
+      it "should be a kind of Base connection" do
+        connection.should be_a_kind_of(OnStomp::Connections::Base)
+      end
+      it "should be a kind of Stomp_1 connection" do
+        connection.should be_a_kind_of(OnStomp::Connections::Stomp_1)
+      end
+    end
+    
+    describe ".serializer" do
+      it "should use a Stomp_1_0 serializer" do
+        connection.serializer.should be_a_kind_of(OnStomp::Connections::Serializers::Stomp_1_0)
+      end
+    end
+    
+    describe ".ack_frame" do
+      let(:message_frame) {
+        OnStomp::Components::Frame.new('MESSAGE', :'message-id' => 'm-1234')
+      }
+      it "should create an ack frame for a MESSAGE frame" do
+        connection.ack_frame(message_frame).should be_an_onstomp_frame('ACK',
+          {:'message-id' => 'm-1234'}, nil)
+      end
+      it "should create an ack frame for a message id" do
+        connection.ack_frame('m-5678').should be_an_onstomp_frame('ACK',
+          {:'message-id' => 'm-5678'}, nil)
+      end
+      it "should override the supplied message id with a 'message-id' header" do
+        connection.ack_frame('m-5678', {
+          :'message-id' => 'm-1234'}
+        ).should be_an_onstomp_frame('ACK', {:'message-id' => 'm-1234'}, nil)
+      end
+      it "should raise an exception if a message-id cannot be inferred" do
+        lambda {
+          connection.ack_frame(nil, {:'message-id' => ''})
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/onstomp/connections/stomp_1_1_spec.rb

@@ -0,0 +1,137 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections
+  describe Stomp_1_1 do
+    let(:io) {
+      mock('io')
+    }
+    let(:client) {
+      mock('client')
+    }
+    let(:connection) {
+      Stomp_1_1.new(io, client)
+    }
+    describe "ancestors" do
+      it "should be a kind of Base connection" do
+        connection.should be_a_kind_of(OnStomp::Connections::Base)
+      end
+      it "should be a kind of Stomp_1 connection" do
+        connection.should be_a_kind_of(OnStomp::Connections::Stomp_1)
+      end
+      it "should be a kind of Heartbeating connection" do
+        connection.should be_a_kind_of(OnStomp::Connections::Heartbeating)
+      end
+    end
+    
+    describe ".serializer" do
+      it "should use a Stomp_1_1 serializer" do
+        connection.serializer.should be_a_kind_of(OnStomp::Connections::Serializers::Stomp_1_1)
+      end
+    end
+    
+    describe ".ack_frame" do
+      let(:message_frame) {
+        OnStomp::Components::Frame.new('MESSAGE',
+          :'message-id' => 'm-1234', :subscription => 's-5678')
+      }
+      it "should create an ACK frame for a MESSAGE frame" do
+        connection.ack_frame(message_frame).should be_an_onstomp_frame('ACK',
+          {:'message-id' => 'm-1234', :subscription => 's-5678'}, nil)
+      end
+      it "should create an ACK frame for a message id and subscription" do
+        connection.ack_frame('m-5678', 's-1234').should be_an_onstomp_frame('ACK',
+          {:'message-id' => 'm-5678', :subscription => 's-1234'}, nil)
+      end
+      it "should override the message id and subscription with headers" do
+        connection.ack_frame('m-5678', 's-1234', {
+          :'message-id' => 'm-1234', :subscription => 's-5678'}
+        ).should be_an_onstomp_frame('ACK', {:'message-id' => 'm-1234',
+          :subscription => 's-5678'}, nil)
+      end
+      it "should raise an error if a message-id cannot be inferred" do
+        lambda {
+          connection.ack_frame(nil, {:'message-id' => '', :subscription => 's-1234'})
+        }.should raise_error(ArgumentError)
+      end
+      it "should raise an error if a subscription cannot be inferred" do
+        lambda {
+          connection.ack_frame('m-1234', nil, { :subscription => ''})
+        }.should raise_error(ArgumentError)
+      end
+    end
+    
+    describe ".connected?" do
+      it "should be connected if Base is connected and it has a pulse" do
+        io.stub(:closed? => false)
+        connection.stub(:pulse? => true)
+        connection.connected?.should be_true
+      end
+      it "should not be connected if Base is not connected" do
+        io.stub(:closed? => true)
+        connection.stub(:pulse? => true)
+        connection.connected?.should be_false
+      end
+      it "should not be connected if it has no pulse" do
+        io.stub(:closed? => false)
+        connection.stub(:pulse? => false)
+        connection.connected?.should be_false
+      end
+    end
+    
+    describe ".configure" do
+      let(:client_beats) { mock('client beats') }
+      let(:broker_beats) { mock('broker beats') }
+      let(:connected_frame) {
+        mock('connected frame', :heart_beat => broker_beats).tap do |m|
+          m.stub(:header?).with(:version).and_return(true)
+          m.stub(:[]).with(:version).and_return('1.1')
+        end
+      }
+      
+      it "should configure heartbeating" do
+        client.stub(:heartbeats => client_beats)
+        connection.should_receive(:configure_heartbeating).
+          with(client_beats, broker_beats)
+        connection.configure(connected_frame, {})
+      end
+    end
+    
+    describe ".nack_frame" do
+      let(:message_frame) {
+        OnStomp::Components::Frame.new('MESSAGE',
+          :'message-id' => 'm-1234', :subscription => 's-5678')
+      }
+      it "should create a NACK frame for a MESSAGE frame" do
+        connection.nack_frame(message_frame).should be_an_onstomp_frame('NACK',
+          {:'message-id' => 'm-1234', :subscription => 's-5678'}, nil)
+      end
+      it "should create a NACK frame for a message id and subscription" do
+        connection.nack_frame('m-5678', 's-1234').should be_an_onstomp_frame('NACK',
+          {:'message-id' => 'm-5678', :subscription => 's-1234'}, nil)
+      end
+      it "should override the message id and subscription with headers" do
+        connection.nack_frame('m-5678', 's-1234', {
+          :'message-id' => 'm-1234', :subscription => 's-5678'}
+        ).should be_an_onstomp_frame('NACK', {:'message-id' => 'm-1234',
+          :subscription => 's-5678'}, nil)
+      end
+      it "should raise an error if a message-id cannot be inferred" do
+        lambda {
+          connection.nack_frame(nil, {:'message-id' => '', :subscription => 's-1234'})
+        }.should raise_error(ArgumentError)
+      end
+      it "should raise an error if a subscription cannot be inferred" do
+        lambda {
+          connection.nack_frame('m-1234', nil, { :subscription => ''})
+        }.should raise_error(ArgumentError)
+      end
+    end
+    
+    describe ".heartbeat_frame" do
+      it "should create a heartbeat frame (frame with no command)" do
+        connection.heartbeat_frame.should be_an_onstomp_frame(nil, {}, nil)
+      end
+    end
+  end
+end

data/spec/onstomp/connections/stomp_1_spec.rb

@@ -0,0 +1,113 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Connections
+  describe Stomp_1 do
+    let(:connection) {
+      mock('connection').tap do |m|
+        m.extend Stomp_1
+      end
+    }
+    
+    describe ".connect_frame" do
+      it "should build a CONNECT frame" do
+        connection.connect_frame({:header1 => 'value 1',
+          :header2 => 'value 2'}, {:header1 => '', :header2 => 'value 22',
+          :header3 => 'value 3'}
+        ).should be_an_onstomp_frame('CONNECT', {:header1 => 'value 1',
+          :header2 => 'value 22', :header3 => 'value 3'}, nil)
+      end
+    end
+    
+    describe ".send_frame" do
+      it "should build a SEND frame" do
+        connection.send_frame('/queue/test', 'body of message',
+          {:header1 => 'value 1', :destination => '/queue/not-test'}
+        ).should be_an_onstomp_frame('SEND', {:header1 => 'value 1',
+          :destination => '/queue/test'}, 'body of message')
+      end
+    end
+    
+    describe ".begin_frame" do
+      it "should build a BEGIN frame" do
+        connection.begin_frame('tx-1234', {:transaction => 'tx-5678',
+          :header1 => 'value 1'}
+        ).should be_an_onstomp_frame('BEGIN', {:header1 => 'value 1',
+          :transaction => 'tx-1234'}, nil)
+      end
+    end
+    
+    describe ".commit_frame" do
+      it "should build a COMMIT frame" do
+        connection.commit_frame('tx-1234', {:transaction => 'tx-5678',
+          :header1 => 'value 1'}
+        ).should be_an_onstomp_frame('COMMIT', {:header1 => 'value 1',
+          :transaction => 'tx-1234'}, nil)
+      end
+    end
+    
+    describe ".abort_frame" do
+      it "should build an ABORT frame" do
+        connection.abort_frame('tx-1234', {:transaction => 'tx-5678',
+          :header1 => 'value 1'}
+        ).should be_an_onstomp_frame('ABORT', {:header1 => 'value 1',
+          :transaction => 'tx-1234'}, nil)
+      end
+    end
+    
+    describe ".disconnect_frame" do
+      it "should build a DISCONNECT frame" do
+        connection.disconnect_frame({:receipt => 'r-5678',
+          :header1 => 'value 1'}
+        ).should be_an_onstomp_frame('DISCONNECT', {:header1 => 'value 1',
+          :receipt => 'r-5678'}, nil)
+      end
+    end
+    
+    describe ".subscribe_frame" do
+      it "should automatically generate an 'id' header if one is not supplied" do
+        frame = connection.subscribe_frame('/queue/test', :ack => 'client',
+          :destination => '/queue/not-test')
+        frame.should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'client',
+          :destination => '/queue/test'}, nil)
+        frame.header?(:id).should be_true
+      end
+      it "should build a SUBSCRIBE frame" do
+        connection.subscribe_frame('/queue/test', :ack => 'auto',
+          :destination => '/queue/not-test', :id => 's-1234'
+        ).should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'auto',
+          :destination => '/queue/test', :id => 's-1234'}, nil)
+      end
+    end
+    
+    describe ".unsubscribe_frame" do
+      it "should build an UNSUBSCRIBE frame from a SUBSCRIBE frame" do
+        subscribe_frame = connection.subscribe_frame('/queue/test',
+          :ack => 'auto',
+          :destination => '/queue/not-test', :id => 's-1234')
+        unsubscribe_frame = connection.unsubscribe_frame(subscribe_frame,
+          :header1 => 'value 1')
+        unsubscribe_frame.should be_an_onstomp_frame('UNSUBSCRIBE',
+          {:header1 => 'value 1', :id => 's-1234'}, nil)
+      end
+      it "should build an UNSUBSCRIBE frame from an id" do
+        connection.unsubscribe_frame('s-1234',
+          :header1 => 'value 1'
+        ).should be_an_onstomp_frame('UNSUBSCRIBE',
+          {:header1 => 'value 1', :id => 's-1234'}, nil)
+      end
+      it "should use a supplied ID header over the supplied id" do
+        connection.unsubscribe_frame('s-1234',
+          :header1 => 'value 1', :id => 's-5678'
+        ).should be_an_onstomp_frame('UNSUBSCRIBE',
+          {:header1 => 'value 1', :id => 's-5678'}, nil)
+      end
+      it "should raise an error if no id header can be inferred" do
+        lambda {
+          connection.unsubscribe_frame(nil,
+            :header1 => 'value 1', :id => '')
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/onstomp/connections_spec.rb

@@ -0,0 +1,135 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp
+  describe Connections do
+    describe ".supported" do
+      it "should be 1.0 and 1.1" do
+        Connections.supported.should == ['1.0', '1.1']
+      end
+    end
+    
+    describe ".select_supported" do
+      it "should filter out any unsupported version" do
+        Connections.select_supported(['1.9', '1.0', '2.x']).should ==
+          ['1.0']
+      end
+      it "should be empty if none are supported" do
+        Connections.select_supported(['1.5', '1.9', '1.x']).should be_empty
+      end
+    end
+    
+    describe ".connect" do
+      let(:client_uri) { mock('uri', :host => 'host.domain.tld', :port => 10101) }
+      let(:stomp_1_0_class) { mock('stomp 1.0 class') }
+      let(:stomp_1_1_class) { mock('stomp 1.1 class') }
+      let(:stomp_1_0) {
+        mock('stomp 1.0', :is_a? => false).tap do |m|
+          m.stub(:is_a?).with(stomp_1_0_class).and_return(true)
+        end
+      }
+      let(:stomp_1_1) {
+        mock('stomp 1.1', :is_a? => false).tap do |m|
+          m.stub(:is_a?).with(stomp_1_1_class).and_return(true)
+        end
+      }
+      let(:tcp_socket) { mock('tcp socket') }
+      let(:ssl_socket) { mock('ssl socket', :sync_close= => nil, :connect => nil) }
+      let(:ssl_context) { mock('ssl context') }
+      let(:ssl_options) {
+        {
+          :post_connection_check => 'some hostname',
+          :ca_file => '/path/to/ca_file.pem',
+          :ca_path => '/path/to/ca_files/',
+          :cert => '/path/to/client/cert.pem',
+          :key => '/path/to/client/key.pem',
+          :verify_mode => 'super_duper_mode'
+        }
+      }
+      let(:connected_frame) { mock('CONNECTED frame') }
+      let(:client) {
+        mock('client', :ssl => nil, :uri => client_uri)
+      }
+      let(:user_headers) {
+        {}
+      }
+      let(:connect_headers) {
+        {}
+      }
+      let(:pend_events) { mock('pending events') }
+      before(:each) do
+        ::TCPSocket.stub(:new => nil)
+        ::OpenSSL::SSL::SSLSocket.stub(:new => nil)
+        Connections::PROTOCOL_VERSIONS['1.0'] = stomp_1_0_class
+        Connections::PROTOCOL_VERSIONS['1.1'] = stomp_1_1_class
+      end
+      
+      describe "TCP connections" do
+        before(:each) do
+          ::TCPSocket.should_receive(:new).with('host.domain.tld', 10101).and_return(tcp_socket)
+          stomp_1_0_class.should_receive(:new).with(tcp_socket, client).and_return(stomp_1_0)
+        end
+        
+        it "should create a 1.0 connection" do
+          stomp_1_0.should_receive(:connect).and_return(['1.0', connected_frame])
+          stomp_1_0.should_receive(:configure).with(connected_frame, pend_events)
+          Connections.connect client, user_headers, connect_headers, pend_events
+        end
+        it "should create a 1.1 connection" do
+          stomp_1_0.should_receive(:connect).and_return(['1.1', connected_frame])
+          stomp_1_0.should_receive(:socket).and_return(tcp_socket)
+          stomp_1_1_class.should_receive(:new).with(tcp_socket, client).and_return(stomp_1_1)
+          stomp_1_1.should_receive(:configure).with(connected_frame, pend_events)
+          Connections.connect client, user_headers, connect_headers, pend_events
+        end
+      end
+      
+      describe "SSL connections" do
+        before(:each) do
+          ::TCPSocket.should_receive(:new).with('host.domain.tld', 10101).and_return(tcp_socket)
+          ::OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_context).and_return(ssl_socket)
+          ::OpenSSL::SSL::SSLContext.should_receive(:new).and_return(ssl_context)
+          stomp_1_0_class.should_receive(:new).with(ssl_socket, client).and_return(stomp_1_0)
+        end
+        
+        it "should create a 1.0 connection" do
+          client.stub(:ssl => ssl_options)
+          stomp_1_0.should_receive(:connect).and_return(['1.0', connected_frame])
+          stomp_1_0.should_receive(:configure).with(connected_frame, pend_events)
+          ssl_options.each do |k, v|
+            next if k == :post_connection_check
+            ssl_context.should_receive(:"#{k}=").with(v)
+          end
+          ssl_socket.should_receive(:post_connection_check).with(ssl_options[:post_connection_check])
+          Connections.connect client, user_headers, connect_headers, pend_events
+        end
+        it "should create a 1.1 connection" do
+          client.stub(:ssl => nil)
+          client_uri.stub(:onstomp_socket_type => :ssl)
+          stomp_1_0.should_receive(:connect).and_return(['1.1', connected_frame])
+          Connections::DEFAULT_SSL_OPTIONS.each do |k, v|
+            next if k == :post_connection_check
+            ssl_context.should_receive(:"#{k}=").with(v)
+          end
+          ssl_socket.should_receive(:post_connection_check).with(client_uri.host)
+          stomp_1_0.should_receive(:socket).and_return(ssl_socket)
+          stomp_1_1_class.should_receive(:new).with(ssl_socket, client).and_return(stomp_1_1)
+          stomp_1_1.should_receive(:configure).with(connected_frame, pend_events)
+          Connections.connect client, user_headers, connect_headers, pend_events
+        end
+      end
+      
+      describe "raising an OnStompError while negotiating connection" do
+        it "should close the base connection in a blocking fashion" do
+          Connections.stub(:create_connection).and_return(stomp_1_0)
+          stomp_1_0.stub(:connect => ['1.0', connected_frame])
+          Connections.stub(:negotiate_connection).and_raise OnStomp::OnStompError
+          stomp_1_0.should_receive(:close).with(true)
+          lambda {
+            Connections.connect client, user_headers, connect_headers, pend_events
+          }.should raise_error(OnStomp::OnStompError)
+        end
+      end
+    end
+  end
+end

data/spec/onstomp/interfaces/client_events_spec.rb

@@ -0,0 +1,108 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Interfaces
+  describe ClientEvents do
+    let(:connection) { mock('connection') }
+    let(:eventable) {
+      mock('eventable').tap do |m|
+        m.extend ClientEvents
+      end
+    }
+    
+    describe "client frame events" do
+      [ :ack, :nack, :begin, :abort, :commit, :send, :subscribe,
+        :unsubscribe, :disconnect, :client_beat ].each do |ftype|
+        it "should provide an 'on_#{ftype}' event" do
+          frame = if ftype == :client_beat
+            OnStomp::Components::Frame.new
+          else
+            OnStomp::Components::Frame.new(ftype.to_s.upcase)
+          end
+          triggered = false
+          eventable.__send__(:"on_#{ftype}") { triggered = true }
+          eventable.trigger_after_transmitting frame
+          triggered.should be_true
+        end
+        it "should provide a 'before_#{ftype}' event" do
+          frame = if ftype == :client_beat
+            OnStomp::Components::Frame.new
+          else
+            OnStomp::Components::Frame.new(ftype.to_s.upcase)
+          end
+          triggered = false
+          eventable.__send__(:"before_#{ftype}") { triggered = true }
+          eventable.trigger_before_transmitting frame
+          triggered.should be_true
+        end
+      end
+    end
+    
+    describe "broker frame events" do
+      [ :error, :message, :receipt, :broker_beat ].each do |ftype|
+        it "should provide an 'on_#{ftype}' event" do
+          frame = if ftype == :broker_beat
+            OnStomp::Components::Frame.new
+          else
+            OnStomp::Components::Frame.new(ftype.to_s.upcase)
+          end
+          triggered = false
+          eventable.__send__(:"on_#{ftype}") { triggered = true }
+          eventable.trigger_after_receiving frame
+          triggered.should be_true
+        end
+        it "should provide a 'before_#{ftype}' event" do
+          frame = if ftype == :broker_beat
+            OnStomp::Components::Frame.new
+          else
+            OnStomp::Components::Frame.new(ftype.to_s.upcase)
+          end
+          triggered = false
+          eventable.__send__(:"before_#{ftype}") { triggered = true }
+          eventable.trigger_before_receiving frame
+          triggered.should be_true
+        end
+      end
+    end
+    
+    describe "frame io events" do
+      let(:frame) {
+        OnStomp::Components::Frame.new
+      }
+      [:transmitting, :receiving].each do |evtype|
+        it "should provide a 'before_#{evtype}' event" do
+          triggered = false
+          eventable.__send__(:"before_#{evtype}") { triggered = true }
+          eventable.__send__(:"trigger_before_#{evtype}", frame)
+          triggered.should be_true
+        end
+        
+        it "should provide an 'after_#{evtype}' event" do
+          triggered = false
+          eventable.__send__(:"after_#{evtype}") { triggered = true }
+          eventable.__send__(:"trigger_after_#{evtype}", frame)
+          triggered.should be_true
+        end
+      end
+    end
+    
+    describe "connection events" do
+      [:established, :terminated, :died, :closed].each do |ctype|
+        it "should store in pending connection events if there is no connection" do
+          triggered = nil
+          eventable.stub(:connection => nil)
+          eventable.__send__(:"on_connection_#{ctype}") { |ct| triggered = ct }
+          eventable.pending_connection_events[:"on_#{ctype}"].first.call(ctype)
+          triggered.should == ctype
+        end
+        it "should pass on to connection if there is a connection" do
+          triggered = nil
+          eventable.stub(:connection => connection)
+          connection.should_receive(:"on_#{ctype}").and_yield(ctype)
+          eventable.__send__(:"on_connection_#{ctype}") { |ct| triggered = ct }
+          triggered.should == ctype
+        end
+      end
+    end
+  end
+end