bunny 2.7.4 → 2.22.0

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(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c2) do
-    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c3) do
-    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c4) do
-    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:c5) do
-    c = Bunny.new(username: "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)
-
-    expect(xs.size).to eq n
-    expect(xs.last).to eq "msg #{n - 1}"
-  end
-end

data/spec/higher_level_api/integration/message_properties_access_spec.rb

@@ -1,95 +0,0 @@
-require "spec_helper"
-
-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
-
-  let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-  it "provides delivery handler access to message properties" do
-    @now     = Time.now
-    metadata = {}
-    envelope = {}
-
-    t = Thread.new do
-      ch = connection.create_channel
-      q = ch.queue(queue_name, auto_delete: true, durable: false)
-      q.subscribe(exclusive: true, manual_ack: false) do |delivery_info, properties, payload|
-        metadata = properties
-        envelope = delivery_info
-      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,
-              app_id: "bunny.example",
-              priority: 8,
-              type: "kinda.checkin",
-              # headers table keys can be anything
-              headers: {
-                coordinates: {
-                  latitude: 59.35,
-                  longitude: 18.066667
-                },
-                time: @now,
-                participants: 11,
-                venue: "Stockholm",
-                true_field: true,
-                false_field: false,
-                nil_field: nil,
-                ary_field: ["one", 2.0, 3, [{"abc" => 123}]]
-              },
-              timestamp: @now.to_i,
-              reply_to: "a.sender",
-              correlation_id: "r-1",
-              message_id: "m-1")
-
-    sleep 0.7
-
-    expect(metadata.content_type).to eq "application/octet-stream"
-    expect(metadata.priority).to     eq 8
-
-    time = metadata.headers["time"]
-    expect(time.year).to eq @now.year
-    expect(time.month).to eq @now.month
-    expect(time.day).to eq @now.day
-    expect(time.hour).to eq @now.hour
-    expect(time.min).to eq @now.min
-    expect(time.sec).to eq @now.sec
-
-    expect(metadata.headers["coordinates"]["latitude"]).to eq 59.35
-    expect(metadata.headers["participants"]).to eq 11
-    expect(metadata.headers["venue"]).to eq "Stockholm"
-    expect(metadata.headers["true_field"]).to eq true
-    expect(metadata.headers["false_field"]).to eq false
-    expect(metadata.headers["nil_field"]).to be_nil
-    expect(metadata.headers["ary_field"]).to eq ["one", 2.0, 3, [{ "abc" => 123}]]
-
-    expect(metadata.timestamp).to eq Time.at(@now.to_i)
-    expect(metadata.type).to eq "kinda.checkin"
-    expect(metadata.reply_to).to eq "a.sender"
-    expect(metadata.correlation_id).to eq "r-1"
-    expect(metadata.message_id).to eq "m-1"
-    expect(metadata.app_id).to eq "bunny.example"
-
-    expect(envelope.consumer_tag).not_to be_nil
-    expect(envelope.consumer_tag).not_to be_empty
-    expect(envelope).not_to be_redelivered
-    expect(envelope.delivery_tag).to eq 1
-    expect(envelope.routing_key).to  eq queue_name
-    expect(envelope.exchange).to eq ""
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/predeclared_exchanges_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe "amq.* exchanges" 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 "are predeclared" do
-    ch = connection.create_channel
-
-    ["amq.fanout", "amq.direct", "amq.topic", "amq.match", "amq.headers"].each do |e|
-      x = ch.exchange(e)
-      expect(x).to be_predeclared
-    end
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/publisher_confirms_spec.rb

