stomper 0.4 → 1.0.0

data/spec/frame_writer_spec.rb

@@ -0,0 +1,27 @@
+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

@@ -4,138 +4,62 @@ module Stomper::Frames
   describe ClientFrame do
     before(:each) do
       ClientFrame.generate_content_length = true
-      @client_frame = ClientFrame.new('COMMAND')
+      @client_frame = ClientFrame.new({}, nil, 'COMMAND')
     end
 
     def str_size(str)
       str.respond_to?(:bytesize) ? str.bytesize : str.size
     end
 
-    it "should be provide a headers as an instance of Headers" do
-      @client_frame.headers.should be_an_instance_of(Stomper::Frames::Headers)
-    end
-
-    it "should be convertable into a stomp frame" do
-      @client_frame.to_stomp.should == "COMMAND\n\n\0"
-      @client_frame.headers.destination = "/queue/test/1"
-      @client_frame.headers['transaction-id'] = '2'
-      @client_frame.headers[:ack] = 'client'
-      @client_frame.to_stomp.should == "COMMAND\nack:client\ndestination:/queue/test/1\ntransaction-id:2\n\n\0"
-    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('COMMAND', {'content-length' => 1}, @frame_body)
-        @client_frame.to_stomp.should == "COMMAND\ncontent-length:#{str_size(@frame_body)}\n\n#{@frame_body}\0"
+        @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('COMMAND', {}, @frame_body)
-        @client_frame.to_stomp.should == "COMMAND\n\n#{@frame_body}\0"
-        @client_frame = ClientFrame.new('COMMAND', {}, @frame_body)
+        @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.to_stomp.should == "COMMAND\ncontent-length:#{str_size(@frame_body)}\n\n#{@frame_body}\0"
+        @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('COMMAND', {}, @frame_body)
+        @client_frame = ClientFrame.new({}, @frame_body, 'COMMAND')
         @client_frame.generate_content_length = false
-        @client_frame.to_stomp.should == "COMMAND\n\n#{@frame_body}\0"
-        @client_frame = ClientFrame.new('COMMAND', {:generate_content_length => false}, @frame_body)
-        @client_frame.to_stomp.should == "COMMAND\n\n#{@frame_body}\0"
+        @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('COMMAND', { 'content-length' => 4}, @frame_body)
+        @client_frame = ClientFrame.new({ :'content-length' => 4}, @frame_body, 'COMMAND')
         @client_frame.generate_content_length = false
-        @client_frame.to_stomp.should == "COMMAND\ncontent-length:4\n\n#{@frame_body}\0"
+        @client_frame.headers[:'content-length'].should == 4
         ClientFrame.generate_content_length = false
-        @client_frame = ClientFrame.new('COMMAND', {'content-length' => 2}, @frame_body)
-        @client_frame.to_stomp.should == "COMMAND\ncontent-length:2\n\n#{@frame_body}\0"
+        @client_frame = ClientFrame.new({ :'content-length' => 2}, @frame_body, 'COMMAND')
+        @client_frame.headers[:'content-length'].should == 2
       end
 
-      it "should the class option should be scoped to the class it is set on" do
+      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('COMMAND', {}, @frame_body)
-        @client_frame.to_stomp.should == "COMMAND\ncontent-length:#{str_size(@frame_body)}\n\n#{@frame_body}\0"
-        @send_frame.to_stomp.should == "SEND\ndestination:#{@send_frame.headers.destination}\n\n#{@frame_body}\0"
+        @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('COMMAND', {}, @frame_body)
-        @client_frame.to_stomp.should == "COMMAND\n\n#{@frame_body}\0"
-        @send_frame.to_stomp.should == "SEND\ncontent-length:#{str_size(@frame_body)}\ndestination:#{@send_frame.headers.destination}\n\n#{@frame_body}\0"
-      end
-    end
-    describe "client frames" do
-      describe Abort do
-        it "should produce a proper stomp message" do
-          @abort = Abort.new("transaction-test", { :a_header => 'test'})
-          @abort.to_stomp.should == "ABORT\na_header:test\ntransaction:transaction-test\n\n\0"
-        end
-      end
-      describe Ack do
-        it "should produce a proper stomp message" do
-          @ack = Ack.new("message-test", { :a_header => 'test'})
-          @ack.to_stomp.should == "ACK\na_header:test\nmessage-id:message-test\n\n\0"
-        end
-
-        it "should provide an Ack for a given message frame" do
-          @ack = Ack.ack_for(Message.new({'message-id' => 'test'}, "a body"))
-          @ack.to_stomp.should == "ACK\nmessage-id:test\n\n\0"
-          @ack = Ack.ack_for(Message.new({'message-id' => 'test', 'transaction' => 'tx-test'}, "a body"))
-          @ack.to_stomp.should == "ACK\nmessage-id:test\ntransaction:tx-test\n\n\0"
-        end
-
-      end
-      describe Begin do
-        it "should produce a proper stomp message" do
-          @begin = Begin.new("transaction-test", { :a_header => 'test'})
-          @begin.to_stomp.should == "BEGIN\na_header:test\ntransaction:transaction-test\n\n\0"
-        end
-      end
-      describe Commit do
-        it "should produce a proper stomp message" do
-          @commit = Commit.new("transaction-test", { :a_header => 'test'})
-          @commit.to_stomp.should == "COMMIT\na_header:test\ntransaction:transaction-test\n\n\0"
-        end
-      end
-      describe Connect do
-        it "should produce a proper stomp message" do
-          @connect = Connect.new('uzer','s3cr3t', { :a_header => 'test' })
-          @connect.to_stomp.should == "CONNECT\na_header:test\nlogin:uzer\npasscode:s3cr3t\n\n\0"
-        end
-      end
-      describe Disconnect do
-        it "should produce a proper stomp message" do
-          @disconnect = Disconnect.new({ :a_header => 'test'})
-          @disconnect.to_stomp.should == "DISCONNECT\na_header:test\n\n\0"
-        end
-      end
-      describe Send do
-        it "should produce a proper stomp message" do
-          @send = Send.new("/queue/a/target", "a body", { :a_header => 'test'})
-          @send.to_stomp.should == "SEND\na_header:test\ncontent-length:6\ndestination:/queue/a/target\n\na body\0"
-        end
-      end
-      describe Subscribe do
-        it "should produce a proper stomp message" do
-          @subscribe = Subscribe.new("/topic/some/target", { :a_header => 'test'})
-          @subscribe.to_stomp.should == "SUBSCRIBE\na_header:test\nack:auto\ndestination:/topic/some/target\n\n\0"
-        end
-      end
-      describe Unsubscribe do
-        it "should produce a proper stomp message" do
-          @unsubscribe = Unsubscribe.new("/topic/target.name.path", { :a_header => 'test'})
-          @unsubscribe.to_stomp.should == "UNSUBSCRIBE\na_header:test\ndestination:/topic/target.name.path\n\n\0"
-        end
+        @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

