bunny 1.7.0 → 2.17.0

data/spec/higher_level_api/integration/connection_stop_spec.rb

@@ -4,66 +4,78 @@ describe Bunny::Session do
   let(:http_client) { RabbitMQ::HTTP::Client.new("http://127.0.0.1:15672") }
 
   def close_connection(client_port)
+    # let whatever actions were taken before
+    # this call a chance to propagate, e.g. to make
+    # sure that connections are accounted for in the
+    # stats DB.
+    #
+    # See bin/ci/before_build for management plugin
+    # pre-configuration.
+    #
+    # MK.
+    sleep 1.1
     c = http_client.
       list_connections.
-      find   { |conn_info| conn_info.peer_port.to_i == client_port }
+      find   { |conn_info| conn_info && conn_info.peer_port.to_i == client_port }
 
-    http_client.close_connection(c.name)
+    http_client.close_connection(c.name) if c
   end
 
   def wait_for_recovery
-    sleep 0.5
+    sleep 1.5
   end
 
   it "can be closed" do
-    c  = Bunny.new(:automatically_recover => false)
+    c  = Bunny.new(automatically_recover: false)
     c.start
     ch = c.create_channel
 
-    c.should be_connected
+    expect(c).to be_connected
     c.stop
-    c.should be_closed
+    expect(c).to be_closed
   end
 
   it "can be closed twice (Session#close is idempotent)" do
-    c  = Bunny.new(:automatically_recover => false)
+    c  = Bunny.new(automatically_recover: false)
     c.start
     ch = c.create_channel
 
-    c.should be_connected
+    expect(c).to be_connected
     c.stop
-    c.should be_closed
+    expect(c).to be_closed
     c.stop
-    c.should be_closed
+    expect(c).to be_closed
   end
 
   describe "in a single threaded mode" do
     it "can be closed" do
-      c  = Bunny.new(:automatically_recover => false, :threaded => false)
+      c  = Bunny.new(automatically_recover: false, threaded: false)
       c.start
       ch = c.create_channel
 
-      c.should be_connected
+      expect(c).to be_connected
       c.stop
-      c.should be_closed
+      expect(c).to be_closed
     end
   end
 
 
   describe "that recovers from connection.close" do
     it "can be closed" do
-      c  = Bunny.new(:automatically_recover => false, :recover_from_connection_close => true, :network_recovery_interval => 0.2)
+      c  = Bunny.new(automatically_recover: true,
+        recover_from_connection_close: true,
+        network_recovery_interval: 0.2)
       c.start
       ch = c.create_channel
 
-      c.should be_open
+      sleep 1.5
+      expect(c).to be_open
+      sleep 1.5
       close_connection(c.local_port)
-      sleep 0.2
-      c.should_not be_open
 
       wait_for_recovery
-      c.should be_open
-      ch.should be_open
+      expect(c).to be_open
+      expect(ch).to be_open
 
       c.close
     end

data/spec/higher_level_api/integration/consumer_cancellation_notification_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Channel do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
     c.start
     c
   end
@@ -20,21 +20,21 @@ describe Bunny::Channel do
       ch = connection.create_channel
       t  = Thread.new do
         ch2 = connection.create_channel
-        q   = ch2.queue(queue_name, :auto_delete => true)
+        q   = ch2.queue(queue_name, auto_delete: true)
 
-        q.subscribe(:on_cancellation => Proc.new { cancelled = true })
+        q.subscribe(on_cancellation: Proc.new { cancelled = true })
       end
       t.abort_on_exception = true
 
       sleep 0.5
       x = ch.default_exchange
-      x.publish("abc", :routing_key => queue_name)
+      x.publish("abc", routing_key: queue_name)
 
       sleep 0.5
-      ch.queue(queue_name, :auto_delete => true).delete
+      ch.queue(queue_name, auto_delete: true).delete
 
       sleep 0.5
-      cancelled.should be_true
+      expect(cancelled).to eq true
 
       ch.close
     end
@@ -60,7 +60,7 @@ describe Bunny::Channel do
       ch = connection.create_channel
       t  = Thread.new do
         ch2 = connection.create_channel
