bunny 1.7.0 → 2.17.0

data/spec/higher_level_api/integration/basic_cancel_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Consumer, "#cancel" 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
@@ -19,14 +19,14 @@ describe Bunny::Consumer, "#cancel" do
 
       t = Thread.new do
         ch         = connection.create_channel
-        q          = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        consumer = q.subscribe(:block => false) do |_, _, payload|
+        q          = ch.queue(queue_name, auto_delete: true, durable: false)
+        consumer = q.subscribe do |_, _, payload|
           delivered_data << payload
         end
 
-        consumer.consumer_tag.should_not be_nil
+        expect(consumer.consumer_tag).not_to be_nil
         cancel_ok = consumer.cancel
-        cancel_ok.consumer_tag.should == consumer.consumer_tag
+        expect(cancel_ok.consumer_tag).to eq consumer.consumer_tag
 
         ch.close
       end
@@ -34,10 +34,10 @@ describe Bunny::Consumer, "#cancel" do
       sleep 0.5
 
       ch = connection.create_channel
-      ch.default_exchange.publish("", :routing_key => queue_name)
+      ch.default_exchange.publish("", routing_key: queue_name)
 
       sleep 0.7
-      delivered_data.should be_empty
+      expect(delivered_data).to be_empty
     end
   end
 
@@ -51,14 +51,14 @@ describe Bunny::Consumer, "#cancel" do
 
       t = Thread.new do
         ch         = connection.create_channel
-        q          = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        q          = ch.queue(queue_name, auto_delete: true, durable: false)
 
         consumer   = Bunny::Consumer.new(ch, q)
         consumer.on_delivery do |_, _, payload|
           delivered_data << payload
         end
 
-        q.subscribe_with(consumer, :block => false)
+        q.subscribe_with(consumer)
       end
       t.abort_on_exception = true
       sleep 1.0
@@ -67,10 +67,76 @@ describe Bunny::Consumer, "#cancel" do
       sleep 1.0
 
       ch = connection.create_channel
-      ch.default_exchange.publish("", :routing_key => queue_name)
+      ch.default_exchange.publish("", routing_key: queue_name)
 
       sleep 0.7
-      delivered_data.should be_empty
+      expect(delivered_data).to be_empty
+    end
+  end
+
+  context "with a worker pool shutdown timeout configured" do
+    let(:queue_name) { "bunny.queues.#{rand}" }
+
+    it "processes the message if processing completes within the timeout" do
+      delivered_data = []
+      consumer       = nil
+
+      t = Thread.new do
+        ch         = connection.create_channel(nil, 1, false, 5)
+        q          = ch.queue(queue_name, auto_delete: true, durable: false)
+
+        consumer   = Bunny::Consumer.new(ch, q)
+        consumer.on_delivery do |_, _, payload|
+          sleep 2
+          delivered_data << payload
+        end
+
+        q.subscribe_with(consumer)
+      end
+      t.abort_on_exception = true
+      sleep 1.0
+
+      ch = connection.create_channel
+      ch.confirm_select
+      ch.default_exchange.publish("", routing_key: queue_name)
+      ch.wait_for_confirms
+      sleep 0.5
+
+      consumer.cancel
+      sleep 1.0
+
+      expect(delivered_data).to_not be_empty
+    end
+
+    it "kills the consumer if processing takes longer than the timeout" do
+      delivered_data = []
+      consumer       = nil
+
+      t = Thread.new do
+        ch         = connection.create_channel(nil, 1, false, 1)
+        q          = ch.queue(queue_name, auto_delete: true, durable: false)
+
+        consumer   = Bunny::Consumer.new(ch, q)
+        consumer.on_delivery do |_, _, payload|
+          sleep 3
+          delivered_data << payload
+        end
+
+        q.subscribe_with(consumer)
+      end
+      t.abort_on_exception = true
+      sleep 1.0
+
+      ch = connection.create_channel
+      ch.confirm_select
+      ch.default_exchange.publish("", routing_key: queue_name)
+      ch.wait_for_confirms
+      sleep 0.5
+
+      consumer.cancel
+      sleep 1.0
+
+      expect(delivered_data).to be_empty
     end
   end
 end

data/spec/higher_level_api/integration/basic_consume_spec.rb

@@ -3,7 +3,7 @@ require "set"
 
 describe Bunny::Queue, "#subscribe" 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
@@ -21,8 +21,8 @@ describe Bunny::Queue, "#subscribe" do
 
       t = Thread.new do
         ch = connection.create_channel
-        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+        q = ch.queue(queue_name, auto_delete: true, durable: false)
+        q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
           delivered_keys << delivery_info.routing_key
           delivered_data << payload
         end
@@ -32,13 +32,13 @@ describe Bunny::Queue, "#subscribe" do
 
       ch = connection.create_channel
       x  = ch.default_exchange
-      x.publish("hello", :routing_key => queue_name)
+      x.publish("hello", routing_key: queue_name)
 
       sleep 0.7
-      delivered_keys.should include(queue_name)
-      delivered_data.should include("hello")
+      expect(delivered_keys).to include(queue_name)
+      expect(delivered_data).to include("hello")
 
