qpid_proton 0.19.0 → 0.21.0

data/tests/test_connection_driver.rb

@@ -0,0 +1,134 @@
+# 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
+#
+# 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'
+
+include Qpid::Proton
+
+# Test delivery of raw proton events
+
+class RawDriverTest < MiniTest::Test
+
+  # Raw handler to record all on_xxx calls
+  class RecordingHandler
+    def initialize() @calls =[]; end
+    def proton_adapter_class() nil; end # Raw adapter
+    attr_reader :calls
+
+    def method_missing(name, *args) respond_to_missing?(name) ? @calls << name : super; end
+    def respond_to_missing?(name, private=false); (/^on_/ =~ name); end
+    def respond_to?(name, all=false) super || respond_to_missing?(name); end # For ruby < 1.9.2
+  end
+
+  def test_send_recv
+    send_class = Class.new do
+      def proton_adapter_class() nil; end # Raw adapter
+      attr_reader :outcome
+      def on_link_flow(event) event.sender.send Message.new("foo"); end
+      def on_delivery(event)
+        @outcome = event.delivery.state
+        event.connection.close;
+      end
+    end
+
+    recv_class = Class.new do
+      def proton_adapter_class() nil; end # Raw adapter
+      attr_reader :message
+      def on_connection_remote_open(event) event.context.open; end
+      def on_session_remote_open(event) event.context.open; end
+      def on_link_remote_open(event) event.link.open; event.link.flow(1); end
+      def on_delivery(event) @message = event.message; event.delivery.accept; end
+    end
+
+    d = DriverPair.new(send_class.new, recv_class.new)
+    d.client.connection.open(:container_id => __method__);
+    d.client.connection.open_sender()
+    d.run
+    assert_equal(d.server.handler.message.body, "foo")
+    assert_equal Transfer::ACCEPTED, d.client.handler.outcome
+  end
+
+  def test_idle
+
+    d = DriverPair.new(RecordingHandler.new, RecordingHandler.new)
+    ms = 444
+    secs = Rational(ms, 1000)   # Use rationals to keep it accurate
+    opts = {:idle_timeout => secs}
+    d.client.transport.apply(opts)
+    assert_equal(ms, d.client.transport.idle_timeout) # Transport converts to ms
+    d.server.transport.set_server
+    d.client.connection.open(opts)
+
+    start = Time.at(1)          # Dummy timeline
+    tick = d.run start          # Process all IO events
+    assert_equal(secs/4, tick - start)
+    assert_equal [:on_connection_init, :on_connection_local_open, :on_connection_bound], d.client.handler.calls
+    assert_equal [:on_connection_init, :on_connection_bound, :on_connection_remote_open, :on_transport], d.server.handler.calls
+    assert_equal (ms), d.client.transport.idle_timeout
+    assert_equal (ms/2), d.server.transport.remote_idle_timeout # proton changes the value
+    assert_equal (secs/2), d.server.connection.idle_timeout
+
+    # Now update the time till we get connections closing
+    d.each { |x| x.handler.calls.clear }
+    d.run(start + secs - 0.001) # Should nothing, timeout not reached
+    assert_equal [[],[]], d.collect { |x| x.handler.calls }
+    d.run(start + secs*2)   # After 2x timeout, connections should close
+    assert_equal [[:on_transport_error, :on_transport_tail_closed, :on_transport_head_closed, :on_transport_closed], [:on_connection_remote_close, :on_transport_tail_closed, :on_transport_head_closed, :on_transport_closed]], d.collect { |x| x.handler.calls }
+  end
+
+  # Test each_session/each_link methods both with a block and returning Enumerator
+  def test_enumerators
+    connection = Connection.new()
+    (3.times.collect { connection.open_session }).each { |s|
+      s.open_sender; s.open_receiver
+    }
+
+    assert_equal 3, connection.each_session.to_a.size
+    assert_equal 6, connection.each_link.to_a.size
+
+    # Build Session => Set<Links> map using connection link enumerator
+    map1 = {}
+    connection.each_link { |l| map1[l.session] ||= Set.new; map1[l.session] << l }
+    assert_equal 3, map1.size
+    map1.each do |session,links|
+      assert_equal 2, links.size
+      links.each { |l| assert_equal session, l.session }
+    end
+
+    # Build Session => Set<Links> map using connection and session blocks
+    map2 = {}
+    connection.each_session do |session|
+      map2[session] = Set.new
+      session.each_link { |l| map2[session] << l }
+    end
+    assert_equal map1, map2
+
+    # Build Session => Set<Links> map using connection session and session enumerators
+    map3 = Hash[connection.each_session.collect { |s| [s, Set.new(s.each_link)] }]
+    assert_equal map1, map3
+
+    assert_equal [true, true, true], connection.each_sender.collect { |l| l.is_a? Sender }
+    assert_equal [true, true, true], connection.each_receiver.collect { |l| l.is_a? Receiver }
+    connection.each_session { |session|
+      assert_equal [true], session.each_sender.collect { |l| l.is_a? Sender }
+      assert_equal [true], session.each_receiver.collect { |l| l.is_a? Receiver }
+    }
+
+
+  end
+end

