qpid_proton 0.21.0 → 0.22.0

data/tests/test_container.rb

@@ -20,26 +20,26 @@ require 'test_tools'
 require 'minitest/unit'
 require 'socket'
 
-# Container that listens on a random port
-class TestContainer < Qpid::Proton::Container
-
-  def initialize(handler, lopts=nil, id=nil)
-    super handler, id
-    @listener = listen_io(TCPServer.open(0), ListenOnceHandler.new(lopts))
-  end
-
-  def port() @listener.to_io.addr[1]; end
-  def url() "amqp://:#{port}"; end#
+# MessagingHandler that raises in on_error to catch unexpected errors
+class ExceptionMessagingHandler
+  def on_error(e) raise e; end
 end
 
 class ContainerTest < MiniTest::Test
   include Qpid::Proton
 
   def test_simple()
-    send_handler = Class.new(MessagingHandler) do
+    send_handler = Class.new(ExceptionMessagingHandler) do
       attr_reader :accepted, :sent
+
+      def initialize() @sent, @accepted = nil; end
+
       def on_sendable(sender)
-        sender.send Message.new("foo") unless @sent
+        unless @sent
+          m = Message.new("hello")
+          m[:foo] = :bar
+          sender.send m
+        end
         @sent = true
       end
 
@@ -49,7 +49,7 @@ class ContainerTest < MiniTest::Test
       end
     end.new
 
-    receive_handler = Class.new(MessagingHandler) do
+    receive_handler = Class.new(ExceptionMessagingHandler) do
       attr_reader :message, :link
       def on_receiver_open(link)
         @link = link
@@ -64,13 +64,14 @@ class ContainerTest < MiniTest::Test
       end
     end.new
 
-    c = TestContainer.new(receive_handler, {}, __method__)
+    c = ServerContainer.new(__method__, {:handler => receive_handler})
     c.connect(c.url, {:handler => send_handler}).open_sender({:name => "testlink"})
     c.run
 
     assert send_handler.accepted
     assert_equal "testlink", receive_handler.link.name
-    assert_equal "foo", receive_handler.message.body
+    assert_equal "hello", receive_handler.message.body
+    assert_equal :bar, receive_handler.message[:foo]
     assert_equal "test_simple", receive_handler.link.connection.container_id
   end
 
@@ -153,48 +154,48 @@ class ContainerTest < MiniTest::Test
   def test_bad_host
     cont = Container.new(__method__)
     assert_raises (SocketError) { cont.listen("badlisten.example.com:999") }
-    assert_raises (SocketError) { c = cont.connect("badconnect.example.com:999") }
+    assert_raises (SocketError) { cont.connect("badconnect.example.com:999") }
   end
 
-  # Verify that connection options are sent to the peer and available as Connection methods
+  # Verify that connection options are sent to the peer
   def test_connection_options
     # Note: user, password and sasl_xxx options are tested by ContainerSASLTest below
-    server_handler = Class.new(MessagingHandler) do
-      def on_error(e) raise e.inspect; end
+    server_handler = Class.new(ExceptionMessagingHandler) do
       def on_connection_open(c)
         @connection = c
         c.open({
-                :virtual_host => "server.to.client",
-                :properties => { :server => :client },
-                :offered_capabilities => [ :s1 ],
-                :desired_capabilities => [ :s2 ],
-                :container_id => "box",
-               })
+          :virtual_host => "server.to.client",
+          :properties => { :server => :client },
+          :offered_capabilities => [ :s1 ],
+          :desired_capabilities => [ :s2 ],
+          :container_id => "box",
+        })
         c.close
       end
       attr_reader :connection
     end.new
-    # Transport options must be provided to the listener, by Connection#open it is too late
-    cont = TestContainer.new(nil, {
-                                   :handler => server_handler,
-                                   :idle_timeout => 88,
-                                   :max_sessions =>1000,
-                                   :max_frame_size => 8888,
-                                  })
+    # Transport options set by listener, by Connection#open it is too late
+    cont = ServerContainer.new(__method__, {
+      :handler => server_handler,
+      :idle_timeout => 88,
+      :max_sessions =>1000,
+      :max_frame_size => 8888,
+    })
     client = cont.connect(cont.url,
-                          {:virtual_host => "client.to.server",
-                           :properties => { :foo => :bar, "str" => "str" },
-                           :offered_capabilities => [:c1 ],
-                           :desired_capabilities => ["c2" ],
-                           :idle_timeout => 42,
-                           :max_sessions =>100,
-                           :max_frame_size => 4096,
-                           :container_id => "bowl"
-                          })
+      {:virtual_host => "client.to.server",
+        :properties => { "foo" => :bar, "str" => "str" },
+        :offered_capabilities => [:c1 ],
+        :desired_capabilities => [:c2 ],
+        :idle_timeout => 42,
+        :max_sessions =>100,
+        :max_frame_size => 4096,
+        :container_id => "bowl"
+      })
     cont.run
