stomper 1.0.0 → 2.0.0

data/spec/stomper/sockets_spec.rb

@@ -0,0 +1,113 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper
+  describe Sockets do
+    describe Sockets::TCP do
+      before(:each) do
+        @tcp_socket = mock('tcp socket')
+        ::TCPSocket.stub(:new => @tcp_socket)
+        @tcp = ::Stomper::Sockets::TCP.new('host', 12345)
+      end
+      it "should create a new instance that delegates to TCPSocket" do
+        @tcp_socket.should_receive(:ready?).and_return(true)
+        @tcp_socket.should_receive(:read).and_return('this is what we read')
+        @tcp_socket.should_receive(:write).with('blather').and_return(42)
+        
+        @tcp.ready?.should be_true
+        @tcp.read.should == 'this is what we read'
+        @tcp.write('blather').should == 42
+      end
+    end
+    
+    describe Sockets::SSL do
+      before(:each) do
+        @tcp_socket = mock('tcp socket')
+        ::TCPSocket.stub(:new => @tcp_socket)
+        @ssl_socket = mock('ssl socket', :sync_close= => true, :connect => true, :io => @tcp_socket)
+        ::OpenSSL::SSL::SSLSocket.stub(:new => @ssl_socket)
+      end
+      
+      it "should use the underlying TCP socket for :ready?" do
+        @ssl_socket.should_receive(:post_connection_check).with('host').and_return(true)
+        @ssl = ::Stomper::Sockets::SSL.new('host', 56789)
+        @tcp_socket.should_receive(:ready?).and_return(true)
+        
+        @ssl.ready?.should be_true
+      end
+      
+      it "should use the underlying TCP socket for :shutdown" do
+        @ssl_socket.should_receive(:post_connection_check).with('host').and_return(true)
+        @ssl = ::Stomper::Sockets::SSL.new('host', 56789)
+        @tcp_socket.should_receive(:shutdown).with('args').and_return(true)
+        
+        @ssl.shutdown('args').should be_true
+      end
+      
+      it "should delegate unknown methods to SSLSocket" do
+        @ssl_socket.should_receive(:post_connection_check).with('host').and_return(true)
+        @ssl = ::Stomper::Sockets::SSL.new('host', 56789)
+        @ssl_socket.should_receive(:read).and_return('this is what we read')
+        @ssl_socket.should_receive(:write).with('blather').and_return(42)
+        
+        @ssl.read.should == 'this is what we read'
+        @ssl.write('blather').should == 42
+      end
+      
+      it "should not perform a post_connection_check if option value is nil or false" do
+        @ssl_socket.should_not_receive(:post_connection_check)
+        @ssl = ::Stomper::Sockets::SSL.new('host', 56789, { :post_connection_check => false })
+        @ssl = ::Stomper::Sockets::SSL.new('host', 56789, { :post_connection_check => nil })
+      end
+      
+      it "should perform a post_connection_check against the host if the option value is true" do
+        @ssl_socket.should_receive(:post_connection_check).with('host.name.tld').and_return(true)
+        @ssl = ::Stomper::Sockets::SSL.new('host.name.tld', 56789, { :post_connection_check => true })
+      end
+      
+      it "should perform a post_connection_check against the option value otherwise" do
+        @ssl_socket.should_receive(:post_connection_check).with('user specified name').and_return(true)
+        @ssl = ::Stomper::Sockets::SSL.new('host.name.tld', 56789, { :post_connection_check => 'user specified name' })
+        
+        @ssl_socket.should_receive(:post_connection_check).with(66).and_return(true)
+        @ssl = ::Stomper::Sockets::SSL.new('host.name.tld', 56789, { :post_connection_check => 66 })
+      end
+      
+      describe "SSL Context Options" do
+        before(:each) do
+          @ssl_context = mock('context')
+          ::OpenSSL::SSL::SSLContext.stub(:new => @ssl_context)
+        end
+        
+        it "should apply sensible defaults when no options are specified" do
+          @ssl_context.should_receive(:verify_mode=).with(::OpenSSL::SSL::VERIFY_PEER |
+            ::OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT)
+          @ssl_context.should_receive(:ca_file=).with(nil)
+          @ssl_context.should_receive(:ca_path=).with(nil)
+          @ssl_context.should_receive(:cert=).with(nil)
+          @ssl_context.should_receive(:key=).with(nil)
+          
+          @ssl_socket.should_receive(:post_connection_check).with('host').and_return(true)
+          @ssl = ::Stomper::Sockets::SSL.new('host', 56789)
+        end
+        
+        it "should override sensible defaults with supplied options" do
+          @ssl_context.should_receive(:verify_mode=).with("kage")
+          @ssl_context.should_receive(:ca_file=).with("jables")
+          @ssl_context.should_receive(:ca_path=).with("the d")
+          @ssl_context.should_receive(:cert=).with("scepter")
+          @ssl_context.should_receive(:key=).with("key")
+          
+          @ssl_socket.should_receive(:post_connection_check).with('host').and_return(true)
+          @ssl = ::Stomper::Sockets::SSL.new('host', 56789, {
+            :verify_mode => "kage",
+            :ca_file => "jables",
+            :ca_path => "the d",
+            :cert => "scepter",
+            :key => "key"
+          })
+        end
+      end
+    end
+  end
+end

