amq-protocol 2.3.4 → 2.4.0

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

data/spec/amq/protocol/value_decoder_spec.rb

@@ -81,6 +81,103 @@ module AMQ
           end
         end
       end
+
+      describe ".decode_string" do
+        it "decodes string values" do
+          # 4 bytes length + string content
+          data = "\x00\x00\x00\x05hello"
+          value, offset = described_class.decode_string(data, 0)
+          expect(value).to eq("hello")
+          expect(offset).to eq(9)
+        end
+      end
+
+      describe ".decode_integer" do
+        it "decodes 32-bit unsigned integers" do
+          data = "\x00\x00\x00\x0A"
+          value, offset = described_class.decode_integer(data, 0)
+          expect(value).to eq(10)
+          expect(offset).to eq(4)
+        end
+      end
+
+      describe ".decode_long" do
+        it "decodes 64-bit signed integers" do
+          data = "\x00\x00\x00\x00\x00\x00\x00\x0A"
+          value, offset = described_class.decode_long(data, 0)
+          expect(value).to eq(10)
+          expect(offset).to eq(8)
+        end
+      end
+
+      describe ".decode_time" do
+        it "decodes timestamp values" do
+          timestamp = Time.now.to_i
+          data = [timestamp].pack('Q>')
+          value, offset = described_class.decode_time(data, 0)
+          expect(value.to_i).to eq(timestamp)
+          expect(offset).to eq(8)
+        end
+      end
+
+      describe ".decode_boolean" do
+        it "decodes true" do
+          value, offset = described_class.decode_boolean("\x01", 0)
+          expect(value).to eq(true)
+          expect(offset).to eq(1)
+        end
+
+        it "decodes false" do
+          value, offset = described_class.decode_boolean("\x00", 0)
+          expect(value).to eq(false)
+          expect(offset).to eq(1)
+        end
+      end
+
+      describe ".decode_64bit_float" do
+        it "decodes 64-bit floats" do
+          data = [3.14159].pack('G')
+          value, offset = described_class.decode_64bit_float(data, 0)
+          expect(value).to be_within(0.00001).of(3.14159)
+          expect(offset).to eq(8)
+        end
+      end
+
+      describe ".decode_value_type" do
+        it "returns the type byte and incremented offset" do
+          data = "Shello"
+          type, offset = described_class.decode_value_type(data, 0)
+          expect(type).to eq("S")
+          expect(offset).to eq(1)
+        end
+      end
+
+      describe ".decode_short" do
+        it "decodes 16-bit signed integers" do
+          data = "\x06\x8D"
+          value, offset = described_class.decode_short(data, 0)
+          expect(value).to eq(1677)
+          expect(offset).to eq(2)
+        end
+      end
+
+      describe ".decode_big_decimal" do
+        it "decodes BigDecimal values" do
+          # Scale 2, raw value 100 = 1.00
+          data = "\x02\x00\x00\x00\x64"
+          value, offset = described_class.decode_big_decimal(data, 0)
+          expect(value).to be_a(BigDecimal)
+          expect(offset).to eq(5)
+        end
+      end
+
+      describe ".decode_hash" do
+        it "decodes nested hash values" do
+          encoded = AMQ::Protocol::Table.encode({"nested" => "value"})
+          value, _offset = described_class.decode_hash(encoded, 0)
+          expect(value).to eq({"nested" => "value"})
+        end
+      end
     end
   end
 end

data/spec/amq/protocol/value_encoder_spec.rb

@@ -134,6 +134,27 @@ module AMQ
         expect(described_class.encode(input4).bytesize).to eq(69)
       end
 
+      it "encodes symbols as strings" do
+        encoded = described_class.encode(:test_symbol)
+        expect(encoded).to start_with("S")
+        expect(encoded).to include("test_symbol")
+      end
+
+      it "encodes BigDecimal values" do
+        bd = BigDecimal("123.45")
+        encoded = described_class.encode(bd)
+        expect(encoded).to start_with("D")
+      end
+
+      it "encodes BigDecimal with zero exponent" do
+        bd = BigDecimal("100")
+        encoded = described_class.encode(bd)
+        expect(encoded).to start_with("D")
+      end
+
+      it "raises ArgumentError for unsupported types" do
+        expect { described_class.encode(Object.new) }.to raise_error(ArgumentError)
+      end
 
     end # TableValueEncoder
   end # Protocol