+
     c = server_handler.connection
     assert_equal "client.to.server", c.virtual_host
-    assert_equal({ :foo => :bar, :str => "str" }, c.properties)
+    assert_equal({ "foo" => :bar, "str" => "str" }, c.properties)
     assert_equal([:c1], c.offered_capabilities)
     assert_equal([:c2], c.desired_capabilities)
     assert_equal 21, c.idle_timeout # Proton divides by 2
@@ -212,108 +213,184 @@ class ContainerTest < MiniTest::Test
     assert_equal 44, c.idle_timeout # Proton divides by 2
     assert_equal 100, c.max_sessions
   end
-end
-
 
-class ContainerSASLTest < MiniTest::Test
-  include Qpid::Proton
+  def test_link_options
+    server_handler = Class.new(ExceptionMessagingHandler) do
+      def initialize() @links = []; end
+      attr_reader :links
+      def on_sender_open(l) @links << l; end
+      def on_receiver_open(l) @links << l; end
+    end.new
 
-  # Handler for test client/server that sets up server and client SASL options
-  class SASLHandler < TestHandler
+    client_handler = Class.new(ExceptionMessagingHandler) do
+      def on_connection_open(c)
+        @links = [];
+        @links << c.open_sender("s1")
+        @links << c.open_sender({:name => "s2-n", :target => "s2-t", :source => "s2-s"})
+        @links << c.open_receiver("r1")
+        @links << c.open_receiver({:name => "r2-n", :target => "r2-t", :source => "r2-s"})
+        c.close
+      end
+      attr_reader :links
+    end.new
 
-    def initialize(url="amqp://", opts=nil)
-      super()
-      @url, @opts = url, opts
-    end
+    cont = ServerContainer.new(__method__, {:handler => server_handler }, 1)
+    cont.connect(cont.url, :handler => client_handler)
+    cont.run
 
-    def on_container_start(container)
-      @client = container.connect("#{@url}:#{container.port}", @opts)
-    end
+    expect = ["test_link_options/1", "s2-n", "test_link_options/2", "r2-n"]
+    assert_equal expect, server_handler.links.map(&:name)
+    assert_equal expect, client_handler.links.map(&:name)
 
-    attr_reader :auth_user
+    expect = [[nil,"s1"], ["s2-s","s2-t"], ["r1",nil], ["r2-s","r2-t"]]
+    assert_equal expect, server_handler.links.map { |l| [l.remote_source.address, l.remote_target.address] }
+    assert_equal expect, client_handler.links.map { |l| [l.source.address, l.target.address] }
+  end
 
-    def on_connection_open(connection)
-      super
-      if connection == @client
-        connection.close
-      else
-        @auth_user = connection.user
-      end
-    end
+  def extract_terminus_options(t)
+    opts = Hash[[:address, :distribution_mode, :durability_mode, :timeout, :expiry_policy].map { |m| [m, t.send(m)] }]
+    opts[:filter] = t.filter.map
+    opts[:capabilities] = t.capabilities.map
+    opts[:dynamic] = t.dynamic?
+    opts
   end
 
