amq-protocol 2.3.3 → 2.8.0

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

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/frame_spec.rb

@@ -1,92 +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
-      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