-      ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+      expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
 
       ch.close
     end
@@ -50,8 +50,8 @@ describe Bunny::Queue, "#subscribe" do
         delivery_tags = SortedSet.new
 
         cch = connection.create_channel
-        q = cch.queue(queue_name, :auto_delete => true, :durable => false)
-        q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+        q = cch.queue(queue_name, auto_delete: true, durable: false)
+        q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
           delivery_tags << delivery_info.delivery_tag
         end
         sleep 0.5
@@ -59,13 +59,13 @@ describe Bunny::Queue, "#subscribe" do
         ch = connection.create_channel
         x  = ch.default_exchange
         100.times do
-          x.publish("hello", :routing_key => queue_name)
+          x.publish("hello", routing_key: queue_name)
         end
 
         sleep 1.0
-        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
+        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
 
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
 
         ch.close
       end
@@ -79,10 +79,10 @@ describe Bunny::Queue, "#subscribe" do
         delivery_tags = SortedSet.new
 
         cch = connection.create_channel
-        q   = cch.queue(queue_name, :auto_delete => true, :durable => false)
+        q   = cch.queue(queue_name, auto_delete: true, durable: false)
 
         7.times do
-          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+          q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
             delivery_tags << delivery_info.delivery_tag
           end
         end
@@ -91,13 +91,13 @@ describe Bunny::Queue, "#subscribe" do
         ch = connection.create_channel
         x  = ch.default_exchange
         100.times do
-          x.publish("hello", :routing_key => queue_name)
+          x.publish("hello", routing_key: queue_name)
         end
 
         sleep 1.5
-        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
+        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
 
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
 
         ch.close
       end
@@ -113,8 +113,8 @@ describe Bunny::Queue, "#subscribe" do
 
       t = Thread.new do
         ch = connection.create_channel
-        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        q.subscribe(:exclusive => false, :manual_ack => true) do |delivery_info, properties, payload|
+        q = ch.queue(queue_name, auto_delete: true, durable: false)
+        q.subscribe(exclusive: false, manual_ack: true) do |delivery_info, properties, payload|
           delivered_keys << delivery_info.routing_key
           delivered_data << payload
 
@@ -126,13 +126,13 @@ describe Bunny::Queue, "#subscribe" do
 
       ch = connection.create_channel
       x  = ch.default_exchange
-      x.publish("hello", :routing_key => queue_name)
+      x.publish("hello", routing_key: queue_name)
 
       sleep 0.7
-      delivered_keys.should include(queue_name)
-      delivered_data.should include("hello")
+      expect(delivered_keys).to include(queue_name)
+      expect(delivered_data).to include("hello")
 
-      ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+      expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
 
       ch.close
     end
@@ -147,19 +147,19 @@ describe Bunny::Queue, "#subscribe" do
         delivered_data = []
 
         ch = connection.create_channel
-        q  = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        q  = ch.queue(queue_name, auto_delete: true, durable: false)
         x  = ch.default_exchange
         100.times do
-          x.publish("hello", :routing_key => queue_name)
+          x.publish("hello", routing_key: queue_name)
         end
 
         sleep 0.7
-        q.message_count.should be > 50
+        expect(q.message_count).to be > 50
 
         t = Thread.new do
           ch = connection.create_channel
-          q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+          q = ch.queue(queue_name, auto_delete: true, durable: false)
+          q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
             delivered_keys << delivery_info.routing_key
             delivered_data << payload
           end
@@ -167,10 +167,10 @@ describe Bunny::Queue, "#subscribe" do
         t.abort_on_exception = true
         sleep 0.5
 
-        delivered_keys.should include(queue_name)
-        delivered_data.should include("hello")
+        expect(delivered_keys).to include(queue_name)
+        expect(delivered_data).to include("hello")
 
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
 
         ch.close
       end
@@ -189,17 +189,17 @@ describe Bunny::Queue, "#subscribe" do
         ch = connection.create_channel
         q  = ch.queue(queue_name)
 
-        c1  = q.subscribe(:exclusive => false, :manual_ack => false, :block => false) do |delivery_info, properties, payload|
+        c1  = q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
         end
         c1.cancel
 
-        c2  = q.subscribe(:exclusive => false, :manual_ack => false, :block => false) do |delivery_info, properties, payload|
+        c2  = q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
           delivered_keys << delivery_info.routing_key
           delivered_data << payload
         end
         c2.cancel
 
-        q.subscribe(:exclusive => false, :manual_ack => false, :block => true) do |delivery_info, properties, payload|
+        q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
           delivered_keys << delivery_info.routing_key
           delivered_data << payload
         end
@@ -209,13 +209,13 @@ describe Bunny::Queue, "#subscribe" do
 
       ch = connection.create_channel
       x  = ch.default_exchange
-      x.publish("hello", :routing_key => queue_name)
+      x.publish("hello", routing_key: queue_name)
 
       sleep 0.7
-      delivered_keys.should include(queue_name)
-      delivered_data.should include("hello")
+      expect(delivered_keys).to include(queue_name)
+      expect(delivered_data).to include("hello")
 