data/tests/test_container.rb

@@ -0,0 +1,319 @@
+# 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, 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#
+end
+
+class ContainerTest < MiniTest::Test
+  include Qpid::Proton
+
+  def test_simple()
+    send_handler = Class.new(MessagingHandler) do
+      attr_reader :accepted, :sent
+      def on_sendable(sender)
+        sender.send Message.new("foo") unless @sent
+        @sent = true
+      end
+
+      def on_tracker_accept(tracker)
+        @accepted = true
+        tracker.connection.close
+      end
+    end.new
+
+    receive_handler = Class.new(MessagingHandler) do
+      attr_reader :message, :link
+      def on_receiver_open(link)
+        @link = link
+        @link.open
+        @link.flow(1)
+      end
+
+      def on_message(delivery, message)
+        @message = message;
+        delivery.update Disposition::ACCEPTED
+        delivery.settle
+      end
+    end.new
+
+    c = TestContainer.new(receive_handler, {}, __method__)
+    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 "test_simple", receive_handler.link.connection.container_id
+  end
+
+  class CloseOnOpenHandler < TestHandler
+    def on_connection_open(c) super; c.close; end
+  end
+
+  def test_auto_stop_one
+    # A listener and a connection
+    start_stop_handler = Class.new do
+      def on_container_start(c) @start = c; end
+      def on_container_stop(c) @stop = c; end
+      attr_reader :start, :stop
+    end.new
+    c = Container.new(start_stop_handler, __method__)
+    threads = 3.times.collect { Thread.new { c.run } }
+    sleep(0.01) while c.running < 3
+    assert_equal c, start_stop_handler.start
+    l = c.listen_io(TCPServer.new(0), ListenOnceHandler.new({ :handler => CloseOnOpenHandler.new}))
+    c.connect("amqp://:#{l.to_io.addr[1]}", { :handler => CloseOnOpenHandler.new} )
+    threads.each { |t| assert t.join(1) }
+    assert_equal c, start_stop_handler.stop
+    assert_raises(Container::StoppedError) { c.run }
+  end
+
+  def test_auto_stop_two
+    # Connect between different containers
+    c1, c2 = Container.new("#{__method__}-1"), Container.new("#{__method__}-2")
+    threads = [ Thread.new {c1.run }, Thread.new {c2.run } ]
+    l = c2.listen_io(TCPServer.new(0), ListenOnceHandler.new({ :handler => CloseOnOpenHandler.new}))
+    c1.connect(l.url, { :handler => CloseOnOpenHandler.new} )
+    assert threads.each { |t| t.join(1) }
+    assert_raises(Container::StoppedError) { c1.run }
+    assert_raises(Container::StoppedError) { c2.connect("") }
+  end
+
+  def test_auto_stop_listener_only
+    c = Container.new(__method__)
+    # Listener only, external close
+    t = Thread.new { c.run }
+    l = c.listen_io(TCPServer.new(0))
+    l.close
+    assert t.join(1)
+  end
+
+  def test_stop_empty
+    c = Container.new(__method__)
+    threads = 3.times.collect { Thread.new { c.run } }
+    sleep(0.01) while c.running < 3
+    assert_nil threads[0].join(0.001) # Not stopped
+    c.stop
+    assert c.stopped
+    assert_raises(Container::StoppedError) { c.connect("") }
+    assert_raises(Container::StoppedError) { c.run }
+    threads.each { |t| assert t.join(1) }
+  end
+
+  def test_stop
+    c = Container.new(__method__)
+    c.auto_stop = false
+
+    l = c.listen_io(TCPServer.new(0))
+    threads = 3.times.collect { Thread.new { c.run } }
+    sleep(0.01) while c.running < 3
+    l.close
+    assert_nil threads[0].join(0.001) # Not stopped, no auto_stop
+
+    l = c.listen_io(TCPServer.new(0)) # New listener
+    conn = c.connect("amqp://:#{l.to_io.addr[1]}")
+    c.stop
+    assert c.stopped
+    threads.each { |t| assert t.join(1) }
+
+    assert_raises(Container::StoppedError) { c.run }
+    assert_equal 0, c.running
+    assert_nil l.condition
+    assert_nil conn.condition
+  end
+
+  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") }
+  end
+
+  # Verify that connection options are sent to the peer and available as Connection methods
+  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
+      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",
+               })
+        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,
+                                  })
+    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"
+                          })
+    cont.run
+    c = server_handler.connection
+    assert_equal "client.to.server", c.virtual_host
+    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
+    assert_equal 100, c.max_sessions
+    assert_equal 4096, c.max_frame_size
+    assert_equal "bowl", c.container_id
+
+    c = client
+    assert_equal "server.to.client", c.virtual_host
+    assert_equal({ :server => :client }, c.properties)
+    assert_equal([:s1], c.offered_capabilities)
+    assert_equal([:s2], c.desired_capabilities)
+    assert_equal "box", c.container_id
+    assert_equal 8888, c.max_frame_size
+    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
+
+  # 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.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
+
+    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
+
+    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: #{makepw_cmd}")
+    end
+    DEFAULT = SASLConfig.new
+  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()
+    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)
+  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)
+  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_data.rb

