bunny 2.7.4 → 2.22.0

data/spec/higher_level_api/integration/queue_declare_spec.rb

@@ -1,221 +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 on 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 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 different set of attributes" 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("bunny.tests.queues.auto-delete", auto_delete: false, durable: true)
-      }.to raise_error(Bunny::PreconditionFailed)
-
-      expect(ch).to be_closed
-    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

data/spec/higher_level_api/integration/tls_connection_spec.rb

@@ -1,222 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  CERTIFICATE_DIR=ENV.fetch("BUNNY_CERTIFICATE_DIR", "./spec/tls")
-  puts "Will use certificates from #{CERTIFICATE_DIR}"
-
-  shared_examples_for "successful TLS connection" do
-    it "succeeds" do
-      expect(subject).to be_tls
-      ch = subject.create_channel
-      ch.confirm_select
-
-      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)
-
-      x.wait_for_confirms
-      expect(q.message_count).to eq 4
-
-      i = 0
-      q.subscribe do |delivery_info, _, payload|
-        i += 1
-      end
-      sleep 1.0
-      expect(i).to eq 4
-      expect(q.message_count).to eq 0
-
-      ch.close
-    end
-  end
-
-  def local_hostname
-    ENV.fetch("BUNNY_RABBITMQ_HOSTNAME", "127.0.0.1")
-  end
-
-  context "initialized with :tls => true" do
-    let(:subject) do
-      Bunny.new(:user     => "bunny_gem",
-        :password => "bunny_password",
-        :vhost    => "bunny_testbed",
-        :tls                   => true,
-        :verify_peer           => verify_peer,
-        :tls_cert              => "#{CERTIFICATE_DIR}/client_certificate.pem",
-        :tls_key               => "#{CERTIFICATE_DIR}/client_key.pem",
-        :tls_ca_certificates   => ["#{CERTIFICATE_DIR}/ca_certificate.pem"])
-    end
-
-    context "peer verification is off" do
-      let(:verify_peer) { false }
-
-      it "uses TLS port" do
-        expect(subject.port).to eq AMQ::Protocol::TLS_PORT
-      end
-
-      it "sends the SNI details" do
-        # https://github.com/ruby-amqp/bunny/issues/440
-        subject.start
-        expect(subject.transport.socket.hostname).to_not be_empty
-      end
-
-      after :each do
-        subject.close
-      end
-    end
-
-    context "peer verification is on" do
-      let(:verify_peer) { true }
-
-      it "uses TLS port" do
-        expect(subject.port).to eq AMQ::Protocol::TLS_PORT
-      end
-    end
-  end
-
-  describe "TLS connection to RabbitMQ with client certificates" do
-    let(:subject) do
-      c = Bunny.new(username: "bunny_gem",
-        password: "bunny_password",
-        vhost: "bunny_testbed",
-        tls: true,
-        tls_cert: "#{CERTIFICATE_DIR}/client_certificate.pem",
-        tls_key: "#{CERTIFICATE_DIR}/client_key.pem",
-        tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-        verify_peer: false)
-      c.start
-      c
-    end
-
-    after :each do
-      subject.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-
-  describe "TLS connection to RabbitMQ without client certificates" do
-    let(:subject) do
-      c = Bunny.new(username: "bunny_gem",
-        password: "bunny_password",
-        vhost: "bunny_testbed",
-        tls: true,
-        tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-        verify_peer: false)
-      c.start
-      c
-    end
-
-    after :each do
-      subject.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-
-  describe "TLS connection to RabbitMQ with a connection string" do
-    let(:subject) do
-      c = Bunny.new("amqps://bunny_gem:bunny_password@#{local_hostname}/bunny_testbed",
-        tls_cert: "#{CERTIFICATE_DIR}/client_certificate.pem",
-        tls_key: "#{CERTIFICATE_DIR}/client_key.pem",
-        tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-        verify_peer: false)
-      c.start
-      c
-    end
-
-    after :each do
-      subject.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-
-  describe "TLS connection to RabbitMQ with a connection string and w/o client certificate and key" do
-    let(:subject) do
-      c = Bunny.new("amqps://bunny_gem:bunny_password@#{local_hostname}/bunny_testbed",
-        tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-        verify_peer: verify_peer)
-      c.start
-      c
-    end
-
-    after :each do
-      subject.close
-    end
-
-    context "peer verification is off" do
-      let(:verify_peer) { false }
-
-      include_examples "successful TLS connection"
-
-      it "sends the SNI details" do
-        # https://github.com/ruby-amqp/bunny/issues/440
-        expect(subject.transport.socket.hostname).to_not be_empty
-      end
-    end
-
-    context "peer verification is on" do
-      let(:verify_peer) { true }
-
-      include_examples "successful TLS connection"
-
-      it "sends the SNI details" do
-        # https://github.com/ruby-amqp/bunny/issues/440
-        expect(subject.transport.socket.hostname).to_not be_empty
-      end
-    end
-  end
-
-
-  describe "TLS connection to RabbitMQ with client certificates provided inline" do
-    let(:subject) do
-      c = Bunny.new(username: "bunny_gem",
-        password: "bunny_password",
-        vhost: "bunny_testbed",
-        tls: true,
-        tls_cert: File.read("#{CERTIFICATE_DIR}/client_certificate.pem"),
-        tls_key: File.read("#{CERTIFICATE_DIR}/client_key.pem"),
-        tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-        verify_peer: false)
-      c.start
-      c
-    end
-
-    after :each do
-      subject.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-  describe "TLS connection to RabbitMQ with tls_version TLSv1.1 specified" do
-    let(:subject) do
-      c = Bunny.new(username: "bunny_gem",
-        password: "bunny_password",
-        vhost: "bunny_testbed",
-        tls: true,
-        tls_protocol: :TLSv1_1,
-        tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-        verify_peer: false)
-      c.start
-      c
-    end
-
-    after :each do
-      subject.close
-    end
-
-    include_examples "successful TLS connection"
-
-    it "connects using TLSv1.1" do
-      expect(subject.transport.socket.ssl_version).to eq "TLSv1.1"
-    end
-  end
-end

data/spec/higher_level_api/integration/tx_commit_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#tx_commit" 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 "is supported" do
-    ch = connection.create_channel
-    ch.tx_select
-    ch.tx_commit
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/tx_rollback_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#tx_rollback" 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 "is supported" do
-    ch = connection.create_channel
-    ch.tx_select
-    ch.tx_rollback
-
-    ch.close
-  end
-end