amq-protocol 2.3.4 → 2.5.0

data/lib/amq/protocol/table_value_decoder.rb

@@ -1,6 +1,6 @@
 # encoding: binary
+# frozen_string_literal: true
 
-require "amq/endianness"
 require "amq/protocol/type_constants"
 require "amq/protocol/float_32bit"
 
@@ -15,15 +15,23 @@ module AMQ
 
       include TypeConstants
 
+      # Pack format strings use explicit endianness (available as of Ruby 1.9.3)
+      PACK_UINT32_BE   = 'N'.freeze
+      PACK_INT64_BE    = 'q>'.freeze
+      PACK_INT16_BE    = 's>'.freeze
+      PACK_UINT64_BE   = 'Q>'.freeze
+      PACK_FLOAT32     = 'f'.freeze  # single precision float (native endian, matches encoder)
+      PACK_FLOAT64     = 'G'.freeze  # big-endian double precision float
+      PACK_UCHAR_UINT32 = 'CN'.freeze
 
       #
       # API
       #
 
       def self.decode_array(data, initial_offset)
-        array_length = data.slice(initial_offset, 4).unpack(PACK_UINT32).first
+        array_length = data.byteslice(initial_offset, 4).unpack1(PACK_UINT32_BE)
 
-        ary    = Array.new
+        ary    = []
         offset = initial_offset + 4
 
         while offset <= (initial_offset + array_length)
@@ -54,25 +62,25 @@ module AMQ
               when TYPE_BOOLEAN
                 v, offset = decode_boolean(data, offset)
                 v
-              when TYPE_BYTE then
+              when TYPE_BYTE
                 v, offset = decode_byte(data, offset)
                 v
-              when TYPE_SIGNED_16BIT then
+              when TYPE_SIGNED_16BIT
                 v, offset = decode_short(data, offset)
                 v
-              when TYPE_SIGNED_64BIT then
+              when TYPE_SIGNED_64BIT
                 v, offset = decode_long(data, offset)
                 v
-              when TYPE_32BIT_FLOAT then
+              when TYPE_32BIT_FLOAT
                 v, offset = decode_32bit_float(data, offset)
                 v
-              when TYPE_64BIT_FLOAT then
+              when TYPE_64BIT_FLOAT
                 v, offset = decode_64bit_float(data, offset)
                 v
               when TYPE_VOID
                 nil
               when TYPE_ARRAY
-                v, offset = TableValueDecoder.decode_array(data, offset)
+                v, offset = decode_array(data, offset)
                 v
               else
                 raise ArgumentError.new("unsupported type in a table value: #{type.inspect}, do not know how to decode!")
@@ -83,113 +91,101 @@ module AMQ
 
 
         [ary, initial_offset + array_length + 4]
-      end # self.decode_array(data, initial_offset)
+      end
 
 
       def self.decode_string(data, offset)
-        length = data.slice(offset, 4).unpack(PACK_UINT32).first
+        length = data.byteslice(offset, 4).unpack1(PACK_UINT32_BE)
         offset += 4
-        v = data.slice(offset, length)
+        v = data.byteslice(offset, length)
         offset += length
 
         [v, offset]
-      end # self.decode_string(data, offset)
+      end
 
 
       def self.decode_integer(data, offset)
-        v = data.slice(offset, 4).unpack(PACK_UINT32).first
+        v = data.byteslice(offset, 4).unpack1(PACK_UINT32_BE)
         offset += 4
 
         [v, offset]
-      end # self.decode_integer(data, offset)
-
+      end
 
-      if AMQ::Endianness.big_endian?
-        def self.decode_long(data, offset)
-          v    = data.slice(offset, 8).unpack(PACK_INT64)
 
-          offset += 8
-          [v, offset]
-        end
-      else
-        def self.decode_long(data, offset)
-          slice = data.slice(offset, 8).bytes.to_a.reverse.map(&:chr).join
-          v     = slice.unpack(PACK_INT64).first
-
-          offset += 8
-          [v, offset]
-        end
+      def self.decode_long(data, offset)
+        v = data.byteslice(offset, 8).unpack1(PACK_INT64_BE)
+        offset += 8
+        [v, offset]
       end
 
 
       def self.decode_big_decimal(data, offset)
-        decimals, raw = data.slice(offset, 5).unpack(PACK_UCHAR_UINT32)
+        decimals, raw = data.byteslice(offset, 5).unpack(PACK_UCHAR_UINT32)
         offset += 5
         v = BigDecimal(raw.to_s) * (BigDecimal(TEN) ** -decimals)
 
         [v, offset]
-      end # self.decode_big_decimal(data, offset)
+      end
 
 
       def self.decode_time(data, offset)
