bunny 2.19.0 → 2.20.0

data/spec/higher_level_api/integration/consumer_cancellation_notification_spec.rb

@@ -1,128 +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 if connection.open?
-  end
-
-  context "with implicit consumer construction" do
-    let(:queue_name) { "basic.consume#{rand}" }
-
-    it "supports consumer cancellation notifications" do
-      cancelled = false
-
-      ch = connection.create_channel
-      t  = Thread.new do
-        ch2 = connection.create_channel
-        q   = ch2.queue(queue_name, auto_delete: true)
-
-        q.subscribe(on_cancellation: Proc.new { cancelled = true })
-      end
-      t.abort_on_exception = true
-
-      sleep 0.5
-      x = ch.default_exchange
-      x.publish("abc", routing_key: queue_name)
-
-      sleep 0.5
-      ch.queue(queue_name, auto_delete: true).delete
-
-      sleep 0.5
-      expect(cancelled).to eq true
-
-      ch.close
-    end
-  end
-
-
-  context "with explicit consumer construction" do
-    class ExampleConsumer < Bunny::Consumer
-      def cancelled?
-        @cancelled
-      end
-
-      def handle_cancellation(_)
-        @cancelled = true
-      end
-    end
-
-    let(:queue_name) { "basic.consume#{rand}" }
-
-    it "supports consumer cancellation notifications" do
-      consumer = nil
-
-      ch = connection.create_channel
-      t  = Thread.new do
-        ch2 = connection.create_channel
-        q   = ch2.queue(queue_name, auto_delete: true)
-
-        consumer = ExampleConsumer.new(ch2, q, "")
-        q.subscribe_with(consumer)
-      end
-      t.abort_on_exception = true
-
-      sleep 0.5
-      x = ch.default_exchange
-      x.publish("abc", routing_key: queue_name)
-
-      sleep 0.5
-      ch.queue(queue_name, auto_delete: true).delete
-
-      sleep 0.5
-      expect(consumer).to be_cancelled
-
-      ch.close
-    end
-  end
-
-
-
-  context "with consumer re-registration" do
-    class ExampleConsumerThatReregisters < Bunny::Consumer
-      def handle_cancellation(_)
-        @queue = @channel.queue("basic.consume.after_cancellation", auto_delete: true)
-        @channel.basic_consume_with(self)
-      end
-    end
-
-    let(:queue_name) { "basic.consume#{rand}" }
-
-    it "works correctly" do
-      consumer = nil
-      xs       = []
-
-      ch = connection.create_channel
-      t  = Thread.new do
-        ch2 = connection.create_channel
-        q   = ch2.queue(queue_name, auto_delete: true)
-
-        consumer = ExampleConsumerThatReregisters.new(ch2, q, "")
-        consumer.on_delivery do |_, _, payload|
-          xs << payload
-        end
-        q.subscribe_with(consumer)
-      end
-      t.abort_on_exception = true
-
-      sleep 0.5
-      x = ch.default_exchange
-      x.publish("abc", routing_key: queue_name)
-
-      sleep 0.5
-      ch.queue(queue_name, auto_delete: true).delete
-
-      x.publish("abc", routing_key: queue_name)
-      sleep 0.5
-      q = ch.queue("basic.consume.after_cancellation", auto_delete: true)
-      expect(xs).to eq ["abc"]
-
-      ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/dead_lettering_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-describe "A 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
-
-  it "is considered to be dead-lettered when it is rejected without requeueing" do
-    ch   = connection.create_channel
-    x    = ch.fanout("amq.fanout")
-    dlx  = ch.fanout("bunny.tests.dlx.exchange")
-    q    = ch.queue("", exclusive: true, arguments: {"x-dead-letter-exchange" => dlx.name}).bind(x)
-    # dead letter queue
-    dlq  = ch.queue("", exclusive: true).bind(dlx)
-
-    x.publish("")
-    sleep 0.2
-
-    delivery_info, _, _ = q.pop(manual_ack: true)
-    expect(dlq.message_count).to be_zero
-    ch.nack(delivery_info.delivery_tag)
-
-    sleep 0.2
-    expect(q.message_count).to be_zero
-
-    delivery, properties, body = dlq.pop
-    ds = properties.headers["x-death"]
-    expect(ds).not_to be_empty
-    expect(ds.first["reason"]).to eq("rejected")
-
-    dlx.delete
-  end
-
-  it "is considered to be dead-lettered when it expires" do
-    ch   = connection.create_channel
-    x    = ch.fanout("amq.fanout")
-    dlx  = ch.fanout("bunny.tests.dlx.exchange")
-    q    = ch.queue("", exclusive: true, arguments: {"x-dead-letter-exchange" => dlx.name, "x-message-ttl" => 100}).bind(x)
-    # dead letter queue
-    dlq  = ch.queue("", exclusive: true).bind(dlx)
-
-    x.publish("")
-    sleep 0.2
-
-    expect(q.message_count).to be_zero
-    expect(dlq.message_count).to eq 1
-
-    dlx.delete
-  end
-
-  it "carries the x-death header" do
-    ch   = connection.create_channel
-    x    = ch.fanout("amq.fanout")
-    dlx  = ch.fanout("bunny.tests.dlx.exchange")
-    q    = ch.queue("", exclusive: true, arguments: {"x-dead-letter-exchange" => dlx.name, "x-message-ttl" => 100}).bind(x)
-    # dead letter queue
-    dlq  = ch.queue("", exclusive: true).bind(dlx)
-
-    x.publish("")
-    sleep 0.2
-
-    delivery, properties, body = dlq.pop
-    ds = properties.headers["x-death"]
-    expect(ds).not_to be_empty
-    expect(ds.first["reason"]).to eq("expired")
-
-    dlx.delete
-  end
-end

