bunny 1.0.7 → 2.24.0

data/spec/issues/issue97_spec.rb

@@ -1,176 +0,0 @@
-require "spec_helper"
-
-describe "Message framing implementation" do
-  let(:connection) do
-    c = Bunny.new(:user     => "bunny_gem",
-                  :password => "bunny_password",
-                  :vhost    => "bunny_testbed",
-                  :port     => ENV.fetch("RABBITMQ_PORT", 5672))
-    c.start
-    c
-  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)
-        q.message_count.should == 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)
-      q.message_count.should == 1
-
-      _, _, payload      = q.pop
-      payload.bytesize.should == 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)
-      q.message_count.should == 1
-
-      envelope, headers, payload = q.pop
-
-      payload.should == ""
-
-      headers[:content_type].should == "application/octet-stream"
-      headers[:delivery_mode].should == 2
-      headers[:priority].should == 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)
-      q.message_count.should == 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)
-      q.message_count.should == 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)
-      q.message_count.should == 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)
-      q.message_count.should == 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)
-      q.message_count.should == 1
-
-      q.purge
-      ch.close
-    end
-  end
-end

data/spec/lower_level_api/integration/basic_cancel_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#basic_cancel" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  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)
-
-    cancel_ok.should be_instance_of(AMQ::Protocol::Basic::CancelOk)
-    cancel_ok.consumer_tag.should == 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
-
-        consume_ok.consumer_tag.should_not be_nil
-        cancel_ok = ch.basic_cancel(consume_ok.consumer_tag)
-        cancel_ok.consumer_tag.should == 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
-      delivered_data.should 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
-end

data/spec/lower_level_api/integration/basic_consume_spec.rb

@@ -1,100 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#basic_consume" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  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)
-    consume_ok.should be_instance_of(AMQ::Protocol::Basic::ConsumeOk)
-    consume_ok.consumer_tag.should_not 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, "")
-    consume_ok.consumer_tag.should =~ /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
-      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
-
-  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
-      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

data/spec/spec_helper.rb

@@ -1,64 +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 "amq/protocol/version"
-puts "Using Ruby #{RUBY_VERSION}, amq-protocol #{AMQ::Protocol::VERSION}"
-
-
-
-#
-# Ruby version-specific
-#
-
-case RUBY_VERSION
-when "1.8.7" then
-  class Array
-    alias sample choice
-  end
-when "1.8.6" then
-  raise "Ruby 1.8.6 is not supported. Sorry, pal. Time to move on beyond One True Ruby. Yes, time flies by."
-end
-
-
-
-module RabbitMQ
-  module Control
-    def rabbitmq_pid
-      $1.to_i if `rabbitmqctl status` =~ /\{pid,(\d+)\}/
-    end
-
-    def start_rabbitmq(delay = 1.0)
-      # this is Homebrew-specific :(
-      `rabbitmq-server > /dev/null 2>&1 &`; sleep(delay)
-    end
-
-    def stop_rabbitmq(pid = rabbitmq_pid, delay = 1.0)
-      `rabbitmqctl 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_open_stress_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-
-unless ENV["CI"]
-  describe "Rapidly opening and closing lots of channels" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false)
-      c.start
-      c
-    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"
-
-        xs.size.should == n
-        xs.each do |ch|
-          ch.close
-        end
-      end
-    end
-
-    context "in a multi-threaded scenario" 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
-        n.times do
-          t = Thread.new do
-            ch = connection.create_channel
-
-            ch.close
-          end
-          t.abort_on_exception = true
-        end
-      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
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatic_recovery => false, :threaded => false)
-      c.start
-      c
-    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 }
-
-        xs.size.should == n
-        xs.each do |ch|
-          ch.close
-        end
-      end
-    end
-  end
-end

data/spec/stress/concurrent_consumers_stress_spec.rb

@@ -1,69 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  describe "Concurrent consumers sharing a connection" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed",
-                    :automatic_recovery => false, :continuation_timeout => 6000)
-      c.start
-      c
-    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) { 32 }
-      let(:m) { 1000 }
-
-      it "successfully drain all queues" do
-        ch   = connection.create_channel
-        body = "абвг"
-        x    = ch.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..."
-        end
-
-        while any_not_drained?(qs)
-          sleep 1.0
-        end
-        puts "Drained all the queues..."
-
-        ch.close
-      end
-    end
-  end
-end

data/spec/stress/concurrent_publishers_stress_spec.rb

@@ -1,57 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  describe "Concurrent publishers sharing a connection" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :automatically_recover => false, :continuation_timeout => 20.0)
-      c.start
-      c
-    end
-
-    after :all do
-      connection.close
-    end
-
-    let(:concurrency) { 24 }
-    let(:rate)        { 5_000 }
-
-    it "successfully finish publishing" do
-      ch = connection.create_channel
-
-      q    = ch.queue("", :exclusive => true)
-      body = "сообщение"
-
-      # let the queue name be sent back by RabbitMQ
-      sleep 0.25
-
-      chs  = {}
-      concurrency.times do |i|
-        chs[i] = connection.create_channel
-      end
-
-      ts = []
-
-      concurrency.times do |i|
-        t = Thread.new do
-          cht = chs[i]
-          x   = ch.default_exchange
-
-          5.times do |i|
-            rate.times do
-              x.publish(body, :routing_key => q.name)
-            end
-            puts "Published #{(i + 1) * rate} messages..."
-          end
-        end
-        t.abort_on_exception = true
-
-        ts << t
-      end
-
-      ts.each do |t|
-        t.join
-      end
-    end
-  end
-end

data/spec/stress/connection_open_close_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-unless defined?(JRUBY_VERSION) && !ENV["FORCE_JRUBY_RUN"]
-  describe Bunny::Session do
-    # creating thousands of connections means creating
-    # twice as many threads and this won't fly with the JVM
-    # in CI containers. MK.
-    n = if defined?(JRUBY_VERSION)
-          250
-        else
-          2500
-        end
-
-    n.times do |i|
-      it "can be closed (take #{i})" do
-        c  = Bunny.new(:automatically_recover => false)
-        c.start
-        ch = c.create_channel
-
-        c.should be_connected
-        c.stop
-        c.should be_closed
-      end
-    end
-
-    context "in the single threaded mode" do
-      n.times do |i|
-        it "can be closed (take #{i})" do
-          c  = Bunny.new(:automatically_recover => false, :threaded => false)
-          c.start
-          ch = c.create_channel
-
-          c.should be_connected
-          c.stop
-          c.should be_closed
-        end
-      end
-    end
-  end
-end