-        q   = ch2.queue(queue_name, :auto_delete => true)
+        q   = ch2.queue(queue_name, auto_delete: true)
 
         consumer = ExampleConsumer.new(ch2, q, "")
         q.subscribe_with(consumer)
@@ -69,13 +69,13 @@ describe Bunny::Channel do
 
       sleep 0.5
       x = ch.default_exchange
-      x.publish("abc", :routing_key => queue_name)
+      x.publish("abc", routing_key: queue_name)
 
       sleep 0.5
-      ch.queue(queue_name, :auto_delete => true).delete
+      ch.queue(queue_name, auto_delete: true).delete
 
       sleep 0.5
-      consumer.should be_cancelled
+      expect(consumer).to be_cancelled
 
       ch.close
     end
@@ -86,7 +86,7 @@ describe Bunny::Channel do
   context "with consumer re-registration" do
     class ExampleConsumerThatReregisters < Bunny::Consumer
       def handle_cancellation(_)
-        @queue = @channel.queue("basic.consume.after_cancellation", :auto_delete => true)
+        @queue = @channel.queue("basic.consume.after_cancellation", auto_delete: true)
         @channel.basic_consume_with(self)
       end
     end
@@ -100,7 +100,7 @@ describe Bunny::Channel do
       ch = connection.create_channel
       t  = Thread.new do
         ch2 = connection.create_channel
-        q   = ch2.queue(queue_name, :auto_delete => true)
+        q   = ch2.queue(queue_name, auto_delete: true)
 
         consumer = ExampleConsumerThatReregisters.new(ch2, q, "")
         consumer.on_delivery do |_, _, payload|
@@ -112,15 +112,15 @@ describe Bunny::Channel do
 
       sleep 0.5
       x = ch.default_exchange
-      x.publish("abc", :routing_key => queue_name)
+      x.publish("abc", routing_key: queue_name)
 
       sleep 0.5
-      ch.queue(queue_name, :auto_delete => true).delete
+      ch.queue(queue_name, auto_delete: true).delete
 
-      x.publish("abc", :routing_key => queue_name)
+      x.publish("abc", routing_key: queue_name)
       sleep 0.5
-      q = ch.queue("basic.consume.after_cancellation", :auto_delete => true)
-      xs.should == ["abc"]
+      q = ch.queue("basic.consume.after_cancellation", auto_delete: true)
+      expect(xs).to eq ["abc"]
 
       ch.close
     end

data/spec/higher_level_api/integration/dead_lettering_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "A message" do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
     c.start
     c
   end
@@ -15,23 +15,23 @@ describe "A message" do
     ch   = connection.create_channel
     x    = ch.fanout("amq.fanout")
     dlx  = ch.fanout("bunny.tests.dlx.exchange")
-    q    = ch.queue("", :exclusive => true, :arguments => {"x-dead-letter-exchange" => dlx.name}).bind(x)
+    q    = ch.queue("", exclusive: true, arguments: {"x-dead-letter-exchange" => dlx.name}).bind(x)
     # dead letter queue
-    dlq  = ch.queue("", :exclusive => true).bind(dlx)
+    dlq  = ch.queue("", exclusive: true).bind(dlx)
 
     x.publish("")
     sleep 0.2
 
-    delivery_info, _, _ = q.pop(:manual_ack => true)
-    dlq.message_count.should be_zero
+    delivery_info, _, _ = q.pop(manual_ack: true)
+    expect(dlq.message_count).to be_zero
     ch.nack(delivery_info.delivery_tag)
 
     sleep 0.2
-    q.message_count.should be_zero
+    expect(q.message_count).to be_zero
 
     delivery, properties, body = dlq.pop
     ds = properties.headers["x-death"]
-    ds.should_not be_empty
+    expect(ds).not_to be_empty
     expect(ds.first["reason"]).to eq("rejected")
 
     dlx.delete
@@ -41,15 +41,15 @@ describe "A message" do
     ch   = connection.create_channel
     x    = ch.fanout("amq.fanout")
     dlx  = ch.fanout("bunny.tests.dlx.exchange")
