bunny 1.7.0 → 2.17.0

data/spec/higher_level_api/integration/publishing_edge_cases_spec.rb

@@ -4,10 +4,10 @@ require "spec_helper"
 unless ENV["CI"]
   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 = Bunny.new(username: "bunny_gem",
+        password: "bunny_password",
+        vhost: "bunny_testbed",
+        port: ENV.fetch("RABBITMQ_PORT", 5672))
       c.start
       c
     end
@@ -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" * (1024 * 1024 * 4 + 28237777))
-        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
@@ -42,17 +42,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 = "кириллца, йо" * (1024 * 1024)
-        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
@@ -64,21 +64,21 @@ unless ENV["CI"]
       it "successfully publishes the message" do
         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 => false, :mandatory => true)
+        x.publish("", routing_key: q.name, persistent: false, mandatory: true)
 
         sleep(0.5)
-        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 == 1
-        headers[:priority].should == 0
+        expect(headers[:content_type]).to eq "application/octet-stream"
+        expect(headers[:delivery_mode]).to eq 1
+        expect(headers[:priority]).to eq 0
 
         ch.close
       end

data/spec/higher_level_api/integration/queue_bind_spec.rb

@@ -2,38 +2,38 @@ require "spec_helper"
 
 describe "A client-named", Bunny::Queue 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
 
   it "can be bound to a pre-declared exchange" do
     ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", :exclusive => true)
-    q.should_not be_server_named
+    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
+    expect(q).not_to be_server_named
 
-    q.bind("amq.fanout").should == q
+    expect(q.bind("amq.fanout")).to eq q
 
     ch.close
   end
 
   it "can be unbound from a pre-declared exchange" do
     ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", :exclusive => true)
-    q.should_not be_server_named
+    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
+    expect(q).not_to be_server_named
 
     q.bind("amq.fanout")
-    q.unbind("amq.fanout").should == q
+    expect(q.unbind("amq.fanout")).to eq q
 
     ch.close
   end
 
   it "can be bound to a custom exchange" do
     ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", :exclusive => true)
+    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
 
     x  = ch.fanout("bunny.tests.exchanges.fanout#{rand}")
-    q.bind(x).should == q
+    expect(q.bind(x)).to eq q
 
     x.delete
     ch.close
@@ -41,13 +41,13 @@ describe "A client-named", Bunny::Queue do
 
   it "can be unbound from a custom exchange" do
     ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", :exclusive => true)
-    q.should_not be_server_named
+    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
+    expect(q).not_to be_server_named
 
-    x  = ch.fanout("bunny.tests.fanout", :auto_delete => true, :durable => false)
+    x  = ch.fanout("bunny.tests.fanout", auto_delete: true, durable: false)
 
     q.bind(x)
-    q.unbind(x).should == q
+    expect(q.unbind(x)).to eq q
 
     ch.close
   end
@@ -64,31 +64,31 @@ describe "A server-named", Bunny::Queue do
 
   it "can be bound to a pre-declared exchange" do
     ch = connection.create_channel
-    q  = ch.queue("", :exclusive => true)
-    q.should be_server_named
+    q  = ch.queue("", exclusive: true)
+    expect(q).to be_server_named
 
-    q.bind("amq.fanout").should == q
+    expect(q.bind("amq.fanout")).to eq q
 
     ch.close
   end
 
   it "can be unbound from a pre-declared exchange" do
     ch = connection.create_channel
-    q  = ch.queue("", :exclusive => true)
-    q.should be_server_named
+    q  = ch.queue("", exclusive: true)
+    expect(q).to be_server_named
 
     q.bind("amq.fanout")
-    q.unbind("amq.fanout").should == q
+    expect(q.unbind("amq.fanout")).to eq q
 
     ch.close
   end
 
   it "can be bound to a custom exchange" do
     ch = connection.create_channel
-    q  = ch.queue("", :exclusive => true)
+    q  = ch.queue("", exclusive: true)
 
     x  = ch.fanout("bunny.tests.exchanges.fanout#{rand}")
-    q.bind(x).should == q
+    expect(q.bind(x)).to eq q
 
     x.delete
     ch.close
@@ -96,12 +96,12 @@ describe "A server-named", Bunny::Queue do
 
   it "can be bound from a custom exchange" do
     ch   = connection.create_channel
-    q    = ch.queue("", :exclusive => true)
+    q    = ch.queue("", exclusive: true)
 
     name = "bunny.tests.exchanges.fanout#{rand}"
     x    = ch.fanout(name)
     q.bind(x)
