stomper 1.0.0 → 2.0.0

data/lib/stomper/transactor.rb

@@ -1,50 +0,0 @@
-module Stomper
-  module Transactor
-    # Creates a new Stomper::Transaction object and evaluates
-    # the supplied +block+ within a transactional context.  If
-    # the block executes successfully, the transaction is committed,
-    # otherwise it is aborted.  This method is meant to provide a less
-    # tedious approach to transactional messaging than the +begin+,
-    # +abort+ and +commit+ methods.
-    #
-    # See also: Stomper::ClientInterface::begin, Stomper::ClientInterface::commit,
-    # Stomper::ClientInterface::abort, Stomper::Transaction
-    def transaction(transaction_id=nil, &block)
-      begin
-        Stomper::Transaction.new(self, transaction_id, &block)
-      rescue Stomper::TransactionAborted
-        nil
-      end
-    end
-    
-    # Tells the stomp broker to commit a transaction named by the
-    # supplied +transaction_id+ parameter.  When used in conjunction with
-    # +begin+, and +abort+, a means for manually handling transactional
-    # message passing is provided.
-    #
-    # See Also: transaction
-    def commit(transaction_id)
-      transmit(Stomper::Frames::Commit.new(transaction_id))
-    end
-
-    # Tells the stomp broker to abort a transaction named by the
-    # supplied +transaction_id+ parameter.  When used in conjunction with
-    # +begin+, and +commit+, a means for manually handling transactional
-    # message passing is provided.
-    #
-    # See Also: transaction
-    def abort(transaction_id)
-      transmit(Stomper::Frames::Abort.new(transaction_id))
-    end
-
-    # Tells the stomp broker to begin a transaction named by the
-    # supplied +transaction_id+ parameter.  When used in conjunction with
-    # +commit+, and +abort+, a means for manually handling transactional
-    # message passing is provided.
-    #
-    # See also: transaction
-    def begin(transaction_id)
-      transmit(Stomper::Frames::Begin.new(transaction_id))
-    end
-  end
-end

data/lib/stomper/uri.rb

@@ -1,55 +0,0 @@
-module URI
-  class STOMP < ::URI::Generic
-    # Got to love the magic of URI::Generic.
-    # By setting this constant, you ensure that all
-    # Stomp URI's have this port if one isn't specified.
-    DEFAULT_PORT = 61613
-
-    def initialize(*args)
-      super
-    end
-
-    def create_socket
-      ::Stomper::Sockets::TCP.new(self.host||'localhost', self.port)
-    end
-
-    def open(*args)
-      conx = Stomper::Connection.open(self, :threaded_receiver => false)
-      conx.extend Stomper::OpenUriInterface
-      if block_given?
-        begin
-          yield conx
-        ensure
-          conx.disconnect
-        end
-      end
-      conx
-    end
-  end
-
-  class STOMP_SSL < STOMP
-    DEFAULT_PORT = 61612
-
-    def initialize(*args)
-      super
-    end
-
-    # Creates a socket from the URI
-    def create_socket
-      ::Stomper::Sockets::SSL.new(self.host||'localhost', self.port)
-    end
-
-    # The +uri+ standard library resolves string URI's to concrete classes
-    # by matching the string's schema to the name of a subclass of URI::Generic.
-    # Ruby doesn't support '+' symbols in a class name, so the only way to handle
-    # schemas with odd characters is to override the "to_s" function of the class.
-    #
-    # Why do I get the feeling this might be a bad idea?
-    def self.to_s
-      "URI::STOMP+SSL"
-    end
-  end
-
-  @@schemes['STOMP'] = STOMP
-  @@schemes['STOMP+SSL'] = STOMP_SSL
-end

data/spec/client_spec.rb

@@ -1,29 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-
-module Stomper
-  describe Client do
-    class MockConcreteClient
-      include Stomper::Client
-    end
-
-    before(:each) do
-      @client = MockConcreteClient.new
-    end
-    
-    describe "expected interface" do
-      it "should provide a send method" do
-        @client.should respond_to(:send)
-        @client.should_receive(:transmit).with(an_instance_of(Stomper::Frames::Send)).twice.and_return(nil)
-        @client.send("/queue/to", "message body", {:additional => 'header'})
-        @client.send("/queue/to", "message body")
-      end
-      it "should provide an ack method" do
-        @client.should respond_to(:ack)
-        @client.should_receive(:transmit).with(an_instance_of(Stomper::Frames::Ack)).exactly(3).times.and_return(nil)
-        @client.ack("message-id", {:additional => "header"})
-        @client.ack("message-id")
-        @client.ack(Stomper::Frames::Message.new({:'message-id' => 'msg-001'}, "body"))
-      end
-    end
-  end
-end