@@ -1,191 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel do
-  after :each do
-    connection.close if connection.open?
-  end
-
-  let(:n) { 200 }
-
-  shared_examples "publish confirms" do
-    context "when publishing with confirms enabled" do
-      it "increments delivery index" do
-        ch = connection.create_channel
-        expect(ch).not_to be_using_publisher_confirmations
-
-        ch.confirm_select
-        expect(ch).to be_using_publisher_confirmations
-
-        q  = ch.queue("", exclusive: true)
-        x  = ch.default_exchange
-
-        n.times do
-          x.publish("xyzzy", routing_key: q.name)
-        end
-
-        expect(ch.next_publish_seq_no).to eq n + 1
-        expect(ch.wait_for_confirms).to eq true
-        sleep 0.25
-
-        expect(q.message_count).to eq n
-        q.purge
-
-        ch.close
-      end
-
-      describe "#wait_for_confirms" do
-        it "should not hang when all the publishes are confirmed" do
-          ch = connection.create_channel
-          expect(ch).not_to be_using_publisher_confirmations
-
-          ch.confirm_select
-          expect(ch).to be_using_publisher_confirmations
-
-          q  = ch.queue("", exclusive: true)
-          x  = ch.default_exchange
-
-          n.times do
-            x.publish("xyzzy", routing_key: q.name)
-          end
-
-          expect(ch.next_publish_seq_no).to eq n + 1
-          expect(ch.wait_for_confirms).to eq true
-
-          sleep 0.25
-
-          expect {
-            Bunny::Timeout.timeout(2) do
-              expect(ch.wait_for_confirms).to eq true
-            end
-          }.not_to raise_error
-
-        end
-
-        it "raises an error when called on a closed channel" do
-          ch = connection.create_channel
-
-          ch.confirm_select
-
-          ch.close
-
-          expect {
-            ch.wait_for_confirms
-          }.to raise_error(Bunny::ChannelAlreadyClosed)
-        end
-      end
-
-      context "when some of the messages get nacked" do
-        it "puts the nacks in the nacked_set" do
-          ch = connection.create_channel
-          expect(ch).not_to be_using_publisher_confirmations
-
-          ch.confirm_select
-          expect(ch).to be_using_publisher_confirmations
-
-          q  = ch.queue("", exclusive: true)
-          x  = ch.default_exchange
-
-          n.times do
-            x.publish("xyzzy", routing_key: q.name)
-          end
-
-          #be sneaky to simulate a nack
-          nacked_tag = nil
-          ch.instance_variable_get(:@unconfirmed_set_mutex).synchronize do
-            expect(ch.unconfirmed_set).to_not be_empty
-            nacked_tag = ch.unconfirmed_set.reduce(ch.next_publish_seq_no - 1) { |lowest, i| i < lowest ? i : lowest }
-            ch.handle_ack_or_nack(nacked_tag, false, true)
-          end
-
-          expect(ch.nacked_set).not_to be_empty
-          expect(ch.nacked_set).to include(nacked_tag)
-
-          expect(ch.next_publish_seq_no).to eq n + 1
-          expect(ch.wait_for_confirms).to eq false
-
-          expect(ch.nacked_set).not_to be_empty
-          expect(ch.nacked_set).to include(nacked_tag)
-
-          sleep 0.25
-          expect(q.message_count).to eq n
-          q.purge
-
-          ch.close
-        end
-      end
-    end
-  end
-
-  context "with a multi-threaded connection" do
-    let(:connection) do
-      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", continuation_timeout: 10000)
-      c.start
-      c
-    end
-
-    include_examples "publish confirms"
-
-    it "returns only when all confirmations for publishes are received" do
-      ch = connection.create_channel
-
-      operations_log = []
-      operations_log_mutex = Mutex.new
-      acks_received = Queue.new
-
-      log_acks = proc do |tag, _, is_nack|
-        operations_log_mutex.synchronize do
-          operation = "#{'n' if is_nack}ack_#{tag}"
-          operations_log << operation unless operations_log.include?(operation)
-        end
-        acks_received << true
-      end
-
-      ch.confirm_select(log_acks)
-
-      x = ch.default_exchange
-      q = ch.temporary_queue
-
-      x.publish('msg', routing_key: q.name)
-
-      # wait for the confirmation to arrive
-      acks_received.pop
-
-      # artificially simulate a slower ack. the test should work properly even
-      # without this patch, but it's here just to be sure we catch it.
-      def (x.channel).handle_ack_or_nack(delivery_tag_before_offset, multiple, nack)
-        sleep 0.1
-        super
-      end
-
-      x.publish('msg', routing_key: q.name)
-      x.publish('msg', routing_key: q.name)
-
-      if x.wait_for_confirms
-        operations_log_mutex.synchronize do
-          operations_log << 'all_confirmed'
-        end
-      end
-
-      # wait for all the confirmations to arrive
-      acks_received.pop
-      acks_received.pop
-
-      expect(operations_log).to eq([
-        'ack_1',
-        'ack_2',
-        'ack_3',
-        'all_confirmed',
-      ])
-    end
-  end
-
-  context "with a single-threaded connection" do
-    let(:connection) do
-      c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed", continuation_timeout: 10000, threaded: false)
-      c.start
-      c
-    end
-
-    include_examples "publish confirms"
-  end
-end

data/spec/higher_level_api/integration/publishing_edge_cases_spec.rb

