bunny 1.3.0 → 2.17.0

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

data/spec/lower_level_api/integration/basic_cancel_spec.rb

@@ -1,27 +1,26 @@
 require "spec_helper"
 
 describe Bunny::Channel, "#basic_cancel" 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
 
   let(:queue_name) { "bunny.queues.#{rand}" }
 
   it "returns basic.cancel-ok" do
-    ch = connection.create_channel
+    ch = @connection.create_channel
     q  = ch.queue("", :exclusive => true)
 
     consume_ok = ch.basic_consume(q, "")
     cancel_ok  = ch.basic_cancel(consume_ok.consumer_tag)
 
-    cancel_ok.should be_instance_of(AMQ::Protocol::Basic::CancelOk)
-    cancel_ok.consumer_tag.should == consume_ok.consumer_tag
+    expect(cancel_ok).to be_instance_of AMQ::Protocol::Basic::CancelOk
+    expect(cancel_ok.consumer_tag).to eq consume_ok.consumer_tag
 
     ch.close
   end
@@ -33,32 +32,32 @@ describe Bunny::Channel, "#basic_cancel" do
       delivered_data = []
 
       t = Thread.new do
-        ch         = connection.create_channel
+        ch         = @connection.create_channel
         q          = ch.queue(queue_name, :auto_delete => true, :durable => false)
         consume_ok = ch.basic_consume(q, "", true, false) do |_, _, payload|
           delivered_data << payload
         end
 
-        consume_ok.consumer_tag.should_not be_nil
+        expect(consume_ok.consumer_tag).not_to be_nil
         cancel_ok = ch.basic_cancel(consume_ok.consumer_tag)
-        cancel_ok.consumer_tag.should == consume_ok.consumer_tag
+        expect(cancel_ok.consumer_tag).to eq consume_ok.consumer_tag
 
         ch.close
       end
       t.abort_on_exception = true
       sleep 0.5
 
-      ch = connection.create_channel
+      ch = @connection.create_channel
       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 "when the given consumer tag is invalid (was never registered)" do
     it "DOES NOT cause a channel error" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
       # RabbitMQ 3.1 does not raise an exception w/ unknown consumer tag. MK.
       ch.basic_cancel("878798s7df89#{rand}#{Time.now.to_i}")
@@ -69,8 +68,8 @@ describe Bunny::Channel, "#basic_cancel" do
 
   context "when the given consumer tag belongs to a different channel" do
     it "DOES NOT cause a channel error" do
-      ch1 = connection.create_channel
-      ch2 = connection.create_channel
+      ch1 = @connection.create_channel
+      ch2 = @connection.create_channel
 
       q    = ch1.queue("", :exclusive => true)
       cons = q.subscribe do |_, _, _|

data/spec/lower_level_api/integration/basic_consume_spec.rb

@@ -1,33 +1,32 @@
 require "spec_helper"
 
 describe Bunny::Channel, "#basic_consume" 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 "returns basic.consume-ok when it is received" do
-    ch = connection.create_channel
+    ch = @connection.create_channel
     q  = ch.queue("", :exclusive => true)
 
     consume_ok = ch.basic_consume(q)
-    consume_ok.should be_instance_of(AMQ::Protocol::Basic::ConsumeOk)
-    consume_ok.consumer_tag.should_not be_nil
+    expect(consume_ok).to be_instance_of AMQ::Protocol::Basic::ConsumeOk
+    expect(consume_ok.consumer_tag).not_to be_nil
 
     ch.close
   end
 
   it "carries server-generated consumer tag with basic.consume-ok" do
-    ch = connection.create_channel
+    ch = @connection.create_channel
     q  = ch.queue("", :exclusive => true)
 
     consume_ok = ch.basic_consume(q, "")
-    consume_ok.consumer_tag.should =~ /amq\.ctag.*/
+    expect(consume_ok.consumer_tag).to match /amq\.ctag.*/
 
     ch.close
   end
@@ -40,7 +39,7 @@ describe Bunny::Channel, "#basic_consume" do
       delivered_data = []
 
       t = Thread.new do
-        ch = connection.create_channel
+        ch = @connection.create_channel
         q = ch.queue(queue_name, :auto_delete => true, :durable => false)
         ch.basic_consume(q, "", true, false) do |delivery_info, properties, payload|
           delivered_keys << delivery_info.routing_key
