bunny 2.7.4 → 2.22.0

data/spec/issues/issue97_spec.rb

@@ -1,175 +0,0 @@
-require "spec_helper"
-
-describe "Message framing implementation" do
-    before :all do
-    @connection = Bunny.new(username: "bunny_gem",
-      password:  "bunny_password",
-      vhost: "bunny_testbed",
-      port: ENV.fetch("RABBITMQ_PORT", 5672))
-    @connection.start
-  end
-
-  after :all do
-    @connection.close if @connection.open?
-  end
-
-
-  unless ENV["CI"]
-    context "with payload ~ 248K in size including non-ASCII characters" do
-      it "successfully frames the message" do
-        ch = @connection.create_channel
-
-        q  = ch.queue("", exclusive: true)
-        x  = ch.default_exchange
-
-        body = IO.read("spec/issues/issue97_attachment.json")
-        x.publish(body, routing_key: q.name, persistent: true)
-
-        sleep(1)
-        expect(q.message_count).to eq 1
-
-        q.purge
-        ch.close
-      end
-    end
-  end
-
-
-  context "with payload of several MBs in 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 + 2823777))
-      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: true)
-
-      sleep(1)
-      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 2
-      expect(headers[:priority]).to eq 0
-
-      ch.close
-    end
-  end
-
-
-  context "with payload being 2 bytes less than 128K bytes in size" do
-    it "successfully frames the message" do
-      ch = @connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.default_exchange
-
-      as = "a" * (1024 * 128 - 2)
-      x.publish(as, routing_key:  q.name, persistent: true)
-
-      sleep(1)
-      expect(q.message_count).to eq 1
-
-      q.purge
-      ch.close
-    end
-  end
-
-  context "with payload being 1 byte less than 128K bytes in size" do
-    it "successfully frames the message" do
-      ch = @connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.default_exchange
-
-      as = "a" * (1024 * 128 - 1)
-      x.publish(as, routing_key:  q.name, persistent: true)
-
-      sleep(1)
-      expect(q.message_count).to eq 1
-
-      q.purge
-      ch.close
-    end
-  end
-
-  context "with payload being exactly 128K bytes in size" do
-    it "successfully frames the message" do
-      ch = @connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.default_exchange
-
-      as = "a" * (1024 * 128)
-      x.publish(as, routing_key:  q.name, persistent: true)
-
-      sleep(1)
-      expect(q.message_count).to eq 1
-
-      q.purge
-      ch.close
-    end
-  end
-
-
-  context "with payload being 1 byte greater than 128K bytes in size" do
-    it "successfully frames the message" do
-      ch = @connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.default_exchange
-
-      as = "a" * (1024 * 128 + 1)
-      x.publish(as, routing_key:  q.name, persistent: true)
-
-      sleep(1)
-      expect(q.message_count).to eq 1
-
-      q.purge
-      ch.close
-    end
-  end
-
-  context "with payload being 2 bytes greater than 128K bytes in size" do
-    it "successfully frames the message" do
-      ch = @connection.create_channel
-
-      q  = ch.queue("", exclusive: true)
-      x  = ch.default_exchange
-
-      as = "a" * (1024 * 128 + 2)
-      x.publish(as, routing_key:  q.name, persistent: true)
-
-      sleep(1)
-      expect(q.message_count).to eq 1
-
-      q.purge
-      ch.close
-    end
-  end
-end

data/spec/lower_level_api/integration/basic_cancel_spec.rb

