amq-protocol 2.2.0 → 2.3.2

data/spec/amq/protocol/table_spec.rb

@@ -1,17 +1,12 @@
-# -*- coding: utf-8 -*-
-
-require File.expand_path('../../../spec_helper', __FILE__)
 require 'bigdecimal'
 require 'time'
 
-
 module AMQ
   module Protocol
-    describe Table do
+    RSpec.describe Table do
       timestamp    = Time.utc(2010, 12, 31, 23, 58, 59)
-      bigdecimal_1 = BigDecimal.new("1.0")
-      bigdecimal_2 = BigDecimal.new("5E-3")
-
+      bigdecimal_1 = BigDecimal("1.0")
+      bigdecimal_2 = BigDecimal("5E-3")
 
       DATA = {
           {}                       => "\x00\x00\x00\x00",
@@ -51,6 +46,16 @@ module AMQ
             to eql("\x00\x00\x00$\vcoordinatesF\x00\x00\x00\x13\tlongituded@2\x11\x11\x16\xA8\xB8\xF1".force_encoding(Encoding::ASCII_8BIT))
         end
 
+        it "should serialize long UTF-8 strings and symbols" do
+          long_utf8 = "à" * 192
+          long_ascii8 = long_utf8.dup.force_encoding(::Encoding::ASCII_8BIT)
+
+          input = { "utf8_string" => long_utf8, "utf8_symbol" => long_utf8.to_sym }
+          output = { "utf8_string" => long_ascii8, "utf8_symbol" => long_ascii8 }
+
+          expect(Table.decode(Table.encode(input))).to eq(output)
+        end
+
         DATA.each do |data, encoded|
           it "should return #{encoded.inspect} for #{data.inspect}" do
             expect(Table.encode(data)).to eql(encoded.force_encoding(Encoding::ASCII_8BIT))
@@ -209,7 +214,7 @@ module AMQ
                 "rev"   => 1.0,
                 "spec"  => {
                   "url"  => "http://bit.ly/hw2ELX",
-                  "utf8" => "à bientôt".force_encoding(::Encoding::ASCII_8BIT)
+                  "utf8" => "à bientôt"
                 }
               },
               "true"     => true,
@@ -217,7 +222,7 @@ module AMQ
               "nil"      => nil
             }
           }
-          expect(Table.decode(Table.encode(input))).to eq(input)
+          expect(Table.decode(Table.encode(input))).to eq(input.tap { |r| r["hashval"]["protocol"]["spec"]["utf8"].force_encoding(::Encoding::ASCII_8BIT) })
         end
 
 

data/spec/amq/protocol/tx_spec.rb

@@ -1,12 +1,9 @@
 # encoding: binary
 
-require File.expand_path('../../../spec_helper', __FILE__)
-
-
 module AMQ
   module Protocol
     class Tx
-      describe Select do
+      RSpec.describe Select do
         describe '.encode' do
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
@@ -17,12 +14,12 @@ module AMQ
         end
       end
 
-      # describe SelectOk do
+      # RSpec.describe SelectOk do
       #   describe '.decode' do
       #   end
       # end
 
-      describe Commit do
+      RSpec.describe Commit do
         describe '.encode' do
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
@@ -32,13 +29,13 @@ module AMQ
           end
         end
       end
-      
-      # describe CommitOk do
+
+      # RSpec.describe CommitOk do
       #   describe '.decode' do
       #   end
       # end
 
-      describe Rollback do
+      RSpec.describe Rollback do
         describe '.encode' do
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
@@ -49,7 +46,7 @@ module AMQ
         end
       end
 
-      # describe RollbackOk do
+      # RSpec.describe RollbackOk do
       #   describe '.decode' do
       #   end
       # end

data/spec/amq/protocol/value_decoder_spec.rb

@@ -1,17 +1,14 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('../../../spec_helper', __FILE__)
-
 require 'time'
 require "amq/protocol/table_value_decoder"
 
 module AMQ
   module Protocol
-    describe TableValueDecoder do
+    RSpec.describe TableValueDecoder do
 
       it "is capable of decoding basic arrays TableValueEncoder encodes" do
         input1 = [1, 2, 3]
 
