bunny 1.7.1 → 2.0.0.rc1

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,15 +83,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

data/spec/stress/channel_open_stress_spec.rb

@@ -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

data/spec/stress/channel_open_stress_with_single_threaded_connection_spec.rb

@@ -2,23 +2,22 @@ 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(:user => "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",
+    before :all do
+      @connection = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed",
                     :automatic_recovery => false, :continuation_timeout => 6000)
-      c.start
-      c
+      @connection.start
     end
 
     after :all do
-      connection.close
+      @connection.close
     end
 
     def any_not_drained?(qs)
@@ -25,13 +24,13 @@ unless ENV["CI"]
       let(:m) { 1000 }
 
       it "successfully drain all queues" do
-        ch   = connection.create_channel
+        ch   = @connection.create_channel
         body = "абвг"
         x    = ch.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   = []
 

data/spec/stress/concurrent_publishers_stress_spec.rb

@@ -3,21 +3,20 @@ 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(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatically_recover => false, :continuation_timeout => 20.0)
+      @connection.start
     end
 
     after :all do
-      connection.close
+      @connection.close
     end
 
     let(:concurrency) { 24 }
     let(:rate)        { 5_000 }
 
     it "successfully finish publishing" do
-      ch = connection.create_channel
+      ch = @connection.create_channel
 
       q    = ch.queue("", :exclusive => true)
       body = "сообщение"
@@ -27,7 +26,7 @@ unless ENV["CI"]
 
       chs  = {}
       concurrency.times do |i|
-        chs[i] = connection.create_channel
+        chs[i] = @connection.create_channel
       end
 
       ts = []

data/spec/stress/connection_open_close_spec.rb

@@ -17,9 +17,9 @@ unless defined?(JRUBY_VERSION) && !ENV["FORCE_JRUBY_RUN"]
         c.start
         ch = c.create_channel
 
-        c.should be_connected
+        expect(c).to be_connected
         c.stop
-        c.should be_closed
+        expect(c).to be_closed
       end
     end
 
@@ -29,9 +29,9 @@ unless defined?(JRUBY_VERSION) && !ENV["FORCE_JRUBY_RUN"]
         c.start
         ch = c.create_channel
 
-        c.should be_connected
+        expect(c).to be_connected
         c.stop
-        c.should be_closed
+        expect(c).to be_closed
       end
     end
 
@@ -42,9 +42,9 @@ unless defined?(JRUBY_VERSION) && !ENV["FORCE_JRUBY_RUN"]
           c.start
           ch = c.create_channel
 
-          c.should be_connected
+          expect(c).to be_connected
           c.stop
-          c.should be_closed
+          expect(c).to be_closed
         end
       end
     end

data/spec/stress/long_running_consumer_spec.rb

@@ -6,14 +6,13 @@ unless ENV["CI"]
   require "bunny/test_kit"
 
   describe "Long running [relatively to heartbeat interval] consumer that never publishes" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false, :heartbeat_interval => 6)
-      c.start
-      c
+    before :all do
+      @connection = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false, :heartbeat_interval => 6)
+      @connection.start
     end
 
     after :all do
-      connection.close
+      @connection.close
     end
 
     let(:target) { 512 * 1024 * 1024 }
@@ -29,7 +28,7 @@ unless ENV["CI"]
 
       ct = Thread.new do
         t  = 0
-        ch = connection.create_channel(nil, 6)
+        ch = @connection.create_channel(nil, 6)
         begin
           q  = ch.queue(queue, :exclusive => true)
 
@@ -53,7 +52,7 @@ unless ENV["CI"]
 
       pt = Thread.new do
         t  = 0
-        ch = connection.create_channel
+        ch = @connection.create_channel
         begin
           x  = ch.fanout("amq.fanout")
 

data/spec/unit/bunny_spec.rb

@@ -2,14 +2,14 @@ require "spec_helper"
 
 describe Bunny do
   it "has library version" do
-    Bunny::VERSION.should_not be_nil
-    Bunny.version.should_not be_nil
+    expect(Bunny::VERSION).not_to be_nil
+    expect(Bunny.version).not_to be_nil
   end
 
 
   it "has AMQP protocol version" do
-    Bunny::PROTOCOL_VERSION.should == "0.9.1"
-    AMQ::Protocol::PROTOCOL_VERSION.should == "0.9.1"
-    Bunny.protocol_version.should == "0.9.1"
+    expect(Bunny::PROTOCOL_VERSION).to eq "0.9.1"
+    expect(AMQ::Protocol::PROTOCOL_VERSION).to eq "0.9.1"
+    expect(Bunny.protocol_version).to eq "0.9.1"
   end
 end