data/spec/connection_spec.rb

@@ -1,22 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'shared_connection_examples'))
-
-module Stomper
-  describe Connection do
-    describe "standard connection" do
-      before(:each) do
-        @connection = Connection.new("stomp:///")
-      end
-    
-      it_should_behave_like "All Client Connections"
-    end
-    
-    describe "ssl connection" do
-      before(:each) do
-        @connection = Connection.new("stomp+ssl:///")
-      end
-      
-      it_should_behave_like "All Client Connections"
-    end
-  end
-end

data/spec/frame_reader_spec.rb

@@ -1,37 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-module Stomper
-  describe FrameReader do
-    before(:each) do
-      @input_stream = StringIO.new("", "w+")
-      @input_stream.send(:extend, Stomper::FrameReader)
-    end
-
-    it "should produce a stomper frame" do
-      @input_stream.string = "CONNECTED\n\n\0"
-      @input_stream.receive_frame.should be_an_instance_of(Stomper::Frames::Connected)
-    end
-
-    it "should read headers appropriately" do
-      @input_stream.string = "CONNECTED\nheader_1:a test value\nheader_2:another test value\nblather:47\n\nthe frame body\0"
-      @frame = @input_stream.receive_frame
-      @frame.headers.map { |(k,v)|
-        [k,v]
-      }.sort { |a, b| a.first.to_s <=> b.first.to_s }.should == [ [:blather, '47'], [:header_1, 'a test value'], [:header_2, 'another test value'] ]
-    end
-
-    it "should raise an exception when an invalid content-length is specified" do
-      @input_stream.string = "CONNECTED\ncontent-length:3\n\nsomething more than 3 bytes long\0"
-      lambda { @input_stream.receive_frame }.should raise_error(Stomper::MalformedFrameError)
-    end
-
-    it "should read the body of a message when a content length is specified" do
-      @input_stream.string = "CONNECTED\ncontent-length:6\n\na test\0followed by trailing nonsense"
-      @input_stream.receive_frame.body.should == "a test"
-    end
-    it "should read the body of a message when no content length is specified" do
-      @input_stream.string = "CONNECTED\n\na bit more text and no direction\0followed by trailing nonsense"
-      @input_stream.receive_frame.body.should == "a bit more text and no direction"
-    end
-  end
-end

data/spec/frame_writer_spec.rb

@@ -1,27 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-module Stomper
-  describe FrameWriter do
-    before(:each) do
-      @output_buffer = StringIO.new("", "w+")
-      @output_buffer.send(:extend, Stomper::FrameWriter)
-    end
-
-    it "should write commands appropriately" do
-      @output_buffer.transmit_frame(Stomper::Frames::Send.new('/test/queue','body of message'))
-      @output_buffer.string.should =~ /\ASEND/
-    end
-
-    it "should write headers appropriately" do
-      @output_buffer.transmit_frame(Stomper::Frames::Send.new('/test/queue','body of message', :a_header => "3", :another => 23))
-      split_str = @output_buffer.string.split("\n")
-      split_str.shift
-      headers = ['a_header:3', 'another:23', 'content-length:15', 'destination:/test/queue']
-      until (header_line = split_str.shift).empty?
-        headers.should include(header_line)
-        headers.delete(header_line)
-      end
-      headers.should be_empty
-    end
-  end
-end

data/spec/frames/client_frame_spec.rb