-    q    = ch.queue("", :exclusive => true, :arguments => {"x-dead-letter-exchange" => dlx.name, "x-message-ttl" => 100}).bind(x)
+    q    = ch.queue("", exclusive: true, arguments: {"x-dead-letter-exchange" => dlx.name, "x-message-ttl" => 100}).bind(x)
     # dead letter queue
-    dlq  = ch.queue("", :exclusive => true).bind(dlx)
+    dlq  = ch.queue("", exclusive: true).bind(dlx)
 
     x.publish("")
     sleep 0.2
 
-    q.message_count.should be_zero
-    dlq.message_count.should == 1
+    expect(q.message_count).to be_zero
+    expect(dlq.message_count).to eq 1
 
     dlx.delete
   end
@@ -58,16 +58,16 @@ describe "A message" do
     ch   = connection.create_channel
     x    = ch.fanout("amq.fanout")
     dlx  = ch.fanout("bunny.tests.dlx.exchange")
-    q    = ch.queue("", :exclusive => true, :arguments => {"x-dead-letter-exchange" => dlx.name, "x-message-ttl" => 100}).bind(x)
+    q    = ch.queue("", exclusive: true, arguments: {"x-dead-letter-exchange" => dlx.name, "x-message-ttl" => 100}).bind(x)
     # dead letter queue
-    dlq  = ch.queue("", :exclusive => true).bind(dlx)
+    dlq  = ch.queue("", exclusive: true).bind(dlx)
 
     x.publish("")
     sleep 0.2
 
     delivery, properties, body = dlq.pop
     ds = properties.headers["x-death"]
-    ds.should_not be_empty
+    expect(ds).not_to be_empty
     expect(ds.first["reason"]).to eq("expired")
 
     dlx.delete

data/spec/higher_level_api/integration/exchange_bind_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Exchange do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
     c.start
     c
   end
@@ -14,17 +14,17 @@ describe Bunny::Exchange do
   it "binds two existing exchanges" do
     ch          = connection.create_channel
 
-    source      = ch.fanout("bunny.exchanges.source", :auto_delete => true)
-    destination = ch.fanout("bunny.exchanges.destination", :auto_delete => true)
+    source      = ch.fanout("bunny.exchanges.source", auto_delete: true)
+    destination = ch.fanout("bunny.exchanges.destination", auto_delete: true)
 
-    queue       = ch.queue("", :exclusive => true)
+    queue       = ch.queue("", exclusive: true)
     queue.bind(destination)
 
     destination.bind(source)
     source.publish("")
     sleep 0.5
 
-    queue.message_count.should be > 0
+    expect(queue.message_count).to be > 0
 
     ch.close
   end

data/spec/higher_level_api/integration/exchange_declare_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Exchange do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
     c.start
     c
   end
@@ -17,7 +17,7 @@ describe Bunny::Exchange do
 
       x = Bunny::Exchange.default(ch)
 
-      x.name.should == ''
+      expect(x.name).to eq ''
     end
   end
 
