bunny 2.19.0 → 2.20.0

data/spec/higher_level_api/integration/queue_declare_spec.rb

@@ -1,285 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue 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 "when queue name is specified" do
-    let(:name) { "a queue declared at #{Time.now.to_i}" }
-
-    it "declares a new queue with that name" do
-      ch   = connection.create_channel
-
-      q    = ch.queue(name)
-      expect(q.name).to eq name
-
-      q.delete
-      ch.close
-    end
-
-    it "caches that queue" do
-      ch   = connection.create_channel
-
-      q = ch.queue(name)
-      expect(ch.queue(name).object_id).to eq q.object_id
-
-      q.delete
-      ch.close
-    end
-  end
-
-
-  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("")
-      expect(q.name).not_to be_empty
-      expect(q.name).to match /^amq.gen.+/
-      expect(q).to be_server_named
-      q.delete
-
-      ch.close
-    end
-  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)
-      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
-    end
-  end
-
-
-  context "when queue is declared as exclusive" do
-    it "declares it as exclusive" do
-      ch   = connection.create_channel
-
-      q = ch.queue("bunny.tests.queues.exclusive", exclusive: true)
-      expect(q).to be_exclusive
-      expect(q).not_to be_durable
-      q.delete
-
-      ch.close
-    end
-  end
-
-
-  context "when queue is declared as auto-delete" do
-    it "declares it as auto-delete" do
-      ch   = connection.create_channel
-
-      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
-    end
-  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
-
-      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.durable", durable: true)
-      expect {
-        # force re-declaration
-        ch.queue_declare(q.name, durable: false)
-      }.to raise_error(Bunny::PreconditionFailed)
-
-      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
-
-
-  context "when queue is declared with message TTL" do
-    let(:args) do
-      # in ms
-      {"x-message-ttl" => 1000}
-    end
-
-    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)
-      expect(q.arguments).to eq args
-
-      q.publish("xyzzy")
-      sleep 0.1
-
-      expect(q.message_count).to eq 1
-      sleep 1.5
-      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
-  end
-
-
-  describe "#queue_exists?" do
-    context "when a queue exists" do
-      it "returns true" do
-        ch = connection.create_channel
-        q  = ch.queue("", exlusive: true)
-
-        expect(connection.queue_exists?(q.name)).to eq true
-      end
-    end
-
-    context "when a queue DOES NOT exist" do
-      it "returns false" do
-        expect(connection.queue_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}")).to eq false
-      end
-    end
-  end
-
-
-
-  unless ENV["CI"]
-    # requires RabbitMQ 3.1+
-    context "when queue is declared with bounded length" do
-      let(:n) { 10 }
-      let(:args) do
-        # in ms
-        {"x-max-length" => n}
-      end
-
-      # see http://www.rabbitmq.com/maxlength.html for more info
-      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)
-        expect(q.arguments).to eq args
-
-        (n * 10).times do
-          q.publish("xyzzy")
-        end
-
-        expect(q.message_count).to eq n
-        (n * 5).times do
-          q.publish("xyzzy")
-        end
-
-        expect(q.message_count).to eq n
-        q.delete
-
-        ch.close
-      end
-    end
-  end
-end

data/spec/higher_level_api/integration/queue_delete_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "#delete" 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 name of an existing queue" do
-    it "deletes that queue" do
-      ch = connection.create_channel
-      q  = ch.queue("")
-
-      q.delete
-      # no exception as of RabbitMQ 3.2. MK.
-      q.delete
-
-      expect(ch.queues.size).to eq 0
-    end
-  end
-
-
-  context "with a name of an existing queue" do
-    it "DOES NOT raise an exception" do
-      ch = connection.create_channel
-
-      # no exception as of RabbitMQ 3.2. MK.
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-    end
-  end
-end