-        value, offset = described_class.decode_array(TableValueEncoder.encode(input1), 1)
+        value, _offset = described_class.decode_array(TableValueEncoder.encode(input1), 1)
         expect(value.size).to eq(3)
         expect(value.first).to eq(1)
         expect(value).to eq(input1)
@@ -20,7 +17,7 @@ module AMQ
 
         input2 = ["one", 2, "three"]
 
-        value, offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
+        value, _offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
         expect(value.size).to eq(3)
         expect(value.first).to eq("one")
         expect(value).to eq(input2)
@@ -29,7 +26,7 @@ module AMQ
 
         input3 = ["one", 2, "three", 4.0, 5000000.0]
 
-        value, offset = described_class.decode_array(TableValueEncoder.encode(input3), 1)
+        value, _offset = described_class.decode_array(TableValueEncoder.encode(input3), 1)
         expect(value.size).to eq(5)
         expect(value.last).to eq(5000000.0)
         expect(value).to eq(input3)
@@ -45,7 +42,7 @@ module AMQ
         # puts(TableValueEncoder.encode(input1).inspect)
 
 
-        value, offset = described_class.decode_array(data1, 1)
+        value, _offset = described_class.decode_array(data1, 1)
         expect(value.size).to eq(2)
         expect(value.first).to eq(Hash["one" => 2])
         expect(value).to eq(input1)
@@ -54,7 +51,7 @@ module AMQ
 
         input2 = ["one", 2, { "three" => { "four" => 5.0 } }]
 
-        value, offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
+        value, _offset = described_class.decode_array(TableValueEncoder.encode(input2), 1)
         expect(value.size).to eq(3)
         expect(value.last["three"]["four"]).to eq(5.0)
         expect(value).to eq(input2)

data/spec/amq/protocol/value_encoder_spec.rb

@@ -1,14 +1,10 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('../../../spec_helper', __FILE__)
-
 require 'time'
 require "amq/protocol/table_value_encoder"
 require "amq/protocol/float_32bit"
 
 module AMQ
   module Protocol
-    describe TableValueEncoder do
-
+    RSpec.describe TableValueEncoder do
 
       it "calculates size of string field values" do
         expect(described_class.field_value_size("amqp")).to eq(9)

data/spec/amq/protocol_spec.rb

@@ -1,10 +1,5 @@
-# encoding: binary
-
-require File.expand_path('../../spec_helper', __FILE__)
-
-
 module AMQ
-  describe Protocol do
+  RSpec.describe Protocol do
     it "should have PROTOCOL_VERSION constant" do
       expect(Protocol::PROTOCOL_VERSION).to match(/^\d+\.\d+\.\d$/)
     end

data/spec/amq/settings_spec.rb

@@ -1,9 +1,6 @@
-# encoding: utf-8
-
-require "spec_helper"
 require "amq/settings"
 
-describe AMQ::Settings do
+RSpec.describe AMQ::Settings do
   describe ".default" do
     it "should provide some default values" do
       expect(AMQ::Settings.default).to_not be_nil

data/spec/amq/uri_parsing_spec.rb

@@ -1,95 +1,280 @@
-# encoding: utf-8
-
-require "spec_helper"
 require "amq/uri"
 
-describe AMQ::URI, ".parse" do
-  context "when schema is not one of [amqp, amqps]" do
-    it "raises ArgumentError" do
-      expect {
-        described_class.parse_amqp_url("http://dev.rabbitmq.com")
-      }.to raise_error(ArgumentError, /amqp or amqps schema/)
-    end
-  end
+# https://www.rabbitmq.com/uri-spec.html
+# http://www.ietf.org/rfc/rfc3986.txt
+# https://tools.ietf.org/rfc/rfc5246.txt
 
+RSpec.describe AMQ::URI do
+  describe ".parse" do
+    subject { described_class.parse(uri) }
 
-  it "handles amqp:// URIs w/o path part" do
-    val = described_class.parse_amqp_url("amqp://dev.rabbitmq.com")
+    context "schema is not amqp or amqps" do
+      let(:uri) { "http://rabbitmq" }
 