@@ -50,15 +49,15 @@ describe Bunny::Channel, "#basic_consume" do
       t.abort_on_exception = true
       sleep 0.5
 
-      ch = connection.create_channel
+      ch = @connection.create_channel
       x  = ch.default_exchange
       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
@@ -72,7 +71,7 @@ describe Bunny::Channel, "#basic_consume" do
       delivered_data = []
 
       t = Thread.new do
-        ch = connection.create_channel
+        ch = @connection.create_channel
         q = ch.queue(queue_name, :auto_delete => true, :durable => false)
         ch.basic_consume(q, "", false, false) do |delivery_info, properties, payload|
           delivered_keys << delivery_info.routing_key
@@ -84,17 +83,17 @@ describe Bunny::Channel, "#basic_consume" do
       t.abort_on_exception = true
       sleep 0.5
 
-      ch = connection.create_channel
+      ch = @connection.create_channel
       x  = ch.default_exchange
       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      
+      ch.close
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,47 +3,29 @@
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 
 require 'bundler'
-Bundler.setup(:default, :test)
+Bundler.require(:default, :test)
 
-
-require "effin_utf8"
 require "bunny"
-require "rabbitmq/http/client"
-
+require "bunny/test_kit"
 
-require "amq/protocol/version"
 puts "Using Ruby #{RUBY_VERSION}, amq-protocol #{AMQ::Protocol::VERSION}"
 
-
-
-#
-# Ruby version-specific
-#
-
-case RUBY_VERSION
-when "1.8.7" then
-  class Array
-    alias sample choice
-  end
-when "1.8.6" then
-  raise "Ruby 1.8.6 is not supported. Sorry, pal. Time to move on beyond One True Ruby. Yes, time flies by."
-end
-
-
-
 module RabbitMQ
   module Control
+
+    RABBITMQ_NODENAME = ENV['RABBITMQ_NODENAME'] || 'rabbit'
+
     def rabbitmq_pid
-      $1.to_i if `rabbitmqctl status` =~ /\{pid,(\d+)\}/
+      $1.to_i if `rabbitmqctl -n #{RABBITMQ_NODENAME} status` =~ /\{pid,(\d+)\}/
     end
 
     def start_rabbitmq(delay = 1.0)
       # this is Homebrew-specific :(
-      `rabbitmq-server > /dev/null 2>&1 &`; sleep(delay)
+      `RABBITMQ_NODENAME=#{RABBITMQ_NODENAME} rabbitmq-server > /dev/null 2>&1 &`; sleep(delay)
     end
 
     def stop_rabbitmq(pid = rabbitmq_pid, delay = 1.0)
-      `rabbitmqctl stop`; sleep(delay)
+      `rabbitmqctl -n #{RABBITMQ_NODENAME} stop`; sleep(delay)
     end
 
     def kill_rabbitmq(pid = rabbitmq_pid, delay = 1.0)

data/spec/stress/channel_close_stress_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe "Rapidly closing lots of temporary channels" do
+  before :all do
+    @connection = Bunny.new(automatic_recovery: false).tap do |c|
+      c.start
+    end
+  end
+
+  after :all do
+    @connection.close
+  end
+
+  100.times do |i|
+    context "in a multi-threaded scenario A (take #{i})" do
+      let(:n) { 20 }
+
+      it "works correctly" do
+        ts = []
+
+        n.times do
+          t = Thread.new do
+            @connection.with_channel do |ch1|
+              q   = ch1.queue("", exclusive: true)
+              q.delete
+              ch1.close
+            end
+
+            ch2 = @connection.create_channel
+            ch2.close
+          end
+          t.abort_on_exception = true
+          ts << t
+        end
+
+        ts.each { |t| t.join }
+      end
+    end
+  end
+
+  100.times do |i|
+    context "in a multi-threaded scenario B (take #{i})" do
+      let(:n) { 20 }
+
+      it "works correctly" do
+        ts = []
+
+        n.times do
+          t = Thread.new do
+            3.times do
+              @connection.with_channel do |ch|
+                x  = ch.topic('bunny.stress.topics.t2', durable: false)
+              end
+            end
+          end
+          t.abort_on_exception = true
+          ts << t
+        end
+
+        ts.each { |t| t.join }
+      end
+    end
+  end
+end