data/spec/amq/settings_spec.rb

@@ -6,9 +6,18 @@ RSpec.describe AMQ::Settings do
       expect(AMQ::Settings.default).to_not be_nil
       expect(AMQ::Settings.default[:host]).to_not be_nil
     end
+
+    it "includes default port" do
+      expect(AMQ::Settings.default[:port]).to eq(5672)
+    end
+
+    it "includes default credentials" do
+      expect(AMQ::Settings.default[:user]).to eq("guest")
+      expect(AMQ::Settings.default[:pass]).to eq("guest")
+    end
   end
 
-  describe ".configure(&block)" do
+  describe ".configure" do
     it "should merge custom settings with default settings" do
       settings = AMQ::Settings.configure(:host => "tagadab")
       expect(settings[:host]).to eql("tagadab")
@@ -18,5 +27,32 @@ RSpec.describe AMQ::Settings do
       settings = AMQ::Settings.configure("amqp://tagadab")
       expect(settings[:host]).to eql("tagadab")
     end
+
+    it "returns default when passed nil" do
+      settings = AMQ::Settings.configure(nil)
+      expect(settings).to eq(AMQ::Settings.default)
+    end
+
+    it "normalizes username to user" do
+      settings = AMQ::Settings.configure(:username => "admin")
+      expect(settings[:user]).to eq("admin")
+    end
+
+    it "normalizes password to pass" do
+      settings = AMQ::Settings.configure(:password => "secret")
+      expect(settings[:pass]).to eq("secret")
+    end
+
+    it "prefers user over username when both provided" do
+      settings = AMQ::Settings.configure(:user => "admin", :username => "other")
+      expect(settings[:user]).to eq("admin")
+    end
+  end
+
+  describe ".parse_amqp_url" do
+    it "delegates to AMQ::URI.parse" do
+      result = AMQ::Settings.parse_amqp_url("amqp://localhost")
+      expect(result[:host]).to eq("localhost")
+    end
   end
 end

data/spec/amq/uri_parsing_spec.rb

@@ -277,4 +277,11 @@ RSpec.describe AMQ::URI do
       end
     end
   end
+
+  describe ".parse_amqp_url" do
+    it "is an alias for .parse" do
+      result = described_class.parse_amqp_url("amqp://localhost")
+      expect(result[:host]).to eq("localhost")
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amq-protocol
 version: !ruby/object:Gem::Version
-  version: 2.3.4
+  version: 2.4.0
 platform: ruby
 authors:
 - Jakub Stastny
@@ -10,7 +10,7 @@ authors:
 - Mark Abramov
 bindir: bin
 cert_chain: []
-date: 2025-05-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |2
     amq-protocol is an AMQP 0.9.1 serialization library for Ruby. It is not a
@@ -34,9 +34,14 @@ files:
 - README.md
 - Rakefile
 - amq-protocol.gemspec
+- benchmarks/frame_encoding.rb
 - benchmarks/int_allocator.rb
+- benchmarks/method_encoding.rb
+- benchmarks/pack_unpack.rb
 - benchmarks/pure/body_framing_with_256k_payload.rb
 - benchmarks/pure/body_framing_with_2k_payload.rb
+- benchmarks/run_all.rb
+- benchmarks/table_encoding.rb
 - codegen/__init__.py
 - codegen/amqp_0.9.1_changes.json
 - codegen/codegen.py
@@ -63,6 +68,7 @@ files:
 - profiling/README.md
 - profiling/stackprof/body_framing_with_2k_payload.rb
 - spec/amq/bit_set_spec.rb
+- spec/amq/endianness_spec.rb
 - spec/amq/int_allocator_spec.rb
 - spec/amq/pack_spec.rb
 - spec/amq/protocol/basic_spec.rb
@@ -71,7 +77,9 @@ files:
 - spec/amq/protocol/confirm_spec.rb
 - spec/amq/protocol/connection_spec.rb
 - spec/amq/protocol/constants_spec.rb
+- spec/amq/protocol/exceptions_spec.rb
 - spec/amq/protocol/exchange_spec.rb
+- spec/amq/protocol/float_32bit_spec.rb
 - spec/amq/protocol/frame_spec.rb
 - spec/amq/protocol/method_spec.rb
 - spec/amq/protocol/queue_spec.rb
@@ -101,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: AMQP 0.9.1 encoding & decoding library.
 test_files: []