data/spec/higher_level_api/integration/queue_purge_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue 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
-
-
-  it "can be purged" do
-    ch = connection.create_channel
-
-    q  = ch.queue("", exclusive: true)
-    x  = ch.default_exchange
-
-    x.publish("xyzzy", routing_key: q.name)
-    sleep(0.5)
-
-    expect(q.message_count).to eq 1
-    q.purge
-    expect(q.message_count).to eq 0
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/queue_unbind_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "bound to an exchange" 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
-
-
-  it "can be unbound from an exchange it was bound to" do
-    ch = connection.create_channel
-    x  = ch.fanout("amq.fanout")
-    q  = ch.queue("", exclusive: true).bind(x)
-
-    x.publish("")
-    sleep 0.3
-    expect(q.message_count).to eq 1
-
-    q.unbind(x)
-
-    x.publish("")
-    expect(q.message_count).to eq 1
-  end
-end
-
-
-
-describe Bunny::Queue, "NOT bound to an exchange" 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
-
-
-  it "is idempotent (succeeds)" do
-    ch = connection.create_channel
-    x  = ch.fanout("amq.fanout")
-    q  = ch.queue("", exclusive: true)
-
-    # No exception as of RabbitMQ 3.2. MK.
-    q.unbind(x)
-    q.unbind(x)
-  end
-end

data/spec/higher_level_api/integration/read_only_consumer_spec.rb

@@ -1,60 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "#subscribe" do
-  let(:publisher_connection) do
-    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:consumer_connection) do
-    c = Bunny.new(username: "bunny_reader", password: "reader_password", vhost: "bunny_testbed")
-    c.start
-    c
-  end
-
-  after :each do
-    publisher_connection.close if publisher_connection.open?
-    consumer_connection.close  if consumer_connection.open?
-  end
-
-  context "with automatic acknowledgement mode" do
-    let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-    it "registers the consumer" do
-      delivered_keys = []
-      delivered_data = []
-
-      ch = publisher_connection.create_channel
-      # declare the queue because the read-only user won't be able to issue
-      # queue.declare
-      q  = ch.queue(queue_name, auto_delete: true, durable: false)
-
-      t = Thread.new do
-        # give the main thread a bit of time to declare the queue
-        sleep 0.5
-        ch = consumer_connection.create_channel
-        # this connection is read only, use passive declare to only get
-        # a reference to the queue
-        q  = ch.queue(queue_name, auto_delete: true, durable: false, passive: true)
-        q.subscribe(exclusive: false) do |delivery_info, properties, payload|
-          delivered_keys << delivery_info.routing_key
-          delivered_data << payload
-        end
-      end
-      t.abort_on_exception = true
-      sleep 0.5
-
-      x  = ch.default_exchange
-      x.publish("hello", routing_key: queue_name)
-
-      sleep 0.7
-      expect(delivered_keys).to include(queue_name)
-      expect(delivered_data).to include("hello")
-
-      expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
-
-      ch.close
-    end
-  end
-end # describe

data/spec/higher_level_api/integration/sender_selected_distribution_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-describe "Sender-selected distribution" 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
-
-  it "lets publishers specify additional routing keys using CC and BCC headers" do
-    ch   = connection.create_channel
-    x    = ch.direct("bunny.tests.ssd.exchange")
-    q1   = ch.queue("", exclusive: true).bind(x, routing_key: "one")
-    q2   = ch.queue("", exclusive: true).bind(x, routing_key: "two")
-    q3   = ch.queue("", exclusive: true).bind(x, routing_key: "three")
-    q4   = ch.queue("", exclusive: true).bind(x, routing_key: "four")
-
-    n    = 10
-    n.times do |i|
-      x.publish("Message #{i}", routing_key: "one", headers: {"CC" => ["two", "three"]})
-    end
-
-    sleep 0.5
-
-    expect(q1.message_count).to eq n
-    expect(q2.message_count).to eq n
-    expect(q3.message_count).to eq n
-    expect(q4.message_count).to be_zero
-
-    x.delete
-  end
-end