@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  describe "Message framing implementation" do
-    let(:connection) do
-      c = Bunny.new(username: "bunny_gem",
-        password: "bunny_password",
-        vhost: "bunny_testbed",
-        port: ENV.fetch("RABBITMQ_PORT", 5672))
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close if connection.open?
-    end
-
-
-    context "with payload exceeding 128 Kb (max frame size)" do
-      it "successfully frames the message" do
-        ch = connection.create_channel
-
-        q  = ch.queue("", exclusive: true)
-        x  = ch.default_exchange
-
-        as = ("a" * (1024 * 1024 * 4 + 28237777))
-        x.publish(as, routing_key: q.name, persistent: true)
-
-        sleep(1)
-        expect(q.message_count).to eq 1
-
-        _, _, payload      = q.pop
-        expect(payload.bytesize).to eq as.bytesize
-
-        ch.close
-      end
-    end
-
-
-    context "with payload of several MBs of non-ASCII characters" do
-      it "successfully frames the message" do
-        ch = connection.create_channel
-
-        q  = ch.queue("", exclusive: true)
-        x  = ch.default_exchange
-
-        as = "кириллца, йо" * (1024 * 1024)
-        x.publish(as, routing_key: q.name, persistent: true)
-
-        sleep(1)
-        expect(q.message_count).to eq 1
-
-        _, _, payload      = q.pop
-        expect(payload.bytesize).to eq as.bytesize
-
-        ch.close
-      end
-    end
-
-
-
-    context "with empty message body" do
-      it "successfully publishes the message" do
-        ch = connection.create_channel
-
-        q  = ch.queue("", exclusive: true)
-        x  = ch.default_exchange
-
-        x.publish("", routing_key: q.name, persistent: false, mandatory: true)
-
-        sleep(0.5)
-        expect(q.message_count).to eq 1
-
-        envelope, headers, payload = q.pop
-
-        expect(payload).to eq ""
-
-        expect(headers[:content_type]).to eq "application/octet-stream"
-        expect(headers[:delivery_mode]).to eq 1
-        expect(headers[:priority]).to eq 0
-
-        ch.close
-      end
-    end
-  end
-end

data/spec/higher_level_api/integration/queue_bind_spec.rb

@@ -1,109 +0,0 @@
-require "spec_helper"
-
-describe "A client-named", Bunny::Queue do
-  let(:connection) do
-    c = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed")
-    c.start
-    c
-  end
-
-  it "can be bound to a pre-declared exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
-    expect(q).not_to be_server_named
-
-    expect(q.bind("amq.fanout")).to eq q
-
-    ch.close
-  end
-
-  it "can be unbound from a pre-declared exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
-    expect(q).not_to be_server_named
-
-    q.bind("amq.fanout")
-    expect(q.unbind("amq.fanout")).to eq q
-
-    ch.close
-  end
-
-  it "can be bound to a custom exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
-
-    x  = ch.fanout("bunny.tests.exchanges.fanout#{rand}")
-    expect(q.bind(x)).to eq q
-
-    x.delete
-    ch.close
-  end
-
-  it "can be unbound from a custom exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("bunny.tests.queues.client-named#{rand}", exclusive: true)
-    expect(q).not_to be_server_named
-
-    x  = ch.fanout("bunny.tests.fanout", auto_delete: true, durable: false)
-
-    q.bind(x)
-    expect(q.unbind(x)).to eq q
-
-    ch.close
-  end
-end
-
-
-
-describe "A server-named", Bunny::Queue do
-  let(:connection) do
-    c = Bunny.new
-    c.start
-    c
-  end
-
-  it "can be bound to a pre-declared exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("", exclusive: true)
-    expect(q).to be_server_named
-
-    expect(q.bind("amq.fanout")).to eq q
-
-    ch.close
-  end
-
-  it "can be unbound from a pre-declared exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("", exclusive: true)
-    expect(q).to be_server_named
-
-    q.bind("amq.fanout")
-    expect(q.unbind("amq.fanout")).to eq q
-
-    ch.close
-  end
-
-  it "can be bound to a custom exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("", exclusive: true)
-
-    x  = ch.fanout("bunny.tests.exchanges.fanout#{rand}")
-    expect(q.bind(x)).to eq q
-
-    x.delete
-    ch.close
-  end
-
-  it "can be bound from a custom exchange" do
-    ch   = connection.create_channel
-    q    = ch.queue("", exclusive: true)
-
-    name = "bunny.tests.exchanges.fanout#{rand}"
-    x    = ch.fanout(name)
-    q.bind(x)
-    expect(q.unbind(name)).to eq q
-
-    x.delete
-    ch.close
-  end
-end