stomper 1.0.0 → 2.0.0

data/spec/stomper/frame_serializer_spec.rb

@@ -0,0 +1,316 @@
+# -*- 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",
+        }
+        @messages.each { |k, v| v.force_encoding('ASCII-8BIT') }
+      
+        @frames = {
+          :common => ::Stomper::Frame.new('FRAME', { :header_1 => 'value 1', :header_2 => '3', :header_3 => '', :'content-type' => 'text/plain'}, 'body of message'),
+          :no_headers => ::Stomper::Frame.new('FRAME', {}, 'body of message'.encode('ISO-8859-1')),
+          :no_body => ::Stomper::Frame.new('FRAME', { :header_1 => 'val', :musical => '', :offering => '4'}),
+          :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'.encode('ASCII-8BIT')),
+          :charset_header_text_body => ::Stomper::Frame.new('FRAME', {:'content-type' => 'text/plain; param="value";charset=ISO-8859-1'}, 'body of message'.encode('UTF-8')),
+          :charset_header_binary_body => ::Stomper::Frame.new('FRAME', {:'content-type' => 'application/pdf; param="value";charset=ISO-8859-1'}, 'body of message'.encode('ASCII-8BIT'))
+        }
+        @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" do
+            @frame_serializer.write_frame(@frames[:no_headers])
+            @frame_io.string.should == "FRAME\ncontent-type:text/plain;charset=ISO-8859-1\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 overwrite the charset parameter with the encoding when the body is text" do
+            @frame_serializer.write_frame(@frames[:charset_header_text_body])
+            @frame_io.string.should == "FRAME\ncontent-type:text/plain; param=\"value\";charset=UTF-8\ncontent-length:15\n\nbody of message\000"
+          end
+        
+          it "should omit the charset parameter when the content-type is not text/* and the encoding is binary" do
+            @frame_serializer.write_frame(@frames[:charset_header_binary_body])
+            @frame_io.string.should == "FRAME\ncontent-type:application/pdf; param=\"value\"\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" do
+            @frame_serializer.write_frame(@frames[:no_headers])
+            @frame_io.string.should == "FRAME\ncontent-type:text/plain;charset=ISO-8859-1\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ëllo!".encode("ISO-8859-1")
+            frame.body.encoding.name.should == 'ISO-8859-1'
+          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 "
+            frame.body.encoding.name.should == 'UTF-8'
+          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!"
+            frame.body.encoding.name.should == 'UTF-8'
+          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
+            frame.body.encoding.name.should == 'ASCII-8BIT'
+          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
+            frame.body.encoding.name.should == 'ASCII-8BIT'
+          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
+            frame['repeated header'].should == 'a value'
+          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

data/spec/stomper/frame_spec.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper
+  describe Frame do
+    before(:each) do
+      @frame = Frame.new
+    end
+    
+    it "should have a command attribute" do
+      @frame.should respond_to(:command)
+      @frame.should respond_to(:command=)
+      @frame.command = 'command name'
+      @frame.command.should == 'command name'
+    end
+    
+    describe "headers" do
+      it "should provide access to the headers through :headers" do
+        @frame.headers.should be_a_kind_of(::Stomper::Headers)
+      end
+      
+      it "should provide hash-like access to header assignment" do
+        @frame['header name'] = 'header value'
+        @frame['header name'].should == 'header value'
+      end
+      
+      it "should provide a convenience method for content-type" do
+        @frame[:'content-type'] = 'text/plain; charset=UTF-8; param=val'
+        @frame.content_type.should == 'text/plain'
+        
+        @frame[:'content-type'] = nil
+        @frame.content_type.should == ''
+      end
+    end
+  end
+end

data/spec/stomper/headers_spec.rb