data/spec/stomper/subscription_manager_spec.rb

@@ -0,0 +1,107 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper
+  describe SubscriptionManager do
+    before(:each) do
+      @connection = mock("connection")
+    end
+    
+    it "should bind to the on_receipt event handler" do
+      receipt = mock('receipt')
+      @connection.should_receive(:on_message)
+      @connection.should_receive(:on_unsubscribe)
+      @subscription_manager = SubscriptionManager.new(@connection)
+    end
+    
+    describe "usage" do
+      before(:each) do
+        @connection.extend ::Stomper::Extensions::Events
+        @subscription_manager = SubscriptionManager.new(@connection)
+        @subscribe_frame = ::Stomper::Frame.new('SUBSCRIBE', {:id => '1234', :destination => '/queue/testing'})
+        @unsubscribe_frame = ::Stomper::Frame.new('UNSUBSCRIBE', {:id => '1234'})
+      end
+      
+      it "should correctly report subscribed IDs" do
+        @subscription_manager.add(@subscribe_frame, lambda { |m| true })
+        @subscription_manager.subscribed_id?('1234').should be_true
+        @subscription_manager.subscribed_id?('4321').should be_false
+        @subscription_manager.__send__(:remove, @unsubscribe_frame)
+        @subscription_manager.subscribed_id?('1234').should be_false
+      end
+      
+      it "should correctly report subscribed destinations" do
+        @subscription_manager.add(@subscribe_frame, lambda { |m| true })
+        @subscription_manager.subscribed_destination?('/queue/testing').should be_true
+        @subscription_manager.subscribed_destination?('/queue/test').should be_false
+        @subscription_manager.__send__(:remove, @unsubscribe_frame)
+        @subscription_manager.subscribed_destination?('/queue/testing').should be_false
+      end
+      
+      it "should correctly map subscribed destinations to their IDs" do
+        alt_subscribe_frame = ::Stomper::Frame.new('SUBSCRIBE', {:id => '4567', :destination => '/queue/testing'})
+        alt_unsubscribe_frame = ::Stomper::Frame.new('UNSUBSCRIBE', {:id => '4567'})
+        @subscription_manager.add(@subscribe_frame, lambda { |m| true })
+        @subscription_manager.add(alt_subscribe_frame, lambda { |m| true })
+        @subscription_manager.ids_for_destination('/queue/testing').should == ['1234', '4567']
+        @subscription_manager.ids_for_destination('/queue/test').should be_nil
+        @subscription_manager.__send__(:remove, @unsubscribe_frame)
+        @subscription_manager.ids_for_destination('/queue/testing').should == ['4567']
+        @subscription_manager.__send__(:remove, alt_unsubscribe_frame)
+        @subscription_manager.ids_for_destination('/queue/testing').should be_nil
+      end
+      
+      it "should allow a subscription handler to be registered within a callback" do
+        alt_subscribe_frame = ::Stomper::Frame.new('SUBSCRIBE', {:id => '4567', :destination => '/queue/testing'})
+        triggered = [false, false]
+        callback = lambda do |m|
+          triggered[0] = true
+          @subscription_manager.add(alt_subscribe_frame, lambda { |m| triggered[1] = true })
+        end
+        @subscription_manager.add(@subscribe_frame, callback)
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('MESSAGE', { :subscription => '1234' }))
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('MESSAGE', { :subscription => '4567' }))
+        triggered.should == [true, true]
+      end
+      
+      it "should allow a subscription to be removed within a callback" do
+        triggered = 0
+        callback = lambda do |m|
+          triggered += 1
+          @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('UNSUBSCRIBE', { :id => '1234' }))
+        end
+        @subscription_manager.add(@subscribe_frame, callback)
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('MESSAGE', { :subscription => '1234' }))
+        @connection.__send__(:trigger_received_frame, ::Stomper::Frame.new('MESSAGE', { :subscription => '1234' }))
+        triggered.should == 1
+      end
+      
+      it "should allow a receipt handler to be registered within a callback in separate threads" do
+        alt_subscribe_frame = ::Stomper::Frame.new('SUBSCRIBE', {:id => '4567', :destination => '/queue/testing'})
+        triggered = [false, false]
+        started_r1 = false
+        callback = lambda do |r|
+          triggered[0] = true
+          Thread.stop
+        end
+        @subscription_manager.add(@subscribe_frame, callback)
+        r_1 = Thread.new(@connection) do |c|
+          started_r1 = true
+          Thread.stop
+          c.__send__(:trigger_received_frame, ::Stomper::Frame.new('MESSAGE', { :subscription => '1234' }))
+        end
+        r_2 = Thread.new(@connection) do |c|
+          Thread.pass until triggered[0]
+          @subscription_manager.add(alt_subscribe_frame, lambda { |r| triggered[1] = true })
+          r_1.run
+          c.__send__(:trigger_received_frame, ::Stomper::Frame.new('MESSAGE', { :subscription => '4567' }))
+        end
+        Thread.pass until started_r1
+        r_1.run
+        r_1.join
+        r_2.join
+        triggered.should == [true, true]
+      end
+    end
+  end
+end

