amq-protocol 2.3.3 → 2.8.0

data/spec/amq/int_allocator_spec.rb

@@ -1,113 +0,0 @@
-require "amq/int_allocator"
-
-RSpec.describe AMQ::IntAllocator do
-
-  #
-  # Environment
-  #
-
-  subject do
-    described_class.new(1, 5)
-  end
-
-
-  # ...
-
-
-  #
-  # Examples
-  #
-
-  describe "#number_of_bits" do
-    it "returns number of bits available for allocation" do
-      expect(subject.number_of_bits).to eq(4)
-    end
-  end
-
-
-  describe "#hi" do
-    it "returns upper bound of the allocation range" do
-      expect(subject.hi).to eq(5)
-    end
-  end
-
-  describe "#lo" do
-    it "returns lower bound of the allocation range" do
-      expect(subject.lo).to eq(1)
-    end
-  end
-
-
-  describe "#allocate" do
-    context "when integer in the range is available" do
-      it "returns allocated integer" do
-        expect(subject.allocate).to eq(1)
-        expect(subject.allocate).to eq(2)
-        expect(subject.allocate).to eq(3)
-        expect(subject.allocate).to eq(4)
-
-        expect(subject.allocate).to eq(-1)
-      end
-    end
-
-    context "when integer in the range IS NOT available" do
-      it "returns -1" do
-        4.times { subject.allocate }
-
-        expect(subject.allocate).to eq(-1)
-        expect(subject.allocate).to eq(-1)
-        expect(subject.allocate).to eq(-1)
-        expect(subject.allocate).to eq(-1)
-      end
-    end
-  end
-
-
-  describe "#free" do
-    context "when the integer WAS allocated" do
-      it "returns frees that integer" do
-        4.times { subject.allocate }
-        expect(subject.allocate).to eq(-1)
-
-        subject.free(1)
-        expect(subject.allocate).to eq(1)
-        expect(subject.allocate).to eq(-1)
-        subject.free(2)
-        expect(subject.allocate).to eq(2)
-        expect(subject.allocate).to eq(-1)
-        subject.free(3)
-        expect(subject.allocate).to eq(3)
-        expect(subject.allocate).to eq(-1)
-      end
-    end
-
-    context "when the integer WAS NOT allocated" do
-      it "has no effect" do
-        32.times { subject.free(1) }
-        expect(subject.allocate).to eq(1)
-      end
-    end
-  end
-
-
-  describe "#allocated?" do
-    context "when given position WAS allocated" do
-      it "returns true" do
-        3.times { subject.allocate }
-
-        expect(subject.allocated?(1)).to be_truthy
-        expect(subject.allocated?(2)).to be_truthy
-        expect(subject.allocated?(3)).to be_truthy
-      end
-    end
-
-    context "when given position WAS NOT allocated" do
-      it "returns false" do
-        2.times { subject.allocate }
-
-        expect(subject.allocated?(3)).to be_falsey
-        expect(subject.allocated?(4)).to be_falsey
-      end
-    end
-  end
-end

data/spec/amq/pack_spec.rb

@@ -1,68 +0,0 @@
-# encoding: binary
-
-RSpec.describe AMQ::Pack do
-  context "16-bit big-endian packing / unpacking" do
-    let(:examples_16bit) {
-      {
-          0x068D => "\x06\x8D" # 1677
-      }
-    }
-
-    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)
-      end
-    end
-  end
-
-  context "64-bit big-endian packing / unpacking" do
-    let(:examples) {
-      {
-        0x0000000000000000 => "\x00\x00\x00\x00\x00\x00\x00\x00",
-        0x000000000000000A => "\x00\x00\x00\x00\x00\x00\x00\x0A",
-        0x00000000000000A0 => "\x00\x00\x00\x00\x00\x00\x00\xA0",
-        0x000000000000B0A0 => "\x00\x00\x00\x00\x00\x00\xB0\xA0",
-        0x00000000000CB0AD => "\x00\x00\x00\x00\x00\x0C\xB0\xAD",
-        0x8BADF00DDEFEC8ED => "\x8B\xAD\xF0\x0D\xDE\xFE\xC8\xED",
-        0x0D15EA5EFEE1DEAD => "\x0D\x15\xEA\x5E\xFE\xE1\xDE\xAD",
-        0xDEADBEEFDEADBABE => "\xDE\xAD\xBE\xEF\xDE\xAD\xBA\xBE"
-      }
-    }
-
-    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
-
-    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
-    end
-  end
-end

data/spec/amq/protocol/basic_spec.rb