-    expect(val[:vhost]).to be_nil # in this case, default / will be used
-    expect(val[:host]).to eq("dev.rabbitmq.com")
-    expect(val[:port]).to eq(5672)
-    expect(val[:scheme]).to eq("amqp")
-    expect(val[:ssl]).to be_falsey
-  end
+      it "raises ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError, /amqp or amqps schema/)
+      end
+    end
 
-  it "handles amqps:// URIs w/o path part" do
-    val = described_class.parse_amqp_url("amqps://dev.rabbitmq.com")
+    describe "host" do
+      context "present" do
+        let(:uri) { "amqp://rabbitmq" }
 
-    expect(val[:vhost]).to be_nil
-    expect(val[:host]).to eq("dev.rabbitmq.com")
-    expect(val[:port]).to eq(5671)
-    expect(val[:scheme]).to eq("amqps")
-    expect(val[:ssl]).to be_truthy
-  end
+        it "parses host" do
+          expect(subject[:host]).to eq("rabbitmq")
+        end
+      end
 
+      if RUBY_VERSION >= "2.2"
+        context "absent" do
+          let(:uri) { "amqp://" }
 
-  context "when URI ends in a slash" do
-    it "parses vhost as an empty string" do
-      val = described_class.parse_amqp_url("amqp://dev.rabbitmq.com/")
+          # Note that according to the ABNF, the host component may not be absent, but it may be zero-length.
+          it "falls back to default nil host" do
+            expect(subject[:host]).to be_nil
+          end
+        end
+      end
 
-      expect(val[:host]).to eq("dev.rabbitmq.com")
-      expect(val[:port]).to eq(5672)
-      expect(val[:scheme]).to eq("amqp")
-      expect(val[:ssl]).to be_falsey
-      expect(val[:vhost]).to eq("")
+      if RUBY_VERSION < "2.2"
+        context "absent" do
+          let(:uri) { "amqp://" }
+
+          # Note that according to the ABNF, the host component may not be absent, but it may be zero-length.
+          it "raises InvalidURIError" do
+            expect { subject[:host] }.to raise_error(URI::InvalidURIError, /bad URI\(absolute but no path\)/)
+          end
+        end
+      end
     end
-  end
 
+    describe "port" do
+      context "present" do
+        let(:uri) { "amqp://rabbitmq:5672" }
+
+        it "parses port" do
+          expect(subject[:port]).to eq(5672)
+        end
+      end
 
-  context "when URI ends in /%2Fvault" do
-    it "parses vhost as /vault" do
-      val = described_class.parse_amqp_url("amqp://dev.rabbitmq.com/%2Fvault")
+      context "absent" do
+        context "schema amqp" do
+          let(:uri) { "amqp://rabbitmq" }
 
-      expect(val[:host]).to eq("dev.rabbitmq.com")
-      expect(val[:port]).to eq(5672)
-      expect(val[:scheme]).to eq("amqp")
-      expect(val[:ssl]).to be_falsey
-      expect(val[:vhost]).to eq("/vault")
+          it "falls back to 5672 port" do
+            expect(subject[:port]).to eq(5672)
+          end
+        end
+
+        context "schema amqps" do
+          let(:uri) { "amqps://rabbitmq" }
+
+          it "falls back to 5671 port" do
+            expect(subject[:port]).to eq(5671)
+          end
+        end
+      end
     end
-  end
 
+    describe "username and passowrd" do
+      context "both present" do
+        let(:uri) { "amqp://alpha:beta@rabbitmq" }
 
-  context "when URI is amqp://dev.rabbitmq.com/a.path.without.slashes" do
-    it "parses vhost as a.path.without.slashes" do
-      val = described_class.parse_amqp_url("amqp://dev.rabbitmq.com/a.path.without.slashes")
+        it "parses user and pass" do
+          expect(subject[:user]).to eq("alpha")
+          expect(subject[:pass]).to eq("beta")
+        end
+      end
 