data/spec/frames/indirect_frame_spec.rb

@@ -0,0 +1,45 @@
+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

@@ -7,31 +7,26 @@ module Stomper
         @server_frame = ServerFrame.new("SERVER COMMAND")
       end
 
-      it "should provide a method for subclasses to register the command they handle" do
-        ServerFrame.should respond_to(:factory_for)
-      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 = 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[: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.headers[:a_header].should == "test"
         @built_frame.body.should == "a body"
         class MockServerFrame < ServerFrame
-          factory_for :testing
           def initialize(headers, body)
-            super('TESTING', headers, body)
+            super(headers, body)
           end
         end
-        @built_frame = ServerFrame.build("TESTING", {:a_header => "test"}, "a body")
+        @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.headers[:a_header].should == "test"
         @built_frame.body.should == "a body"
       end
 
@@ -40,7 +35,8 @@ module Stomper
           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.headers.a_header.should == "test"
+            @server_frame.command.should == "CONNECTED"
+            @server_frame.headers[:a_header].should == "test"
             @server_frame.body.should == "test body"
           end
         end
@@ -48,7 +44,8 @@ module Stomper
           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.headers.a_header.should == "test"
+            @server_frame.command.should == "ERROR"
+            @server_frame.headers[:a_header].should == "test"
             @server_frame.body.should == "test body"
           end
         end
@@ -56,7 +53,8 @@ module Stomper
           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.headers.a_header.should == "test"
+            @server_frame.command.should == "MESSAGE"
+            @server_frame.headers[:a_header].should == "test"
             @server_frame.body.should == "test body"
           end
 
@@ -71,7 +69,8 @@ module Stomper
           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.headers.a_header.should == "test"
+            @server_frame.command.should == "RECEIPT"
+            @server_frame.headers[:a_header].should == "test"
             @server_frame.body.should == "test body"
           end
 

data/spec/open_uri_interface_spec.rb

@@ -0,0 +1,132 @@
+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

data/spec/receiptor_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+module Stomper
+  describe Receiptor do
+    class MockConcreteReceipter
+      include Stomper::Receiptor
+    end
+
+    before(:each) do
+      @client = MockConcreteReceipter.new
+    end
+    
+    describe "expected interface" do
+    end
+
+    describe "receipt handling" do
+      before(:each) do
+        @client.should_receive(:connected?).any_number_of_times.and_return(true)
+        @client.should_receive(:send_without_receipt_handler).with('/queue/to','message body',a_kind_of(Hash)).at_least(:once).and_return(nil)
+      end
+
+      it "should dispatch a receipt when sent with a block" do
+        @client.should_receive(:receive_without_receipt_dispatch).once.and_return(Stomper::Frames::Receipt.new({ :'receipt-id' => 'msg-0001' }, ''))
+        receipt_processed = false
+        @client.send('/queue/to', 'message body', :receipt => 'msg-0001') do |r|
+          receipt_processed = true
+        end
+        @client.receipt_handlers.size.should == 1
+        @client.receive_with_receipt_dispatch
+        receipt_processed.should be_true
+        @client.receipt_handlers.size.should == 0
+      end
+    end
+  end
+end