bunny 2.15.0 → 2.22.0

data/spec/higher_level_api/integration/basic_ack_spec.rb

@@ -1,230 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#ack" 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 valid (known) delivery tag" do
-    it "acknowledges a message" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 1
-      delivery_details, properties, content = q.pop(manual_ack: true)
-
-      ch.ack(delivery_details.delivery_tag, true)
-      ch.close
-
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      expect(q.message_count).to eq 0
-      ch.close
-    end
-  end
-
-  context "with a valid (known) delivery tag (multiple = true)" do
-    it "acknowledges a message" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 2
-      delivery_details_1, _properties, _content = q.pop(manual_ack: true)
-      delivery_details_2, _properties, _content = q.pop(manual_ack: true)
-
-      ch.ack(delivery_details_2.delivery_tag, true)
-      ch.close
-
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      expect(q.message_count).to eq 0
-      ch.close
-    end
-  end
-
-  context "with a valid (known) delivery tag (multiple = false)" do
-    it "acknowledges a message" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 2
-      delivery_details_1, _properties, _content = q.pop(manual_ack: true)
-      delivery_details_2, _properties, _content = q.pop(manual_ack: true)
-
-      ch.ack(delivery_details_2.delivery_tag, false)
-      ch.close
-
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      expect(q.message_count).to eq 1
-      ch.close
-    end
-  end
-
-  context "with a valid (known) delivery tag and automatic ack mode" do
-    it "results in a channel exception" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      q.subscribe(manual_ack: false) do |delivery_info, properties, payload|
-        ch.ack(delivery_info.delivery_tag, false)
-      end
-
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect do
-        q.message_count
-      end.to raise_error(Bunny::ChannelAlreadyClosed)
-    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.ack.unknown-delivery-tag", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 1
-      _, _, content = q.pop(manual_ack: true)
-
-      ch.on_error do |ch, channel_close|
-        @channel_close = channel_close
-      end
-      ch.ack(82, true)
-      sleep 0.25
-
-      expect(@channel_close.reply_code).to eq AMQ::Protocol::PreconditionFailed::VALUE
-    end
-  end
-
-  context "with a valid (known) delivery tag" do
-    it "gets a depricated message warning for using :ack" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 1
-
-      orig_stderr = $stderr
-      $stderr = StringIO.new
-
-      delivery_details, properties, content = q.pop(ack: true)
-
-      $stderr.rewind
-      expect($stderr.string.chomp).to eq("[DEPRECATION] `:ack` is deprecated.  Please use `:manual_ack` instead.\n[DEPRECATION] `:ack` is deprecated.  Please use `:manual_ack` instead.")
-
-      $stderr = orig_stderr
-
-      ch.ack(delivery_details.delivery_tag, true)
-      ch.close
-
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      expect(q.message_count).to eq 0
-      ch.close
-    end
-  end
-end
-
-describe Bunny::Channel, "#basic_ack" 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 valid (known) delivery tag (multiple = true)" do
-    it "acknowledges a message" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 2
-      delivery_details_1, _properties, _content = q.pop(manual_ack: true)
-      delivery_details_2, _properties, _content = q.pop(manual_ack: true)
-
-      ch.basic_ack(delivery_details_2.delivery_tag.to_i, true)
-      ch.close
-
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      expect(q.message_count).to eq 0
-      ch.close
-    end
-  end
-
-  context "with a valid (known) delivery tag (multiple = false)" do
-    it "acknowledges a message" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 2
-      delivery_details_1, _properties, _content = q.pop(manual_ack: true)
-      delivery_details_2, _properties, _content = q.pop(manual_ack: true)
-
-      ch.basic_ack(delivery_details_2.delivery_tag.to_i, false)
-      ch.close
-
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      expect(q.message_count).to eq 1
-      ch.close
-    end
-  end
-
-  context "with a valid (known) delivery tag (multiple = default)" do
-    it "acknowledges a message" do
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      x  = ch.default_exchange
-
-      x.publish("bunneth", routing_key: q.name)
-      x.publish("bunneth", routing_key: q.name)
-      sleep 0.5
-      expect(q.message_count).to eq 2
-      delivery_details_1, _properties, _content = q.pop(manual_ack: true)
-      delivery_details_2, _properties, _content = q.pop(manual_ack: true)
-
-      ch.basic_ack(delivery_details_2.delivery_tag.to_i)
-      ch.close
-
-      ch = connection.create_channel
-      q  = ch.queue("bunny.basic.ack.manual-acks", exclusive: true)
-      expect(q.message_count).to eq 1
-      ch.close
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_cancel_spec.rb