-      expect(val[:host]).to eq("dev.rabbitmq.com")
-      expect(val[:port]).to eq(5672)
-      expect(val[:scheme]).to eq("amqp")
-      expect(val[:ssl]).to be_falsey
-      expect(val[:vhost]).to eq("a.path.without.slashes")
+      context "only username present" do
+        let(:uri) { "amqp://alpha@rabbitmq" }
+
+        it "parses user and falls back to nil pass" do
+          expect(subject[:user]).to eq("alpha")
+          expect(subject[:pass]).to be_nil
+        end
+
+        context "with ':'" do
+          let(:uri) { "amqp://alpha:@rabbitmq" }
+
+          it "parses user and falls back to "" (empty) pass" do
+            expect(subject[:user]).to eq("alpha")
+            expect(subject[:pass]).to eq("")
+          end
+        end
+      end
+
+      context "only password present" do
+        let(:uri) { "amqp://:beta@rabbitmq" }
+
+        it "parses pass and falls back to "" (empty) user" do
+          expect(subject[:user]).to eq("")
+          expect(subject[:pass]).to eq("beta")
+        end
+      end
+
+      context "both absent" do
+        let(:uri) { "amqp://rabbitmq" }
+
+        it "falls back to nil user and pass" do
+          expect(subject[:user]).to be_nil
+          expect(subject[:pass]).to be_nil
+        end
+
+        context "with ':'" do
+          let(:uri) { "amqp://:@rabbitmq" }
+
+          it "falls back to "" (empty) user and "" (empty) pass" do
+            expect(subject[:user]).to eq("")
+            expect(subject[:pass]).to eq("")
+          end
+        end
+      end
+
+      context "%-encoded" do
+        let(:uri) { "amqp://%61lpha:bet%61@rabbitmq" }
+
+        it "parses user and pass" do
+          expect(subject[:user]).to eq("alpha")
+          expect(subject[:pass]).to eq("beta")
+        end
+      end
     end
-  end
 
-  context "when URI is amqp://dev.rabbitmq.com/a/path/with/slashes" do
-    it "raises an ArgumentError" do
-      expect { described_class.parse_amqp_url("amqp://dev.rabbitmq.com/a/path/with/slashes") }.to raise_error(ArgumentError)
+    describe "path" do
+      context "present" do
+        let(:uri) { "amqp://rabbitmq/staging" }
+
+        it "parses vhost" do
+          expect(subject[:vhost]).to eq("staging")
+        end
+
+        context "with dots" do
+          let(:uri) { "amqp://rabbitmq/staging.critical.subsystem-a" }
+
+          it "parses vhost" do
+            expect(subject[:vhost]).to eq("staging.critical.subsystem-a")
+          end
+        end
+
+        context "with slashes" do
+          let(:uri) { "amqp://rabbitmq/staging/critical/subsystem-a" }
+
+          it "raises ArgumentError" do
+            expect { subject[:vhost] }.to raise_error(ArgumentError)
+          end
+        end
+
+        context "with trailing slash" do
+          let(:uri) { "amqp://rabbitmq/" }
+
+          it "parses vhost as an empty string" do
+            expect(subject[:vhost]).to eq("")
+          end
+        end
+
+        context "with trailing %-encoded slashes" do
+          let(:uri) { "amqp://rabbitmq/%2Fstaging" }
+
+          it "parses vhost as string with leading slash" do
+            expect(subject[:vhost]).to eq("/staging")
+          end
+        end
+
+        context "%-encoded" do
+          let(:uri) { "amqp://rabbitmq/%2Fstaging%2Fcritical%2Fsubsystem-a" }
+
+          it "parses vhost as string with leading slash" do
+            expect(subject[:vhost]).to eq("/staging/critical/subsystem-a")
+          end
+        end
+      end
+
+      context "absent" do
+        let(:uri) { "amqp://rabbitmq" }
+
+        it "falls back to default nil vhost" do
+          expect(subject[:vhost]).to be_nil
+        end
+      end
     end
-  end
 
