bunny 1.3.0 → 2.17.0

data/spec/higher_level_api/integration/exchange_delete_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Exchange, "#delete" 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,7 +21,7 @@ describe Bunny::Exchange, "#delete" do
       # no exception as of RabbitMQ 3.2. MK.
       x.delete
 
-      ch.exchanges.size.should == 0
+      expect(ch.exchanges.size).to eq 0
     end
   end
 
@@ -43,7 +43,7 @@ describe Bunny::Exchange, "#delete" do
       ch = connection.create_channel
       x  = ch.direct('amq.direct')
 
-      x.delete.should == nil
+      expect(x.delete).to eq nil
     end
   end
 
@@ -52,7 +52,7 @@ describe Bunny::Exchange, "#delete" do
       ch = connection.create_channel
       x  = ch.fanout('amq.fanout')
 
-      x.delete.should == nil
+      expect(x.delete).to eq nil
     end
   end
 
@@ -61,7 +61,7 @@ describe Bunny::Exchange, "#delete" do
       ch = connection.create_channel
       x  = ch.topic('amq.topic')
 
-      x.delete.should == nil
+      expect(x.delete).to eq nil
     end
   end
 
@@ -70,7 +70,7 @@ describe Bunny::Exchange, "#delete" do
       ch = connection.create_channel
       x  = ch.headers('amq.headers')
 
-      x.delete.should == nil
+      expect(x.delete).to eq nil
     end
   end
 
@@ -79,7 +79,7 @@ describe Bunny::Exchange, "#delete" do
       ch = connection.create_channel
       x  = ch.headers('amq.match')
 
-      x.delete.should == nil
+      expect(x.delete).to eq nil
     end
   end
 
@@ -89,16 +89,16 @@ describe Bunny::Exchange, "#delete" do
       it "returns true" do
         ch = connection.create_channel
 
-        connection.exchange_exists?("amq.fanout").should be_true
-        connection.exchange_exists?("amq.direct").should be_true
-        connection.exchange_exists?("amq.topic").should be_true
-        connection.exchange_exists?("amq.match").should be_true
+        expect(connection.exchange_exists?("amq.fanout")).to eq true
+        expect(connection.exchange_exists?("amq.direct")).to eq true
+        expect(connection.exchange_exists?("amq.topic")).to eq true
+        expect(connection.exchange_exists?("amq.match")).to eq true
       end
     end
 
     context "when a exchange DOES NOT exist" do
       it "returns false" do
-        connection.exchange_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}").should be_false
+        expect(connection.exchange_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}")).to eq false
       end
     end
   end

data/spec/higher_level_api/integration/exchange_unbind_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,21 +17,21 @@ describe Bunny::Exchange do
     source      = ch.fanout("bunny.exchanges.source#{rand}")
     destination = ch.fanout("bunny.exchanges.destination#{rand}")
 
-    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 == 1
-    queue.pop(:ack => true)
+    expect(queue.message_count).to eq 1
+    queue.pop(manual_ack: true)
 
     destination.unbind(source)
     source.publish("")
     sleep 0.5
 
-    queue.message_count.should be == 0
+    expect(queue.message_count).to eq 0
 
     source.delete
     destination.delete

data/spec/higher_level_api/integration/exclusive_queue_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Queue 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,13 +14,13 @@ describe Bunny::Queue do
   it "is closed when the connection it was declared on is closed" do
     ch1 = connection.create_channel
     ch2 = connection.create_channel
-    q   = ch1.queue("", :exclusive => true)
+    q   = ch1.queue("", exclusive: true)
 
-    ch1.queue_declare(q.name, :passive => true)
-    ch2.queue_declare(q.name, :passive => true)
+    ch1.queue_declare(q.name, passive: true)
+    ch2.queue_declare(q.name, passive: true)
 
     ch1.close
-    ch2.queue_declare(q.name, :passive => true)
+    ch2.queue_declare(q.name, passive: true)
 
     ch2.queue_delete(q.name)
     ch2.close

data/spec/higher_level_api/integration/heartbeat_spec.rb

@@ -1,23 +1,41 @@
 require "spec_helper"
 
 describe "Client-defined heartbeat interval" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :heartbeat_interval => 4)