data/spec/unit/concurrent/atomic_fixnum_spec.rb

@@ -5,31 +5,31 @@ describe Bunny::Concurrent::AtomicFixnum do
   it "allows retrieving the current value" do
     af = described_class.new(0)
 
-    af.get.should == 0
-    af.should == 0
+    expect(af.get).to eq 0
+    expect(af).to eq 0
   end
 
   it "can be updated" do
     af = described_class.new(0)
 
-    af.get.should == 0
+    expect(af.get).to eq 0
     Thread.new do
       af.set(10)
     end
     sleep 0.6
-    af.get.should == 10
+    expect(af.get).to eq 10
   end
 
   it "can be incremented" do
     af = described_class.new(0)
 
-    af.get.should == 0
+    expect(af.get).to eq 0
     10.times do
       Thread.new do
         af.increment
       end
     end
     sleep 0.6
-    af.get.should == 10
+    expect(af.get).to eq 10
   end
 end

data/spec/unit/concurrent/condition_spec.rb

@@ -18,7 +18,7 @@ describe Bunny::Concurrent::Condition do
         t.abort_on_exception = true
 
         condition.wait
-        xs.should == [:notified]
+        expect(xs).to eq [:notified]
       end
     end
   end
@@ -45,7 +45,7 @@ describe Bunny::Concurrent::Condition do
         sleep 0.25
         condition.notify
         sleep 0.5
-        xs.should satisfy { |ys| ys.size == 1 && (ys.include?(:notified1) || ys.include?(:notified2)) }
+        expect(xs).to satisfy { |ys| ys.size == 1 && (ys.include?(:notified1) || ys.include?(:notified2)) }
       end
     end
   end
@@ -74,7 +74,7 @@ describe Bunny::Concurrent::Condition do
         n.times do |i|
           item = "notified#{i + 1}".to_sym
 
-          @xs.should include(item)
+          expect(@xs).to include item
         end
       end
     end

data/spec/unit/concurrent/linked_continuation_queue_spec.rb

@@ -14,7 +14,7 @@ if defined?(JRUBY_VERSION)
         t.abort_on_exception = true
 
         v = subject.poll(500)
-        v.should == 10
+        expect(v).to eq 10
       end
     end
 
@@ -28,7 +28,7 @@ if defined?(JRUBY_VERSION)
         end
         t.abort_on_exception = true
 
-        lambda { subject.poll(500) }.should raise_error(::Timeout::Error)
+        expect { subject.poll(500) }.to raise_error(::Timeout::Error)
       end
     end
   end

data/spec/unit/concurrent/synchronized_sorted_set_spec.rb

@@ -6,42 +6,42 @@ unless ENV["CI"]
     50.times do |i|
       it "provides the same API as SortedSet for key operations (take #{i})" do
         s = described_class.new
-        s.length.should == 0
+        expect(s.length).to eq 0
 
         s << 1
-        s.length.should == 1
+        expect(s.length).to eq 1
         s << 1
-        s.length.should == 1
+        expect(s.length).to eq 1
         s << 2
-        s.length.should == 2
+        expect(s.length).to eq 2
         s << 3
-        s.length.should == 3
+        expect(s.length).to eq 3
         s << 4
-        s.length.should == 4
+        expect(s.length).to eq 4
         s << 4
         s << 4
         s << 4
-        s.length.should == 4
+        expect(s.length).to eq 4
         s << 5
-        s.length.should == 5
+        expect(s.length).to eq 5
         s << 5
         s << 5
         s << 5
-        s.length.should == 5
+        expect(s.length).to eq 5
         s << 6
-        s.length.should == 6
+        expect(s.length).to eq 6
         s << 7
-        s.length.should == 7
+        expect(s.length).to eq 7
         s << 8
-        s.length.should == 8
+        expect(s.length).to eq 8
         s.delete 8
-        s.length.should == 7
+        expect(s.length).to eq 7
         s.delete_if { |i| i == 1 }
-        s.length.should == 6
+        expect(s.length).to eq 6
       end
       it "synchronizes common operations needed by Bunny (take #{i})" do
         s = described_class.new
-        s.length.should == 0
+        expect(s.length).to eq 0
 
         10.times do
           Thread.new do
@@ -66,7 +66,7 @@ unless ENV["CI"]
         end
         sleep 0.5
 
-        s.length.should == 6
+        expect(s.length).to eq 6
       end
     end
   end