-    q.unbind(name).should == q
+    expect(q.unbind(name)).to eq q
 
     x.delete
     ch.close

data/spec/higher_level_api/integration/queue_declare_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Bunny::Queue do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
     c.start
     c
   end
@@ -18,7 +18,7 @@ describe Bunny::Queue do
       ch   = connection.create_channel
 
       q    = ch.queue(name)
-      q.name.should == name
+      expect(q.name).to eq name
 
       q.delete
       ch.close
@@ -28,7 +28,7 @@ describe Bunny::Queue do
       ch   = connection.create_channel
 
       q = ch.queue(name)
-      ch.queue(name).object_id.should == q.object_id
+      expect(ch.queue(name).object_id).to eq q.object_id
 
       q.delete
       ch.close
@@ -36,14 +36,14 @@ describe Bunny::Queue do
   end
 
 
-  context "when queue name is passed on as an empty string" do
+  context "when queue name is passed as an empty string" do
     it "uses server-assigned queue name" do
       ch   = connection.create_channel
 
       q = ch.queue("")
-      q.name.should_not be_empty
-      q.name.should =~ /^amq.gen.+/
-      q.should be_server_named
+      expect(q.name).not_to be_empty
+      expect(q.name).to match /^amq.gen.+/
+      expect(q).to be_server_named
       q.delete
 
       ch.close
@@ -51,15 +51,26 @@ describe Bunny::Queue do
   end
 
 