-  # Generate SASL server configuration files and database, initialize proton SASL
-  class SASLConfig
-    include Qpid::Proton
-    attr_reader :conf_dir, :conf_file, :conf_name, :database
-
-    def initialize()
-      if SASL.extended? # Configure cyrus SASL
-        @conf_dir = File.expand_path('sasl_conf')
-        @conf_name = "proton-server"
-        @database = File.join(@conf_dir, "proton.sasldb")
-        @conf_file = File.join(conf_dir,"#{@conf_name}.conf")
-        Dir::mkdir(@conf_dir) unless File.directory?(@conf_dir)
-        # Same user name in different realms
-        make_user("user", "password", "proton") # proton realm
-        make_user("user", "default_password") # Default realm
-        File.open(@conf_file, 'w') do |f|
-          f.write("
-sasldb_path: #{database}
-mech_list: EXTERNAL DIGEST-MD5 SCRAM-SHA-1 CRAM-MD5 PLAIN ANONYMOUS
-                  ")
-        end
-        # Tell proton library to use the new configuration
-        SASL.config_path =  conf_dir
-        SASL.config_name = conf_name
-      end
-    end
+  def test_terminus_options
+    opts = {
+      :distribution_mode => Terminus::DIST_MODE_COPY,
+      :durability_mode => Terminus::DELIVERIES,
+      :timeout => 5,
+      :expiry_policy => Terminus::EXPIRE_WITH_LINK,
+      :filter => { :try => 'me' },
+      :capabilities => { :cap => 'len' },
+    }
+    src_opts = { :address => "src", :dynamic => true }.update(opts)
+    tgt_opts = { :address => "tgt", :dynamic => false }.update(opts)
+
+    cont = ServerContainer.new(__method__, {}, 1)
+    c = cont.connect(cont.url)
+    s = c.open_sender({:target => tgt_opts, :source => src_opts })
+    assert_equal src_opts, extract_terminus_options(s.source)
+    assert_equal tgt_opts, extract_terminus_options(s.target)
+    assert s.source.dynamic?
+    assert !s.target.dynamic?
+  end
 
-    private
+  # Test for time out on connecting to an unresponsive server
+  def test_idle_timeout_server_no_open
+    s = TCPServer.new(0)
+    cont = Container.new(__method__)
+    cont.connect(":#{s.addr[1]}", {:idle_timeout => 0.1, :handler => ExceptionMessagingHandler.new })
+    ex = assert_raises(Qpid::Proton::Condition) { cont.run }
+    assert_match(/resource-limit-exceeded/, ex.to_s)
+  ensure
+    s.close if s
+  end
 
-    SASLPASSWD = (ENV['SASLPASSWD'] or 'saslpasswd2')
+  # Test for time out on unresponsive client
+  def test_idle_timeout_client
+    server = ServerContainerThread.new("#{__method__}.server", {:idle_timeout => 0.1})
+    client_handler = Class.new(ExceptionMessagingHandler) do
+      def initialize() @ready, @block = Queue.new, Queue.new; end
+      attr_reader :ready, :block
+      def on_connection_open(c)
+        @ready.push nil        # Tell the main thread we are now open
+        @block.pop             # Block the client so the server will time it out
+      end
+    end.new
 
-    def make_user(user, password, realm=nil)
-      realm_opt = (realm ? "-u #{realm}" : "")
-      cmd = "echo '#{password}' | #{SASLPASSWD} -c -p -f #{database} #{realm_opt} #{user}"
-      system(cmd) or raise RuntimeError.new("saslpasswd2 failed: #{makepw_cmd}")
-    end
-    DEFAULT = SASLConfig.new
+    client = Container.new(nil, "#{__method__}.client")
+    client.connect(server.url, {:handler => client_handler})
+    client_thread = Thread.new { client.run }
+    client_handler.ready.pop    # Wait till the client has connected
+    server.join                 # Exits when the connection closes from idle-timeout
+    client_handler.block.push nil   # Unblock the client
+    ex = assert_raises(Qpid::Proton::Condition) { client_thread.join }
+    assert_match(/resource-limit-exceeded/, ex.to_s)
   end
 
-  def test_sasl_anonymous()
-    s = SASLHandler.new("amqp://",  {:sasl_allowed_mechs => "ANONYMOUS"})
-    TestContainer.new(s, {:sasl_allowed_mechs => "ANONYMOUS"}, __method__).run
-    assert_equal "anonymous", s.connections[0].user
+  # Make sure we stop and clean up if an aborted connection causes a handler to raise.
+  # https://issues.apache.org/jira/browse/PROTON-1791
+  def test_handler_raise
+    cont = ServerContainer.new(__method__, {}, 0) # Don't auto-close the listener
+    client_handler = Class.new(MessagingHandler) do
+      # TestException is < Exception so not handled by default rescue clause
+      def on_connection_open(c) raise TestException.new("Bad Dog"); end
+    end.new
+    threads = 3.times.collect { Thread.new { cont.run } }
+    sleep 0.01 while cont.running < 3 # Wait for all threads to be running
+    sockets = 2.times.collect { TCPSocket.new("", cont.port) }
+    cont.connect_io(sockets[1]) # No exception
+    cont.connect_io(sockets[0], {:handler => client_handler}) # Should stop container
+
+    threads.each { |t| assert_equal("Bad Dog", assert_raises(TestException) {t.join}.message) }
+    sockets.each { |s| assert s.closed? }
+    assert cont.listener.to_io.closed?
+    assert_raises(Container::StoppedError) { cont.run }
+    assert_raises(Container::StoppedError) { cont.listen "" }
   end
 
-  def test_sasl_plain_url()
-    skip unless SASL.extended?
-    # Use default realm with URL, should authenticate with "default_password"
-    opts = {:sasl_allowed_mechs => "PLAIN", :sasl_allow_insecure_mechs => true}
-    s = SASLHandler.new("amqp://user:default_password@",  opts)
-    TestContainer.new(s, opts, __method__).run
-    assert_equal(2, s.connections.size)
-    assert_equal("user", s.auth_user)
+  # Make sure Container::Scheduler puts tasks in proper order.
+  def test_scheduler
+    a = []
+    s = Schedule.new
+
+    assert_equal true,  s.add(Time.at 3) { a << 3 }
+    assert_equal false, s.process(Time.at 2)      # Should not run
+    assert_equal [], a
+    assert_equal true, s.process(Time.at 3)      # Should run
+    assert_equal [3], a
+
+    a = []
+    assert_equal true, s.add(Time.at 3) { a << 3 }
+    assert_equal false, s.add(Time.at 5) { a << 5 }
+    assert_equal false, s.add(Time.at 1) { a << 1 }
+    assert_equal false, s.add(Time.at 4) { a << 4 }
+    assert_equal false, s.add(Time.at 4) { a << 4.1 }
+    assert_equal false, s.add(Time.at 4) { a << 4.2 }
+    assert_equal false, s.process(Time.at 4)
+    assert_equal [1, 3, 4, 4.1, 4.2], a
+    a = []
+    assert_equal true, s.process(Time.at 5)
+    assert_equal [5], a
   end
 
-  def test_sasl_plain_options()
-    skip unless SASL.extended?
-    # Use default realm with connection options, should authenticate with "default_password"
-    opts = {:sasl_allowed_mechs => "PLAIN",:sasl_allow_insecure_mechs => true,
-            :user => 'user', :password => 'default_password' }
-    s = SASLHandler.new("amqp://", opts)
-    TestContainer.new(s, {:sasl_allowed_mechs => "PLAIN",:sasl_allow_insecure_mechs => true}, __method__).run
-    assert_equal(2, s.connections.size)
-    assert_equal("user", s.auth_user)
+  def test_container_schedule
+    c = Container.new __method__
+    delays = [0.1, 0.03, 0.02, 0.04]
+    a = []
+    delays.each { |d| c.schedule(d) { a << [d, Time.now] } }
+    start = Time.now
+    c.run
+    delays.sort.each do |d|
+      x = a.shift
+      assert_equal d, x[0]
+      assert_in_delta  start + d, x[1], 0.01
+    end
   end
 
-  # Ensure we don't allow PLAIN if allow_insecure_mechs = true is not explicitly set
-  def test_disallow_insecure()
-    # Don't set allow_insecure_mechs, but try to use PLAIN
-    s = SASLHandler.new("amqp://user:password@", {:sasl_allowed_mechs => "PLAIN", :sasl_allow_insecure_mechs => true})
-    e = assert_raises(TestError) { TestContainer.new(s, {:sasl_allowed_mechs => "PLAIN"}, __method__).run }
-    assert_match(/amqp:unauthorized-access.*Authentication failed/, e.to_s)
+  def test_work_queue
+    cont = ServerContainer.new(__method__, {}, 1)
+    c = cont.connect(cont.url)
+    t = Thread.new { cont.run }
+    q = Queue.new
+
+    start = Time.now
+    c.work_queue.schedule(0.02) { q << [3, Thread.current] }
+    c.work_queue.add { q << [1, Thread.current] }
+    c.work_queue.schedule(0.04) { q << [4, Thread.current] }
+    c.work_queue.add { q << [2, Thread.current] }
+
+    assert_equal [1, t], q.pop
+    assert_equal [2, t], q.pop
+    assert_in_delta  0.0, Time.now - start, 0.01
+    assert_equal [3, t], q.pop
+    assert_in_delta  0.02, Time.now - start, 0.01
+    assert_equal [4, t], q.pop
+    assert_in_delta  0.04, Time.now - start, 0.01
+
+    c.work_queue.add { c.close }
+    t.join
+    assert_raises(EOFError) { c.work_queue.add {  } }
   end
 end
-

data/tests/test_container_sasl.rb

@@ -0,0 +1,141 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+require 'test_tools'
+require 'minitest/unit'
+require 'socket'
+
+# Container that listens on a random port
+class TestContainer < Qpid::Proton::Container
+
+  def initialize(handler, listener_opts, id)
+    super handler, id
+    @listener = listen_io(TCPServer.open(0), ListenOnceHandler.new(listener_opts))
+  end
+  attr_reader :listener
+end
+
+class ContainerSASLTest < MiniTest::Test
+  include Qpid::Proton
+
+  # Handler for test client/server that sets up server and client SASL options
+  class SASLHandler < TestHandler
+
+    def initialize(url="amqp://", opts=nil)
+      super()
+      @url, @opts = url, opts
+    end
+
+    def on_container_start(container)
+      @client = container.connect("#{@url}:#{container.listener.port}", @opts)
+    end
+
+    attr_reader :auth_user
+
+    def on_connection_open(connection)
+      super
+      if connection == @client
+        connection.close
+      else
+        @auth_user = connection.user
+      end
+    end
+  end
+
+  # Generate SASL server configuration files and database, initialize proton SASL
+  class SASLConfig
+    include Qpid::Proton
+    attr_reader :conf_dir, :conf_file, :conf_name, :database, :error
+
+    def initialize()
+      if SASL.extended? # Configure cyrus SASL
+        @conf_dir = File.expand_path('sasl_conf')
+        @conf_name = "proton-server"
+        @database = File.join(@conf_dir, "proton.sasldb")
+        @conf_file = File.join(conf_dir,"#{@conf_name}.conf")
+        Dir::mkdir(@conf_dir) unless File.directory?(@conf_dir)
+        # Same user name in different realms
+        make_user("user", "password", "proton") # proton realm
+        make_user("user", "default_password") # Default realm
+        File.open(@conf_file, 'w') do |f|
+          f.write("
+sasldb_path: #{database}
+mech_list: EXTERNAL DIGEST-MD5 SCRAM-SHA-1 CRAM-MD5 PLAIN ANONYMOUS
+            ")
+        end
+        # Tell proton library to use the new configuration
+        SASL.config_path =  conf_dir
+        SASL.config_name = conf_name
+      end
+    rescue => e
+      @error = e
+    end
+
+    private
+
+    SASLPASSWD = (ENV['SASLPASSWD'] or 'saslpasswd2')
+
+    def make_user(user, password, realm=nil)
+      realm_opt = (realm ? "-u #{realm}" : "")
+      cmd = "echo '#{password}' | #{SASLPASSWD} -c -p -f #{database} #{realm_opt} #{user}"
+      system(cmd) or raise RuntimeError.new("saslpasswd2 failed: #{cmd}")
+    end
+
+    INSTANCE = SASLConfig.new
+  end
+
+  def begin_extended_test
+    skip("Extended SASL not enabled") unless SASL.extended?
+    skip("Extended SASL setup error: #{SASLConfig::INSTANCE.error}") if SASLConfig::INSTANCE.error
+  end
+
+  def test_sasl_anonymous()
+    s = SASLHandler.new("amqp://",  {:sasl_allowed_mechs => "ANONYMOUS"})
+    TestContainer.new(s, {:sasl_allowed_mechs => "ANONYMOUS"}, __method__).run
+    assert_equal "anonymous", s.connections[0].user
+  end
+
+  def test_sasl_plain_url()
+    begin_extended_test
+    # Use default realm with URL, should authenticate with "default_password"
+    opts = {:sasl_allowed_mechs => "PLAIN", :sasl_allow_insecure_mechs => true}
+    s = SASLHandler.new("amqp://user:default_password@",  opts)
+    TestContainer.new(s, opts, __method__).run
+    assert_equal(2, s.connections.size)
+    assert_equal("user", s.auth_user)
+  end
+
+  def test_sasl_plain_options()
+    begin_extended_test
+    # Use default realm with connection options, should authenticate with "default_password"
+    opts = {:sasl_allowed_mechs => "PLAIN",:sasl_allow_insecure_mechs => true,
+            :user => 'user', :password => 'default_password' }
+    s = SASLHandler.new("amqp://", opts)
+    TestContainer.new(s, {:sasl_allowed_mechs => "PLAIN",:sasl_allow_insecure_mechs => true}, __method__).run
+    assert_equal(2, s.connections.size)
+    assert_equal("user", s.auth_user)
+  end
+
+  # Ensure we don't allow PLAIN if allow_insecure_mechs = true is not explicitly set
+  def test_disallow_insecure()
+    # Don't set allow_insecure_mechs, but try to use PLAIN
+    s = SASLHandler.new("amqp://user:password@", {:sasl_allowed_mechs => "PLAIN", :sasl_allow_insecure_mechs => true})
+    e = assert_raises(TestError) { TestContainer.new(s, {:sasl_allowed_mechs => "PLAIN"}, __method__).run }
+    assert_match(/amqp:unauthorized-access.*Authentication failed/, e.to_s)
+  end
+end

data/tests/test_interop.rb

@@ -23,7 +23,7 @@ class InteropTest < MiniTest::Test
   # Walk up the directory tree to find the tests directory.
   def get_data(name)
     path = File.join(File.dirname(__FILE__), "../../../../tests/interop/#{name}.amqp")
-    raise "Can't find test/interop directory from #{__FILE__}" unless File.exists?(path)
+    raise "Can't find test/interop directory from #{__FILE__}" unless File.exist?(path)
     File.open(path, "rb") { |f| f.read }
   end
 

data/tests/test_messaging_adapter.rb

@@ -112,7 +112,7 @@ class TestMessagingHandler < MiniTest::Test
   def test_session_error
     d = DriverPair.new(RecordingHandler.new, RecordingHandler.new)
     d.client.connection.open
-    s = d.client.connection.session; s.open; d.run
+    s = d.client.connection.default_session; s.open; d.run
     assert_equal [:on_connection_open, :on_session_open], d.client.handler.names
     assert_equal [:on_connection_open, :on_session_open], d.server.handler.names
     d.clear

data/tests/test_tools.rb

@@ -28,7 +28,8 @@ rescue NameError                # For older versions of MiniTest
   MiniTest::Test = MiniTest::Unit::TestCase
 end
 
-class TestError < Exception; end
+class TestError < RuntimeError; end  # Normal error
+class TestException < Exception; end # Not caught by default rescue
 
 def wait_port(port, timeout=5)
   deadline = Time.now + timeout
@@ -95,15 +96,15 @@ class TestHandler < Qpid::Proton::MessagingHandler
   end
 end
 
-# ListenHandler that closes the Listener after first accept
+# ListenHandler that closes the Listener after first (or n) accepts
 class ListenOnceHandler < Qpid::Proton::Listener::Handler
-  def on_error(l, e)  raise TestError, e.inspect; end
-  def on_accept(l) l.close; super; end
+  def initialize(opts, n=1) super(opts); @n=n; end
+  def on_error(l, e) raise e; end
+  def on_accept(l) l.close if (@n -= 1).zero?; super; end
 end
 
 # Add port/url to Listener, assuming a TCP socket
 class Qpid::Proton::Listener
-  def port() to_io.addr[1]; end
   def url() "amqp://:#{port}"; end
 end
 
@@ -145,3 +146,27 @@ DriverPair = Struct.new(:client, :server) do
   end
 end
 
+# Container that listens on a random port
+class ServerContainer < Qpid::Proton::Container
+  include Qpid::Proton
+
+  def initialize(id=nil, listener_opts=nil, n=1)
+    super id
+    @listener = listen_io(TCPServer.open(0), ListenOnceHandler.new(listener_opts, n))
+  end
+
+  attr_reader :listener
+
+  def port() @listener.port; end
+  def url() "amqp://:#{port}"; end
+end
+
+class ServerContainerThread < ServerContainer
+  def initialize(id=nil, listener_opts=nil, n=1)
+    super
+    @thread = Thread.new { run }
+  end
+
+  attr_reader :thread
+  def join() @thread.join; end
+end

data/tests/test_uri.rb

@@ -67,6 +67,8 @@ class TestURI < MiniTest::Test
     assert_equal URI("amqp://h:1"), uri("h:1")
     assert_equal URI("amqp://h"), uri("h")
     assert_equal URI("amqp://h"), uri("h:")
+    assert_equal ["amqp", nil, "", 5672, ""], uri_parts("")
+    assert_equal ["amqp", nil, "", 5672, ""], uri_parts(":")
     assert_equal ["amqp", nil, "", 1, ""], uri_parts(":1")
     assert_equal ["amqp", nil, "", 1, ""], uri_parts("amqp://:1")
     assert_equal URI("amqp://[::1:2]:1"), uri("[::1:2]:1")