data/spec/stomper/support_spec.rb

@@ -0,0 +1,69 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper
+  describe Support do
+    before(:each) do
+      @hash = {
+        'a' => 'value 1',
+        :somekey => ['a', :set, 'of values', 33],
+        '13' => nil
+      }
+    end
+    
+    describe "keys_to_sym" do
+      it "should symbolize the keys of a hash without changing the original hash" do
+        symbolized_hash = Support.keys_to_sym(@hash)
+
+        @hash['a'].should == 'value 1'
+        @hash[:somekey].should == ['a', :set, 'of values', 33]
+        @hash['13'].should be_nil
+                
+        symbolized_hash.keys.sort.should == [ :'13', :a, :somekey ]
+        symbolized_hash[:a].should == 'value 1'
+        symbolized_hash[:somekey].should == ['a', :set, 'of values', 33]
+        symbolized_hash[:'13'].should be_nil
+      end
+    end
+    
+    describe "keys_to_sym!" do
+      it "should symbolize the keys of a hash and replace the existing hash" do
+        Support.keys_to_sym!(@hash)
+        @hash.keys.sort.should == [ :'13', :a, :somekey ]
+        @hash[:a].should == 'value 1'
+        @hash[:somekey].should == ['a', :set, 'of values', 33]
+        @hash[:'13'].should be_nil
+      end
+    end
+    
+    describe "next_serial" do
+      it "should generate sequential numbers" do
+        first = Support.next_serial.to_i
+        second = Support.next_serial.to_i
+        third = Support.next_serial.to_i
+        first.should == second - 1
+        second.should == third - 1
+      end
+    end
+    
+    describe "constantize" do
+      it "should constantize a Class" do
+        Support.constantize(Class).should == ::Class
+        Support.constantize(::Stomper::Extensions::Events).should == ::Stomper::Extensions::Events
+      end
+      
+      it "should constantize string representations of known classes" do
+        Support.constantize("Module").should == ::Module
+        Support.constantize("::Module").should == ::Module
+        Support.constantize("::Stomper::Extensions").should == ::Stomper::Extensions
+        Support.constantize("Stomper::Receivers::Threaded").should == ::Stomper::Receivers::Threaded
+      end
+      
+      it "should fail to constantize un-resolvable classes" do
+        lambda { Support.constantize("::Not::::Valid") }.should raise_error(NameError)
+        lambda { Support.constantize("Module::Does::Not::Exist") }.should raise_error(NameError)
+        lambda { Support.constantize("::Stomper::FrameSerializer::Nada") }.should raise_error(NameError)
+      end
+    end
+  end
+end