@@ -1,142 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Consumer, "#cancel" 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 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 do |_, _, payload|
-          delivered_data << payload
-        end
-
-        expect(consumer.consumer_tag).not_to be_nil
-        cancel_ok = consumer.cancel
-        expect(cancel_ok.consumer_tag).to eq 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
-      expect(delivered_data).to 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)
-      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
-      expect(delivered_data).to be_empty
-    end
-  end
-
-  context "with a worker pool shutdown timeout configured" do
-    let(:queue_name) { "bunny.queues.#{rand}" }
-
-    it "processes the message if processing completes within the timeout" do
-      delivered_data = []
-      consumer       = nil
-
-      t = Thread.new do
-        ch         = connection.create_channel(nil, 1, false, 5)
-        q          = ch.queue(queue_name, auto_delete: true, durable: false)
-
-        consumer   = Bunny::Consumer.new(ch, q)
-        consumer.on_delivery do |_, _, payload|
-          sleep 2
-          delivered_data << payload
-        end
-
-        q.subscribe_with(consumer)
-      end
-      t.abort_on_exception = true
-      sleep 1.0
-
-      ch = connection.create_channel
-      ch.confirm_select
-      ch.default_exchange.publish("", routing_key: queue_name)
-      ch.wait_for_confirms
-      sleep 0.5
-
-      consumer.cancel
-      sleep 1.0
-
-      expect(delivered_data).to_not be_empty
-    end
-
-    it "kills the consumer if processing takes longer than the timeout" do
-      delivered_data = []
-      consumer       = nil
-
-      t = Thread.new do
-        ch         = connection.create_channel(nil, 1, false, 1)
-        q          = ch.queue(queue_name, auto_delete: true, durable: false)
-
-        consumer   = Bunny::Consumer.new(ch, q)
-        consumer.on_delivery do |_, _, payload|
-          sleep 3
-          delivered_data << payload
-        end
-
-        q.subscribe_with(consumer)
-      end
-      t.abort_on_exception = true
-      sleep 1.0
-
-      ch = connection.create_channel
-      ch.confirm_select
-      ch.default_exchange.publish("", routing_key: queue_name)
-      ch.wait_for_confirms
-      sleep 0.5
-
-      consumer.cancel
-      sleep 1.0
-
-      expect(delivered_data).to be_empty
-    end
-  end
-end

data/spec/higher_level_api/integration/basic_consume_spec.rb

@@ -1,349 +0,0 @@
-require "spec_helper"
-require "set"
-
-describe Bunny::Queue, "#subscribe" 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 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
-      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
-
-    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
-        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
-
-        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 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
-        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
-
-        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 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
-      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
-
-  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
-        expect(q.message_count).to 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
-
-        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 # 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) do |delivery_info, properties, payload|
-        end
-        c1.cancel
-
-        c2  = q.subscribe(exclusive: false, manual_ack: 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) 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
-      expect(delivered_keys).to include(queue_name)
-      expect(delivered_data).to include("hello")
-
-      expect(ch.queue(queue_name).message_count).to eq 0
-
-      ch.queue_delete(queue_name)
-      ch.close
-    end
-  end
-
-
-  context "with uncaught exceptions in delivery handler" do
-    context "and defined exception handler" do
-      let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-      it "uses exception handler" do
-        caught = nil
-        t = Thread.new do
-          ch = connection.create_channel
-          q  = ch.queue(queue_name, auto_delete: true, durable: false)
-
-          ch.on_uncaught_exception do |e, consumer|
-            caught = e
-          end
-
-          q.subscribe(exclusive: false, manual_ack: false) do |delivery_info, properties, payload|
-            raise RuntimeError.new(queue_name)
-          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.5
-
-        expect(caught.message).to eq queue_name
-
-        ch.close
-      end
-    end
-
-
-    context "and default exception handler" do
-      let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-      it "uses exception handler" do
-        caughts = []
-        t = Thread.new do
-          allow(connection.logger).to receive(:error) { |x| caughts << x }
-
-          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|
-            raise RuntimeError.new(queue_name)
-          end
-        end
-        t.abort_on_exception = true
-        sleep 0.5
-
-        ch     = connection.create_channel
-        x  = ch.default_exchange
-        5.times { x.publish("hello", routing_key: queue_name) }
-        sleep 1.5
-
-        expect(caughts.size).to eq(5)
-
-        ch.close
-      end
-    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
-        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
-
-        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 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
-        expect(delivery_tags).to eq SortedSet.new(Range.new(1, 100).to_a)
-
-        expect(ch.queue(queue_name, auto_delete: true, durable: false).message_count).to eq 0
-
-        ch.close
-      end
-    end
-  end
-end # describe