-    c.start
-    c
+  context "with value > 0" do
+    let(:connection) do
+      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", heartbeat_timeout: 4)
+      c.start
+      c
+    end
+
+    it "can be enabled explicitly" do
+      sleep 5.0
+
+      connection.close
+    end
   end
 
-  it "can be enabled explicitly" do
-    sleep 5.0
+  # issue 267
+  context "with value = 0" do
+    let(:connection) do
+      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+        heartbeat_timeout: 0, automatically_recover: false)
+      c.start
+      c
+    end
 
-    connection.close
+    it "disables heartbeats" do
+      sleep 1.0
+
+      connection.close
+    end
   end
 end
 
 
 describe "Server-defined heartbeat interval" do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :heartbeat_interval => :server)
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", heartbeat_timeout: :server)
     c.start
     c
   end

data/spec/higher_level_api/integration/message_properties_access_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 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
@@ -20,8 +20,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 => true, :ack => false) do |delivery_info, properties, payload|
+      q = ch.queue(queue_name, auto_delete: true, durable: false)
+      q.subscribe(exclusive: true, manual_ack: false) do |delivery_info, properties, payload|
         metadata = properties
         envelope = delivery_info
       end
@@ -32,63 +32,63 @@ describe Bunny::Queue, "#subscribe" do
     ch = connection.create_channel
     x  = ch.default_exchange
     x.publish("hello",
-              :routing_key => queue_name,
-              :app_id      => "bunny.example",
-              :priority    => 8,
-              :type        => "kinda.checkin",
+              routing_key: queue_name,
+              app_id: "bunny.example",
+              priority: 8,
+              type: "kinda.checkin",
               # headers table keys can be anything
-              :headers     => {
-                :coordinates => {
-                  :latitude  => 59.35,
-                  :longitude => 18.066667
+              headers: {
+                coordinates: {
+                  latitude: 59.35,
+                  longitude: 18.066667
                 },
-                :time         => @now,
-                :participants => 11,
-                :venue        => "Stockholm",
-                :true_field   => true,
-                :false_field  => false,
-                :nil_field    => nil,
-                :ary_field    => ["one", 2.0, 3, [{"abc" => 123}]]
+                time: @now,
+                participants: 11,
+                venue: "Stockholm",
+                true_field: true,
+                false_field: false,
+                nil_field: nil,
+                ary_field: ["one", 2.0, 3, [{"abc" => 123}]]
               },
-              :timestamp      => @now.to_i,
-              :reply_to       => "a.sender",
-              :correlation_id => "r-1",
-              :message_id     => "m-1")
+              timestamp: @now.to_i,
+              reply_to: "a.sender",
+              correlation_id: "r-1",
+              message_id: "m-1")
 
     sleep 0.7
 
-    metadata.content_type.should == "application/octet-stream"
-    metadata.priority.should     == 8
+    expect(metadata.content_type).to eq "application/octet-stream"
+    expect(metadata.priority).to     eq 8
 
     time = metadata.headers["time"]
-    time.year.should == @now.year
-    time.month.should == @now.month
-    time.day.should == @now.day
-    time.hour.should == @now.hour
-    time.min.should == @now.min
-    time.sec.should == @now.sec
+    expect(time.year).to eq @now.year
+    expect(time.month).to eq @now.month
+    expect(time.day).to eq @now.day
+    expect(time.hour).to eq @now.hour
+    expect(time.min).to eq @now.min
+    expect(time.sec).to eq @now.sec
 
-    metadata.headers["coordinates"]["latitude"].should == 59.35
-    metadata.headers["participants"].should == 11
-    metadata.headers["venue"].should == "Stockholm"
-    metadata.headers["true_field"].should == true
-    metadata.headers["false_field"].should == false
-    metadata.headers["nil_field"].should be_nil
-    metadata.headers["ary_field"].should == ["one", 2.0, 3, [{ "abc" => 123}]]
+    expect(metadata.headers["coordinates"]["latitude"]).to eq 59.35
+    expect(metadata.headers["participants"]).to eq 11
+    expect(metadata.headers["venue"]).to eq "Stockholm"
+    expect(metadata.headers["true_field"]).to eq true
+    expect(metadata.headers["false_field"]).to eq false
+    expect(metadata.headers["nil_field"]).to be_nil
+    expect(metadata.headers["ary_field"]).to eq ["one", 2.0, 3, [{ "abc" => 123}]]
 
-    metadata.timestamp.should == Time.at(@now.to_i)
-    metadata.type.should == "kinda.checkin"
-    metadata.reply_to.should == "a.sender"
-    metadata.correlation_id.should == "r-1"
-    metadata.message_id.should == "m-1"
-    metadata.app_id.should == "bunny.example"
+    expect(metadata.timestamp).to eq Time.at(@now.to_i)
+    expect(metadata.type).to eq "kinda.checkin"
+    expect(metadata.reply_to).to eq "a.sender"
+    expect(metadata.correlation_id).to eq "r-1"
+    expect(metadata.message_id).to eq "m-1"
+    expect(metadata.app_id).to eq "bunny.example"
 
-    envelope.consumer_tag.should_not be_nil
-    envelope.consumer_tag.should_not be_empty
-    envelope.should_not be_redelivered
-    envelope.delivery_tag.should == 1
-    envelope.routing_key.should  == queue_name
-    envelope.exchange.should == ""
+    expect(envelope.consumer_tag).not_to be_nil
+    expect(envelope.consumer_tag).not_to be_empty
+    expect(envelope).not_to be_redelivered
+    expect(envelope.delivery_tag).to eq 1
+    expect(envelope.routing_key).to  eq queue_name
+    expect(envelope.exchange).to eq ""
 
     ch.close
   end

data/spec/higher_level_api/integration/predeclared_exchanges_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "amq.* exchanges" 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
@@ -16,7 +16,7 @@ describe "amq.* exchanges" do
 
     ["amq.fanout", "amq.direct", "amq.topic", "amq.match", "amq.headers"].each do |e|
       x = ch.exchange(e)
-      x.should be_predeclared
+      expect(x).to be_predeclared
     end
 
     ch.close

data/spec/higher_level_api/integration/publisher_confirms_spec.rb

@@ -1,77 +1,191 @@
 require "spec_helper"
 
 describe Bunny::Channel do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :continuation_timeout => 10000)