data/spec/stomper/uris_spec.rb

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module URI
+  describe STOMP do
+    before(:each) do
+      @uri = ::URI.parse('stomp:///')
+      @uri_host = ::URI.parse('stomp://host.domain.tld:12345')
+    end
+    
+    it "should be the class of URIs with a scheme of 'stomp' parsed by URI.parse" do
+      @uri.should be_an_instance_of(::URI::STOMP)
+    end
+    
+    it "should use port 61613 as a default if no port is specified" do
+      @uri.port.should == 61613
+    end
+    
+    it "should respond to :create_socket and return a TCP/IP socket built from its socket_factory" do
+      socket = mock('socket')
+      host_socket = mock('socket with host')
+      ::Stomper::Sockets::TCP.should_receive(:new).with('localhost', 61613).and_return(socket)
+      ::Stomper::Sockets::TCP.should_receive(:new).with('host.domain.tld', 12345).and_return(host_socket)
+      
+      @uri.create_socket.should equal(socket)
+      @uri_host.create_socket.should equal(host_socket)
+    end
+  end
+  
+  describe STOMP_SSL do
+    before(:each) do
+      @uri = ::URI.parse("stomp+ssl:///")
+      @uri_host = ::URI.parse('stomp+ssl://other.domain.tld:98765')
+    end
+    
+    it "should be the class of URIs with a scheme of 'stomp+ssl' parsed by URI.parse" do
+      @uri.should be_an_instance_of(::URI::STOMP_SSL)
+    end
+    
+    it "should use port 61612 as a default if no port is specified" do
+      @uri.port.should == 61612
+    end
+    
+    it "should respond to :create_socket and return a TCP/IP socket built from its socket_factory" do
+      socket = mock('socket')
+      host_socket = mock('socket with host')
+      ::Stomper::Sockets::SSL.should_receive(:new).with('localhost', 61612, {}).and_return(socket)
+      ::Stomper::Sockets::SSL.should_receive(:new).with('other.domain.tld', 98765, {}).and_return(host_socket)
+      
+      @uri.create_socket.should equal(socket)
+      @uri_host.create_socket.should equal(host_socket)
+    end
+  end
+end

data/spec/stomper_spec.rb

@@ -0,0 +1,9 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+describe Stomper do
+  it "should define a version" do
+    Stomper.const_defined?(:VERSION).should be_true
+    Stomper::VERSION.should == '2.0.0'
+  end
+end

data/spec/support/custom_argument_matchers.rb

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      def stomper_frame_with_headers(*args)
+        command = args.last.is_a?(String) ? args.pop : nil
+        StomperFrameMatcher.new(command, nil, anythingize_lonely_keys(*args))
+      end
+      
+      def stomper_frame_with_body(body, command=nil)
+        StomperFrameMatcher.new(command, body, nil)
+      end
+      
+      def stomper_frame(body, *args)
+        command = args.last.is_a?(String) ? args.pop : nil
+        StomperFrameMatcher.new(command, body, anythingize_lonely_keys(*args))
+      end
+      
+      def stomper_heartbeat_frame
+        StomperFrameMatcher.new(nil, nil, {})
+      end
+      
+      class StomperFrameMatcher
+        def initialize(e_command, e_body, e_headers)
+          @expected_command = e_command && e_command.upcase
+          @expected_body = e_body
+          @expected_headers = e_headers
+        end
+        
+        def ==(actual)
+          if @expected_command
+            return false unless @expected_command == actual.command
+          end
+          if @expected_body
+            return false unless @expected_body == actual.body
+          end
+          if @expected_headers
+            @expected_headers.each do |key, val|
+              return false unless actual[key] == val.to_s
+            end
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+        
+        def description
+          frame_name = @expected_command || 'Any frame'
+          with_headers = @expected_headers ? "with headers (#{@expected_headers.inspect.sub(/^\{/,"").sub(/\}$/,"")})" : nil
+          with_body = @expected_body ? "with body (#{@expected_body})" : nil
+          additional_desc = [with_headers, with_body].compact.join(' and ')
+          "#{frame_name} #{additional_desc}"
+        end
+      end
+    end
+  end
+end

data/spec/support/existential_frame_matchers.rb

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+# Spec::Matchers.define :be_a_registered_server_frame do
+#   match do |actual|
+#     command_name = actual.name.split('::').last.upcase
+#     frame = Stomp::Frames::ServerFrame.build(command_name, { :a_header => 'test' }, 'body')
+#     frame.should be_an_instance_of(actual)
+#     frame.command.should == command_name
+#     frame.headers[:a_header].should == 'test'
+#     frame.body.should == 'test body'
+#   end
+# end
+# 
+# Spec::Matchers.define :be_able_to_access_header_values_like_a_hash do
+#   match do |actual|
+#     frame = actual.new( { :header_1 => 1, :header_2 => 'test' })
+#     frame[:header_1].should == 1
+#     frame[:header_2].should == 'test'
+#   end
+# end

data/spec/support/frame_header_matchers.rb

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+RSpec::Matchers.define :have_header do |header_name, expected|
+  match do |actual|
+    actual[header_name.to_sym] == expected
+  end
+end
+
+RSpec::Matchers.define :have_transaction_header do |expected|
+  have_frame_header :transaction, expected
+end