bunny 1.7.0 → 2.17.0

data/spec/higher_level_api/integration/toxiproxy_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+require_relative "../../toxiproxy_helper"
+
+if ::Toxiproxy.running?
+  describe Bunny::Channel, "#basic_publish" do
+    include RabbitMQ::Toxiproxy
+
+    after :each do
+      @connection.close if @connection.open?
+    end
+
+    context "when the the connection detects missed heartbeats with automatic recovery" do
+      before(:each) do
+        setup_toxiproxy
+        @connection = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+          host: "localhost:11111", heartbeat_timeout: 1, automatically_recover: true)
+        @connection.start
+      end
+
+      let(:queue_name) { "bunny.basic.publish.queue#{rand}" }
+
+      it "raises a ConnectionClosedError" do
+        ch = @connection.create_channel
+        begin
+          rabbitmq_toxiproxy.down do
+            sleep 2
+            expect { ch.default_exchange.publish("", :routing_key => queue_name) }.to raise_error(Bunny::ConnectionClosedError)
+          end
+        ensure
+          cleanup_toxiproxy
+        end
+      end
+    end
+
+    context "when the the connection detects missed heartbeats without automatic recovery" do
+      before(:each) do
+        setup_toxiproxy
+        @connection = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+          host: "localhost:11111", heartbeat_timeout: 1, automatically_recover: false, threaded: false)
+        @connection.start
+      end
+
+      it "does not raise an exception on session thread" do
+       rabbitmq_toxiproxy.down do
+          sleep 5
+        end
+      end
+    end
+
+    context "recovery attempt limit that's exceeded" do
+      before(:each) do
+        setup_toxiproxy
+        @connection = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+          host: "localhost:11111", heartbeat_timeout: 1, automatically_recover: true, network_recovery_interval: 1,
+          recovery_attempts: 2, reset_recovery_attempts_after_reconnection: true,
+          disconnect_timeout: 1)
+        @connection.start
+      end
+
+      it "permanently closes connection" do
+        expect(@connection.open?).to be(true)
+
+        rabbitmq_toxiproxy.down do
+          sleep 5
+        end
+        # give the connection one last chance to recover
+        sleep 3
+
+        expect(@connection.open?).to be(false)
+        expect(@connection.closed?).to be(true)
+      end
+    end # context
+  end # describe
+else
+  puts "Toxiproxy isn't running, some examples will be skipped"
+end

data/spec/higher_level_api/integration/tx_commit_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Channel, "#tx_commit" 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

data/spec/higher_level_api/integration/tx_rollback_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Channel, "#tx_rollback" 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

data/spec/higher_level_api/integration/with_channel_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Channel, "#with_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,6 +20,6 @@ describe Bunny::Channel, "#with_channel" do
       end
     rescue Exception
     end
-    ch.should be_closed
+    expect(ch).to be_closed
   end
 end

data/spec/issues/issue100_spec.rb

@@ -2,18 +2,17 @@ require "spec_helper"
 
 unless ENV["CI"]
   describe Bunny::Channel, "#basic_publish" do
-    let(:connection) do
-      c = Bunny.new(:user     => "bunny_gem",
-                    :password => "bunny_password",
-                    :vhost    => "bunny_testbed",
-                    :write_timeout => 0,
-                    :read_timeout => 0)
-      c.start
-      c
+    before :all do
+      @connection = Bunny.new(username: "bunny_gem",
+                              password: "bunny_password",
+                              vhost: "bunny_testbed",
+                              write_timeout: 0,
+                              read_timeout:  0)
+      @connection.start
     end
 
     after :all do
-      connection.close if connection.open?
+      @connection.close if @connection.open?
     end
 
 
@@ -22,15 +21,15 @@ unless ENV["CI"]
       let(:m) { 10 }
 
       it "successfully publishers them all" do
-        ch = connection.create_channel
+        ch = @connection.create_channel
 
-        q  = ch.queue("", :exclusive => true)
+        q  = ch.queue("", exclusive: true)
         x  = ch.default_exchange
 
         body = "x" * 1024
         m.times do |i|
           n.times do
-            x.publish(body, :routing_key => q.name)
+            x.publish(body, routing_key:  q.name)
           end
           puts "Published #{i * n} 1K messages..."
         end