data/spec/higher_level_api/integration/exchange_bind_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Bunny::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 if connection.open?
-  end
-
-  it "binds two existing exchanges" do
-    ch          = connection.create_channel
-
-    source      = ch.fanout("bunny.exchanges.source", auto_delete: true)
-    destination = ch.fanout("bunny.exchanges.destination", auto_delete: true)
-
-    queue       = ch.queue("", exclusive: true)
-    queue.bind(destination)
-
-    destination.bind(source)
-    source.publish("")
-    sleep 0.5
-
-    expect(queue.message_count).to be > 0
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/exchange_declare_spec.rb

@@ -1,237 +0,0 @@
-require "spec_helper"
-
-describe Bunny::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
-
-  context "of default type" do
-    it "is declared with an empty name" do
-      ch = connection.create_channel
-
-      x = Bunny::Exchange.default(ch)
-
-      expect(x.name).to eq ''
-    end
-  end
-
-  context "of type fanout" do
-    context "with a non-predefined name" do
-      it "is declared" do
-        ch = connection.create_channel
-
-        name = "bunny.tests.exchanges.fanout#{rand}"
-        x    = ch.fanout(name)
-        expect(x.name).to eq name
-
-        x.delete
-        ch.close
-      end
-    end
-
-    context "with a predefined name" do
-      it "is NOT declared" do
-        ch = connection.create_channel
-
-        name = "amq.fanout"
-        x    = ch.fanout(name)
-        expect(x.name).to eq name
-
-        ch.close
-      end
-    end
-
-    context "with a name prefixed with 'amq.'" do
-      it "raises an exception" do
-        ch   = connection.create_channel
-
-        expect {
-          ch.fanout("amq.test")
-        }.to raise_error(Bunny::AccessRefused)
-
-        expect(ch).to be_closed
-        expect {
-          ch.fanout("amq.test")
-        }.to raise_error(Bunny::ChannelAlreadyClosed)
-      end
-    end
-
-    context "with the durable property" do
-      it "is declared as durable" do
-        ch = connection.create_channel
-
-        name = "bunny.tests.exchanges.durable"
-        x    = ch.fanout(name, durable: true)
-        expect(x.name).to eq name
-        expect(x).to be_durable
-        expect(x).not_to be_auto_delete
-
-        x.delete
-        ch.close
-      end
-    end
-
-
-    context "with the auto-delete property" do
-      it "is declared as auto-delete" do
-        ch = connection.create_channel
-
-        name = "bunny.tests.exchanges.auto-delete"
-        x    = ch.fanout(name, auto_delete: true)
-        expect(x.name).to eq name
-        expect(x).not_to be_durable
-        expect(x).to be_auto_delete
-
-        ch.exchange(name, type: :fanout, auto_delete: true)
-
-        x.delete
-        ch.close
-      end
-    end
-
-
-    context "when declared with a different set of attributes" do
-      it "raises an exception" do
-        ch1   = connection.create_channel
-        ch2   = connection.create_channel
-
-        x = ch1.fanout("bunny.tests.exchanges.fanout", auto_delete: true, durable: false)
-        expect {
-          # force re-declaration
-          ch2.exchange_declare("bunny.tests.exchanges.fanout", :direct, auto_delete: false, durable: true)
-        }.to raise_error(Bunny::PreconditionFailed)
-
-        expect(ch2).to be_closed
-        expect {
-          ch2.fanout("bunny.tests.exchanges.fanout", auto_delete: true, durable: false)
-        }.to raise_error(Bunny::ChannelAlreadyClosed)
-      end
-    end
-  end
-
-  context "of type direct" do
-    context "with a non-predefined name" do
-      it "is declared" do
-        ch = connection.create_channel
-
-        name = "bunny.tests.exchanges.direct"
-        x    = ch.direct(name)
-        expect(x.name).to eq name
-
-        ch.exchange(name, type: :direct)
-
-        x.delete
-        ch.close
-      end
-    end
-
-    context "with a predefined name" do
-      it "is NOT declared" do
-        ch = connection.create_channel
-
-        name = "amq.direct"
-        x    = ch.direct(name)
-        expect(x.name).to eq name
-
-        ch.close
-      end
-    end
-  end
-
-  context "of type topic" do
-    context "with a non-predefined name" do
-      it "is declared" do
-        ch = connection.create_channel
-
-        name = "bunny.tests.exchanges.topic"
-        x    = ch.topic(name)
-        expect(x.name).to eq name
-
-        ch.exchange(name, type: :topic)
-
-        x.delete
-        ch.close
-      end
-    end
-
-    context "with a predefined name" do
-      it "is NOT declared" do
-        ch = connection.create_channel
-
-        name = "amq.topic"
-        x    = ch.topic(name)
-        expect(x.name).to eq name
-
-        ch.close
-      end
-    end
-  end
-
-  context "of type headers" do
-    context "with a non-predefined name" do
-      it "is declared" do
-        ch = connection.create_channel
-
-        name = "bunny.tests.exchanges.headers"
-        x    = ch.headers(name)
-        expect(x.name).to eq name
-
-        x.delete
-        ch.close
-      end
-    end
-
-    context "with a predefined name (amq.match)" do
-      it "is NOT declared" do
-        ch = connection.create_channel
-
-        name = "amq.match"
-        x    = ch.headers(name)
-        expect(x.name).to eq name
-
-        ch.close
-      end
-    end
-
-    context "with a predefined name (amq.headers)" do
-      it "is NOT declared" do
-        ch = connection.create_channel
-
-        name = "amq.headers"
-        x    = ch.headers(name)
-        expect(x.name).to eq name
-
-        ch.close
-      end
-    end
-  end
-
-
-  context "that is internal" do
-    it "can be declared" do
-      ch = connection.create_channel
-      x  = ch.fanout("bunny.tests.exchanges.internal", internal: true)
-      expect(x).to be_internal
-      x.delete
-
-      ch.close
-    end
-  end
-
-  context "not declared as internal" do
-    it "is not internal" do
-      ch = connection.create_channel
-      x  = ch.fanout("bunny.tests.exchanges.non-internal")
-      expect(x).not_to be_internal
-      x.delete
-
-      ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/exchange_delete_spec.rb