@@ -1,83 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#basic_cancel" do
-  before(:all) do
-    @connection = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    @connection.start
-  end
-
-  after :all do
-    @connection.close if @connection.open?
-  end
-
-  let(:queue_name) { "bunny.queues.#{rand}" }
-
-  it "returns basic.cancel-ok" do
-    ch = @connection.create_channel
-    q  = ch.queue("", :exclusive => true)
-
-    consume_ok = ch.basic_consume(q, "")
-    cancel_ok  = ch.basic_cancel(consume_ok.consumer_tag)
-
-    expect(cancel_ok).to be_instance_of AMQ::Protocol::Basic::CancelOk
-    expect(cancel_ok.consumer_tag).to eq consume_ok.consumer_tag
-
-    ch.close
-  end
-
-  context "when the given consumer tag is valid" do
-    let(:queue_name) { "bunny.basic.cancel.queue#{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)
-        consume_ok = ch.basic_consume(q, "", true, false) do |_, _, payload|
-          delivered_data << payload
-        end
-
-        expect(consume_ok.consumer_tag).not_to be_nil
-        cancel_ok = ch.basic_cancel(consume_ok.consumer_tag)
-        expect(cancel_ok.consumer_tag).to eq consume_ok.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 "when the given consumer tag is invalid (was never registered)" do
-    it "DOES NOT cause a channel error" do
-      ch = @connection.create_channel
-
-      # RabbitMQ 3.1 does not raise an exception w/ unknown consumer tag. MK.
-      ch.basic_cancel("878798s7df89#{rand}#{Time.now.to_i}")
-
-      ch.close
-    end
-  end
-
-  context "when the given consumer tag belongs to a different channel" do
-    it "DOES NOT cause a channel error" do
-      ch1 = @connection.create_channel
-      ch2 = @connection.create_channel
-
-      q    = ch1.queue("", :exclusive => true)
-      cons = q.subscribe do |_, _, _|
-      end
-      ch2.basic_cancel(cons.consumer_tag)
-
-      ch1.close
-      ch2.close
-    end
-  end
-end

data/spec/lower_level_api/integration/basic_consume_spec.rb

@@ -1,99 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#basic_consume" do
-  before(:all) do
-    @connection = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    @connection.start
-  end
-
-  after :all do
-    @connection.close if @connection.open?
-  end
-
-  it "returns basic.consume-ok when it is received" do
-    ch = @connection.create_channel
-    q  = ch.queue("", :exclusive => true)
-
-    consume_ok = ch.basic_consume(q)
-    expect(consume_ok).to be_instance_of AMQ::Protocol::Basic::ConsumeOk
-    expect(consume_ok.consumer_tag).not_to be_nil
-
-    ch.close
-  end
-
-  it "carries server-generated consumer tag with basic.consume-ok" do
-    ch = @connection.create_channel
-    q  = ch.queue("", :exclusive => true)
-
-    consume_ok = ch.basic_consume(q, "")
-    expect(consume_ok.consumer_tag).to match /amq\.ctag.*/
-
-    ch.close
-  end
-
-  context "with automatic acknowledgement mode" do
-    let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-    it "causes messages to be automatically removed from the queue after delivery" do
-      delivered_keys = []
-      delivered_data = []
-
-      t = Thread.new do
-        ch = @connection.create_channel
-        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        ch.basic_consume(q, "", true, 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
-  end
-
-  context "with manual acknowledgement mode" do
-    let(:queue_name) { "bunny.basic_consume#{rand}" }
-
-    it "waits for an explicit acknowledgement" do
-      delivered_keys = []
-      delivered_data = []
-
-      t = Thread.new do
-        ch = @connection.create_channel
-        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
-        ch.basic_consume(q, "", false, false) do |delivery_info, properties, payload|
-          delivered_keys << delivery_info.routing_key
-          delivered_data << payload
-
-          ch.close
-        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
-end

data/spec/spec_helper.rb

@@ -1,51 +0,0 @@
-# -*- encoding: utf-8; mode: ruby -*-
-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-
-require 'bundler'
-Bundler.setup(:default, :test)
-
-
-require "effin_utf8"
-require "bunny"
-require "rabbitmq/http/client"
-
-
-require "amq/protocol/version"
-puts "Using Ruby #{RUBY_VERSION}, amq-protocol #{AMQ::Protocol::VERSION}"
-
-module RabbitMQ
-  module Control
-
-    RABBITMQ_NODENAME = ENV['RABBITMQ_NODENAME'] || 'rabbit'
-
-    def rabbitmq_pid
-      $1.to_i if `rabbitmqctl -n #{RABBITMQ_NODENAME} status` =~ /\{pid,(\d+)\}/
-    end
-
-    def start_rabbitmq(delay = 1.0)
-      # this is Homebrew-specific :(
-      `RABBITMQ_NODENAME=#{RABBITMQ_NODENAME} rabbitmq-server > /dev/null 2>&1 &`; sleep(delay)
-    end
-
-    def stop_rabbitmq(pid = rabbitmq_pid, delay = 1.0)
-      `rabbitmqctl -n #{RABBITMQ_NODENAME} stop`; sleep(delay)
-    end
-
-    def kill_rabbitmq(pid = rabbitmq_pid, delay = 1.0)
-      # tango is down, tango is down!
-      Process.kill("KILL", pid); sleep(delay)
-    end
-  end
-end
-
-
-module PlatformDetection
-  def mri?
-    !defined?(RUBY_ENGINE) || (defined?(RUBY_ENGINE) && ("ruby" == RUBY_ENGINE))
-  end
-
-  def rubinius?
-    defined?(RUBY_ENGINE) && (RUBY_ENGINE == 'rbx')
-  end
-end

data/spec/stress/channel_close_stress_spec.rb

@@ -1,64 +0,0 @@
-require "spec_helper"
-
-describe "Rapidly closing lots of temporary channels" do
-  before :all do
-    @connection = Bunny.new(automatic_recovery: false).tap do |c|
-      c.start
-    end
-  end
-
-  after :all do
-    @connection.close
-  end
-
-  100.times do |i|
-    context "in a multi-threaded scenario A (take #{i})" do
-      let(:n) { 20 }
-
-      it "works correctly" do
-        ts = []
-
-        n.times do
-          t = Thread.new do
-            @connection.with_channel do |ch1|
-              q   = ch1.queue("", exclusive: true)
-              q.delete
-              ch1.close
-            end
-
-            ch2 = @connection.create_channel
-            ch2.close
-          end
-          t.abort_on_exception = true
-          ts << t
-        end
-
-        ts.each { |t| t.join }
-      end
-    end
-  end
-
-  100.times do |i|
-    context "in a multi-threaded scenario B (take #{i})" do
-      let(:n) { 20 }
-
-      it "works correctly" do
-        ts = []
-
-        n.times do
-          t = Thread.new do
-            3.times do
-              @connection.with_channel do |ch|
-                x  = ch.topic('bunny.stress.topics.t2', durable: false)
-              end
-            end
-          end
-          t.abort_on_exception = true
-          ts << t
-        end
-
-        ts.each { |t| t.join }
-      end
-    end
-  end
-end

data/spec/stress/channel_open_stress_spec.rb

@@ -1,84 +0,0 @@
-require "spec_helper"
-
-describe "Rapidly opening and closing lots of channels" do
-  before :all do
-    @connection = Bunny.new(automatic_recovery: false).tap do |c|
-      c.start
-    end
-  end
-
-  after :all do
-    @connection.close
-  end
-
-  context "in a single-threaded scenario" do
-    let(:n) { 500 }
-
-    it "works correctly" do
-      xs = Array.new(n) { @connection.create_channel }
-      puts "Opened #{n} channels"
-
-      expect(xs.size).to eq n
-      xs.each do |ch|
-        ch.close
-      end
-    end
-  end
-
-  100.times do |i|
-    context "in a multi-threaded scenario A (take #{i})" do
-      # actually, on MRI values greater than ~100 will eventually cause write
-      # operations to fail with a timeout (1 second is not enough)
-      # which will cause recovery to re-acquire @channel_mutex in Session.
-      # Because Ruby's mutexes are not re-entrant, it will raise a ThreadError.
-      #
-      # But this already demonstrates that within these platform constraints,
-      # Bunny is safe to use in such scenarios.
-      let(:n) { 20 }
-
-      it "works correctly" do
-        ts = []
-
-        n.times do
-          t = Thread.new do
-            ch1 = @connection.create_channel
-            q   = ch1.queue("", exclusive: true)
-            q.delete
-            ch1.close
-
-            ch2 = @connection.create_channel
-            ch2.close
-          end
-          t.abort_on_exception = true
-          ts << t
-        end
-
-        ts.each { |t| t.join }
-      end
-    end
-  end
-
-  100.times do |i|
-    context "in a multi-threaded scenario B (take #{i})" do
-      let(:n) { 20 }
-
-      it "works correctly" do
-        ts = []
-
-        n.times do
-          t = Thread.new do
-            3.times do
-              ch = @connection.create_channel
-              x  = ch.topic('bunny.stress.topics.t2', durable: false)
-              ch.close
-            end
-          end
-          t.abort_on_exception = true
-          ts << t
-        end
-
-        ts.each { |t| t.join }
-      end
-    end
-  end
-end

data/spec/stress/channel_open_stress_with_single_threaded_connection_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-unless ENV["CI"]
-  describe "Rapidly opening and closing lots of channels on a non-threaded connection" do
-    before :all do
-      @connection = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
-        automatic_recovery: false, threaded: false)
-      @connection.start
-    end
-
-    after :all do
-      @connection.close
-    end
-
-    context "in a single-threaded scenario" do
-      let(:n) { 500 }
-
-      it "works correctly" do
-        xs = Array.new(n) { @connection.create_channel }
-
-        expect(xs.size).to eq n
-        xs.each do |ch|
-          ch.close
-        end
-      end
-    end
-  end
-end

data/spec/stress/concurrent_consumers_stress_spec.rb

@@ -1,71 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  describe "Concurrent consumers sharing a connection" do
-    before :all do
-      @connection = Bunny.new(username: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
-                    automatic_recovery: false, continuation_timeout: 45000)
-      @connection.start
-    end
-
-    after :all do
-      @connection.close
-    end
-
-    def any_not_drained?(qs)
-      qs.any? { |q| !q.message_count.zero? }
-    end
-
-    context "when publishing thousands of messages over 128K in size" do
-      let(:colors) { ["red", "blue", "white"] }
-
-      let(:n) { 16 }
-      let(:m) { 5000 }
-
-      it "successfully drain all queues" do
-        ch0  = @connection.create_channel
-        ch0.confirm_select
-        body = "абвг"
-        x    = ch0.topic("bunny.stress.concurrent.consumers.topic", durable: true)
-
-        chs  = {}
-        n.times do |i|
-          chs[i] = @connection.create_channel
-        end
-        qs   = []
-
-        n.times do |i|
-          t = Thread.new do
-            cht = chs[i]
-
-            q = cht.queue("", exclusive: true)
-            q.bind(x.name, routing_key: colors.sample).subscribe do |delivery_info, meta, payload|
-              # no-op
-            end
-            qs << q
-          end
-          t.abort_on_exception = true
-        end
-
-        sleep 1.0
-
-        5.times do |i|
-          m.times do
-            x.publish(body, routing_key: colors.sample)
-          end
-          puts "Published #{(i + 1) * m} messages..."
-          ch0.wait_for_confirms
-        end
-
-        while any_not_drained?(qs)
-          sleep 1.0
-        end
-        puts "Drained all queues, winding down..."
-
-        ch0.close
-        chs.each { |_, ch| ch.close }
-      end
-    end
-  end
-end

data/spec/stress/concurrent_publishers_stress_spec.rb

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  describe "Concurrent publishers sharing a connection" do
-    before :all do
-      @connection = Bunny.new(username: "bunny_gem", password: "bunny_password",
-        vhost: "bunny_testbed", automatically_recover: false)
-      @connection.start
-    end
-
-    after :all do
-      @connection.close
-    end
-
-    let(:concurrency) { 24 }
-    let(:messages)    { 5_000 }
-
-    it "successfully finish publishing" do
-      body = "сообщение"
-
-      chs  = {}
-      concurrency.times do |i|
-        ch     = @connection.create_channel
-        ch.confirm_select
-        chs[i] = ch
-      end
-
-      ts = []
-
-      concurrency.times do |i|
-        t = Thread.new do
-          cht = chs[i]
-          x   = cht.default_exchange
-
-          messages.times do
-            x.publish(body)
-          end
-          puts "Published #{messages} messages..."
-          cht.wait_for_confirms
-        end
-        t.abort_on_exception = true
-
-        ts << t
-      end
-
-      ts.each do |t|
-        t.join
-      end
-
-      chs.each { |_, ch| ch.close }
-    end
-  end
-end