@@ -1,66 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-module Stomper::Frames
-  describe ClientFrame do
-    before(:each) do
-      ClientFrame.generate_content_length = true
-      @client_frame = ClientFrame.new({}, nil, 'COMMAND')
-    end
-
-    def str_size(str)
-      str.respond_to?(:bytesize) ? str.bytesize : str.size
-    end
-
-    describe "generating content-length header" do
-      it "should provide the header by default, overriding any existing header" do
-        @frame_body = 'testing'
-        @client_frame = ClientFrame.new({'content-length' => 1}, @frame_body, "COMMAND")
-        @client_frame.headers[:'content-length'].should == str_size(@frame_body)
-      end
-
-      it "should not provide the header if the class option is set to false, unless explicitly set on the frame in particular" do
-        ClientFrame.generate_content_length = false
-        @frame_body = 'testing'
-        @client_frame = ClientFrame.new({}, @frame_body, 'COMMAND')
-        @client_frame.headers[:'content-length'].should be_nil
-        @client_frame = ClientFrame.new({}, @frame_body, 'COMMAND')
-        @client_frame.generate_content_length = true
-        @client_frame.headers[:'content-length'].should == str_size(@frame_body)
-      end
-
-      it "should not provide the header if instance option is set false, when the class option is true" do
-        @frame_body = 'testing'
-        @client_frame = ClientFrame.new({}, @frame_body, 'COMMAND')
-        @client_frame.generate_content_length = false
-        @client_frame.headers[:'content-length'].should be_nil
-        @client_frame = ClientFrame.new({:generate_content_length => false}, @frame_body, 'COMMAND')
-        @client_frame.headers[:'content-length'].should be_nil
-      end
-
-      it "should not overwrite an explicit content-length header when option is off at class or instance level" do
-        @frame_body = 'testing'
-        @client_frame = ClientFrame.new({ :'content-length' => 4}, @frame_body, 'COMMAND')
-        @client_frame.generate_content_length = false
-        @client_frame.headers[:'content-length'].should == 4
-        ClientFrame.generate_content_length = false
-        @client_frame = ClientFrame.new({ :'content-length' => 2}, @frame_body, 'COMMAND')
-        @client_frame.headers[:'content-length'].should == 2
-      end
-
-      it "should scope the class option to the class it is set on" do
-        @frame_body = 'testing'
-        Send.generate_content_length = false
-        @send_frame = Send.new('/queue/test/1', @frame_body)
-        @client_frame = ClientFrame.new({}, @frame_body, 'COMMAND')
-        @client_frame.headers[:'content-length'].should == str_size(@frame_body)
-        @send_frame.headers[:'content-length'].should be_nil
-        Send.generate_content_length = true
-        ClientFrame.generate_content_length = false
-        @send_frame = Send.new('/queue/test/1', @frame_body)
-        @client_frame = ClientFrame.new({}, @frame_body, 'COMMAND')
-        @client_frame.headers[:'content-length'].should be_nil
-        @send_frame.headers[:'content-length'].should == str_size(@frame_body)
-      end
-    end
-  end
-end

data/spec/frames/indirect_frame_spec.rb

@@ -1,45 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-module Stomper
-  module Frames
-    describe IndirectFrame do
-      describe "interface" do
-        before(:each) do
-          @indirect_frame = IndirectFrame.new({}, nil, "INDIRECT_COMMAND")
-        end
-
-        it "should provide a command attribute" do
-          @indirect_frame.should respond_to(:command)
-        end
-        it "should provide a body attribute" do
-          @indirect_frame.should respond_to(:body)
-        end
-        it "should provide a headers attribute" do
-          @indirect_frame.should respond_to(:headers)
-        end
-      end
-
-      describe "command name" do
-        class UnnamedIndirectFrame < IndirectFrame; end
-        class NamedIndirectFrame < IndirectFrame
-          def initialize
-            super({}, nil, :test_command)
-          end
-        end
-
-        it "should use its class name if no command is specified" do
-          @indirect_frame = IndirectFrame.new({}, nil)
-          @indirect_frame.command.should == "INDIRECTFRAME"
-          @unnamed_frame = UnnamedIndirectFrame.new
-          @unnamed_frame.command.should == "UNNAMEDINDIRECTFRAME"
-        end
-
-        it "should use a provided command name when it is provided" do
-          @indirect_frame = IndirectFrame.new({}, nil, "MY_COMMAND")
-          @indirect_frame.command.should == "MY_COMMAND"
-          @named_frame = NamedIndirectFrame.new
-          @named_frame.command.should == "TEST_COMMAND"
-        end
-      end
-    end
-  end
-end

data/spec/frames/server_frame_spec.rb