@@ -0,0 +1,224 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module Stomper
+  describe Headers do
+    before(:each) do
+      @headers = Headers.new
+    end
+    after(:each) do
+      @headers.names.should == @headers.names.uniq
+    end
+    
+    it "should allow setting and getting headers through a hash-style" do
+      @headers[:header_1] = 'some value'
+      @headers[:header_1].should == 'some value'
+    end
+    
+    it "should translate keys to symbols" do
+      @headers['other header'] = '42'
+      @headers[:'other header'].should == '42'
+      @headers['other header'].should == '42'
+    end
+    
+    it "should translate header values to strings" do
+      @headers['test header'] = 42
+      @headers['test header'].should == '42'
+      @headers['test header'] = nil
+      @headers['test header'].should == ''
+    end
+    
+    it "should return an array of header key/value pairs" do
+      @headers['header 1'] = 'testing'
+      @headers['other header'] = 19
+      @headers[:tom] = 'servo'
+      @headers.to_a.should == [ ['header 1', 'testing'], ['other header', '19'], ['tom', 'servo'] ]
+    end
+    
+    it "should preserve the order of keys" do
+      expected_keys = []
+      20.times do |n|
+        expected_keys << :"header #{n}"
+        @headers["header #{n}"] = 'value'
+      end
+      @headers.names.should == expected_keys
+    end
+    
+    it "should preserve the order of keys after deletion and insertion" do
+      expected_keys = []
+      20.times do |n|
+        expected_keys << :"header #{n}" unless n == 3 || n == 16
+        @headers["header #{n}"] = 'value'
+      end
+      expected_keys << :'header x'
+      @headers.delete('header 3')
+      @headers.delete('header 16')
+      @headers['header x'] = 'value'
+      @headers.names.should == expected_keys
+    end
+    
+    it "should not duplicate existing keys" do
+      expected_keys = []
+      10.times do |n|
+        expected_keys << :"header #{n}"
+        @headers["header #{n}"] = 'value'
+        @headers["header #{n}"] = 'other value'
+        @headers.append("header #{n}", 'last value')
+      end
+      @headers.names.should == expected_keys
+    end
+    
+    it "should maintain case sensitivity of keys" do
+      @headers['headeR'] = 'value 1'
+      @headers['Header'] = 'value 2'
+      @headers[:header]  = 'value 3'
+      @headers['headeR'].should == 'value 1'
+      @headers['Header'].should == 'value 2'
+      @headers['header'].should == 'value 3'
+    end
+    
+    it "should overwrite header values through the hash-like interface" do
+      @headers['header 1'] = 'first value'
+      @headers[:'header 1'] = 'second value'
+      @headers['header 1'] = 'third value'
+      @headers[:'header 1'].should == 'third value'
+    end
+    
+    it "should allow appending headers through the append interface method" do
+      @headers.append('header 1', 'first value')
+      @headers.append(:'header 1', 'second value')
+      @headers.append('header 1', 'third value')
+      @headers.all_values('header 1').should == ['first value', 'second value', 'third value']
+    end
+    
+    it "should be convertable to an array" do
+      @headers['header 1'] = 'first value'
+      @headers['header 2'] = 'second value'
+      @headers['header 3'] = 'third value'
+      @headers.to_a.should == [['header 1', 'first value'], ['header 2', 'second value'], ['header 3', 'third value']]
+    end
+    
+    it "should include duplicate headers in the array conversion" do
+      @headers.append('header 1', 'h1 value 1')
+      @headers.append('header 1', 'h1 value 2')
+      @headers.append('header 1', 'h1 value 3')
+      @headers['header 2'] = 'h2 value 1'
+      @headers['header 3'] = 'h3 value 1'
+      @headers.append('header 3', 'h3 value 2')
+      @headers.to_a.should == [ ['header 1', 'h1 value 1'], ['header 1', 'h1 value 2'],
+        ['header 1', 'h1 value 3'], ['header 2', 'h2 value 1'], ['header 3', 'h3 value 1'],
+        ['header 3', 'h3 value 2'] ]
+    end
+    
+    it "should set a header value to the first encountered in a chain of appends" do
+      @headers.append('header 1', 'first value')
+      @headers.append('header 1', 'second value')
+      @headers.append('header 1', 'third value')
+      @headers['header 1'].should == 'first value'
+    end
+    
+    it "should be able to verify if a header has been set" do
+      @headers['header 1'] = 'testing'
+      @headers.has?(:'header 1').should be_true
+      @headers.key?('header 1').should be_true
+      @headers.include?('header 1').should be_true
+      @headers.delete(:'header 1')
+      @headers.has?(:'header 1').should_not be_true
+      @headers.key?('header 1').should_not be_true
+      @headers.include?('header 1').should_not be_true
+    end
+    
+    describe "merging" do
+      before(:each) do
+        @headers = Headers.new({ :name1 => 'value 1', :name2 => 42, :name3 => false })
+      end
+      
+      it "should have header names and values from the hash it was initialized from" do
+        @headers.names.sort.should == [ :name1, :name2, :name3 ]
+        @headers[:name1].should == 'value 1'
+        @headers[:name2].should == '42'
+        @headers[:name3].should == 'false'
+      end
+      
+      it "should include keys and values from a merge, overwriting existing values" do
+        @headers.merge!({ 'name2' => 'frankenberry', :name1 => 'faust', :name4 => 186 })
+        @headers[:name1].should == 'faust'
+        @headers[:name2].should == 'frankenberry'
+        @headers[:name3].should == 'false'
+        @headers[:name4].should == '186'
+      end
+      
+      it "should include keys and values from a reverse merge, only if it did not have those names" do
+        @headers.reverse_merge!(:name1 => 'chicken', :name5 => true, 'name2' => 1066)
+        @headers[:name1].should == 'value 1'
+        @headers[:name2].should == '42'
+        @headers[:name3].should == 'false'
+        @headers[:name5].should == 'true'
+      end
+    end
+    
+    describe "enumerability" do
+      before(:each) do
+        @headers['header 1'] = 'value 1'
+        @headers.append('header 2', 'value 2')
+        @headers.append('header 2', 'value 3')
+        @expected_names = ['header 1', 'header 2', 'header 2']
+        @expected_values = ['value 1', 'value 2', 'value 3']
+        @received_names = []
+        @received_values = []
+        @iteration_result = nil
+      end
+      
+      def iterate_with_arity_one(meth, collection=@headers)
+        @received_names.clear
+        @received_values.clear
+        @iteration_result = collection.__send__(meth) do |kvp|
+          @received_names << kvp.first
+          @received_values << kvp.last
+        end
+      end
+      
+      def iterate_with_arity_two(meth, collection=@headers)
+        @received_names.clear
+        @received_values.clear
+        @iteration_result = collection.__send__(meth) do |k,v|
+          @received_names << k
+          @received_values << v
+        end
+      end
+      
+      it "should be an Enumerable" do
+        @headers.should be_a_kind_of(::Enumerable)
+      end
+
+      it "should iterate with :each, yielding appropriately depending on the arity of the block" do
+        iterate_with_arity_one(:each)
+        @received_names.should == @expected_names
+        @received_values.should == @expected_values
+        @iteration_result.should equal(@headers)
+        
+        iterate_with_arity_two(:each)
+        @received_names.should == @expected_names
+        @received_values.should == @expected_values
+        @iteration_result.should equal(@headers)
+      end
+      
+      it "should yield an Enumerator if :each is called without a block" do
+        enum = @headers.each
+        if RUBY_VERSION >= '1.9'
+          enum.should be_a_kind_of(::Enumerator)
+        else
+          enum.should be_a_kind_of(::Enumerable::Enumerator)
+        end
+      
+        iterate_with_arity_one(:each, enum)
+        @received_names.should == @expected_names
+        @received_values.should == @expected_values
+
+        iterate_with_arity_two(:each, enum)
+        @received_names.should == @expected_names
+        @received_values.should == @expected_values
+      end
+    end
+  end
+end