-    c.start
-    c
-  end
-
   after :each do
     connection.close if connection.open?
   end
 
   let(:n) { 200 }
 
-  context "when publishing with confirms enabled" do
-    it "increments delivery index" do
-      ch = connection.create_channel
-      ch.should_not be_using_publisher_confirmations
+  shared_examples "publish confirms" do
+    context "when publishing with confirms enabled" do
+      it "increments delivery index" do
+        ch = connection.create_channel
+        expect(ch).not_to be_using_publisher_confirmations
+
+        ch.confirm_select
+        expect(ch).to be_using_publisher_confirmations
+
+        q  = ch.queue("", exclusive: true)
+        x  = ch.default_exchange
 
-      ch.confirm_select
-      ch.should be_using_publisher_confirmations
+        n.times do
+          x.publish("xyzzy", routing_key: q.name)
+        end
 
-      q  = ch.queue("", :exclusive => true)
-      x  = ch.default_exchange
+        expect(ch.next_publish_seq_no).to eq n + 1
+        expect(ch.wait_for_confirms).to eq true
+        sleep 0.25
 
-      n.times do
-        x.publish("xyzzy", :routing_key => q.name)
+        expect(q.message_count).to eq n
+        q.purge
+
+        ch.close
       end
 
-      ch.next_publish_seq_no.should == n + 1
-      ch.wait_for_confirms.should be_true
-      sleep 0.25
+      describe "#wait_for_confirms" do
+        it "should not hang when all the publishes are confirmed" do
+          ch = connection.create_channel
+          expect(ch).not_to be_using_publisher_confirmations
+
+          ch.confirm_select
+          expect(ch).to be_using_publisher_confirmations
+
+          q  = ch.queue("", exclusive: true)
+          x  = ch.default_exchange
+
+          n.times do
+            x.publish("xyzzy", routing_key: q.name)
+          end
+
+          expect(ch.next_publish_seq_no).to eq n + 1
+          expect(ch.wait_for_confirms).to eq true
+
+          sleep 0.25
+
+          expect {
+            Bunny::Timeout.timeout(2) do
+              expect(ch.wait_for_confirms).to eq true
+            end
+          }.not_to raise_error
+
+        end
+
+        it "raises an error when called on a closed channel" do
+          ch = connection.create_channel
+
+          ch.confirm_select
+
+          ch.close
+
+          expect {
+            ch.wait_for_confirms
+          }.to raise_error(Bunny::ChannelAlreadyClosed)
+        end
+      end
+
+      context "when some of the messages get nacked" do
+        it "puts the nacks in the nacked_set" do
+          ch = connection.create_channel
+          expect(ch).not_to be_using_publisher_confirmations
+
+          ch.confirm_select
+          expect(ch).to be_using_publisher_confirmations
+
+          q  = ch.queue("", exclusive: true)
+          x  = ch.default_exchange
+
+          n.times do
+            x.publish("xyzzy", routing_key: q.name)
+          end
+
+          #be sneaky to simulate a nack
+          nacked_tag = nil
+          ch.instance_variable_get(:@unconfirmed_set_mutex).synchronize do
+            expect(ch.unconfirmed_set).to_not be_empty
+            nacked_tag = ch.unconfirmed_set.reduce(ch.next_publish_seq_no - 1) { |lowest, i| i < lowest ? i : lowest }
+            ch.handle_ack_or_nack(nacked_tag, false, true)
+          end
 