data/spec/issues/issue141_spec.rb

@@ -1,43 +1,42 @@
 require "spec_helper"
 
 describe "Registering 2nd exclusive consumer on queue" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
+    before :all do
+    @connection = Bunny.new(:user => "bunny_gem", password:  "bunny_password", :vhost => "bunny_testbed")
+    @connection.start
   end
 
   after :each do
-    connection.close if connection.open?
+    @connection.close if @connection.open?
   end
 
 
   it "raises a meaningful exception" do
     xs  = []
 
-    ch1 = connection.create_channel
-    ch2 = connection.create_channel
+    ch1 = @connection.create_channel
+    ch2 = @connection.create_channel
     q1  = ch1.queue("", :auto_delete => true)
     q2  = ch2.queue(q1.name, :auto_delete => true, :passive => true)
 
-    c1  = q1.subscribe(:exclusive => true) do |_, _, payload|
+    c1  = q1.subscribe(exclusive: true) do |_, _, payload|
       xs << payload
     end
     sleep 0.1
 
-    lambda do
-      q2.subscribe(:exclusive => true) do |_, _, _|
+    expect do
+      q2.subscribe(exclusive: true) do |_, _, _|
       end
-    end.should raise_error(Bunny::AccessRefused)
+    end.to raise_error(Bunny::AccessRefused)
 
-    ch1.should be_open
-    ch2.should be_closed
+    expect(ch1).to be_open
+    expect(ch2).to be_closed
 
     q1.publish("abc")
     sleep 0.1
 
     # verify that the first consumer is fine
-    xs.should == ["abc"]
+    expect(xs).to eq ["abc"]
 
     q1.delete
   end

data/spec/issues/issue202_spec.rb

@@ -4,7 +4,7 @@ describe Bunny::Session do
   context "with unreachable host" do
     it "raises Bunny::TCPConnectionFailed" do
       begin
-        conn = Bunny.new(:hostname => "192.192.192.192")
+        conn = Bunny.new(:hostname => "127.0.0.254", :port => 1433)
         conn.start
 
         fail "expected 192.192.192.192 to be unreachable"

data/spec/issues/issue224_spec.rb

@@ -5,7 +5,7 @@ unless ENV["CI"]
   describe "Message framing implementation" do
     let(:connection) do
       c = Bunny.new(:user     => "bunny_gem",
-        :password => "bunny_password",
+        password:  "bunny_password",
         :vhost    => "bunny_testbed",
         :port     => ENV.fetch("RABBITMQ_PORT", 5672))
       c.start
@@ -21,17 +21,17 @@ unless ENV["CI"]
       it "successfully frames the message" do
         ch = connection.create_channel
 
-        q  = ch.queue("", :exclusive => true)
+        q  = ch.queue("", exclusive: true)
         x  = ch.default_exchange
 
         as = ("a" * 272179)
-        x.publish(as, :routing_key => q.name, :persistent => true)
+        x.publish(as, routing_key:  q.name, persistent: true)
 
         sleep(1)
-        q.message_count.should == 1
+        expect(q.message_count).to eq 1
 
         _, _, payload      = q.pop
-        payload.bytesize.should == as.bytesize
+        expect(payload.bytesize).to eq as.bytesize
 
         ch.close
       end

data/spec/issues/issue465_spec.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Bunny::Session do
+  let(:connection) do
+    c = Bunny.new(
+        user: 'bunny_gem', password: 'bunny_password',
+        vhost: 'bunny_testbed',
+        port: ENV.fetch('RABBITMQ_PORT', 5672)
+    )
+    c.start
+    c
+  end
+
+  context 'after the connection has been manually closed' do
+    before :each do
+      connection.close
+    end
+
+    after :each do
+      connection.close if connection.open?
+    end
+
+    describe '#create_channel' do
+      it 'should raise an exception' do
+        expect {
+          connection.create_channel
+        }.to raise_error(Bunny::ConnectionAlreadyClosed)
+      end
+    end
+  end
+end