-        timestamp = data.slice(offset, 8).unpack(PACK_UINT64_BE).last
+        timestamp = data.byteslice(offset, 8).unpack1(PACK_UINT64_BE)
         v = Time.at(timestamp)
         offset += 8
 
         [v, offset]
-      end # self.decode_time(data, offset)
+      end
 
 
       def self.decode_boolean(data, offset)
-        integer = data.slice(offset, 2).unpack(PACK_CHAR).first # 0 or 1
+        byte = data.getbyte(offset)
         offset += 1
-        [(integer == 1), offset]
-      end # self.decode_boolean(data, offset)
+        [(byte == 1), offset]
+      end
 
 
       def self.decode_32bit_float(data, offset)
-        v = data.slice(offset, 4).unpack(PACK_32BIT_FLOAT).first
+        v = data.byteslice(offset, 4).unpack1(PACK_FLOAT32)
         offset += 4
 
         [v, offset]
-      end # self.decode_32bit_float(data, offset)
+      end
 
 
       def self.decode_64bit_float(data, offset)
-        v = data.slice(offset, 8).unpack(PACK_64BIT_FLOAT).first
+        v = data.byteslice(offset, 8).unpack1(PACK_FLOAT64)
         offset += 8
 
         [v, offset]
-      end # self.decode_64bit_float(data, offset)
+      end
 
 
       def self.decode_value_type(data, offset)
-        [data.slice(offset, 1), offset + 1]
-      end # self.decode_value_type(data, offset)
-
+        [data.byteslice(offset, 1), offset + 1]
+      end
 
 
       def self.decode_hash(data, offset)
-        length = data.slice(offset, 4).unpack(PACK_UINT32).first
-        v = Table.decode(data.slice(offset, length + 4))
+        length = data.byteslice(offset, 4).unpack1(PACK_UINT32_BE)
+        v = Table.decode(data.byteslice(offset, length + 4))
         offset += 4 + length
 
         [v, offset]
-      end # self.decode_hash(data, offset)
+      end
 
 
       # Decodes/Converts a byte value from the data at the provided offset.
       #
-      # @param [Array] data - A big-endian ordered array of bytes.
-      # @param [Fixnum] offset - The offset which bytes the byte is consumed.
-      # @return [Array] - The Fixnum value and new offset pair.
+      # @param [String] data - Binary data string
+      # @param [Integer] offset - The offset from which to read the byte
+      # @return [Array] - The Integer value and new offset pair
       def self.decode_byte(data, offset)
-        [data.slice(offset, 1).unpack(PACK_CHAR).first, offset += 1]
+        [data.getbyte(offset), offset + 1]
       end
 
 
       def self.decode_short(data, offset)
-        v = AMQ::Hacks.unpack_int16_big_endian(data.slice(offset, 2)).first
+        v = data.byteslice(offset, 2).unpack1(PACK_INT16_BE)
         offset += 2
         [v, offset]
       end

data/lib/amq/protocol/table_value_encoder.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 require "amq/protocol/type_constants"
 require "date"

data/lib/amq/protocol/type_constants.rb

@@ -1,4 +1,5 @@
 # encoding: binary
+# frozen_string_literal: true
 
 module AMQ
   module Protocol

data/lib/amq/protocol/version.rb

@@ -1,5 +1,5 @@
 module AMQ
   module Protocol
-    VERSION = "2.3.4"
+    VERSION = "2.5.0"
   end # Protocol
 end # AMQ

data/lib/amq/settings.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require "amq/protocol/client"
 require "amq/uri"

data/spec/amq/bit_set_spec.rb

@@ -223,5 +223,27 @@ RSpec.describe AMQ::BitSet do
       subject.unset(254)
       expect(subject.get(254)).to be_falsey
     end # it
+
+    it "returns -1 when all bits are set" do
+      bs = described_class.new(64)
+      0.upto(63) { |i| bs.set(i) }
+      expect(bs.next_clear_bit).to eq(-1)
+    end
+  end # describe
+
+  describe "#to_s" do
+    it "returns a string representation of the bit set" do
+      bs = described_class.new(64)
+      result = bs.to_s
+      expect(result).to be_a(String)
+      expect(result).to include(":")
+    end
+
+    it "shows set bits" do
+      bs = described_class.new(64)
+      bs.set(0)
+      result = bs.to_s
+      expect(result).to end_with("1:")
+    end
   end # describe
 end

data/spec/amq/endianness_spec.rb

@@ -0,0 +1,23 @@
+# encoding: binary
+
+require "amq/endianness"
+
+RSpec.describe AMQ::Endianness do
+  describe ".big_endian?" do
+    it "returns a boolean" do
+      expect([true, false]).to include(described_class.big_endian?)
+    end
+  end
+
+  describe ".little_endian?" do
+    it "returns the opposite of big_endian?" do
+      expect(described_class.little_endian?).to eq(!described_class.big_endian?)
+    end
+  end
+
+  describe "BIG_ENDIAN constant" do
+    it "is a boolean" do
+      expect([true, false]).to include(AMQ::Endianness::BIG_ENDIAN)
+    end
+  end
+end