@@ -28,7 +28,7 @@ describe Bunny::Exchange do
 
         name = "bunny.tests.exchanges.fanout#{rand}"
         x    = ch.fanout(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
         x.delete
         ch.close
@@ -41,7 +41,7 @@ describe Bunny::Exchange do
 
         name = "amq.fanout"
         x    = ch.fanout(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
         ch.close
       end
@@ -55,7 +55,7 @@ describe Bunny::Exchange do
           ch.fanout("amq.test")
         }.to raise_error(Bunny::AccessRefused)
 
-        ch.should be_closed
+        expect(ch).to be_closed
         expect {
           ch.fanout("amq.test")
         }.to raise_error(Bunny::ChannelAlreadyClosed)
@@ -67,10 +67,10 @@ describe Bunny::Exchange do
         ch = connection.create_channel
 
         name = "bunny.tests.exchanges.durable"
-        x    = ch.fanout(name, :durable => true)
-        x.name.should == name
-        x.should be_durable
-        x.should_not be_auto_delete
+        x    = ch.fanout(name, durable: true)
+        expect(x.name).to eq name
+        expect(x).to be_durable
+        expect(x).not_to be_auto_delete
 
         x.delete
         ch.close
@@ -83,12 +83,12 @@ describe Bunny::Exchange do
         ch = connection.create_channel
 
         name = "bunny.tests.exchanges.auto-delete"
-        x    = ch.fanout(name, :auto_delete => true)
-        x.name.should == name
-        x.should_not be_durable
-        x.should be_auto_delete
+        x    = ch.fanout(name, auto_delete: true)
+        expect(x.name).to eq name
+        expect(x).not_to be_durable
+        expect(x).to be_auto_delete
 
-        ch.exchange(name, :type => :fanout, :auto_delete => true)
+        ch.exchange(name, type: :fanout, auto_delete: true)
 
         x.delete
         ch.close
@@ -98,17 +98,18 @@ describe Bunny::Exchange do
 
     context "when declared with a different set of attributes" do
       it "raises an exception" do
-        ch   = connection.create_channel
+        ch1   = connection.create_channel
+        ch2   = connection.create_channel
 
-        x = ch.fanout("bunny.tests.exchanges.fanout", :auto_delete => true, :durable => false)
+        x = ch1.fanout("bunny.tests.exchanges.fanout", auto_delete: true, durable: false)
         expect {
           # force re-declaration
-          ch.exchange_declare("bunny.tests.exchanges.fanout", :direct, :auto_delete => false, :durable => true)
+          ch2.exchange_declare("bunny.tests.exchanges.fanout", :direct, auto_delete: false, durable: true)
         }.to raise_error(Bunny::PreconditionFailed)
 
-        ch.should be_closed
+        expect(ch2).to be_closed
         expect {
-          ch.fanout("bunny.tests.exchanges.fanout", :auto_delete => true, :durable => false)
+          ch2.fanout("bunny.tests.exchanges.fanout", auto_delete: true, durable: false)
         }.to raise_error(Bunny::ChannelAlreadyClosed)
       end
     end
@@ -121,9 +122,9 @@ describe Bunny::Exchange do
 
         name = "bunny.tests.exchanges.direct"
         x    = ch.direct(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
-        ch.exchange(name, :type => :direct)
+        ch.exchange(name, type: :direct)
 
         x.delete
         ch.close
@@ -136,7 +137,7 @@ describe Bunny::Exchange do
 
         name = "amq.direct"
         x    = ch.direct(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
         ch.close
       end
@@ -150,9 +151,9 @@ describe Bunny::Exchange do
 
         name = "bunny.tests.exchanges.topic"
         x    = ch.topic(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
-        ch.exchange(name, :type => :topic)
+        ch.exchange(name, type: :topic)
 
         x.delete
         ch.close
@@ -165,7 +166,7 @@ describe Bunny::Exchange do
 
         name = "amq.topic"
         x    = ch.topic(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
         ch.close
       end
@@ -179,7 +180,7 @@ describe Bunny::Exchange do
 
         name = "bunny.tests.exchanges.headers"
         x    = ch.headers(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
         x.delete
         ch.close
@@ -192,7 +193,7 @@ describe Bunny::Exchange do
 
         name = "amq.match"
         x    = ch.headers(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
         ch.close
       end
@@ -204,7 +205,7 @@ describe Bunny::Exchange do
 
         name = "amq.headers"
         x    = ch.headers(name)
-        x.name.should == name
+        expect(x.name).to eq name
 
         ch.close
       end
@@ -215,8 +216,8 @@ describe Bunny::Exchange do
   context "that is internal" do
     it "can be declared" do
       ch = connection.create_channel
-      x  = ch.fanout("bunny.tests.exchanges.internal", :internal => true)
-      x.should be_internal
+      x  = ch.fanout("bunny.tests.exchanges.internal", internal: true)
+      expect(x).to be_internal
       x.delete
 
       ch.close
@@ -227,7 +228,7 @@ describe Bunny::Exchange do
     it "is not internal" do
       ch = connection.create_channel
       x  = ch.fanout("bunny.tests.exchanges.non-internal")
-      x.should_not be_internal
+      expect(x).not_to be_internal
       x.delete
 
       ch.close