amq-protocol 2.5.0 → 2.5.1

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

data/spec/amq/protocol/connection_spec.rb

@@ -1,146 +0,0 @@
-# encoding: binary
-
-module AMQ
-  module Protocol
-    class Connection
-      RSpec.describe Start do
-        describe '.decode' do
-          subject do
-            Start.decode("\x00\t\x00\x00\x00\xFB\tcopyrightS\x00\x00\x00gCopyright (C) 2007-2010 LShift Ltd., Cohesive Financial Technologies LLC., and Rabbit Technologies Ltd.\vinformationS\x00\x00\x005Licensed under the MPL.  See http://www.rabbitmq.com/\bplatformS\x00\x00\x00\nErlang/OTP\aproductS\x00\x00\x00\bRabbitMQ\aversionS\x00\x00\x00\x052.2.0\x00\x00\x00\x0EPLAIN AMQPLAIN\x00\x00\x00\x05en_US")
-          end
-
-          its(:version_major) { should == 0 }
-          its(:version_minor) { should == 9 }
-          its(:server_properties) { should == {'copyright' => 'Copyright (C) 2007-2010 LShift Ltd., Cohesive Financial Technologies LLC., and Rabbit Technologies Ltd.', 'information' => 'Licensed under the MPL.  See http://www.rabbitmq.com/', 'platform' => 'Erlang/OTP', 'product' => 'RabbitMQ', 'version' => '2.2.0'} }
-          its(:mechanisms) { should == 'PLAIN AMQPLAIN' }
-          its(:locales) { should == 'en_US' }
-        end
-      end
-
-      RSpec.describe StartOk do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            client_properties = {:platform => 'Ruby 1.9.2', :product => 'AMQ Client', :information => 'http://github.com/ruby-amqp/amq-client', :version => '0.2.0'}
-            mechanism = 'PLAIN'
-            response = "\x00guest\x00guest"
-            locale = 'en_GB'
-            method_frame = StartOk.encode(client_properties, mechanism, response, locale)
-            # the order of the table parts isn't deterministic in Ruby 1.8
-            expect(method_frame.payload[0, 8]).to eq("\x00\n\x00\v\x00\x00\x00x")
-            expect(method_frame.payload).to include("\bplatformS\x00\x00\x00\nRuby 1.9.2")
-            expect(method_frame.payload).to include("\aproductS\x00\x00\x00\nAMQ Client")
-            expect(method_frame.payload).to include("\vinformationS\x00\x00\x00&http://github.com/ruby-amqp/amq-client")
-            expect(method_frame.payload).to include("\aversionS\x00\x00\x00\x050.2.0")
-            expect(method_frame.payload[-28, 28]).to eq("\x05PLAIN\x00\x00\x00\f\x00guest\x00guest\x05en_GB")
-            expect(method_frame.payload.length).to eq(156)
-          end
-        end
-      end
-
-      RSpec.describe Secure do
-        describe '.decode' do
-          subject do
-            Secure.decode("\x00\x00\x00\x03foo")
-          end
-
-          its(:challenge) { should eq('foo') }
-        end
-      end
-
-      RSpec.describe SecureOk do
-        describe '.encode' do
-          it 'encodes the parameters as a MethodFrame' do
-            response = 'bar'
-            method_frame = SecureOk.encode(response)
-            expect(method_frame.payload).to eq("\x00\x0a\x00\x15\x00\x00\x00\x03bar")
-          end
-        end
-      end
-
-      RSpec.describe Tune do
-        describe '.decode' do
-          subject do
-            Tune.decode("\x00\x00\x00\x02\x00\x00\x00\x00")
-          end
-
-          its(:channel_max) { should eq(0) }
-          its(:frame_max) { should eq(131072) }
-          its(:heartbeat) { should eq(0) }
-        end
-      end
-
-      RSpec.describe TuneOk do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            channel_max = 0
-            frame_max = 65536
-            heartbeat = 1
-            method_frame = TuneOk.encode(channel_max, frame_max, heartbeat)
-            expect(method_frame.payload).to eq("\x00\n\x00\x1F\x00\x00\x00\x01\x00\x00\x00\x01")
-          end
-        end
-      end
-
-      RSpec.describe Open do
-        describe '.encode' do
-          it 'encodes the parameters into a MethodFrame' do
-            vhost = '/test'
-            method_frame = Open.encode(vhost)
-            expect(method_frame.payload).to eq("\x00\n\x00(\x05/test\x00\x00")
-          end
-        end
-      end
-
-      RSpec.describe OpenOk do
-        describe '.decode' do
-          subject do
-            OpenOk.decode("\x00")
-          end
-
-          its(:known_hosts) { should eq('') }
-        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 an error code' do
-            it 'returns method 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
-            reply_code = 540
-            reply_text = 'NOT_IMPLEMENTED'
-            class_id = 0
-            method_id = 0
-            method_frame = Close.encode(reply_code, reply_text, class_id, method_id)
-            expect(method_frame.payload).to eq("\x00\x0a\x002\x02\x1c\x0fNOT_IMPLEMENTED\x00\x00\x00\x00")
-          end
-        end
-      end
-
-      RSpec.describe CloseOk do
-        describe '.encode' do
-          it 'encodes a MethodFrame' do
-            method_frame = CloseOk.encode
-            expect(method_frame.payload).to eq("\x00\n\x003")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/amq/protocol/constants_spec.rb

@@ -1,10 +0,0 @@
-RSpec.describe "(Some) AMQ::Protocol constants" do
-  it "include regular port" do
-    expect(AMQ::Protocol::DEFAULT_PORT).to eq(5672)
-  end
-
-  it "provides TLS/SSL port" do
-    expect(AMQ::Protocol::TLS_PORT).to eq(5671)
-    expect(AMQ::Protocol::SSL_PORT).to eq(5671)
-  end
-end