bunny 1.0.7 → 2.24.0

data/spec/higher_level_api/integration/basic_cancel_spec.rb

@@ -1,76 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Consumer, "#cancel" 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 non-blocking consumer" do
-    let(:queue_name) { "bunny.queues.#{rand}" }
-
-    it "cancels the consumer" do
-      delivered_data = []
-
-      t = Thread.new do
-        ch         = connection.create_channel
-        q          = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        consumer = q.subscribe(:block => false) do |_, _, payload|
-          delivered_data << payload
-        end
-
-        consumer.consumer_tag.should_not be_nil
-        cancel_ok = consumer.cancel
-        cancel_ok.consumer_tag.should == consumer.consumer_tag
-
-        ch.close
-      end
-      t.abort_on_exception = true
-      sleep 0.5
-
-      ch = connection.create_channel
-      ch.default_exchange.publish("", :routing_key => queue_name)
-
-      sleep 0.7
-      delivered_data.should be_empty
-    end
-  end
-
-
-  context "with a blocking consumer" do
-    let(:queue_name) { "bunny.queues.#{rand}" }
-
-    it "cancels the consumer" do
-      delivered_data = []
-      consumer       = nil
-
-      t = Thread.new do
-        ch         = connection.create_channel
-        q          = ch.queue(queue_name, :auto_delete => true, :durable => false)
-
-        consumer   = Bunny::Consumer.new(ch, q)
-        consumer.on_delivery do |_, _, payload|
-          delivered_data << payload
-        end
-
-        q.subscribe_with(consumer, :block => false)
-      end
-      t.abort_on_exception = true
-      sleep 1.0
-
-      consumer.cancel
-      sleep 1.0
-
-      ch = connection.create_channel
-      ch.default_exchange.publish("", :routing_key => queue_name)
-
-      sleep 0.7
-      delivered_data.should be_empty
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_consume_spec.rb