-      ch.queue(queue_name).message_count.should == 0
+      expect(ch.queue(queue_name).message_count).to eq 0
 
       ch.queue_delete(queue_name)
       ch.close
@@ -231,13 +231,13 @@ describe Bunny::Queue, "#subscribe" do
         caught = nil
         t = Thread.new do
           ch = connection.create_channel
-          q  = ch.queue(queue_name, :auto_delete => true, :durable => false)
+          q  = ch.queue(queue_name, auto_delete: true, durable: false)
 
           ch.on_uncaught_exception do |e, consumer|
             caught = e
           end
 
-          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+          q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
             raise RuntimeError.new(queue_name)
           end
         end
@@ -246,10 +246,10 @@ describe Bunny::Queue, "#subscribe" do
 
         ch     = connection.create_channel
         x  = ch.default_exchange
-        x.publish("hello", :routing_key => queue_name)
+        x.publish("hello", routing_key: queue_name)
         sleep 0.5
 
-        caught.message.should == queue_name
+        expect(caught.message).to eq queue_name
 
         ch.close
       end
@@ -260,11 +260,14 @@ describe Bunny::Queue, "#subscribe" do
       let(:queue_name) { "bunny.basic_consume#{rand}" }
 
       it "uses exception handler" do
+        caughts = []
         t = Thread.new do
+          allow(connection.logger).to receive(:error) { |x| caughts << x }
+
           ch = connection.create_channel
-          q  = ch.queue(queue_name, :auto_delete => true, :durable => false)
+          q  = ch.queue(queue_name, auto_delete: true, durable: false)
 
-          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+          q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
             raise RuntimeError.new(queue_name)
           end
         end
@@ -273,9 +276,11 @@ describe Bunny::Queue, "#subscribe" do
 
         ch     = connection.create_channel
         x  = ch.default_exchange
-        5.times { x.publish("hello", :routing_key => queue_name) }
+        5.times { x.publish("hello", routing_key: queue_name) }
         sleep 1.5
 
+        expect(caughts.size).to eq(5)
+
         ch.close
       end
     end
@@ -288,8 +293,8 @@ describe Bunny::Queue, "#subscribe" do
         delivery_tags = SortedSet.new
 
         cch = connection.create_channel
-        q = cch.queue(queue_name, :auto_delete => true, :durable => false)
-        q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+        q = cch.queue(queue_name, auto_delete: true, durable: false)
+        q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
           delivery_tags << delivery_info.delivery_tag
         end
         sleep 0.5
@@ -297,13 +302,13 @@ describe Bunny::Queue, "#subscribe" do
         ch = connection.create_channel
         x  = ch.default_exchange
         100.times do
-          x.publish("hello", :routing_key => queue_name)
+          x.publish("hello", routing_key: queue_name)
         end
 
         sleep 1.0
-        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
+        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
 
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
 
         ch.close
       end
@@ -317,10 +322,10 @@ describe Bunny::Queue, "#subscribe" do
         delivery_tags = SortedSet.new
 
         cch = connection.create_channel
-        q   = cch.queue(queue_name, :auto_delete => true, :durable => false)
+        q   = cch.queue(queue_name, auto_delete: true, durable: false)
 
         7.times do
-          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
+          q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
             delivery_tags << delivery_info.delivery_tag
           end
         end
@@ -329,13 +334,13 @@ describe Bunny::Queue, "#subscribe" do
         ch = connection.create_channel
         x  = ch.default_exchange
         100.times do
-          x.publish("hello", :routing_key => queue_name)
+          x.publish("hello", routing_key: queue_name)
         end
 
         sleep 1.5
-        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
+        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
 
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
 
         ch.close
       end

data/spec/higher_level_api/integration/basic_consume_with_objects_spec.rb

@@ -3,7 +3,7 @@ require "set"
 
 describe Bunny::Queue, "#subscribe_with" 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
@@ -32,23 +32,23 @@ describe Bunny::Queue, "#subscribe_with" do
     it "requeues messages on channel closure" do
       ch1  = connection.create_channel
       ch2  = connection.create_channel
-      q1   = ch1.queue("bunny.tests.consumer_object1", :exclusive => true)
-      q2   = ch2.queue("bunny.tests.consumer_object1", :exclusive => true)
+      q1   = ch1.queue("bunny.tests.consumer_object1", exclusive: true)
+      q2   = ch2.queue("bunny.tests.consumer_object1", exclusive: true)
       ec   = ExampleConsumer.new(ch1, q1, "", false)
       x    = ch2.default_exchange
 
       t = Thread.new do
         50.times do
-          x.publish("hello", :routing_key => q2.name)
+          x.publish("hello", routing_key: q2.name)
         end
       end
       t.abort_on_exception = true
 
-      q1.subscribe_with(ec, :manual_ack => true)
+      q1.subscribe_with(ec, manual_ack: true)
       sleep 2
       ch1.close
 
-      q2.message_count.should == 50
+      expect(q2.message_count).to eq 50
     end
   end
 end