@@ -0,0 +1,66 @@
+# 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 "securerandom"
+require 'qpid_proton'
+
+class TestData < MiniTest::Test
+  include Qpid::Proton
+
+  def assert_from_to(*values)
+    d = Codec::Data.new
+    values.each do |x|
+      Codec::Data.from_object(d.impl, x)
+      assert_equal x, Codec::Data.to_object(d.impl)
+    end
+  end
+
+  def test_from_to
+    assert_from_to({ 1 => :one, 2=>:two })
+    assert_from_to([{:a => 1, "b" => 2}, 3, 4.4, :five])
+    assert_from_to(Types::UniformArray.new(Types::INT, [1, 2, 3, 4]))
+  end
+
+  def rnum(*arg) SecureRandom.random_number(*arg); end
+  def rstr(*arg) SecureRandom.base64(*arg); end
+
+  def test_nil()
+    assert_nil((Codec::Data.new << nil).object)
+  end
+
+  def assert_convert(*values)
+    values.each { |x| assert_equal x, ((Codec::Data.new << x).object) }
+  end
+
+  def test_bool()
+    assert_convert(true, false)
+  end
+
+  def test_float()
+    assert_convert(0.0, 1.0, -1.0, 1.23e123, rnum(), rnum(), rnum(), rnum())
+  end
+
+  def test_string()
+    assert_convert("", "foo", rstr(100000), rstr(rnum(1000)), rstr(rnum(1000)))
+  end
+
+  def test_symbol()
+    assert_convert(:"", :foo, rstr(256).to_sym)
+  end
+end

data/tests/test_delivery.rb