@@ -1,105 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Exchange, "#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 if connection.open?
-  end
-
-
-  context "with a name of an existing exchange" do
-    it "deletes that exchange" do
-      ch = connection.create_channel
-      x  = ch.fanout("bunny.tests.exchanges.fanout#{rand}")
-
-      x.delete
-      # no exception as of RabbitMQ 3.2. MK.
-      x.delete
-
-      expect(ch.exchanges.size).to eq 0
-    end
-  end
-
-
-  context "with a name of a non-existent exchange" do
-    it "DOES NOT rais an exception" do
-      ch = connection.create_channel
-
-      # no exception as of RabbitMQ 3.2. MK.
-      ch.exchange_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.exchange_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.exchange_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.exchange_delete("sdkhflsdjflskdjflsd#{rand}")
-    end
-  end
-
-  context "with a name of 'amq.direct'" do
-    it "does not delete the exchange" do
-      ch = connection.create_channel
-      x  = ch.direct('amq.direct')
-
-      expect(x.delete).to eq nil
-    end
-  end
-
-  context "with a name of 'amq.fanout'" do
-    it "does not delete the exchange" do
-      ch = connection.create_channel
-      x  = ch.fanout('amq.fanout')
-
-      expect(x.delete).to eq nil
-    end
-  end
-
-  context "with a name of 'amq.topic'" do
-    it "does not delete the exchange" do
-      ch = connection.create_channel
-      x  = ch.topic('amq.topic')
-
-      expect(x.delete).to eq nil
-    end
-  end
-
-  context "with a name of 'amq.headers'" do
-    it "does not delete the exchange" do
-      ch = connection.create_channel
-      x  = ch.headers('amq.headers')
-
-      expect(x.delete).to eq nil
-    end
-  end
-
-  context "with a name of 'amq.match'" do
-    it "does not delete the exchange" do
-      ch = connection.create_channel
-      x  = ch.headers('amq.match')
-
-      expect(x.delete).to eq nil
-    end
-  end
-
-
-  describe "#exchange_exists?" do
-    context "when a exchange exists" do
-      it "returns true" do
-        ch = connection.create_channel
-
-        expect(connection.exchange_exists?("amq.fanout")).to eq true
-        expect(connection.exchange_exists?("amq.direct")).to eq true
-        expect(connection.exchange_exists?("amq.topic")).to eq true
-        expect(connection.exchange_exists?("amq.match")).to eq true
-      end
-    end
-
-    context "when a exchange DOES NOT exist" do
-      it "returns false" do
-        expect(connection.exchange_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}")).to eq false
-      end
-    end
-  end
-end