data/spec/amq/int_allocator_spec.rb

@@ -11,13 +11,17 @@ RSpec.describe AMQ::IntAllocator do
   end
 
 
-  # ...
-
-
   #
   # Examples
   #
 
+  describe "#initialize" do
+    it "raises ArgumentError when hi <= lo" do
+      expect { described_class.new(5, 5) }.to raise_error(ArgumentError)
+      expect { described_class.new(10, 5) }.to raise_error(ArgumentError)
+    end
+  end
+
   describe "#number_of_bits" do
     it "returns number of bits available for allocation" do
       expect(subject.number_of_bits).to eq(4)
@@ -110,4 +114,23 @@ RSpec.describe AMQ::IntAllocator do
       end
     end
   end
+
+  describe "#release" do
+    it "is an alias for #free" do
+      subject.allocate
+      expect(subject.allocated?(1)).to be_truthy
+      subject.release(1)
+      expect(subject.allocated?(1)).to be_falsey
+    end
+  end
+
+  describe "#reset" do
+    it "releases all allocations" do
+      4.times { subject.allocate }
+      expect(subject.allocate).to eq(-1)
+
+      subject.reset
+      expect(subject.allocate).to eq(1)
+    end
+  end
 end

data/spec/amq/pack_spec.rb

@@ -4,10 +4,18 @@ RSpec.describe AMQ::Pack do
   context "16-bit big-endian packing / unpacking" do
     let(:examples_16bit) {
       {
-          0x068D => "\x06\x8D" # 1677
+        0x068D => "\x06\x8D",  # 1677
+        0x0000 => "\x00\x00",  # 0
+        0x7FFF => "\x7F\xFF"   # 32767 (max positive signed 16-bit)
       }
     }
 
+    it "packs signed integers into a big-endian string" do
+      examples_16bit.each do |key, value|
+        expect(described_class.pack_int16_big_endian(key)).to eq(value)
+      end
+    end
+
     it "unpacks signed integers from a string to a number" do
       examples_16bit.each do |key, value|
         expect(described_class.unpack_int16_big_endian(value)[0]).to eq(key)
@@ -35,34 +43,16 @@ RSpec.describe AMQ::Pack do
       end
     end
 
-    it "should unpack string representation into integer" do
+    it "unpacks string representation into integer" do
       examples.each do |key, value|
         expect(described_class.unpack_uint64_big_endian(value)[0]).to eq(key)
       end
     end
+  end
 
-    if RUBY_VERSION < '1.9'
-      describe "with utf encoding" do
-        before do
-          $KCODE = 'u'
-        end
-
-        after do
-          $KCODE = 'NONE'
-        end
-
-        it "packs integers into big-endian string" do
-          examples.each do |key, value|
-            expect(described_class.pack_uint64_big_endian(key)).to eq(value)
-          end
-        end
-
-        it "should unpack string representation into integer" do
-          examples.each do |key, value|
-            expect(described_class.unpack_uint64_big_endian(value)[0]).to eq(key)
-          end
-        end
-      end
+  describe "AMQ::Hacks alias" do
+    it "is an alias for AMQ::Pack (backwards compatibility)" do
+      expect(AMQ::Hacks).to eq(AMQ::Pack)
     end
   end
 end

data/spec/amq/protocol/exceptions_spec.rb

@@ -0,0 +1,70 @@
+# encoding: binary
+
+RSpec.describe AMQ::Protocol::Error do
+  describe ".[]" do
+    it "looks up exception class by error code" do
+      # This only works if subclasses define VALUE constant
+      # Default case: no subclass with VALUE defined returns nil
+      expect { described_class[999999] }.to raise_error(/No such exception class/)
+    end
+  end
+
+  describe ".subclasses_with_values" do
+    it "returns subclasses that define VALUE constant" do
+      result = described_class.subclasses_with_values
+      expect(result).to be_an(Array)
+    end
+  end
+
+  describe "#initialize" do
+    it "uses default message when none provided" do
+      error = described_class.new
+      expect(error.message).to eq("AMQP error")
+    end
+
+    it "uses custom message when provided" do
+      error = described_class.new("Custom error")
+      expect(error.message).to eq("Custom error")
+    end
+  end
+end
+
+RSpec.describe AMQ::Protocol::FrameTypeError do
+  it "formats message with valid types" do
+    error = described_class.new([:method, :headers])
+    expect(error.message).to include("[:method, :headers]")
+  end
+end
+
+RSpec.describe AMQ::Protocol::EmptyResponseError do
+  it "has a default message" do
+    error = described_class.new
+    expect(error.message).to eq("Empty response received from the server.")
+  end
+
+  it "accepts custom message" do
+    error = described_class.new("Custom empty response")
+    expect(error.message).to eq("Custom empty response")
+  end
+end
+
+RSpec.describe AMQ::Protocol::BadResponseError do
+  it "formats message with argument, expected, and actual values" do
+    error = described_class.new("channel", 1, 2)
+    expect(error.message).to include("channel")
+    expect(error.message).to include("1")
+    expect(error.message).to include("2")
+  end
+end
+
+RSpec.describe AMQ::Protocol::SoftError do
+  it "is a subclass of Protocol::Error" do
+    expect(described_class.superclass).to eq(AMQ::Protocol::Error)
+  end
+end
+
+RSpec.describe AMQ::Protocol::HardError do
+  it "is a subclass of Protocol::Error" do
+    expect(described_class.superclass).to eq(AMQ::Protocol::Error)
+  end
+end

