bunny 1.3.0 → 2.17.0

data/spec/higher_level_api/integration/basic_consume_with_objects_spec.rb

@@ -3,7 +3,7 @@ require "set"
 
 describe Bunny::Queue, "#subscribe_with" 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
@@ -32,23 +32,23 @@ describe Bunny::Queue, "#subscribe_with" do
     it "requeues messages on channel closure" do
       ch1  = connection.create_channel
       ch2  = connection.create_channel
-      q1   = ch1.queue("bunny.tests.consumer_object1", :exclusive => true)
-      q2   = ch2.queue("bunny.tests.consumer_object1", :exclusive => true)
+      q1   = ch1.queue("bunny.tests.consumer_object1", exclusive: true)
+      q2   = ch2.queue("bunny.tests.consumer_object1", exclusive: true)
       ec   = ExampleConsumer.new(ch1, q1, "", false)
       x    = ch2.default_exchange
 
       t = Thread.new do
         50.times do
-          x.publish("hello", :routing_key => q2.name)
+          x.publish("hello", routing_key: q2.name)
         end
       end
       t.abort_on_exception = true
 
-      q1.subscribe_with(ec, :ack => true)
+      q1.subscribe_with(ec, manual_ack: true)
       sleep 2
       ch1.close
 
-      q2.message_count.should == 50
+      expect(q2.message_count).to eq 50
     end
   end
 end

data/spec/higher_level_api/integration/basic_get_spec.rb

@@ -2,8 +2,8 @@ require "spec_helper"
 
 describe Bunny::Queue, "#pop" do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed",
-                  :automatically_recover => false)
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+                  automatically_recover: false)
     c.start
     c
   end
@@ -16,11 +16,11 @@ describe Bunny::Queue, "#pop" do
     it "fetches a messages which is automatically acknowledged" do
       ch = connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.default_exchange
 
       msg = "xyzzy"
-      x.publish(msg, :routing_key => q.name)
+      x.publish(msg, routing_key: q.name)
 
       sleep(0.5)
       get_ok, properties, content = q.pop
@@ -30,7 +30,7 @@ describe Bunny::Queue, "#pop" do
       expect(get_ok.routing_key).to eq(q.name)
       expect(get_ok.delivery_tag).to be_kind_of(Bunny::VersionedDeliveryTag)
       expect(content).to eq(msg)
-      q.message_count.should == 0
+      expect(q.message_count).to eq 0
 
       ch.close
     end
@@ -41,16 +41,40 @@ describe Bunny::Queue, "#pop" do
     it "returns an empty response" do
       ch = connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       q.purge
 
       get_empty, properties, content = q.pop
       expect(get_empty).to eq(nil)
       expect(properties).to eq(nil)
       expect(content).to eq(nil)
-      q.message_count.should == 0
+      expect(q.message_count).to eq 0
 
       ch.close
     end
   end
 end
+
+
+describe Bunny::Channel, "#basic_get" do
+  let(:connection) do
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
+                  automatically_recover: false, continuation_timeout: 3000)
+    c.start
+    c
+  end
+
+  after :each do
+    connection.close if connection.open?
+  end
+
+  context "with a non-existent queue" do
+    it "throws a NOT_FOUND" do
+      ch = connection.create_channel
+
+      expect do
+        ch.basic_get "non_existent_#{rand.to_s}"
+      end.to raise_error(Bunny::NotFound)
+    end
+  end
+end

data/spec/higher_level_api/integration/basic_nack_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Channel, "#nack" 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,39 +17,42 @@ describe Bunny::Channel, "#nack" do
 
   context "with requeue = false" do
     it "rejects a message" do
-      q = subject.queue("bunny.basic.nack.with-requeue-false", :exclusive => true)
+      q = subject.queue("bunny.basic.nack.with-requeue-false", exclusive: true)
       x = subject.default_exchange
 
-      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", routing_key: q.name)
       sleep(0.5)
-      q.message_count.should == 1
-      delivery_info, _, content = q.pop(:ack => true)
+      expect(q.message_count).to eq 1
+      delivery_info, _, content = q.pop(manual_ack: true)
 
       subject.nack(delivery_info.delivery_tag, false, false)
       sleep(0.5)