@@ -0,0 +1,110 @@
+# 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 'minitest/autorun'
+require 'qpid_proton'
+require 'test_tools'
+include Qpid::Proton
+
+# Test Delivery and Tracker
+class TestDelivery < MiniTest::Test
+
+  class NoAutoHandler < MessagingHandler
+    def on_sender_open(l) l.open({:auto_settle=>false, :auto_accept=>false}); end
+    def on_receiver_open(l) l.open({:auto_settle=>false, :auto_accept=>false}); end
+  end
+
+  class SendHandler < NoAutoHandler
+    def initialize(to_send)
+      @unsent = to_send
+    end
+
+    def on_connection_open(connection)
+      @outcomes = []
+      @sender = connection.open_sender("x")
+      @unsettled = {}           # Awaiting remote settlement
+    end
+
+    attr_reader :outcomes, :unsent, :unsettled
+
+    def on_sendable(sender)
+      return if @unsent.empty?
+      m = Message.new(@unsent.shift)
+      tracker = sender.send(m)
+      @unsettled[tracker] = m
+    end
+
+    def outcome(method, tracker)
+      t = tracker
+      m = @unsettled.delete(t)
+      @outcomes << [m.body, method, t.id, t.state, t.modifications]
+      tracker.connection.close if @unsettled.empty?
+    end
+
+    def on_tracker_accept(tracker) outcome(__method__, tracker); end
+    def on_tracker_reject(tracker) outcome(__method__, tracker); end
+    def on_tracker_release(tracker) outcome(__method__, tracker); end
+    def on_tracker_modify(tracker) outcome(__method__, tracker); end
+  end
+
+  class ReceiveHandler < NoAutoHandler
+    def initialize
+      @received = []
+    end
+
+    attr_reader :received
+
+    def on_message(delivery, message)
+      @received << message.body
+      case message.body
+      when "accept" then delivery.accept
+      when "reject" then delivery.reject
+      when "release-really" then delivery.release({:failed=>false}) # AMQP RELEASED
+      when "release" then delivery.release # AMQP MODIFIED{ :failed => true }
+      when "modify" then delivery.release({:undeliverable => true, :annotations => {:x => 42 }})
+      when "modify-empty" then delivery.release({:failed => false, :undeliverable => false, :annotations => {}})
+      when "modify-nil" then delivery.release({:failed => false, :undeliverable => false, :annotations => nil})
+      when "reject-raise" then raise Reject
+      when "release-raise" then raise Release
+      else raise inspect
+      end
+    end
+  end
+
+  def test_outcomes
+    rh = ReceiveHandler.new
+    sh = SendHandler.new(["accept", "reject", "release-really", "release", "modify", "modify-empty", "modify-nil", "reject-raise", "release-raise"])
+    c = Container.new(nil, __method__)
+    l = c.listen_io(TCPServer.new(0), ListenOnceHandler.new({ :handler => rh }))
+    c.connect(l.url, {:handler => sh})
+    c.run
+    o = sh.outcomes
+    assert_equal ["accept", :on_tracker_accept, "1", Transfer::ACCEPTED, nil], o.shift
+    assert_equal ["reject", :on_tracker_reject, "2", Transfer::REJECTED, nil], o.shift
+    assert_equal ["release-really", :on_tracker_release, "3", Transfer::RELEASED, nil], o.shift
+    assert_equal ["release", :on_tracker_modify, "4", Transfer::MODIFIED, {:failed=>true, :undeliverable=>false, :annotations=>nil}], o.shift
+    assert_equal ["modify", :on_tracker_modify, "5", Transfer::MODIFIED, {:failed=>true, :undeliverable=>true, :annotations=>{:x => 42}}], o.shift
+    assert_equal ["modify-empty", :on_tracker_release, "6", Transfer::RELEASED, nil], o.shift
+    assert_equal ["modify-nil", :on_tracker_release, "7", Transfer::RELEASED, nil], o.shift
+    assert_equal ["reject-raise", :on_tracker_reject, "8", Transfer::REJECTED, nil], o.shift
+    assert_equal ["release-raise", :on_tracker_modify, "9", Transfer::MODIFIED, {:failed=>true, :undeliverable=>false, :annotations=>nil}], o.shift
+    assert_empty o
+    assert_equal ["accept", "reject", "release-really", "release", "modify", "modify-empty", "modify-nil", "reject-raise", "release-raise"], rh.received
+    assert_empty sh.unsettled
+  end
+end