Improve spec coverage for table decoding and frame handling

Author: eglitobias

spec/amq/protocol/frame_spec.rb

@@ -55,6 +55,17 @@ module Protocol
         it "should raise FrameTypeError if the type is not one of the accepted" do
           expect { Frame.new(10) }.to raise_error(FrameTypeError)
         end
+
+        it "returns the correct subclass for a valid type" do
+          frame = Frame.new(:body, "test", 1)
+          expect(frame).to be_a(BodyFrame)
+        end
+      end
+
+      describe ".decode" do
+        it "raises NotImplementedError" do
+          expect { Frame.decode("anything") }.to raise_error(NotImplementedError)
+        end
       end
 
       describe '#decode_header' do
@@ -65,6 +76,14 @@ module Protocol
         it 'raises EmptyResponseError if the header is nil' do
           expect { Frame.decode_header(nil) }.to raise_error(EmptyResponseError)
         end
+
+        it "returns type, channel and size for a valid header" do
+          header = "\x03\x00\x01\x00\x00\x00\x04"
+          type, channel, size = Frame.decode_header(header)
+          expect(type).to eq(:body)
+          expect(channel).to eq(1)
+          expect(size).to eq(4)
+        end
       end
 
       describe HeaderFrame do
@@ -121,12 +140,14 @@ module Protocol
       end
 
       describe MethodFrame do
+        subject { MethodFrame.new("\x00\x3C\x00\x28\x00\x00\x00\x00\x00", 1) }
+
+        it "resolves method_class from payload" do
+          expect(subject.method_class).to eq(AMQ::Protocol::Basic::Publish)
+        end
+
         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?)
+          expect(subject.final?).to eq(false)
         end
       end
 

spec/amq/protocol/table_spec.rb

@@ -188,6 +188,35 @@ module Protocol
           expect(output).to eq(1677)
         end
 
+        it "decodes TYPE_INTEGER (32-bit unsigned) from raw binary" do
+          # "\x03key" = 1-byte key length + "key", then 'I' type + 4-byte uint32
+          binary = [9].pack("N") + "\x03keyI" + [42].pack("N")
+          expect(Table.decode(binary.force_encoding("BINARY"))).to eq("key" => 42)
+        end
+
+        it "decodes TYPE_BYTE from raw binary" do
+          # "\x01k" = 1-byte key length + "k", then 'b' type + 1-byte value
+          binary = [4].pack("N") + "\x01kb\xFF"
+          expect(Table.decode(binary.force_encoding("BINARY"))).to eq("k" => 255)
+        end
+
+        it "decodes TYPE_SIGNED_16BIT from raw binary" do
+          binary = [5].pack("N") + "\x01ks" + [1000].pack("s>")
+          expect(Table.decode(binary.force_encoding("BINARY"))).to eq("k" => 1000)
+        end
+
+        it "decodes TYPE_32BIT_FLOAT from raw binary" do
+          binary = [7].pack("N") + "\x01kf" + [1.5].pack("f")
+          result = Table.decode(binary.force_encoding("BINARY"))
+          expect(result["k"]).to be_within(0.001).of(1.5)
+        end
+
+        it "raises ArgumentError for unknown type bytes" do
+          # "\x03key" key + unknown type '?'
+          binary = [5].pack("N") + "\x03key?"
+          expect { Table.decode(binary.force_encoding("BINARY")) }.to raise_error(ArgumentError, /Not a valid type/)
+        end
+
         it "is capable of decoding tables" do
           input   = {
             "boolval"      => true,

spec/amq/protocol/value_decoder_spec.rb

@@ -178,6 +178,77 @@ module Protocol
           expect(value).to eq({"nested" => "value"})
         end
       end
+
+      describe ".decode_array type dispatch" do
+        # Builds binary for decode_array(data, 1):
+        # byte 0 = dummy (TYPE_ARRAY tag), bytes 1-4 = content length, bytes 5+ = elements.
+        def array_binary(element_bytes)
+          "\x00" + [element_bytes.bytesize].pack("N") + element_bytes
+        end
+
+        it "decodes TYPE_INTEGER (32-bit unsigned)" do
+          data = array_binary("I" + [99].pack("N"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to eq([99])
+        end
+
+        it "decodes TYPE_DECIMAL" do
+          data = array_binary("D" + "\x02" + [314].pack("N"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result.first).to be_a(BigDecimal)
+          expect(result.first).to eq(BigDecimal("3.14"))
+        end
+
+        it "decodes TYPE_TIME" do
+          ts = 1_700_000_000
+          data = array_binary("T" + [ts].pack("Q>"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result.first.to_i).to eq(ts)
+        end
+
+        it "decodes TYPE_BYTE_ARRAY" do
+          data = array_binary("x" + [3].pack("N") + "foo")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to eq(["foo"])
+        end
+
+        it "decodes TYPE_32BIT_FLOAT" do
+          data = array_binary("f" + [1.5].pack("f"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result.first).to be_within(0.001).of(1.5)
+        end
+
+        it "decodes TYPE_BOOLEAN" do
+          # Two booleans make content length 4, enough for the loop to enter once
+          data = array_binary("t\x01t\x00")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(true)
+        end
+
+        it "decodes TYPE_BYTE" do
+          data = array_binary("b\xFFb\x01")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(255)
+        end
+
+        it "decodes TYPE_SIGNED_16BIT" do
+          data = array_binary("s" + [1000].pack("s>") + "s" + [2000].pack("s>"))
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(1000)
+        end
+
+        it "decodes TYPE_VOID as nil" do
+          data = array_binary("VVVV")
+          result, _ = described_class.decode_array(data, 1)
+          expect(result).to include(nil)
+        end
+
+        it "raises ArgumentError for unsupported types" do
+          data = array_binary("?\x00\x00\x00")
+          expect { described_class.decode_array(data, 1) }
+            .to raise_error(ArgumentError, /unsupported type/)
+        end
+      end
     end
   end
 end