bunny 1.7.0 → 2.17.0

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,30 +3,13 @@
 $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
 

data/spec/stress/channel_close_stress_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "Rapidly closing lots of temporary channels" do
   before :all do
-    @connection = Bunny.new(:automatic_recovery => false).tap do |c|
+    @connection = Bunny.new(automatic_recovery: false).tap do |c|
       c.start
     end
   end
@@ -21,7 +21,7 @@ describe "Rapidly closing lots of temporary channels" do
         n.times do
           t = Thread.new do
             @connection.with_channel do |ch1|
-              q   = ch1.queue("", :exclusive => true)
+              q   = ch1.queue("", exclusive: true)
               q.delete
               ch1.close
             end
@@ -49,7 +49,7 @@ describe "Rapidly closing lots of temporary channels" do
           t = Thread.new do
             3.times do
               @connection.with_channel do |ch|
-                x  = ch.topic('bunny.stress.topics.t2', :durable => false)
+                x  = ch.topic('bunny.stress.topics.t2', durable: false)
               end
             end
           end

data/spec/stress/channel_open_stress_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "Rapidly opening and closing lots of channels" do
   before :all do
-    @connection = Bunny.new(:automatic_recovery => false).tap do |c|
+    @connection = Bunny.new(automatic_recovery: false).tap do |c|
       c.start
     end
   end
@@ -18,7 +18,7 @@ describe "Rapidly opening and closing lots of channels" do
       xs = Array.new(n) { @connection.create_channel }
       puts "Opened #{n} channels"
 
-      xs.size.should == n
+      expect(xs.size).to eq n
       xs.each do |ch|
         ch.close
       end
@@ -42,7 +42,7 @@ describe "Rapidly opening and closing lots of channels" do
         n.times do
           t = Thread.new do
             ch1 = @connection.create_channel
-            q   = ch1.queue("", :exclusive => true)
+            q   = ch1.queue("", exclusive: true)
             q.delete
             ch1.close
 
@@ -69,7 +69,7 @@ describe "Rapidly opening and closing lots of channels" do
           t = Thread.new do
             3.times do
               ch = @connection.create_channel
-              x  = ch.topic('bunny.stress.topics.t2', :durable => false)
+              x  = ch.topic('bunny.stress.topics.t2', durable: false)
               ch.close
             end
           end

data/spec/stress/channel_open_stress_with_single_threaded_connection_spec.rb

@@ -2,23 +2,23 @@ require "spec_helper"
 
 unless ENV["CI"]
   describe "Rapidly opening and closing lots of channels on a non-threaded connection" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false, :threaded => false)
-      c.start
-      c
+    before :all do
+      @connection = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+        automatic_recovery: false, threaded: false)
+      @connection.start
     end
 
     after :all do
-      connection.close
+      @connection.close
     end
 
     context "in a single-threaded scenario" do
       let(:n) { 500 }
 
       it "works correctly" do
-        xs = Array.new(n) { connection.create_channel }
+        xs = Array.new(n) { @connection.create_channel }
 
-        xs.size.should == n
+        expect(xs.size).to eq n
         xs.each do |ch|
           ch.close
         end

data/spec/stress/concurrent_consumers_stress_spec.rb

@@ -3,15 +3,14 @@ require "spec_helper"
 
 unless ENV["CI"]
   describe "Concurrent consumers sharing a connection" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed",
-                    :automatic_recovery => false, :continuation_timeout => 6000)
-      c.start
-      c
+    before :all do
+      @connection = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+                    automatic_recovery: false, continuation_timeout: 45000)
+      @connection.start
     end
 
     after :all do
-      connection.close
+      @connection.close
     end
 
     def any_not_drained?(qs)
@@ -21,17 +20,18 @@ unless ENV["CI"]
     context "when publishing thousands of messages over 128K in size" do
       let(:colors) { ["red", "blue", "white"] }
 
-      let(:n) { 32 }
-      let(:m) { 1000 }
+      let(:n) { 16 }
+      let(:m) { 5000 }
 
       it "successfully drain all queues" do
-        ch   = connection.create_channel
+        ch0  = @connection.create_channel
+        ch0.confirm_select
         body = "абвг"
-        x    = ch.topic("bunny.stress.concurrent.consumers.topic", :durable => true)
+        x    = ch0.topic("bunny.stress.concurrent.consumers.topic", durable: true)
 
         chs  = {}
         n.times do |i|
-          chs[i] = connection.create_channel
+          chs[i] = @connection.create_channel
         end
         qs   = []
 
@@ -39,8 +39,8 @@ unless ENV["CI"]
           t = Thread.new do
             cht = chs[i]
 
-            q = cht.queue("", :exclusive => true)
-            q.bind(x.name, :routing_key => colors.sample).subscribe do |delivery_info, meta, payload|
+            q = cht.queue("", exclusive: true)
+            q.bind(x.name, routing_key: colors.sample).subscribe do |delivery_info, meta, payload|
               # no-op
             end
             qs << q
@@ -52,17 +52,19 @@ unless ENV["CI"]
 
         5.times do |i|
           m.times do
-            x.publish(body, :routing_key => colors.sample)
+            x.publish(body, routing_key: colors.sample)
           end
           puts "Published #{(i + 1) * m} messages..."
+          ch0.wait_for_confirms
         end
 
         while any_not_drained?(qs)
           sleep 1.0
         end
-        puts "Drained all the queues..."
+        puts "Drained all queues, winding down..."
 
-        ch.close
+        ch0.close
+        chs.each { |_, ch| ch.close }
       end
     end
   end

data/spec/stress/concurrent_publishers_stress_spec.rb

@@ -3,31 +3,27 @@ require "spec_helper"
 
 unless ENV["CI"]
   describe "Concurrent publishers sharing a connection" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatically_recover => false, :continuation_timeout => 20.0)
-      c.start
-      c
+    before :all do
+      @connection = Bunny.new(username: "bunny_gem", password: "bunny_password",
+        vhost: "bunny_testbed", automatically_recover: false)
+      @connection.start
     end
 
     after :all do
-      connection.close
+      @connection.close
     end
 
     let(:concurrency) { 24 }
-    let(:rate)        { 5_000 }
+    let(:messages)    { 5_000 }
 
     it "successfully finish publishing" do
-      ch = connection.create_channel
-
-      q    = ch.queue("", :exclusive => true)
       body = "сообщение"
 
-      # let the queue name be sent back by RabbitMQ
-      sleep 0.25
-
       chs  = {}
       concurrency.times do |i|
-        chs[i] = connection.create_channel
+        ch     = @connection.create_channel
+        ch.confirm_select
+        chs[i] = ch
       end
 
       ts = []
@@ -35,14 +31,13 @@ unless ENV["CI"]
       concurrency.times do |i|
         t = Thread.new do
           cht = chs[i]
-          x   = ch.default_exchange
+          x   = cht.default_exchange
 
-          5.times do |i|
-            rate.times do
-              x.publish(body, :routing_key => q.name)
-            end
-            puts "Published #{(i + 1) * rate} messages..."
+          messages.times do
+            x.publish(body)
           end
+          puts "Published #{messages} messages..."
+          cht.wait_for_confirms
         end
         t.abort_on_exception = true
 
@@ -52,6 +47,8 @@ unless ENV["CI"]
       ts.each do |t|
         t.join
       end
+
+      chs.each { |_, ch| ch.close }
     end
   end
 end