@@ -1,225 +0,0 @@
-require "spec_helper"
-require "set"
-
-describe Bunny::Queue, "#subscribe" 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 automatic acknowledgement mode" do
-    let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-    it "registers the consumer" do
-      delivered_keys = []
-      delivered_data = []
-
-      t = Thread.new do
-        ch = connection.create_channel
-        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        q.subscribe(:exclusive => false, :manual_ack => 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
-
-      ch = connection.create_channel
-      x  = ch.default_exchange
-      x.publish("hello", :routing_key => queue_name)
-
-      sleep 0.7
-      delivered_keys.should include(queue_name)
-      delivered_data.should include("hello")
-
-      ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
-
-      ch.close
-    end
-
-    context "with a single consumer" do
-      let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-      it "provides delivery tag access" do
-        delivery_tags = SortedSet.new
-
-        cch = connection.create_channel
-        q = cch.queue(queue_name, :auto_delete => true, :durable => false)
-        q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
-          delivery_tags << delivery_info.delivery_tag
-        end
-        sleep 0.5
-
-        ch = connection.create_channel
-        x  = ch.default_exchange
-        100.times do
-          x.publish("hello", :routing_key => queue_name)
-        end
-
-        sleep 1.0
-        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
-
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
-
-        ch.close
-      end
-    end
-
-
-    context "with multiple consumers on the same channel" do
-      let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-      it "provides delivery tag access" do
-        delivery_tags = SortedSet.new
-
-        cch = connection.create_channel
-        q   = cch.queue(queue_name, :auto_delete => true, :durable => false)
-
-        7.times do
-          q.subscribe(:exclusive => false, :manual_ack => false) do |delivery_info, properties, payload|
-            delivery_tags << delivery_info.delivery_tag
-          end
-        end
-        sleep 1.0
-
-        ch = connection.create_channel
-        x  = ch.default_exchange
-        100.times do
-          x.publish("hello", :routing_key => queue_name)
-        end
-
-        sleep 1.5
-        delivery_tags.should == SortedSet.new(Range.new(1, 100).to_a)
-
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
-
-        ch.close
-      end
-    end
-  end
-
-  context "with manual acknowledgement mode" do
-    let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-    it "register a consumer with manual acknowledgements mode" do
-      delivered_keys = []
-      delivered_data = []
-
-      t = Thread.new do
-        ch = connection.create_channel
-        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        q.subscribe(:exclusive => false, :manual_ack => true) do |delivery_info, properties, payload|
-          delivered_keys << delivery_info.routing_key
-          delivered_data << payload
-
-          ch.ack(delivery_info.delivery_tag)
-        end
-      end
-      t.abort_on_exception = true
-      sleep 0.5
-
-      ch = connection.create_channel
-      x  = ch.default_exchange
-      x.publish("hello", :routing_key => queue_name)
-
-      sleep 0.7
-      delivered_keys.should include(queue_name)
-      delivered_data.should include("hello")
-
-      ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
-
-      ch.close
-    end
-  end
-
-  ENV.fetch("RUNS", 20).to_i.times do |i|
-    context "with a queue that already has messages (take #{i})" do
-      let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-      it "registers the consumer" do
-        delivered_keys = []
-        delivered_data = []
-
-        ch = connection.create_channel
-        q  = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        x  = ch.default_exchange
-        100.times do
-          x.publish("hello", :routing_key => queue_name)
-        end
-
-        sleep 0.7
-        q.message_count.should be > 50
-
-        t = Thread.new do
-          ch = connection.create_channel
-          q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-          q.subscribe(:exclusive => false, :manual_ack => 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
-
-        delivered_keys.should include(queue_name)
-        delivered_data.should include("hello")
-
-        ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
-
-        ch.close
-      end
-    end
-  end # 20.times
-
-
-  context "after consumer pool has already been shut down" do
-    let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-    it "registers the consumer" do
-      delivered_keys = []
-      delivered_data = []
-
-      t = Thread.new do
-        ch = connection.create_channel
-        q  = ch.queue(queue_name)
-
-        c1  = q.subscribe(:exclusive => false, :manual_ack => false, :block => false) do |delivery_info, properties, payload|
-        end
-        c1.cancel
-
-        c2  = q.subscribe(:exclusive => false, :manual_ack => false, :block => false) do |delivery_info, properties, payload|
-          delivered_keys << delivery_info.routing_key
-          delivered_data << payload
-        end
-        c2.cancel
-
-        q.subscribe(:exclusive => false, :manual_ack => false, :block => true) do |delivery_info, properties, payload|
-          delivered_keys << delivery_info.routing_key
-          delivered_data << payload
-        end
-      end
-      t.abort_on_exception = true
-      sleep 0.5
-
-      ch = connection.create_channel
-      x  = ch.default_exchange
-      x.publish("hello", :routing_key => queue_name)
-
-      sleep 0.7
-      delivered_keys.should include(queue_name)
-      delivered_data.should include("hello")
-
-      ch.queue(queue_name).message_count.should == 0
-
-      ch.queue_delete(queue_name)
-      ch.close
-    end
-  end
-
-end # describe

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(:user => "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, :ack => true)
-      sleep 2
-      ch1.close
-
-      q2.message_count.should == 50
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_get_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "#pop" do
-  let(:connection) do
-    c = Bunny.new(:user => "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
-
-      x.publish("xyzzy", :routing_key => q.name)
-
-      sleep(0.5)
-      delivery_info, properties, content = q.pop
-      content.should == "xyzzy"
-      q.message_count.should == 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
-
-      _, _, content = q.pop
-      content.should be_nil
-      q.message_count.should == 0
-
-      ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_nack_spec.rb

@@ -1,79 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#nack" 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
-
-  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)
-      q.message_count.should == 1
-      delivery_info, _, content = q.pop(:ack => true)
-
-      subject.nack(delivery_info.delivery_tag, false, false)
-      sleep(0.5)
-      q.message_count.should == 0
-
-      subject.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)
-      q.message_count.should == 3
-      _, _, _ = q.pop(:ack => true)
-      _, _, _ = q.pop(:ack => true)
-      delivery_info, _, content = q.pop(:ack => true)
-
-      subject.nack(delivery_info.delivery_tag, true, true)
-      sleep(0.5)
-      q.message_count.should == 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)
-      q.message_count.should == 1
-      _, _, content = q.pop(:ack => true)
-
-      subject.on_error do |ch, channel_close|
-        @channel_close = channel_close
-      end
-      subject.nack(82, false, true)
-
-      sleep 0.5
-
-      @channel_close.reply_text.should == "PRECONDITION_FAILED - unknown delivery tag 82"
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_publish_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-
-if RUBY_VERSION <= "1.9"
-  describe "Publishing a message to the default 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
-
-
-    context "with all default delivery and message properties" do
-      it "routes messages to a queue with the same name as the routing key" do
-        connection.should be_threaded
-        ch = connection.create_channel
-
-        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)
-
-        sleep(1)
-        q.message_count.should == 4
-
-        ch.close
-      end
-    end
-
-
-    context "with all default delivery and message properties" do
-      it "routes the messages and preserves all the metadata" do
-        connection.should be_threaded
-        ch = connection.create_channel
-
-        q  = ch.queue("", :exclusive => true)
-        x  = ch.default_exchange
-
-        x.publish("xyzzy", :routing_key => q.name, :persistent => true)
-
-        sleep(1)
-        q.message_count.should == 1
-
-        envelope, headers, payload = q.pop
-
-        payload.should == "xyzzy"
-
-        headers[:content_type].should == "application/octet-stream"
-        headers[:delivery_mode].should == 2
-        headers[:priority].should == 0
-
-        ch.close
-      end
-    end
-
-
-    context "with all default delivery and message properties on a single-threaded connection" do
-      let(:connection) do
-        c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :threaded => false)
-        c.start
-        c
-      end
-
-      it "routes messages to a queue with the same name as the routing key" do
-        connection.should_not be_threaded
-        ch = connection.create_channel
-
-        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)
-
-        sleep(1)
-        q.message_count.should == 4
-
-        ch.close
-      end
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_qos_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#prefetch" 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 "with a positive integer" do
-    it "sets that prefetch level via basic.qos" do
-      ch = connection.create_channel
-      ch.prefetch(10).should be_instance_of(AMQ::Protocol::Basic::QosOk)
-    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)
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_recover_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#recover" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  subject do
-    connection.create_channel
-  end
-
-  it "is supported" do
-    subject.recover(true).should be_instance_of(AMQ::Protocol::Basic::RecoverOk)
-    subject.recover(true).should be_instance_of(AMQ::Protocol::Basic::RecoverOk)
-  end
-end

data/spec/higher_level_api/integration/basic_reject_spec.rb

@@ -1,74 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#reject" 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 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)
-      q.message_count.should == 1
-      delivery_info, _, _ = q.pop(:ack => true)
-
-      ch.reject(delivery_info.delivery_tag, true)
-      sleep(0.5)
-      q.message_count.should == 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)
-      q.message_count.should == 1
-      delivery_info, _, _ = q.pop(:ack => true)
-
-      ch.reject(delivery_info.delivery_tag, false)
-      sleep(0.5)
-      q.message_count.should == 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)
-      q.message_count.should == 1
-      _, _, content = q.pop(:ack => true)
-
-      ch.on_error do |ch, channel_close|
-        @channel_close = channel_close
-      end
-      ch.reject(82, true)
-
-      sleep 0.5
-
-      @channel_close.reply_text.should == "PRECONDITION_FAILED - unknown delivery tag 82"
-    end
-  end
-end