amq-protocol 2.5.0 → 2.5.1

data/spec/amq/protocol/exceptions_spec.rb

@@ -1,70 +0,0 @@
-# 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/exchange_spec.rb

@@ -1,106 +0,0 @@
-# encoding: binary
-
-module AMQ
-  module Protocol
-    class Exchange
-      RSpec.describe Declare do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            exchange = 'amqclient.adapters.em.exchange1'
-            type = 'fanout'
-            passive = false
-            durable = false
-            auto_delete = false
-            internal = false
-            nowait = false
-            arguments = nil
-            method_frame = Declare.encode(channel, exchange, type, passive, durable, auto_delete, internal, nowait, arguments)
-            expect(method_frame.payload).to eq("\x00(\x00\n\x00\x00\x1Famqclient.adapters.em.exchange1\x06fanout\x00\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe Declare, "encoded with a symbol name" do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            exchange = :exchange2
-            type = 'fanout'
-            passive = false
-            durable = false
-            auto_delete = false
-            internal = false
-            nowait = false
-            arguments = nil
-            method_frame = Declare.encode(channel, exchange, type, passive, durable, auto_delete, internal, nowait, arguments)
-            expect(method_frame.payload).to eq("\x00(\x00\n\x00\x00\texchange2\x06fanout\x00\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe Delete do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            exchange = 'amqclient.adapters.em.exchange'
-            if_unused = false
-            nowait = false
-            method_frame = Delete.encode(channel, exchange, if_unused, nowait)
-            expect(method_frame.payload).to eq("\x00(\x00\x14\x00\x00\x1Eamqclient.adapters.em.exchange\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe DeleteOk do
-      #   describe '.decode' do
-      #   end
-      # end
-
-      RSpec.describe Bind do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            destination = 'foo'
-            source = 'bar'
-            routing_key = 'xyz'
-            nowait = false
-            arguments = nil
-            method_frame = Bind.encode(channel, destination, source, routing_key, nowait, arguments)
-            expect(method_frame.payload).to eq("\x00(\x00\x1E\x00\x00\x03foo\x03bar\x03xyz\x00\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe BindOk do
-      #   describe '.decode' do
-      #   end
-      # end
-
-      RSpec.describe Unbind do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            destination = 'foo'
-            source = 'bar'
-            routing_key = 'xyz'
-            nowait = false
-            arguments = nil
-            method_frame = Unbind.encode(channel, destination, source, routing_key, nowait, arguments)
-            expect(method_frame.payload).to eq("\x00(\x00(\x00\x00\x03foo\x03bar\x03xyz\x00\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe UnbindOk do
-      #   describe '.decode' do
-      #   end
-      # end
-    end
-  end
-end

data/spec/amq/protocol/float_32bit_spec.rb

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

@@ -1,156 +0,0 @@
-module AMQ
-  module Protocol
-    RSpec.describe Frame do
-      describe ".encode" do
-        it "should raise FrameTypeError if type isn't one of: [:method, :header, :body, :heartbeat]" do
-          expect { Frame.encode(nil, "", 0) }.to raise_error(FrameTypeError)
-        end
-
-        it "should raise FrameTypeError if type isn't valid (when type is a symbol)" do
-          expect { Frame.encode(:xyz, "test", 12) }.to raise_error(FrameTypeError)
-        end
-
-        it "should raise FrameTypeError if type isn't valid (when type is a number)" do
-          expect { Frame.encode(16, "test", 12) }.to raise_error(FrameTypeError)
-        end
-
-        it "should raise RuntimeError if channel isn't 0 or an integer in range 1..65535" do
-          expect { Frame.encode(:method, "", -1) }.to raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
-          expect { Frame.encode(:method, "", 65536) }.to raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
-          expect { Frame.encode(:method, "", 65535) }.not_to raise_error
-          expect { Frame.encode(:method, "", 0) }.not_to raise_error
-          expect { Frame.encode(:method, "", 1) }.not_to raise_error
-        end
-
-        it "should raise RuntimeError if payload is nil" do
-          expect { Frame.encode(:method, nil, 0) }.to raise_error(RuntimeError, "Payload can't be nil")
-        end
-
-        it "should encode type" do
-          expect(Frame.encode(:body, "", 0).unpack("c").first).to eql(3)
-        end
-
-        it "should encode channel" do
-          expect(Frame.encode(:body, "", 12).unpack("cn").last).to eql(12)
-        end
-
-        it "should encode size" do
-          expect(Frame.encode(:body, "test", 12).unpack("cnN").last).to eql(4)
-        end
-
-        it "should include payload" do
-          expect(Frame.encode(:body, "test", 12)[7..-2]).to eql("test")
-        end
-
-        it "should include final octet" do
-          expect(Frame.encode(:body, "test", 12).each_byte.to_a.last).to eq("CE".hex)
-        end
-
-        it "should encode unicode strings" do
-          expect { Frame.encode(:body, "à bientôt!", 12) }.to_not raise_error
-        end
-      end
-
-      describe ".new" do
-        it "should raise FrameTypeError if the type is not one of the accepted" do
-          expect { Frame.new(10) }.to raise_error(FrameTypeError)
-        end
-      end
-
-      describe '#decode_header' do
-        it 'raises FrameTypeError if the decoded type is not one of the accepted' do
-          expect { Frame.decode_header("\n\x00\x01\x00\x00\x00\x05") }.to raise_error(FrameTypeError)
-        end
-
-        it 'raises EmptyResponseError if the header is nil' do
-          expect { Frame.decode_header(nil) }.to raise_error(EmptyResponseError)
-        end
-      end
-
-      describe HeaderFrame do
-        subject { HeaderFrame.new("\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x98\x00\x18application/octet-stream\x02\x00", nil) }
-
-        it "should decode body_size from payload" do
-          expect(subject.body_size).to eq(10)
-        end
-
-        it "should decode klass_id from payload" do
-          expect(subject.klass_id).to eq(60)
-        end
-
-        it "should decode weight from payload" do
-          expect(subject.weight).to eq(0)
-        end
-
-        it "should decode properties from payload" do
-          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
-end

data/spec/amq/protocol/method_spec.rb

@@ -1,43 +0,0 @@
-module AMQ
-  module Protocol
-    RSpec.describe Method do
-      describe '.split_headers' do
-        it 'splits user defined headers into properties and headers' do
-          input = {:delivery_mode => 2, :content_type => 'application/octet-stream', :foo => 'bar'}
-          properties, headers = Method.split_headers(input)
-          expect(properties).to eq({:delivery_mode => 2, :content_type => 'application/octet-stream'})
-          expect(headers).to eq({:foo => 'bar'})
-        end
-      end
-
-      describe '.encode_body' do
-        context 'when the body fits in a single frame' do
-          it 'encodes a body into a BodyFrame' do
-            body_frames = Method.encode_body('Hello world', 1, 131072)
-            expect(body_frames.first.payload).to eq('Hello world')
-            expect(body_frames.first.channel).to eq(1)
-            expect(body_frames.size).to eq(1)
-          end
-        end
-
-        context 'when the body is too big to fit in a single frame' do
-          it 'encodes a body into a list of BodyFrames that each fit within the frame size' do
-            lipsum = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'
-            frame_size = 100
-            expected_payload_size = 92
-            body_frames = Method.encode_body(lipsum, 1, frame_size)
-            expect(body_frames.map(&:payload)).to eq(lipsum.split('').each_slice(expected_payload_size).map(&:join))
-          end
-        end
-
-        context 'when the body fits perfectly in a single frame' do
-          it 'encodes a body into a single BodyFrame' do
-            body_frames = Method.encode_body('*' * 131064, 1, 131072)
-            expect(body_frames.first.payload).to eq('*' * 131064)
-            expect(body_frames.size).to eq(1)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/amq/protocol/queue_spec.rb

@@ -1,126 +0,0 @@
-# encoding: binary
-
-module AMQ
-  module Protocol
-    class Queue
-      RSpec.describe Declare do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            queue = 'hello.world'
-            passive = false
-            durable = true
-            exclusive = true
-            auto_delete = true
-            nowait = false
-            arguments = nil
-            method_frame = Declare.encode(channel, queue, passive, durable, exclusive, auto_delete, nowait, arguments)
-            expect(method_frame.payload).to eq("\x002\x00\n\x00\x00\vhello.world\x0E\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe DeclareOk do
-        describe '.decode' do
-          subject do
-            DeclareOk.decode(" amq.gen-KduGSqQrpeUo1otnU0TWSA==\x00\x00\x00\x00\x00\x00\x00\x00")
-          end
-
-          its(:queue) { should eq('amq.gen-KduGSqQrpeUo1otnU0TWSA==') }
-          its(:message_count) { should eq(0) }
-          its(:consumer_count) { should eq(0) }
-        end
-      end
-
-      RSpec.describe Bind do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            queue = 'hello.world'
-            exchange = 'foo.bar'
-            routing_key = 'xyz'
-            nowait = false
-            arguments = nil
-            method_frame = Bind.encode(channel, queue, exchange, routing_key, nowait, arguments)
-            expect(method_frame.payload).to eq("\x002\x00\x14\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe BindOk do
-      #   describe '.decode' do
-      #   end
-      # end
-
-      RSpec.describe Purge do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            queue = 'hello.world'
-            nowait = false
-            method_frame = Purge.encode(channel, queue, nowait)
-            expect(method_frame.payload).to eq("\x002\x00\x1E\x00\x00\vhello.world\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe PurgeOk do
-        describe '.decode' do
-          subject do
-            PurgeOk.decode("\x00\x00\x00\x02")
-          end
-
-          its(:message_count) { should eq(2) }
-        end
-      end
-
-      RSpec.describe Delete do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            queue = 'hello.world'
-            if_unused = false
-            if_empty = false
-            nowait = false
-            method_frame = Delete.encode(channel, queue, if_unused, if_empty, nowait)
-            expect(method_frame.payload).to eq("\x002\x00(\x00\x00\vhello.world\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe DeleteOk do
-        describe '.decode' do
-          subject do
-            DeleteOk.decode("\x00\x00\x00\x02")
-          end
-
-          its(:message_count) { should eq(2) }
-        end
-      end
-
-      RSpec.describe Unbind do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            queue = 'hello.world'
-            exchange = 'foo.bar'
-            routing_key = 'xyz'
-            arguments = nil
-            method_frame = Unbind.encode(channel, queue, exchange, routing_key, arguments)
-            expect(method_frame.payload).to eq("\x002\x002\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe UnbindOk do
-      #   describe '.decode' do
-      #   end
-      # end
-    end
-  end
-end