@@ -1,85 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-module Stomper
-  module Frames
-    describe ServerFrame do
-      before(:each) do
-        @server_frame = ServerFrame.new("SERVER COMMAND")
-      end
-
-      it "should build an appropriate object for a given server frame" do
-        @built_frame = ServerFrame.build("MESSAGE", {:'message-id' => 'msg-001', :transaction => 'tx-test', :subscription => 'sub-test'}, "message body")
-        @built_frame.should be_an_instance_of(Message)
-        @built_frame.headers[:transaction].should == "tx-test"
-        @built_frame.headers[:subscription].should == "sub-test"
-        @built_frame.headers[:'message-id'].should == "msg-001"
-        @built_frame.body.should == "message body"
-        @built_frame = ServerFrame.build("AN UNKNOWN COMMAND", {:a_header => "test"}, "a body")
-        @built_frame.should be_an_instance_of(ServerFrame)
-        @built_frame.command.should == "AN UNKNOWN COMMAND"
-        @built_frame.headers[:a_header].should == "test"
-        @built_frame.body.should == "a body"
-        class MockServerFrame < ServerFrame
-          def initialize(headers, body)
-            super(headers, body)
-          end
-        end
-        @built_frame = ServerFrame.build("MOCKSERVERFRAME", {:a_header => "test"}, "a body")
-        @built_frame.should be_an_instance_of(MockServerFrame)
-        @built_frame.headers[:a_header].should == "test"
-        @built_frame.body.should == "a body"
-      end
-
-      describe "server frames" do
-        describe Connected do
-          it "should be registered" do
-            @server_frame = ServerFrame.build("CONNECTED", {:a_header => 'test'}, "test body")
-            @server_frame.should be_an_instance_of(Connected)
-            @server_frame.command.should == "CONNECTED"
-            @server_frame.headers[:a_header].should == "test"
-            @server_frame.body.should == "test body"
-          end
-        end
-        describe Error do
-          it "should be registered" do
-            @server_frame = ServerFrame.build("ERROR", {:a_header => 'test'}, "test body")
-            @server_frame.should be_an_instance_of(Error)
-            @server_frame.command.should == "ERROR"
-            @server_frame.headers[:a_header].should == "test"
-            @server_frame.body.should == "test body"
-          end
-        end
-        describe Message do
-          it "should be registered" do
-            @server_frame = ServerFrame.build("MESSAGE", {:a_header => 'test'}, "test body")
-            @server_frame.should be_an_instance_of(Message)
-            @server_frame.command.should == "MESSAGE"
-            @server_frame.headers[:a_header].should == "test"
-            @server_frame.body.should == "test body"
-          end
-
-          it "should provide the convenience attributes" do
-            @message = Message.new({:destination => '/queue/testing', :subscription => 'sub-001', :'message-id' => 'msg-001'}, "test body")
-            @message.id.should == "msg-001"
-            @message.destination.should == "/queue/testing"
-            @message.subscription.should == "sub-001"
-          end
-        end
-        describe Receipt do
-          it "should be registered" do
-            @server_frame = ServerFrame.build("RECEIPT", {:a_header => 'test'}, "test body")
-            @server_frame.should be_an_instance_of(Receipt)
-            @server_frame.command.should == "RECEIPT"
-            @server_frame.headers[:a_header].should == "test"
-            @server_frame.body.should == "test body"
-          end
-
-          it "should provide the convenience attributes" do
-            @receipt = Receipt.new({:'receipt-id' => 'who the receipt is for'}, "test body")
-            @receipt.for.should == "who the receipt is for"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/open_uri_interface_spec.rb