-      q.message_count.should == 0
-
       subject.close
+
+      ch = connection.create_channel
+      q = ch.queue("bunny.basic.nack.with-requeue-false", exclusive: true)
+      expect(q.message_count).to eq 0
+      ch.close
     end
   end
 
   context "with multiple = true" do
     it "rejects multiple messages" do
-q = subject.queue("bunny.basic.nack.with-requeue-true-multi-true", :exclusive => true)
+q = subject.queue("bunny.basic.nack.with-requeue-true-multi-true", exclusive: true)
       x = subject.default_exchange
 
       3.times do
-        x.publish("bunneth", :routing_key => q.name)
+        x.publish("bunneth", routing_key: q.name)
       end
       sleep(0.5)
-      q.message_count.should == 3
-      _, _, _ = q.pop(:ack => true)
-      _, _, _ = q.pop(:ack => true)
-      delivery_info, _, content = q.pop(:ack => true)
+      expect(q.message_count).to eq 3
+      _, _, _ = q.pop(manual_ack: true)
+      _, _, _ = q.pop(manual_ack: true)
+      delivery_info, _, content = q.pop(manual_ack: true)
 
       subject.nack(delivery_info.delivery_tag, true, true)
       sleep(0.5)
-      q.message_count.should == 3
+      expect(q.message_count).to eq 3
 
       subject.close
     end
