bunny 2.14.2 → 2.22.0

data/spec/higher_level_api/integration/basic_consume_with_objects_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-require "set"
-
-describe Bunny::Queue, "#subscribe_with" 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 explicit acknowledgements mode" do
-    class ExampleConsumer < Bunny::Consumer
-      def cancelled?
-        @cancelled
-      end
-
-      def handle_cancellation(_)
-        @cancelled = true
-      end
-
-      def call(delivery_info, metadata, payload)
-         # no-op
-      end
-    end
-
-    # demonstrates that manual acknowledgement mode is actually
-    # used. MK.
-    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)
-      ec   = ExampleConsumer.new(ch1, q1, "", false)
-      x    = ch2.default_exchange
-
-      t = Thread.new do
-        50.times do
-          x.publish("hello", routing_key: q2.name)
-        end
-      end
-      t.abort_on_exception = true
-
-      q1.subscribe_with(ec, manual_ack: true)
-      sleep 2
-      ch1.close
-
-      expect(q2.message_count).to eq 50
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_get_spec.rb

@@ -1,80 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "#pop" do
-  let(:connection) do
-    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
-                  automatically_recover: false)
-    c.start
-    c
-  end
-
-  after :each do
-    connection.close if connection.open?
-  end
-
-  context "with all defaults" do
-    it "fetches a messages which is automatically acknowledged" do
-      ch = connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.default_exchange
-
-      msg = "xyzzy"
-      x.publish(msg, routing_key: q.name)
-
-      sleep(0.5)
-      get_ok, properties, content = q.pop
-      expect(get_ok).to be_kind_of(Bunny::GetResponse)
-      expect(properties).to be_kind_of(Bunny::MessageProperties)
-      expect(properties.content_type).to eq("application/octet-stream")
-      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)
-      expect(q.message_count).to eq 0
-
-      ch.close
-    end
-  end
-
-
-  context "with an empty queue" do
-    it "returns an empty response" do
-      ch = connection.create_channel
-
-      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)
-      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

@@ -1,82 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#nack" 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
-
-  subject do
-    connection.create_channel
-  end
-
-  context "with requeue = false" do
-    it "rejects a message" do
-      q = subject.queue("bunny.basic.nack.with-requeue-false", exclusive: true)
-      x = subject.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      sleep(0.5)
-      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)
-      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)
-      x = subject.default_exchange
-
-      3.times do
-        x.publish("bunneth", routing_key: q.name)
-      end
-      sleep(0.5)
-      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)
-      expect(q.message_count).to eq 3
-
-      subject.close
-    end
-  end
-
-
-  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)
-      x = subject.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      sleep(0.25)
-      expect(q.message_count).to eq 1
-      _, _, content = q.pop(manual_ack: true)
-
-      subject.on_error do |ch, channel_close|
-        @channel_close = channel_close
-      end
-      subject.nack(82, false, true)
-
-      sleep 0.5
-
-      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,74 +0,0 @@
-require "spec_helper"
-
-describe "Published message" 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 all default delivery and a 254 character long routing key" do
-    it "routes the messages" do
-      ch = connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.fanout("amq.fanout")
-      q.bind(x)
-
-      rk = "a" * 254
-      x.publish("xyzzy", routing_key: rk, persistent: true)
-
-      sleep(1)
-      expect(q.message_count).to eq 1
-
-      _, _, payload = q.pop
-
-      expect(payload).to eq "xyzzy"
-
-      ch.close
-    end
-  end
-
-  context "with all default delivery and a 255 character long routing key" do
-    it "routes the messages" do
-      ch = connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.fanout("amq.fanout")
-      q.bind(x)
-
-      rk = "a" * 255
-      x.publish("xyzzy", routing_key: rk, persistent: true)
-
-      sleep(1)
-      expect(q.message_count).to eq 1
-
-      _, _, payload = q.pop
-
-      expect(payload).to eq "xyzzy"
-
-      ch.close
-    end
-  end
-
-  context "with all default delivery and a 256 character long routing key" do
-    it "fails with a connection exception" do
-      ch = connection.create_channel
-
-      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)
-      end.to raise_error(ArgumentError)
-
-      ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_qos_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#prefetch" 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
-  end
-
-  context "with a positive integer < 65535" do
-    it "sets that prefetch level via basic.qos" do
-      ch = connection.create_channel
-      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
-
-  context "with a negative integer" do
-    it "raises an ArgumentError" do
-      ch = connection.create_channel
-      expect {
-        ch.prefetch(-2)
-      }.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