data/spec/issues/issue549_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Bunny::Session do
+  context 'when retry attempts have been exhausted' do
+    let(:io) { StringIO.new } # keep test output clear
+
+    def create_session
+      described_class.new(
+        host: 'fake.host',
+        recovery_attempts: 0,
+        connection_timeout: 0,
+        network_recovery_interval: 0,
+        logfile: io,
+      )
+    end
+
+    it 'closes the session' do
+      session = create_session
+      session.handle_network_failure(StandardError.new)
+      expect(session.closed?).to be true
+    end
+
+    it 'stops the reader loop' do
+      session = create_session
+      reader_loop = session.reader_loop
+      session.handle_network_failure(StandardError.new)
+      expect(reader_loop.stopping?).to be true
+    end
+  end
+end

data/spec/issues/issue78_spec.rb

@@ -2,20 +2,17 @@ require "spec_helper"
 
 unless ENV["CI"]
   describe Bunny::Queue, "#subscribe" do
-    let(:connection1) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-      c.start
-      c
-    end
-    let(:connection2) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-      c.start
-      c
+    before :all do
+      @connection1 = Bunny.new(:user => "bunny_gem", password:  "bunny_password", :vhost => "bunny_testbed")
+      @connection1.start
+      @connection2 = Bunny.new(:user => "bunny_gem", password:  "bunny_password", :vhost => "bunny_testbed")
+      @connection2.start
     end
 
     after :all do
-      connection1.close if connection1.open?
-      connection2.close if connection2.open?
+      [@connection1, @connection2].select { |c| !!c }.each do |c|
+        c.close if c.open?
+      end
     end
 
 
@@ -23,20 +20,20 @@ unless ENV["CI"]
       it "consumes messages" do
         delivered_data = []
 
-        ch1 = connection1.create_channel
-        ch2 = connection1.create_channel
+        ch1 = @connection1.create_channel
+        ch2 = @connection1.create_channel
 
-        q   = ch1.queue("", :exclusive => true)
-        q.subscribe(:manual_ack => false, :block => false) do |delivery_info, properties, payload|
+        q   = ch1.queue("", exclusive: true)
+        q.subscribe(manual_ack: false) do |delivery_info, properties, payload|
           delivered_data << payload
         end
         sleep 0.5
 
         x = ch2.default_exchange
-        x.publish("abc", :routing_key => q.name)
+        x.publish("abc", routing_key:  q.name)
         sleep 0.7
 
-        delivered_data.should == ["abc"]
+        expect(delivered_data).to eq ["abc"]
 
         ch1.close
         ch2.close
@@ -49,23 +46,23 @@ unless ENV["CI"]
       it "consumes messages" do
         delivered_data = []
 
-        ch1 = connection1.create_channel
-        ch2 = connection1.create_channel
+        ch1 = @connection1.create_channel
+        ch2 = @connection1.create_channel
 
-        q   = ch1.queue(queue_name, :exclusive => true)
+        q   = ch1.queue(queue_name, exclusive: true)
         x = ch2.default_exchange
         3.times do |i|
-          x.publish("data#{i}", :routing_key => queue_name)
+          x.publish("data#{i}", routing_key:  queue_name)
         end
         sleep 0.7
-        q.message_count.should == 3
+        expect(q.message_count).to eq 3
 
-        q.subscribe(:manual_ack => false, :block => false) do |delivery_info, properties, payload|
+        q.subscribe(manual_ack: false) do |delivery_info, properties, payload|
           delivered_data << payload
         end
         sleep 0.7
 
-        delivered_data.should == ["data0", "data1", "data2"]
+        expect(delivered_data).to eq ["data0", "data1", "data2"]
 
         ch1.close
         ch2.close

data/spec/issues/issue83_spec.rb

@@ -1,19 +1,18 @@
 require "spec_helper"
 
 describe Bunny::Channel, "#open" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
+  before :all do
+    @connection = Bunny.new(:user => "bunny_gem", password:  "bunny_password", :vhost => "bunny_testbed")
+    @connection.start
   end
 
   after :all do
-    connection.close if connection.open?
+    @connection.close if @connection.open?
   end
 
 
   it "properly resets channel exception state" do
-    ch = connection.create_channel
+    ch = @connection.create_channel
 
     begin
       ch.queue("bunny.tests.does.not.exist", :passive => true)

data/spec/issues/issue97_spec.rb

@@ -1,33 +1,32 @@
 require "spec_helper"
 
 describe "Message framing implementation" do