@@ -58,13 +61,13 @@ q = subject.queue("bunny.basic.nack.with-requeue-true-multi-true", :exclusive =>
 
   context "with an invalid (random) delivery tag" do
     it "causes a channel-level error" do
-      q = subject.queue("bunny.basic.nack.unknown-delivery-tag", :exclusive => true)
+      q = subject.queue("bunny.basic.nack.unknown-delivery-tag", exclusive: true)
       x = subject.default_exchange
 
-      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", routing_key: q.name)
       sleep(0.25)
-      q.message_count.should == 1
-      _, _, content = q.pop(:ack => true)
+      expect(q.message_count).to eq 1
+      _, _, content = q.pop(manual_ack: true)
 
       subject.on_error do |ch, channel_close|
         @channel_close = channel_close
@@ -73,7 +76,7 @@ q = subject.queue("bunny.basic.nack.with-requeue-true-multi-true", :exclusive =>
 
       sleep 0.5
 
-      @channel_close.reply_text.should == "PRECONDITION_FAILED - unknown delivery tag 82"
+      expect(@channel_close.reply_text).to eq "PRECONDITION_FAILED - unknown delivery tag 82"
     end
   end
 end

data/spec/higher_level_api/integration/basic_publish_spec.rb

@@ -1,97 +1,8 @@
 require "spec_helper"
 
-if RUBY_VERSION <= "1.9"
-  describe "Publishing a message to the default exchange" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close if connection.open?
-    end
-
-
-    context "with all default delivery and message properties" do
-      it "routes messages to a queue with the same name as the routing key" do
-        connection.should be_threaded
-        ch = connection.create_channel
-
-        q  = ch.queue("", :exclusive => true)
-        x  = ch.default_exchange
-
-        x.publish("xyzzy", :routing_key => q.name).
-          publish("xyzzy", :routing_key => q.name).
-          publish("xyzzy", :routing_key => q.name).
-          publish("xyzzy", :routing_key => q.name)
-
-        sleep(1)
-        q.message_count.should == 4
-
-        ch.close
-      end
-    end
-
-
-    context "with all default delivery and message properties" do
-      it "routes the messages and preserves all the metadata" do
-        connection.should be_threaded
-        ch = connection.create_channel
-
-        q  = ch.queue("", :exclusive => true)
-        x  = ch.default_exchange
-
-        x.publish("xyzzy", :routing_key => q.name, :persistent => true)
-
-        sleep(1)
-        q.message_count.should == 1
-
-        envelope, headers, payload = q.pop
-
-        payload.should == "xyzzy"
-
-        headers[:content_type].should == "application/octet-stream"
-        headers[:delivery_mode].should == 2
-        headers[:priority].should == 0
-
-        ch.close
-      end
-    end
-
-
-    context "with all default delivery and message properties on a single-threaded connection" do
-      let(:connection) do
-        c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :threaded => false)
-        c.start
-        c
-      end
-
-      it "routes messages to a queue with the same name as the routing key" do
-        connection.should_not be_threaded
-        ch = connection.create_channel
-
-        q  = ch.queue("", :exclusive => true)
-        x  = ch.default_exchange
-
-        x.publish("xyzzy", :routing_key => q.name).
-          publish("xyzzy", :routing_key => q.name).
-          publish("xyzzy", :routing_key => q.name).
-          publish("xyzzy", :routing_key => q.name)
-
-        sleep(1)
-        q.message_count.should == 4
-
-        ch.close
-      end
-    end
-  end
-end
-
-
 describe "Published message" 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
@@ -104,19 +15,19 @@ describe "Published message" do
     it "routes the messages" do
       ch = connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.fanout("amq.fanout")
       q.bind(x)
 
       rk = "a" * 254
-      x.publish("xyzzy", :routing_key => rk, :persistent => true)
+      x.publish("xyzzy", routing_key: rk, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       _, _, payload = q.pop
 
-      payload.should == "xyzzy"
+      expect(payload).to eq "xyzzy"
 
       ch.close
     end
@@ -126,19 +37,19 @@ describe "Published message" do
     it "routes the messages" do
       ch = connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.fanout("amq.fanout")
       q.bind(x)
 
       rk = "a" * 255
-      x.publish("xyzzy", :routing_key => rk, :persistent => true)
+      x.publish("xyzzy", routing_key: rk, persistent: true)
 
       sleep(1)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       _, _, payload = q.pop
 
-      payload.should == "xyzzy"
+      expect(payload).to eq "xyzzy"
 
       ch.close
     end
@@ -148,13 +59,13 @@ describe "Published message" do
     it "fails with a connection exception" do
       ch = connection.create_channel
 
-      q  = ch.queue("", :exclusive => true)
+      q  = ch.queue("", exclusive: true)
       x  = ch.fanout("amq.fanout")
       q.bind(x)
 
       rk = "a" * 256
       expect do
-        x.publish("xyzzy", :routing_key => rk, :persistent => true)
+        x.publish("xyzzy", routing_key: rk, persistent: true)
       end.to raise_error(ArgumentError)
 
       ch.close

data/spec/higher_level_api/integration/basic_qos_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Channel, "#prefetch" 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
@@ -11,10 +11,35 @@ describe Bunny::Channel, "#prefetch" do
     connection.close
   end
 
-  context "with a positive integer" do
+  context "with a positive integer < 65535" do
     it "sets that prefetch level via basic.qos" do
       ch = connection.create_channel
-      ch.prefetch(10).should be_instance_of(AMQ::Protocol::Basic::QosOk)
+      expect(ch.prefetch_count).not_to eq 10
+      expect(ch.prefetch_global).to be_nil
+      expect(ch.prefetch(10)).to be_instance_of(AMQ::Protocol::Basic::QosOk)
+      expect(ch.prefetch_count).to eq 10
+      expect(ch.prefetch_global).to be false
+    end
+
+    it "sets that prefetch global via basic.qos" do
+      ch = connection.create_channel
+      expect(ch.prefetch_count).not_to eq 42
+      expect(ch.prefetch_global).to be_nil
+      expect(ch.prefetch(42, true)).to be_instance_of(AMQ::Protocol::Basic::QosOk)
+      expect(ch.prefetch_count).to eq 42
+      expect(ch.prefetch_global).to be true
+    end
+  end
+
+  context "with a positive integer > 65535" do
+    it "raises an ArgumentError" do
+      ch = connection.create_channel
+      expect {
+        ch.prefetch(100_000)
+      }.to raise_error(
+        ArgumentError,
+        "prefetch count must be no greater than #{Bunny::Channel::MAX_PREFETCH_COUNT}, given: 100000"
+      )
     end
   end
 
@@ -23,7 +48,10 @@ describe Bunny::Channel, "#prefetch" do
       ch = connection.create_channel
       expect {
         ch.prefetch(-2)
-      }.to raise_error(ArgumentError)
+      }.to raise_error(
+        ArgumentError,
+        "prefetch count must be a positive integer, given: -2"
+      )
     end
   end
 end

data/spec/higher_level_api/integration/basic_reject_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Channel, "#reject" 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,17 +14,17 @@ describe Bunny::Channel, "#reject" do
   context "with requeue = true" do
     it "requeues a message" do
       ch = connection.create_channel
-      q  = ch.queue("bunny.basic.reject.manual-acks", :exclusive => true)
+      q  = ch.queue("bunny.basic.reject.manual-acks", exclusive: true)
       x  = ch.default_exchange
 
-      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", routing_key: q.name)
       sleep(0.5)
-      q.message_count.should == 1
-      delivery_info, _, _ = q.pop(:ack => true)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(manual_ack: true)
 
       ch.reject(delivery_info.delivery_tag, true)
       sleep(0.5)
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
 
       ch.close
     end
@@ -33,18 +33,21 @@ describe Bunny::Channel, "#reject" do
   context "with requeue = false" do
     it "rejects a message" do
       ch = connection.create_channel
-      q  = ch.queue("bunny.basic.reject.with-requeue-false", :exclusive => true)
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", exclusive: true)
       x  = ch.default_exchange
 
-      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", routing_key: q.name)
       sleep(0.5)
-      q.message_count.should == 1
-      delivery_info, _, _ = q.pop(:ack => true)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(manual_ack: true)
 
       ch.reject(delivery_info.delivery_tag, false)
       sleep(0.5)
-      q.message_count.should == 0
+      ch.close
 
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", exclusive: true)
+      expect(q.message_count).to eq 0
       ch.close
     end
   end
@@ -53,13 +56,13 @@ describe Bunny::Channel, "#reject" do
   context "with an invalid (random) delivery tag" do
     it "causes a channel-level error" do
       ch = connection.create_channel
-      q  = ch.queue("bunny.basic.reject.unknown-delivery-tag", :exclusive => true)
+      q  = ch.queue("bunny.basic.reject.unknown-delivery-tag", exclusive: true)
       x  = ch.default_exchange
 
-      x.publish("bunneth", :routing_key => q.name)
+      x.publish("bunneth", routing_key: q.name)
       sleep(0.25)
-      q.message_count.should == 1
-      _, _, content = q.pop(:ack => true)
+      expect(q.message_count).to eq 1
+      _, _, content = q.pop(manual_ack: true)
 
       ch.on_error do |ch, channel_close|
         @channel_close = channel_close
@@ -68,7 +71,82 @@ describe Bunny::Channel, "#reject" do
 
       sleep 0.5
 
-      @channel_close.reply_text.should == "PRECONDITION_FAILED - unknown delivery tag 82"
+      expect(@channel_close.reply_text).to eq "PRECONDITION_FAILED - unknown delivery tag 82"
+    end
+  end
+end
+
+describe Bunny::Channel, "#basic_reject" do
+  let(:connection) do
+    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :each do
+    connection.close if connection.open?
+  end
+
+  context "with requeue = true" do
+    it "requeues a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.manual-acks", exclusive: true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", routing_key: q.name)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(manual_ack: true)
+
+      ch.basic_reject(delivery_info.delivery_tag.to_i, true)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+
+      ch.close
+    end
+  end
+
+  context "with requeue = false" do
+    it "rejects a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", exclusive: true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", routing_key: q.name)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(manual_ack: true)
+
+      ch.basic_reject(delivery_info.delivery_tag.to_i, false)
+      sleep(0.5)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", exclusive: true)
+      expect(q.message_count).to eq 0
+      ch.close
+    end
+  end
+
+  context "with requeue = default" do
+    it "rejects a message" do
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", exclusive: true)
+      x  = ch.default_exchange
+
+      x.publish("bunneth", routing_key: q.name)
+      sleep(0.5)
+      expect(q.message_count).to eq 1
+      delivery_info, _, _ = q.pop(manual_ack: true)
+
+      ch.basic_reject(delivery_info.delivery_tag.to_i)
+      sleep(0.5)
+      ch.close
+
+      ch = connection.create_channel
+      q  = ch.queue("bunny.basic.reject.with-requeue-false", exclusive: true)
+      expect(q.message_count).to eq 0
+      ch.close
     end
   end
 end