data/spec/higher_level_api/integration/exchange_unbind_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-describe Bunny::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 if connection.open?
-  end
-
-  it "unbinds two existing exchanges" do
-    ch          = connection.create_channel
-
-    source      = ch.fanout("bunny.exchanges.source#{rand}")
-    destination = ch.fanout("bunny.exchanges.destination#{rand}")
-
-    queue       = ch.queue("", exclusive: true)
-    queue.bind(destination)
-
-    destination.bind(source)
-    source.publish("")
-    sleep 0.5
-
-    expect(queue.message_count).to eq 1
-    queue.pop(manual_ack: true)
-
-    destination.unbind(source)
-    source.publish("")
-    sleep 0.5
-
-    expect(queue.message_count).to eq 0
-
-    source.delete
-    destination.delete
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/exclusive_queue_spec.rb

@@ -1,28 +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 if connection.open?
-  end
-
-  it "is closed when the connection it was declared on is closed" do
-    ch1 = connection.create_channel
-    ch2 = connection.create_channel
-    q   = ch1.queue("", exclusive: true)
-
-    ch1.queue_declare(q.name, passive: true)
-    ch2.queue_declare(q.name, passive: true)
-
-    ch1.close
-    ch2.queue_declare(q.name, passive: true)
-
-    ch2.queue_delete(q.name)
-    ch2.close
-  end
-end

data/spec/higher_level_api/integration/heartbeat_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe "Client-defined heartbeat interval" do
-  context "with value > 0" do
-    let(:connection) do
-      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", heartbeat_timeout: 4)
-      c.start
-      c
-    end
-
-    it "can be enabled explicitly" do
-      sleep 5.0
-
-      connection.close
-    end
-  end
-
-  # issue 267
-  context "with value = 0" do
-    let(:connection) do
-      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
-        heartbeat_timeout: 0, automatically_recover: false)
-      c.start
-      c
-    end
-
-    it "disables heartbeats" do
-      sleep 1.0
-
-      connection.close
-    end
-  end
-end
-
-
-describe "Server-defined heartbeat interval" do
-  let(:connection) do
-    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", heartbeat_timeout: :server)
-    c.start
-    c
-  end
-
-  it "can be enabled explicitly" do
-    puts "Sleeping for 5 seconds with heartbeat interval of 4"
-    sleep 5.0
-
-    connection.close
-  end
-end