+    describe "query parameters" do
+      context "present" do
+        let(:uri) { "amqp://rabbitmq?heartbeat=10&connection_timeout=100&channel_max=1000&auth_mechanism=plain&auth_mechanism=amqplain" }
+
+        it "parses client connection parameters" do
+          expect(subject[:heartbeat]).to eq(10)
+          expect(subject[:connection_timeout]).to eq(100)
+          expect(subject[:channel_max]).to eq(1000)
+          expect(subject[:auth_mechanism]).to eq(["plain", "amqplain"])
+        end
+      end
+
+      context "absent" do
+        let(:uri) { "amqp://rabbitmq" }
+
+        it "falls back to default client connection parameters" do
+          expect(subject[:heartbeat]).to be_nil
+          expect(subject[:connection_timeout]).to be_nil
+          expect(subject[:channel_max]).to be_nil
+          expect(subject[:auth_mechanism]).to be_empty
+        end
+      end
+
+      context "schema amqp" do
+        context "tls parameters" do
+          %w(verify fail_if_no_peer_cert cacertfile certfile keyfile).each do |tls_param|
+            describe "#{tls_param}" do
+              let(:uri) { "amqp://rabbitmq?#{tls_param}=value" }
+
+              it "raises ArgumentError" do
+                expect { subject }.to raise_error(ArgumentError, /The option '#{tls_param}' can only be used in URIs that use amqps schema/)
+              end
+            end
+          end
+        end
+      end
+
+      context "amqpa schema" do
+        context "TLS parameters in query string" do
+          context "case 1" do
+            let(:uri) { "amqps://rabbitmq?verify=true&fail_if_no_peer_cert=true&cacertfile=/examples/tls/cacert.pem&certfile=/examples/tls/client_cert.pem&keyfile=/examples/tls/client_key.pem" }
+
+            it "parses tls options" do
+              expect(subject[:verify]).to be_truthy
+              expect(subject[:fail_if_no_peer_cert]).to be_truthy
+              expect(subject[:cacertfile]).to eq("/examples/tls/cacert.pem")
+              expect(subject[:certfile]).to eq("/examples/tls/client_cert.pem")
+              expect(subject[:keyfile]).to eq("/examples/tls/client_key.pem")
+            end
+          end
+
+          context "case 2" do
+            let(:uri) { "amqps://bunny_gem:bunny_password@/bunny_testbed?heartbeat=10&connection_timeout=100&channel_max=1000&verify=false&cacertfile=spec/tls/ca_certificate.pem&certfile=spec/tls/client_certificate.pem&keyfile=spec/tls/client_key.pem" }
+
+            it "parses tls options" do
+              expect(subject[:verify]).to be_falsey
+              expect(subject[:fail_if_no_peer_cert]).to be_falsey
+              expect(subject[:cacertfile]).to eq("spec/tls/ca_certificate.pem")
+              expect(subject[:certfile]).to eq("spec/tls/client_certificate.pem")
+              expect(subject[:keyfile]).to eq("spec/tls/client_key.pem")
+            end
+          end
 
-  context "when URI has username:password, for instance, amqp://hedgehog:t0ps3kr3t@hub.megacorp.internal" do
-    it "parses them out" do
-      val = described_class.parse_amqp_url("amqp://hedgehog:t0ps3kr3t@hub.megacorp.internal")
+          context "absent" do
+          let(:uri) { "amqps://rabbitmq" }
 
-      expect(val[:host]).to eq("hub.megacorp.internal")
-      expect(val[:port]).to eq(5672)
-      expect(val[:scheme]).to eq("amqp")
-      expect(val[:ssl]).to be_falsey
-      expect(val[:user]).to eq("hedgehog")
-      expect(val[:pass]).to eq("t0ps3kr3t")
-      expect(val[:vhost]).to be_nil # in this case, default / will be used
+          it "falls back to default tls options" do
+            expect(subject[:verify]).to be_falsey
+            expect(subject[:fail_if_no_peer_cert]).to be_falsey
+            expect(subject[:cacertfile]).to be_nil
+            expect(subject[:certfile]).to be_nil
+            expect(subject[:keyfile]).to be_nil
+          end
+        end
+        end
+      end
     end
   end
 end