@@ -1,132 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'open-uri'
-
-module Stomper
-  describe "Open URI Interface" do
-    describe "basic interface" do
-      it "should be able to connect through open-uri style" do
-        lambda { open("stomp:///") { |s| } }.should_not raise_error
-      end
-      it "should provide a 'put' method" do
-        open("stomp:///") { |s| s.should respond_to(:put) }
-      end
-      it "should provide a 'puts' method" do
-        open("stomp:///") { |s| s.should respond_to(:puts) }
-      end
-      it "should provide a 'write' method" do
-        open("stomp:///") { |s| s.should respond_to(:write) }
-      end
-      it "should provide a 'get' method" do
-        open("stomp:///") { |s| s.should respond_to(:get) }
-      end
-      it "should provide a 'gets' method" do
-        open("stomp:///") { |s| s.should respond_to(:gets) }
-      end
-      it "should provide a 'read' method" do
-        open("stomp:///") { |s| s.should respond_to(:read) }
-      end
-    end
-
-    describe "automatic closing" do
-      it "should automatically connect then disconnect when the block completes" do
-        connection = open("stomp:///") { |s| s.connected?.should be_true; s }
-        connection.connected?.should be_false
-      end
-
-      it "should automatically disconnect if the block raises an exception" do
-        connection = nil
-        begin
-          open("stomp:///") { |s| connection = s; raise ArgumentError, "some error" }
-        rescue ArgumentError
-        end
-        connection.connected?.should be_false
-      end
-    end
-
-    describe "message sending" do
-      it "should transmit a SEND frame for puts on the URI's specified destination with no content-length" do
-        open("stomp://localhost/queue/testing") do |s|
-          frame = s.puts("a test message")
-          frame.should be_a_kind_of(Stomper::Frames::Send)
-          frame.headers[:destination].should == "/queue/testing"
-          frame.headers[:'content-length'].should be_nil
-          frame.body.should == "a test message"
-        end
-      end
-      it "should transmit a SEND frame for put on the URI's specified destination with no content-length" do
-        open("stomp://localhost/queue/testing") do |s|
-          frame = s.put("a test message")
-          frame.should be_a_kind_of(Stomper::Frames::Send)
-          frame.headers[:destination].should == "/queue/testing"
-          frame.headers[:'content-length'].should be_nil
-          frame.body.should == "a test message"
-        end
-      end
-      it "should transmit a SEND frame for write on the URI's specified destination with a content-length" do
-        open("stomp://localhost/queue/testing") do |s|
-          frame = s.write("a test message")
-          frame.should be_a_kind_of(Stomper::Frames::Send)
-          frame.headers[:destination].should == "/queue/testing"
-          frame.headers[:'content-length'].should == "a test message".length
-          frame.body.should == "a test message"
-        end
-      end
-    end
-
-    describe "message receiving" do
-      it "should receive the next message on the queue with gets" do
-        open("stomp://localhost/queue/test_gets") do |s|
-          s.puts "a test message"
-          msg = s.gets
-          msg.should be_a_kind_of(Stomper::Frames::Message)
-          msg.body.should == "a test message"
-          msg.destination.should == "/queue/test_gets"
-        end
-      end
-      it "should receive the next message on the queue with get" do
-        open("stomp://localhost/queue/test_get") do |s|
-          s.puts "a test message"
-          msg = s.get
-          msg.should be_a_kind_of(Stomper::Frames::Message)
-          msg.body.should == "a test message"
-          msg.destination.should == "/queue/test_get"
-        end
-      end
-      it "should receive the next message on the queue with read" do
-        open("stomp://localhost/queue/test_read") do |s|
-          s.puts "a test message"
-          msg = s.read
-          msg.should be_a_kind_of(Stomper::Frames::Message)
-          msg.body.should == "a test message"
-          msg.destination.should == "/queue/test_read"
-        end
-      end
-      it "should receive 4 messages with an optional argument supplied to first" do
-        open("stomp://localhost/queue/test_first_4") do |s|
-          s.puts "test message 1"
-          s.puts "test message 2"
-          s.puts "test message 3"
-          s.puts "test message 4"
-          msgs = s.first(4)
-          msgs.size.should == 4
-          msgs.all? { |m| m.is_a?(Stomper::Frames::Message) }.should be_true
-          msgs.map { |m| m.body }.should == ["test message 1", "test message 2", "test message 3", "test message 4"]
-        end
-      end
-      it "should provide the each iterator" do
-        open("stomp://localhost/queue/test_each") do |s|
-          s.puts "fringe"
-          s.write "dexter"
-          s.put "nip/tuck"
-          s.puts "futurama"
-          s.write "frasier"
-          s.each do |m|
-            m.destination.should == "/queue/test_each"
-            %w(fringe dexter nip/tuck futurama frasier).should include(m.body)
-            break if m.body== "frasier"
-          end
-        end
-      end
-    end
-  end
-end