-  let(:connection) do
-    c = Bunny.new(:user     => "bunny_gem",
-                  :password => "bunny_password",
-                  :vhost    => "bunny_testbed",
-                  :port     => ENV.fetch("RABBITMQ_PORT", 5672))
-    c.start
-    c
+    before :all do
+    @connection = Bunny.new(username: "bunny_gem",
+      password:  "bunny_password",
+      vhost: "bunny_testbed",
+      port: ENV.fetch("RABBITMQ_PORT", 5672))
+    @connection.start
   end
 
   after :all do
-    connection.close if connection.open?
+    @connection.close if @connection.open?
   end
 
 
   unless ENV["CI"]
     context "with payload ~ 248K in size including non-ASCII characters" do
       it "successfully frames the message" do
-        ch = connection.create_channel
+        ch = @connection.create_channel
 
-        q  = ch.queue("", :exclusive => true)
+        q  = ch.queue("", exclusive: true)
         x  = ch.default_exchange
 
         body = IO.read("spec/issues/issue97_attachment.json")
-        x.publish(body, :routing_key => q.name, :persistent => true)
+        x.publish(body, routing_key: q.name, persistent: true)
 
         sleep(1)
-        q.message_count.should == 1
+        expect(q.message_count).to eq 1
 
         q.purge
         ch.close
@@ -38,19 +37,19 @@ describe "Message framing implementation" do
 
   context "with payload of several MBs in size" do
     it "successfully frames the message" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
       as = ("a" * (1024 * 1024 * 4 + 2823777))
-      x.publish(as, :routing_key => q.name, :persistent => true)
+      x.publish(as, routing_key: q.name, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       _, _, payload      = q.pop
-      payload.bytesize.should == as.bytesize
+      expect(payload.bytesize).to eq as.bytesize
 
       ch.close
     end
@@ -60,23 +59,23 @@ describe "Message framing implementation" do
 
   context "with empty message body" do
     it "successfully publishes the message" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
-      x.publish("", :routing_key => q.name, :persistent => true)
+      x.publish("", routing_key: q.name, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       envelope, headers, payload = q.pop
 
-      payload.should == ""
+      expect(payload).to eq ""
 
-      headers[:content_type].should == "application/octet-stream"
-      headers[:delivery_mode].should == 2
-      headers[:priority].should == 0
+      expect(headers[:content_type]).to eq "application/octet-stream"
+      expect(headers[:delivery_mode]).to eq 2
+      expect(headers[:priority]).to eq 0
 
       ch.close
     end
@@ -85,16 +84,16 @@ describe "Message framing implementation" do
 
   context "with payload being 2 bytes less than 128K bytes in size" do
     it "successfully frames the message" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
       as = "a" * (1024 * 128 - 2)
-      x.publish(as, :routing_key => q.name, :persistent => true)
+      x.publish(as, routing_key:  q.name, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       q.purge
       ch.close
@@ -103,16 +102,16 @@ describe "Message framing implementation" do
 
   context "with payload being 1 byte less than 128K bytes in size" do
     it "successfully frames the message" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
       as = "a" * (1024 * 128 - 1)
-      x.publish(as, :routing_key => q.name, :persistent => true)
+      x.publish(as, routing_key:  q.name, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       q.purge
       ch.close
@@ -121,16 +120,16 @@ describe "Message framing implementation" do
 
   context "with payload being exactly 128K bytes in size" do
     it "successfully frames the message" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
       as = "a" * (1024 * 128)
-      x.publish(as, :routing_key => q.name, :persistent => true)
+      x.publish(as, routing_key:  q.name, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       q.purge
       ch.close
@@ -140,16 +139,16 @@ describe "Message framing implementation" do
 
   context "with payload being 1 byte greater than 128K bytes in size" do
     it "successfully frames the message" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
       as = "a" * (1024 * 128 + 1)
-      x.publish(as, :routing_key => q.name, :persistent => true)
+      x.publish(as, routing_key:  q.name, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       q.purge
       ch.close
@@ -158,16 +157,16 @@ describe "Message framing implementation" do
 
   context "with payload being 2 bytes greater than 128K bytes in size" do
     it "successfully frames the message" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
       as = "a" * (1024 * 128 + 2)
-      x.publish(as, :routing_key => q.name, :persistent => true)
+      x.publish(as, routing_key:  q.name, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       q.purge
       ch.close