@@ -1,325 +0,0 @@
-# encoding: binary
-
-module AMQ
-  module Protocol
-    RSpec.describe AMQ::Protocol::Basic do
-      describe '.encode_timestamp' do
-        it 'encodes the timestamp as a 64 byte big endian integer' do
-          expect(Basic.encode_timestamp(12345).last).to eq("\x00\x00\x00\x00\x00\x0009")
-        end
-      end
-
-      # describe '.decode_timestamp' do
-      #   it 'decodes the timestamp from a 64 byte big endian integer and returns a Time object' do
-      #     expect(Basic.decode_timestamp("\x00\x00\x00\x00\x00\x0009")).to eq(Time.at(12345))
-      #   end
-      # end
-
-      describe '.encode_headers' do
-        it 'encodes the headers as a table' do
-          expect(Basic.encode_headers(:hello => 'world').last).to eq("\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world")
-        end
-      end
-
-      # describe '.decode_headers' do
-      #   it 'decodes the headers from a table' do
-      #     expect(Basic.decode_headers("\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world")).to eq({'hello' => 'world'})
-      #   end
-      # end
-
-      describe '.encode_properties' do
-        it 'packs the parameters into a byte array using the other encode_* methods' do
-          result = Basic.encode_properties(10, {:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream'})
-          expect(result).to eq("\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x98\x00\x18application/octet-stream\x02\x00")
-        end
-      end
-
-      describe '.decode_properties' do
-        it 'unpacks the properties from a byte array using the decode_* methods' do
-          result = Basic.decode_properties("\x98@\x18application/octet-stream\x02\x00\x00\x00\x00\x00\x00\x00\x00{")
-          expect(result).to eq({:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream', :timestamp => Time.at(123)})
-        end
-
-        it 'unpacks the properties from a byte array using the decode_* methods, including a table' do
-          result = Basic.decode_properties("\xB8@\x18application/octet-stream\x00\x00\x00\x10\x05helloS\x00\x00\x00\x05world\x02\x00\x00\x00\x00\x00\x00\x00\x00{")
-          expect(result).to eq({:priority => 0, :delivery_mode => 2, :content_type => 'application/octet-stream', :timestamp => Time.at(123), :headers => {'hello' => 'world'}})
-        end
-      end
-
-      %w(content_type content_encoding correlation_id reply_to expiration message_id type user_id app_id cluster_id).each do |method|
-        describe ".encode_#{method}" do
-          it 'encodes the parameter as a Pascal string' do
-            expect(Basic.send("encode_#{method}", 'hello world').last).to eq("\x0bhello world")
-          end
-        end
-
-        # describe ".decode_#{method}" do
-        #   it 'returns the string' do
-        #     # the length has been stripped in .decode_properties
-        #     expect(Basic.send("decode_#{method}", 'hello world')).to eq('hello world')
-        #   end
-        # end
-      end
-
-      %w(delivery_mode priority).each do |method|
-        describe ".encode_#{method}" do
-          it 'encodes the parameter as a char' do
-            expect(Basic.send("encode_#{method}", 10).last).to eq("\x0a")
-          end
-        end
-
-        # describe ".decode_#{method}" do
-        #   it 'decodes the value from a char' do
-        #     expect(Basic.send("decode_#{method}", "\x10")).to eq(16)
-        #   end
-        # end
-      end
-    end
-
-    class Basic
-      RSpec.describe Qos do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            prefetch_size = 3
-            prefetch_count = 5
-            global = false
-            method_frame = Qos.encode(channel, prefetch_size, prefetch_count, global)
-            expect(method_frame.payload).to eq("\x00<\x00\n\x00\x00\x00\x03\x00\x05\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe QosOk do
-      #   describe '.decode' do
-      #   end
-      # end
-
-      RSpec.describe Consume do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            queue = 'foo'
-            consumer_tag = 'me'
-            no_local = false
-            no_ack = false
-            exclusive = true
-            nowait = false
-            arguments = nil
-            method_frame = Consume.encode(channel, queue, consumer_tag, no_local, no_ack, exclusive, nowait, arguments)
-            expect(method_frame.payload).to eq("\x00<\x00\x14\x00\x00\x03foo\x02me\x04\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe ConsumeOk do
-        describe '.decode' do
-          subject do
-            ConsumeOk.decode("\x03foo")
-          end
-
-          its(:consumer_tag) { should eq('foo') }
-        end
-      end
-
-      RSpec.describe Cancel do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            consumer_tag = 'foo'
-            nowait = true
-            method_frame = Cancel.encode(channel, consumer_tag, nowait)
-            expect(method_frame.payload).to eq("\x00<\x00\x1E\x03foo\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-
-        describe '.decode' do
-          subject do
-            CancelOk.decode("\x03foo\x01")
-          end
-
-          its(:consumer_tag) { should eq('foo') }
-        end
-      end
-
-      RSpec.describe CancelOk do
-        describe '.decode' do
-          subject do
-            CancelOk.decode("\x03foo")
-          end
-
-          its(:consumer_tag) { should eq('foo') }
-        end
-      end
-
-      RSpec.describe Publish do
-        describe '.encode' do
-          it 'encodes the parameters into a list of MethodFrames' do
-            channel = 1
-            payload = 'Hello World!'
-            user_headers = {:priority => 0, :content_type => 'application/octet-stream'}
-            exchange = 'foo'
-            routing_key = 'xyz'
-            mandatory = false
-            immediate = true
-            frame_size = 512
-            method_frames = Publish.encode(channel, payload, user_headers, exchange, routing_key, mandatory, immediate, frame_size)
-            expect(method_frames[0].payload).to eq("\x00<\x00(\x00\x00\x03foo\x03xyz\x02")
-            expect(method_frames[1].payload).to eq("\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\f\x88\x00\x18application/octet-stream\x00")
-            expect(method_frames[2].payload).to eq("Hello World!")
-            expect(method_frames[0].channel).to eq(1)
-            expect(method_frames[1].channel).to eq(1)
-            expect(method_frames[2].channel).to eq(1)
-            expect(method_frames.size).to eq(3)
-          end
-        end
-      end
-
-      RSpec.describe Return do
-        describe '.decode' do
-          subject do
-            Return.decode("\x019\fNO_CONSUMERS\namq.fanout\x00")
-          end
-
-          its(:reply_code) { should eq(313) }
-          its(:reply_text) { should eq('NO_CONSUMERS') }
-          its(:exchange) { should eq('amq.fanout') }
-          its(:routing_key) { should eq('') }
-        end
-      end
-
-      RSpec.describe Deliver do
-        describe '.decode' do
-          subject do
-            Deliver.decode("\e-1300560114000-445586772970\x00\x00\x00\x00\x00\x00\x00c\x00\namq.fanout\x00")
-          end
-
-          its(:consumer_tag) { should eq('-1300560114000-445586772970') }
-          its(:delivery_tag) { should eq(99) }
-          its(:redelivered) { should eq(false) }
-          its(:exchange) { should eq('amq.fanout') }
-          its(:routing_key) { should eq('') }
-        end
-      end
-
-      RSpec.describe Get do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            queue = 'foo'
-            no_ack = true
-            method_frame = Get.encode(channel, queue, no_ack)
-            expect(method_frame.payload).to eq("\x00\x3c\x00\x46\x00\x00\x03foo\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe GetOk do
-        describe '.decode' do
-          subject do
-            GetOk.decode("\x00\x00\x00\x00\x00\x00\x00\x06\x00\namq.fanout\x00\x00\x00\x00^")
-          end
-
-          its(:delivery_tag) { should eq(6) }
-          its(:redelivered) { should eq(false) }
-          its(:exchange) { should eq('amq.fanout') }
-          its(:routing_key) { should eq('') }
-          its(:message_count) { should eq(94) }
-        end
-      end
-
-      RSpec.describe GetEmpty do
-        describe '.decode' do
-          subject do
-            GetEmpty.decode("\x03foo")
-          end
-
-          its(:cluster_id) { should eq('foo') }
-        end
-      end
-
-      RSpec.describe Ack do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            delivery_tag = 6
-            multiple = false
-            method_frame = Ack.encode(channel, delivery_tag, multiple)
-            expect(method_frame.payload).to eq("\x00<\x00P\x00\x00\x00\x00\x00\x00\x00\x06\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe Reject do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            delivery_tag = 8
-            requeue = true
-            method_frame = Reject.encode(channel, delivery_tag, requeue)
-            expect(method_frame.payload).to eq("\x00<\x00Z\x00\x00\x00\x00\x00\x00\x00\x08\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe RecoverAsync do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            requeue = true
-            method_frame = RecoverAsync.encode(channel, requeue)
-            expect(method_frame.payload).to eq("\x00<\x00d\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe Recover do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            requeue = true
-            method_frame = Recover.encode(channel, requeue)
-            expect(method_frame.payload).to eq("\x00<\x00n\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      # RSpec.describe RecoverOk do
-      #   describe '.decode' do
-      #   end
-      # end
-
-      RSpec.describe Nack do
-        describe '.decode' do
-          subject do
-            Nack.decode("\x00\x00\x00\x00\x00\x00\x00\x09\x03")
-          end
-
-          its(:delivery_tag) { should eq(9) }
-          its(:multiple) { should eq(true) }
-          its(:requeue) { should eq(true) }
-        end
-
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            delivery_tag = 10
-            multiple = false
-            requeue = true
-            method_frame = Nack.encode(channel, delivery_tag, multiple, requeue)
-            expect(method_frame.payload).to eq("\x00<\x00x\x00\x00\x00\x00\x00\x00\x00\x0a\x02")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/amq/protocol/blank_body_encoding_spec.rb

@@ -1,9 +0,0 @@
-RSpec.describe AMQ::Protocol::Method, ".encode_body" do
-  it "encodes 1-byte long payload as exactly 1 body frame" do
-    expect(described_class.encode_body('1', 1, 65536).size).to eq(1)
-  end
-
-  it "encodes 0-byte long (blank) payload as exactly 0 body frame" do
-    expect(described_class.encode_body('', 1, 65536).size).to eq(0)
-  end
-end

data/spec/amq/protocol/channel_spec.rb

@@ -1,127 +0,0 @@
-# encoding: binary
-
-module AMQ
-  module Protocol
-    class Channel
-      RSpec.describe Open do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            out_of_band = ''
-            method_frame = Open.encode(channel, out_of_band)
-            expect(method_frame.payload).to eq("\x00\x14\x00\n\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe OpenOk do
-        describe '.decode' do
-          subject do
-            OpenOk.decode("\x00\x00\x00\x03foo")
-          end
-
-          its(:channel_id) { should eq('foo') }
-        end
-      end
-
-      RSpec.describe Flow do
-        describe '.decode' do
-          subject do
-            Flow.decode("\x01")
-          end
-
-          its(:active) { should be_truthy }
-        end
-
-        describe '.encode' do
-          it 'encodes the parameters as a MethodFrame' do
-            channel = 1
-            active = true
-            method_frame = Flow.encode(channel, active)
-            expect(method_frame.payload).to eq("\x00\x14\x00\x14\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe FlowOk do
-        describe '.decode' do
-          subject do
-            FlowOk.decode("\x00")
-          end
-
-          its(:active) { should be_falsey }
-        end
-
-        describe '.encode' do
-          it 'encodes the parameters as a MethodFrame' do
-            channel = 1
-            active = true
-            method_frame = FlowOk.encode(channel, active)
-            expect(method_frame.payload).to eq("\x00\x14\x00\x15\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe Close do
-        describe '.decode' do
-          context 'with code 200' do
-            subject do
-              Close.decode("\x00\xc8\x07KTHXBAI\x00\x05\x00\x06")
-            end
-
-            its(:reply_code) { should eq(200) }
-            its(:reply_text) { should eq('KTHXBAI') }
-            its(:class_id) { should eq(5) }
-            its(:method_id) { should eq(6) }
-          end
-
-
-          context 'with code 404 and reply_text length > 127 characters' do
-            subject do
-              raw = "\x01\x94\x80NOT_FOUND - no binding 123456789012345678901234567890123 between exchange 'amq.topic' in vhost '/' and queue 'test' in vhost '/'\x002\x002"
-              Close.decode(raw)
-            end
-
-            its(:reply_code) { should eq(404) }
-            its(:reply_text) { should eq(%q{NOT_FOUND - no binding 123456789012345678901234567890123 between exchange 'amq.topic' in vhost '/' and queue 'test' in vhost '/'}) }
-            its(:class_id) { should eq(50) }
-            its(:method_id) { should eq(50) }
-          end
-
-          context 'with an error code' do
-            it 'returns frame and lets calling code handle the issue' do
-              Close.decode("\x01\x38\x08NO_ROUTE\x00\x00")
-            end
-          end
-        end
-
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            reply_code = 540
-            reply_text = 'NOT_IMPLEMENTED'
-            class_id = 0
-            method_id = 0
-            method_frame = Close.encode(channel, reply_code, reply_text, class_id, method_id)
-            expect(method_frame.payload).to eq("\x00\x14\x00(\x02\x1c\x0fNOT_IMPLEMENTED\x00\x00\x00\x00")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe CloseOk do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            method_frame = CloseOk.encode(channel)
-            expect(method_frame.payload).to eq("\x00\x14\x00\x29")
-            expect(method_frame.channel).to eq(channel)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/amq/protocol/confirm_spec.rb

@@ -1,41 +0,0 @@
-# encoding: binary
-
-module AMQ
-  module Protocol
-    class Confirm
-      RSpec.describe Select do
-        describe '.decode' do
-          subject do
-            Select.decode("\x01")
-          end
-
-          its(:nowait) { should be_truthy }
-        end
-
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            nowait = true
-            method_frame = Select.encode(channel, nowait)
-            expect(method_frame.payload).to eq("\x00U\x00\n\x01")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-
-      RSpec.describe SelectOk do
-        # describe '.decode' do
-        # end
-
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel = 1
-            method_frame = SelectOk.encode(channel)
-            expect(method_frame.payload).to eq("\000U\000\v")
-            expect(method_frame.channel).to eq(1)
-          end
-        end
-      end
-    end
-  end
-end