bunny 1.0.7 → 2.24.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(:user => "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
-      cancelled.should be_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
-      consumer.should 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)
-      xs.should == ["abc"]
-
-      ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/dead_lettering_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-describe "A message" 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
-
-  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(:ack => true)
-    dlq.message_count.should be_zero
-    ch.nack(delivery_info.delivery_tag)
-
-    sleep 0.2
-    q.message_count.should be_zero
-    dlq.message_count.should == 1
-
-    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
-
-    q.message_count.should be_zero
-    dlq.message_count.should == 1
-
-    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(:user => "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
-
-    queue.message_count.should be > 0
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/exchange_declare_spec.rb

@@ -1,204 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Exchange 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
-  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)
-        x.name.should == 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)
-        x.name.should == 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)
-
-        ch.should 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)
-        x.name.should == name
-        x.should be_durable
-        x.should_not 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)
-        x.name.should == name
-        x.should_not be_durable
-        x.should 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
-        ch   = connection.create_channel
-
-        x = ch.fanout("bunny.tests.exchanges.fanout", :auto_delete => true, :durable => false)
-        expect {
-          # force re-declaration
-          ch.exchange_declare("bunny.tests.exchanges.fanout", :direct, :auto_delete => false, :durable => true)
-        }.to raise_error(Bunny::PreconditionFailed)
-
-        ch.should be_closed
-        expect {
-          ch.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)
-        x.name.should == 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)
-        x.name.should == 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)
-        x.name.should == 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)
-        x.name.should == 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)
-        x.name.should == 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)
-        x.name.should == 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)
-        x.name.should == name
-
-        ch.close
-      end
-    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(:user => "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
-
-      ch.exchanges.size.should == 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')
-
-      x.delete.should == 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')
-
-      x.delete.should == 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')
-
-      x.delete.should == 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')
-
-      x.delete.should == 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')
-
-      x.delete.should == nil
-    end
-  end
-
-
-  describe "#exchange_exists?" do
-    context "when a exchange exists" do
-      it "returns true" do
-        ch = connection.create_channel
-
-        connection.exchange_exists?("amq.fanout").should be_true
-        connection.exchange_exists?("amq.direct").should be_true
-        connection.exchange_exists?("amq.topic").should be_true
-        connection.exchange_exists?("amq.match").should be_true
-      end
-    end
-
-    context "when a exchange DOES NOT exist" do
-      it "returns false" do
-        connection.exchange_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}").should be_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(:user => "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
-
-    queue.message_count.should be == 1
-    queue.pop(:ack => true)
-
-    destination.unbind(source)
-    source.publish("")
-    sleep 0.5
-
-    queue.message_count.should be == 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(:user => "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,31 +0,0 @@
-require "spec_helper"
-
-describe "Client-defined heartbeat interval" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :heartbeat_interval => 4)
-    c.start
-    c
-  end
-
-  it "can be enabled explicitly" do
-    sleep 5.0
-
-    connection.close
-  end
-end
-
-
-describe "Server-defined heartbeat interval" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :heartbeat_interval => :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

data/spec/higher_level_api/integration/merry_go_round_spec.rb

@@ -1,85 +0,0 @@
-require "spec_helper"
-
-describe "A message that is proxied by multiple intermediate consumers" do
-  let(:c1) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c2) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c3) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c4) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c5) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  after :each do
-    [c1, c2, c3, c4, c5].each do |c|
-      c.close if c.open?
-    end
-  end
-
-  # message flow is as follows:
-  #
-  # x => q4 => q3 => q2 => q1 => xs (results)
-  it "reaches its final destination" do
-    n   = 10000
-    xs  = []
-
-    ch1 = c1.create_channel
-    q1  = ch1.queue("", :exclusive => true)
-    q1.subscribe do |_, _, payload|
-      xs << payload
-    end
-
-    ch2 = c2.create_channel
-    q2  = ch2.queue("", :exclusive => true)
-    q2.subscribe do |_, _, payload|
-      q1.publish(payload)
-    end
-
-    ch3 = c3.create_channel
-    q3  = ch2.queue("", :exclusive => true)
-    q3.subscribe do |_, _, payload|
-      q2.publish(payload)
-    end
-
-    ch4 = c4.create_channel
-    q4  = ch2.queue("", :exclusive => true)
-    q4.subscribe do |_, _, payload|
-      q3.publish(payload)
-    end
-
-    ch5 = c5.create_channel
-    x   = ch5.default_exchange
-
-    n.times do |i|
-      x.publish("msg #{i}", :routing_key => q4.name)
-    end
-
-    t = n / 1000 * 3.0
-    puts "About to sleep for #{t} seconds..."
-    sleep(t)
-
-    xs.size.should == n
-    xs.last.should == "msg #{n - 1}"
-  end
-end