data/spec/amq/protocol/float_32bit_spec.rb

@@ -0,0 +1,27 @@
+# encoding: binary
+
+RSpec.describe AMQ::Protocol::Float32Bit do
+  describe "#initialize" do
+    it "stores the value" do
+      f = described_class.new(3.14)
+      expect(f.value).to eq(3.14)
+    end
+  end
+
+  describe "#value" do
+    it "returns the stored value" do
+      f = described_class.new(2.718)
+      expect(f.value).to eq(2.718)
+    end
+
+    it "works with zero" do
+      f = described_class.new(0.0)
+      expect(f.value).to eq(0.0)
+    end
+
+    it "works with negative values" do
+      f = described_class.new(-1.5)
+      expect(f.value).to eq(-1.5)
+    end
+  end
+end

data/spec/amq/protocol/frame_spec.rb

@@ -86,6 +86,70 @@ module AMQ
           expect(subject.properties[:delivery_mode]).to eq(2)
           expect(subject.properties[:priority]).to eq(0)
         end
+
+        it "is not final" do
+          expect(subject.final?).to eq(false)
+        end
+      end
+
+      describe BodyFrame do
+        subject { BodyFrame.new("test payload", 1) }
+
+        it "returns payload as decode_payload" do
+          expect(subject.decode_payload).to eq("test payload")
+        end
+
+        it "is not final" do
+          expect(subject.final?).to eq(false)
+        end
+
+        it "has correct size" do
+          expect(subject.size).to eq(12)
+        end
+      end
+
+      describe HeartbeatFrame do
+        it "encodes with empty payload on channel 0" do
+          encoded = HeartbeatFrame.encode
+          expect(encoded.bytes.last).to eq(0xCE)
+        end
+
+        it "is final" do
+          frame = HeartbeatFrame.new("", 0)
+          expect(frame.final?).to eq(true)
+        end
+      end
+
+      describe MethodFrame do
+        it "is not final when method has content" do
+          # Basic.Publish has content
+          payload = "\x00\x3C\x00\x28\x00\x00\x00\x00\x00"
+          frame = MethodFrame.new(payload, 1)
+          # This will depend on the method class
+          expect(frame).to respond_to(:final?)
+        end
+      end
+
+      describe FrameSubclass do
+        subject { BodyFrame.new("test", 1) }
+
+        it "has channel accessor" do
+          expect(subject.channel).to eq(1)
+          subject.channel = 2
+          expect(subject.channel).to eq(2)
+        end
+
+        it "encodes to array" do
+          result = subject.encode_to_array
+          expect(result).to be_an(Array)
+          expect(result.size).to eq(3)
+        end
+
+        it "encodes to string" do
+          result = subject.encode
+          expect(result).to be_a(String)
+          expect(result.bytes.last).to eq(0xCE)
+        end
       end
     end
   end

data/spec/amq/protocol/table_spec.rb

@@ -254,6 +254,38 @@ module AMQ
         end
 
       end # describe
+
+      describe ".length" do
+        it "returns the table length from binary data" do
+          encoded = Table.encode({"test" => 1})
+          expect(Table.length(encoded)).to eq(14)
+        end
+
+        it "returns 0 for empty table" do
+          encoded = Table.encode({})
+          expect(Table.length(encoded)).to eq(0)
+        end
+      end
+
+      describe ".hash_size" do
+        it "calculates size for simple hash" do
+          size = Table.hash_size({"key" => "value"})
+          expect(size).to be > 0
+        end
+
+        it "returns 0 for empty hash" do
+          size = Table.hash_size({})
+          expect(size).to eq(0)
+        end
+      end
+
+      describe "Table::InvalidTableError" do
+        it "formats error message with key and value" do
+          error = Table::InvalidTableError.new("mykey", Object.new)
+          expect(error.message).to include("mykey")
+          expect(error.message).to include("Object")
+        end
+      end
     end
   end
 end