+  context "when a nil is passed for queue name" do
+    it "throws an error" do
+      ch   = connection.create_channel
+
+      expect {
+        ch.queue(nil, durable: true, auto_delete: false)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+
   context "when queue is declared as durable" do
     it "declares it as durable" do
       ch   = connection.create_channel
 
-      q = ch.queue("bunny.tests.queues.durable", :durable => true)
-      q.should be_durable
-      q.should_not be_auto_delete
-      q.should_not be_exclusive
-      q.arguments.should be_nil
+      q = ch.queue("bunny.tests.queues.durable", durable: true)
+      expect(q).to be_durable
+      expect(q).not_to be_auto_delete
+      expect(q).not_to be_exclusive
+      expect(q.arguments).to be_nil
       q.delete
 
       ch.close
@@ -71,9 +82,9 @@ describe Bunny::Queue do
     it "declares it as exclusive" do
       ch   = connection.create_channel
 
-      q = ch.queue("bunny.tests.queues.exclusive", :exclusive => true)
-      q.should be_exclusive
-      q.should_not be_durable
+      q = ch.queue("bunny.tests.queues.exclusive", exclusive: true)
+      expect(q).to be_exclusive
+      expect(q).not_to be_durable
       q.delete
 
       ch.close
@@ -85,10 +96,10 @@ describe Bunny::Queue do
     it "declares it as auto-delete" do
       ch   = connection.create_channel
 
-      q = ch.queue("bunny.tests.queues.auto-delete", :auto_delete => true)
-      q.should be_auto_delete
-      q.should_not be_exclusive
-      q.should_not be_durable
+      q = ch.queue("bunny.tests.queues.auto-delete", auto_delete: true)
+      expect(q).to be_auto_delete
+      expect(q).not_to be_exclusive
+      expect(q).not_to be_durable
       q.delete
 
       ch.close
@@ -96,18 +107,71 @@ describe Bunny::Queue do
   end
 
 
+  context "when queue is declared with a mismatching auto-delete property value" do
+    it "raises an exception" do
+      ch   = connection.create_channel
+
+      q = ch.queue("bunny.tests.queues.auto-delete", auto_delete: true, durable: false)
+      expect {
+        # force re-declaration
+        ch.queue_declare(q.name, auto_delete: false, durable: false)
+      }.to raise_error(Bunny::PreconditionFailed)
+
+      expect(ch).to be_closed
 
-  context "when queue is declared with a different set of attributes" do
+      cleanup_ch = connection.create_channel
+      cleanup_ch.queue_delete(q.name)
+    end
+  end
+
+  context "when queue is declared with a mismatching durable property value" do
     it "raises an exception" do
       ch   = connection.create_channel
 
-      q = ch.queue("bunny.tests.queues.auto-delete", :auto_delete => true, :durable => false)
+      q = ch.queue("bunny.tests.queues.durable", durable: true)
       expect {
         # force re-declaration
-        ch.queue_declare("bunny.tests.queues.auto-delete", :auto_delete => false, :durable => true)
+        ch.queue_declare(q.name, durable: false)
       }.to raise_error(Bunny::PreconditionFailed)
 
-      ch.should be_closed
+      expect(ch).to be_closed
+
+      cleanup_ch = connection.create_channel
+      cleanup_ch.queue_delete(q.name)
+    end
+  end
+
+  context "when queue is declared with a mismatching exclusive property value" do
+    it "raises an exception" do
+      ch   = connection.create_channel
+
+      q = ch.queue("bunny.tests.queues.exclusive.#{rand}", exclusive: true)
+      # when there's an exclusivity property mismatch, a different error
+      # (405 RESOURCE_LOCKED) is used. This is a leaked queue exclusivity/ownership
+      # implementation detail that's now basically a feature. MK.
+      expect {
+        # force re-declaration
+        ch.queue_declare(q.name, exclusive: false)
+      }.to raise_error(Bunny::ResourceLocked)
+
+      expect(ch).to be_closed
+    end
+  end
+
+  context "when queue is declared with a set of mismatching values" do
+    it "raises an exception" do
+      ch   = connection.create_channel
+
+      q = ch.queue("bunny.tests.queues.proprty-equivalence", auto_delete: true, durable: false)
+      expect {
+        # force re-declaration
+        ch.queue_declare(q.name, auto_delete: false, durable: true)
+      }.to raise_error(Bunny::PreconditionFailed)
+
+      expect(ch).to be_closed
+
+      cleanup_ch = connection.create_channel
+      cleanup_ch.queue_delete(q.name)
     end
   end
 
@@ -121,15 +185,46 @@ describe Bunny::Queue do
     it "causes all messages in it to have a TTL" do
       ch   = connection.create_channel
 
-      q = ch.queue("bunny.tests.queues.with-arguments.ttl", :arguments => args, :exclusive => true)
-      q.arguments.should == args
+      q = ch.queue("bunny.tests.queues.with-arguments.ttl", arguments:  args, exclusive: true)
+      expect(q.arguments).to eq args
 
       q.publish("xyzzy")
       sleep 0.1
 
-      q.message_count.should == 1
+      expect(q.message_count).to eq 1
       sleep 1.5
-      q.message_count.should == 0
+      expect(q.message_count).to eq 0
+
+      ch.close
+    end
+  end
+
+
+  context "when queue is declared with priorities" do
+    let(:args) do
+      {"x-max-priority" => 5}
+    end
+
+    it "enables priority implementation" do
+      c = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
+      c.start
+
+      ch   = c.create_channel
+      ch.confirm_select
+
+      q = ch.queue("bunny.tests.queues.with-arguments.priority #{rand}", arguments: args, exclusive: true)
+      expect(q.arguments).to eq args
+
+      q.publish("xyzzy")
+      ch.wait_for_confirms
+      sleep 0.1
+
+      # this test only does sanity checking,
+      # without trying to actually test prioritisation.
+      #
+      # added to guard against issues such as
+      # https://github.com/rabbitmq/rabbitmq-server/issues/488
+      expect(q.message_count).to eq 1
 
       ch.close
     end
@@ -140,15 +235,15 @@ describe Bunny::Queue do
     context "when a queue exists" do
       it "returns true" do
         ch = connection.create_channel
-        q  = ch.queue("", :exlusive => true)
+        q  = ch.queue("", exlusive: true)
 
-        connection.queue_exists?(q.name).should be_true
+        expect(connection.queue_exists?(q.name)).to eq true
       end
     end
 
     context "when a queue DOES NOT exist" do
       it "returns false" do
-        connection.queue_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}").should be_false
+        expect(connection.queue_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}")).to eq false
       end
     end
   end
@@ -168,19 +263,19 @@ describe Bunny::Queue do
       it "causes the queue to be bounded" do
         ch   = connection.create_channel
 
-        q = ch.queue("bunny.tests.queues.with-arguments.max-length", :arguments => args, :exclusive => true)
-        q.arguments.should == args
+        q = ch.queue("bunny.tests.queues.with-arguments.max-length", arguments:  args, exclusive: true)
+        expect(q.arguments).to eq args
 
         (n * 10).times do
           q.publish("xyzzy")
         end
 
-        q.message_count.should == n
+        expect(q.message_count).to eq n
         (n * 5).times do
           q.publish("xyzzy")
         end
 
-        q.message_count.should == n
+        expect(q.message_count).to eq n
         q.delete
 
         ch.close