@@ -1,152 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#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.reject(delivery_info.delivery_tag, 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.reject(delivery_info.delivery_tag, 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 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)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      sleep(0.25)
-      expect(q.message_count).to eq 1
-      _, _, content = q.pop(manual_ack: true)
-
-      ch.on_error do |ch, channel_close|
-        @channel_close = channel_close
-      end
-      ch.reject(82, true)
-
-      sleep 0.5
-
-      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

data/spec/higher_level_api/integration/basic_return_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Exchange, "#publish" 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 mandatory: true and a bad [no routes] routing key" do
-    it "causes a message to be returned" do
-      ch = connection.create_channel
-      x  = ch.default_exchange
-
-      returned = []
-      x.on_return do |basic_deliver, properties, content|
-        returned << content
-      end
-
-      x.publish("xyzzy", routing_key: rand.to_s, mandatory: true)
-      sleep 0.5
-
-      expect(returned).to include("xyzzy")
-
-      ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/channel_close_spec.rb

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel 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
-  end
-
-  context "when closed" do
-    it "releases the id" do
-      ch = connection.create_channel
-      n = ch.number
-
-      expect(ch).to be_open
-      ch.close
-      expect(ch).to be_closed
-
-      # a new channel with the same id can be created
-      connection.create_channel(n)
-    end
-  end
-
-  context "when double closed" do
-    # bunny#528
-    it "raises a meaningful exception" do
-      ch = connection.create_channel
-
-      expect(ch).to be_open
-      ch.close
-      expect(ch).to be_closed
-
-      expect { ch.close }.to raise_error(Bunny::ChannelAlreadyClosed)
-    end
-  end
-
-  context "when double closed after a channel-level protocol exception" do
-    # bunny#528
-    it "raises a meaningful exception" do
-      ch = connection.create_channel
-
-      s  = "bunny-temp-q-#{rand}"
-
-      expect(ch).to be_open
-      ch.queue_declare(s, durable: false)
-
-      expect do
-        ch.queue_declare(s, durable: true)
-      end.to raise_error(Bunny::PreconditionFailed)
-
-      # channel.close is sent and handled concurrently with the test
-      sleep 1
-      expect(ch).to be_closed
-
-      expect { ch.close }.to raise_error(Bunny::ChannelAlreadyClosed)
-
-      cleanup_ch = connection.create_channel
-      cleanup_ch.queue_delete(s)
-      cleanup_ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/channel_open_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "when opened" 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
-  end
-
-  context "without explicitly provided id" do
-    it "gets an allocated id and is successfully opened" do
-      expect(connection).to be_connected
-      ch = connection.create_channel
-      expect(ch).to be_open
-
-      expect(ch.id).to be > 0
-    end
-  end
-
-  context "with an explicitly provided id = 0" do
-    it "raises ArgumentError" do
-      expect(connection).to be_connected
-      expect {
-        connection.create_channel(0)
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-
-  context "with explicitly provided id" do
-    it "uses that id and is successfully opened" do
-      ch = connection.create_channel(767)
-      expect(connection).to be_connected
-      expect(ch).to be_open
-
-      expect(ch.id).to eq 767
-    end
-  end
-
-
-
-  context "with explicitly provided id that is already taken" do
-    it "reuses the channel that is already opened" do
-      ch = connection.create_channel(767)
-      expect(connection).to be_connected
-      expect(ch).to be_open
-
-      expect(ch.id).to eq 767
-
-      expect(connection.create_channel(767)).to eq ch
-    end
-  end
-end