-      q.message_count.should == n
-      q.purge
+          expect(ch.nacked_set).not_to be_empty
+          expect(ch.nacked_set).to include(nacked_tag)
 
-      ch.close
+          expect(ch.next_publish_seq_no).to eq n + 1
+          expect(ch.wait_for_confirms).to eq false
+
+          expect(ch.nacked_set).not_to be_empty
+          expect(ch.nacked_set).to include(nacked_tag)
+
+          sleep 0.25
+          expect(q.message_count).to eq n
+          q.purge
+
+          ch.close
+        end
+      end
     end
   end
 
-
-  context "with a single-threaded connection" do
+  context "with a multi-threaded connection" do
     let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :continuation_timeout => 10000, :threaded => false)
+      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", continuation_timeout: 10000)
       c.start
       c
     end
 
+    include_examples "publish confirms"
 
-    context "when publishing with confirms enabled" do
-      it "increments delivery index" do
-        ch = connection.create_channel
-        ch.should_not be_using_publisher_confirmations
-
-        ch.confirm_select
-        ch.should be_using_publisher_confirmations
+    it "returns only when all confirmations for publishes are received" do
+      ch = connection.create_channel
 
-        q  = ch.queue("", :exclusive => true)
-        x  = ch.default_exchange
+      operations_log = []
+      operations_log_mutex = Mutex.new
+      acks_received = Queue.new
 
-        n.times do
-          x.publish("xyzzy", :routing_key => q.name)
+      log_acks = proc do |tag, _, is_nack|
+        operations_log_mutex.synchronize do
+          operation = "#{'n' if is_nack}ack_#{tag}"
+          operations_log << operation unless operations_log.include?(operation)
         end
+        acks_received << true
+      end
 
-        ch.next_publish_seq_no.should == n + 1
-        ch.wait_for_confirms.should be_true
-        sleep 0.25
+      ch.confirm_select(log_acks)
 
-        q.message_count.should == n
-        q.purge
+      x = ch.default_exchange
+      q = ch.temporary_queue
 
-        ch.close
+      x.publish('msg', routing_key: q.name)
+
+      # wait for the confirmation to arrive
+      acks_received.pop
+
+      # artificially simulate a slower ack. the test should work properly even
+      # without this patch, but it's here just to be sure we catch it.
+      def (x.channel).handle_ack_or_nack(delivery_tag_before_offset, multiple, nack)
+        sleep 0.1
+        super
       end
+
+      x.publish('msg', routing_key: q.name)
+      x.publish('msg', routing_key: q.name)
+
+      if x.wait_for_confirms
+        operations_log_mutex.synchronize do
+          operations_log << 'all_confirmed'
+        end
+      end
+
+      # wait for all the confirmations to arrive
+      acks_received.pop
+      acks_received.pop
+
+      expect(operations_log).to eq([
+        'ack_1',
+        'ack_2',
+        'ack_3',
+        'all_confirmed',
+      ])
     end
   end
+
+  context "with a single-threaded connection" do
+    let(:connection) do
+      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", continuation_timeout: 10000, threaded: false)
+      c.start
+      c
+    end
+
+    include_examples "publish confirms"
+  end
 end