bunny 2.15.0 → 2.22.0

data/spec/higher_level_api/integration/tls_connection_spec.rb

@@ -1,262 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-require "socket"
-
-CERTIFICATE_DIR = ENV.fetch("BUNNY_CERTIFICATE_DIR", "./spec/tls")
-puts "Will use certificates from #{CERTIFICATE_DIR}"
-
-shared_examples_for "successful TLS connection" do
-  it "succeeds", skip: ENV["CI"] do
-    expect(subject).to be_tls
-    ch = subject.create_channel
-    ch.confirm_select
-
-    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)
-
-    x.wait_for_confirms
-    expect(q.message_count).to eq 4
-
-    i = 0
-    q.subscribe do |delivery_info, _, payload|
-      i += 1
-    end
-    sleep 1.0
-    expect(i).to eq 4
-    expect(q.message_count).to eq 0
-
-    ch.close
-  end
-end
-
-def local_hostname
-  ENV.fetch("BUNNY_RABBITMQ_HOSTNAME", "localhost")
-end
-
-def no_tls12_supported?
-  not tls12_supported?
-end
-
-def tls12_supported?
-  begin
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.min_version = ctx.max_version = OpenSSL::SSL::TLS1_2_VERSION
-    true
-  rescue
-    false
-  end
-end
-
-context "initialized with tls: true", skip: ENV["CI"] do
-  let(:subject) do
-    Bunny.new(
-      hostname:  local_hostname(),
-      user:     "bunny_gem",
-      password: "bunny_password",
-      vhost:    "bunny_testbed",
-      tls: true,
-      verify_peer: verify_peer,
-      tls_cert: "#{CERTIFICATE_DIR}/client_certificate.pem",
-      tls_key: "#{CERTIFICATE_DIR}/client_key.pem",
-      tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"])
-  end
-
-  context "peer verification is off" do
-    let(:verify_peer) { false }
-
-    it "uses TLS port" do
-      expect(subject.port).to eq AMQ::Protocol::TLS_PORT
-    end
-
-    it "sends the SNI details" do
-      # https://github.com/ruby-amqp/bunny/issues/440
-      subject.start
-      expect(subject.transport.socket.hostname).to_not be_empty
-    end
-
-    after :each do
-      subject.close
-    end
-  end
-
-  context "peer verification is on" do
-    let(:verify_peer) { true }
-
-    it "uses TLS port" do
-      expect(subject.port).to eq AMQ::Protocol::TLS_PORT
-    end
-  end
-end
-
-describe "TLS connection to RabbitMQ with client certificates", skip: ENV["CI"] do
-  let(:subject) do
-    c = Bunny.new(
-      hostname: local_hostname(),
-      username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      tls: true,
-      tls_cert: "#{CERTIFICATE_DIR}/client_certificate.pem",
-      tls_key: "#{CERTIFICATE_DIR}/client_key.pem",
-      tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-      verify_peer: false)
-    c.start
-    c
-  end
-
-  after :each do
-    subject.close
-  end
-
-  include_examples "successful TLS connection"
-end
-
-
-describe "TLS connection to RabbitMQ without client certificates", skip: ENV["CI"] do
-  let(:subject) do
-    c = Bunny.new(
-      hostname: local_hostname(),
-      username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      tls: true,
-      tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-      verify_peer: false)
-    c.start
-    c
-  end
-
-  after :each do
-    subject.close
-  end
-
-  include_examples "successful TLS connection"
-end
-
-
-describe "TLS connection to RabbitMQ with a connection string", skip: ENV["CI"] do
-  let(:subject) do
-    c = Bunny.new("amqps://bunny_gem:bunny_password@#{local_hostname()}/bunny_testbed",
-      tls_cert: "#{CERTIFICATE_DIR}/client_certificate.pem",
-      tls_key: "#{CERTIFICATE_DIR}/client_key.pem",
-      tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-      verify_peer: false)
-    c.start
-    c
-  end
-
-  after :each do
-    subject.close
-  end
-
-  include_examples "successful TLS connection"
-
-  context "when URI contains query parameters" do
-    subject(:session) do
-      Bunny.new("amqps://bunny_gem:bunny_password@#{local_hostname()}/bunny_testbed?heartbeat=10&connection_timeout=100&channel_max=1000&verify=false&cacertfile=#{CERTIFICATE_DIR}/ca_certificate.pem&certfile=#{CERTIFICATE_DIR}/client_certificate.pem&keyfile=#{CERTIFICATE_DIR}/client_key.pem")
-    end
-
-    it "parses extra connection parameters" do
-      session.start
-
-      expect(session.uses_tls?).to eq(true)
-      expect(session.transport.verify_peer).to eq(false)
-      expect(session.transport.tls_ca_certificates).to eq(["#{CERTIFICATE_DIR}/ca_certificate.pem"])
-      expect(session.transport.tls_certificate_path).to eq("#{CERTIFICATE_DIR}/client_certificate.pem")
-      expect(session.transport.tls_key_path).to eq("#{CERTIFICATE_DIR}/client_key.pem")
-    end
-  end
-end
-
-
-describe "TLS connection to RabbitMQ with a connection string and w/o client certificate and key", skip: ENV["CI"] do
-  let(:subject) do
-    c = Bunny.new("amqps://bunny_gem:bunny_password@#{local_hostname()}/bunny_testbed",
-      tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-      verify_peer: verify_peer)
-    c.start
-    c
-  end
-
-  after :each do
-    subject.close
-  end
-
-  context "peer verification is off" do
-    let(:verify_peer) { false }
-
-    include_examples "successful TLS connection"
-
-    it "sends the SNI details" do
-      # https://github.com/ruby-amqp/bunny/issues/440
-      expect(subject.transport.socket.hostname).to_not be_empty
-    end
-  end
-
-  context "peer verification is on" do
-    let(:verify_peer) { true }
-
-    include_examples "successful TLS connection"
-
-    it "sends the SNI details" do
-      # https://github.com/ruby-amqp/bunny/issues/440
-      expect(subject.transport.socket.hostname).to_not be_empty
-    end
-  end
-end
-
-
-describe "TLS connection to RabbitMQ with client certificates provided inline", skip: ENV["CI"] do
-  let(:subject) do
-    c = Bunny.new(
-      hostname: local_hostname(),
-      username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      tls: true,
-      tls_cert: File.read("#{CERTIFICATE_DIR}/client_certificate.pem"),
-      tls_key: File.read("#{CERTIFICATE_DIR}/client_key.pem"),
-      tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-      verify_peer: false)
-    c.start
-    c
-  end
-
-  after :each do
-    subject.close
-  end
-
-  include_examples "successful TLS connection"
-end
-
-describe "TLS connection to RabbitMQ with tls_version TLSv1.2 specified", skip: ENV["CI"] do
-  let(:subject) do
-    c = Bunny.new(
-      hostname: local_hostname(),
-      username: "bunny_gem",
-      password: "bunny_password",
-      vhost: "bunny_testbed",
-      tls: true,
-      tls_protocol: :TLSv1_2,
-      tls_ca_certificates: ["#{CERTIFICATE_DIR}/ca_certificate.pem"],
-      verify_peer: false)
-    c.start
-    c
-  end
-
-  after :each do
-    subject.close
-  end
-
-  include_examples "successful TLS connection"
-
-  it "connects using TLSv1.2", skip: no_tls12_supported? do
-    expect(subject.transport.socket.ssl_version).to eq "TLSv1.2"
-  end
-end

data/spec/higher_level_api/integration/toxiproxy_spec.rb

@@ -1,76 +0,0 @@
-require "spec_helper"
-require_relative "../../toxiproxy_helper"
-
-if ::Toxiproxy.running?
-  describe Bunny::Channel, "#basic_publish" do
-    include RabbitMQ::Toxiproxy
-
-    after :each do
-      @connection.close if @connection.open?
-    end
-
-    context "when the the connection detects missed heartbeats with automatic recovery" do
-      before(:each) do
-        setup_toxiproxy
-        @connection = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
-          host: "localhost:11111", heartbeat_timeout: 1, automatically_recover: true)
-        @connection.start
-      end
-
-      let(:queue_name) { "bunny.basic.publish.queue#{rand}" }
-
-      it "raises a ConnectionClosedError" do
-        ch = @connection.create_channel
-        begin
-          rabbitmq_toxiproxy.down do
-            sleep 2
-            expect { ch.default_exchange.publish("", :routing_key => queue_name) }.to raise_error(Bunny::ConnectionClosedError)
-          end
-        ensure
-          cleanup_toxiproxy
-        end
-      end
-    end
-
-    context "when the the connection detects missed heartbeats without automatic recovery" do
-      before(:each) do
-        setup_toxiproxy
-        @connection = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
-          host: "localhost:11111", heartbeat_timeout: 1, automatically_recover: false, threaded: false)
-        @connection.start
-      end
-
-      it "does not raise an exception on session thread" do
-       rabbitmq_toxiproxy.down do
-          sleep 5
-        end
-      end
-    end
-
-    context "recovery attempt limit that's exceeded" do
-      before(:each) do
-        setup_toxiproxy
-        @connection = Bunny.new(user: "bunny_gem", password: "bunny_password", vhost: "bunny_testbed",
-          host: "localhost:11111", heartbeat_timeout: 1, automatically_recover: true, network_recovery_interval: 1,
-          recovery_attempts: 2, reset_recovery_attempts_after_reconnection: true,
-          disconnect_timeout: 1)
-        @connection.start
-      end
-
-      it "permanently closes connection" do
-        expect(@connection.open?).to be(true)
-
-        rabbitmq_toxiproxy.down do
-          sleep 5
-        end
-        # give the connection one last chance to recover
-        sleep 3
-
-        expect(@connection.open?).to be(false)
-        expect(@connection.closed?).to be(true)
-      end
-    end # context
-  end # describe
-else
-  puts "Toxiproxy isn't running, some examples will be skipped"
-end

data/spec/higher_level_api/integration/tx_commit_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#tx_commit" 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 "is supported" do
-    ch = connection.create_channel
-    ch.tx_select
-    ch.tx_commit
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/tx_rollback_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#tx_rollback" 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 "is supported" do
-    ch = connection.create_channel
-    ch.tx_select
-    ch.tx_rollback
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/with_channel_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#with_channel" 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 "closes if the block throws an exception" do
-    ch = nil
-    begin
-      connection.with_channel do |wch|
-        ch = wch
-        raise Exception.new
-      end
-    rescue Exception
-    end
-    expect(ch).to be_closed
-  end
-end

data/spec/issues/issue100_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-unless ENV["CI"]
-  describe Bunny::Channel, "#basic_publish" do
-    before :all do
-      @connection = Bunny.new(username: "bunny_gem",
-                              password: "bunny_password",
-                              vhost: "bunny_testbed",
-                              write_timeout: 0,
-                              read_timeout:  0)
-      @connection.start
-    end
-
-    after :all do
-      @connection.close if @connection.open?
-    end
-
-
-    context "when publishing thousands of messages" do
-      let(:n) { 2_000 }
-      let(:m) { 10 }
-
-      it "successfully publishers them all" do
-        ch = @connection.create_channel
-
-        q  = ch.queue("", exclusive: true)
-        x  = ch.default_exchange
-
-        body = "x" * 1024
-        m.times do |i|
-          n.times do
-            x.publish(body, routing_key:  q.name)
-          end
-          puts "Published #{i * n} 1K messages..."
-        end
-
-        q.purge
-        ch.close
-      end
-    end
-  end
-end

data/spec/issues/issue141_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe "Registering 2nd exclusive consumer on queue" do
-    before :all do
-    @connection = Bunny.new(:user => "bunny_gem", password:  "bunny_password", :vhost => "bunny_testbed")
-    @connection.start
-  end
-
-  after :each do
-    @connection.close if @connection.open?
-  end
-
-
-  it "raises a meaningful exception" do
-    xs  = []
-
-    ch1 = @connection.create_channel
-    ch2 = @connection.create_channel
-    q1  = ch1.queue("", :auto_delete => true)
-    q2  = ch2.queue(q1.name, :auto_delete => true, :passive => true)
-
-    c1  = q1.subscribe(exclusive: true) do |_, _, payload|
-      xs << payload
-    end
-    sleep 0.1
-
-    expect do
-      q2.subscribe(exclusive: true) do |_, _, _|
-      end
-    end.to raise_error(Bunny::AccessRefused)
-
-    expect(ch1).to be_open
-    expect(ch2).to be_closed
-
-    q1.publish("abc")
-    sleep 0.1
-
-    # verify that the first consumer is fine
-    expect(xs).to eq ["abc"]
-
-    q1.delete
-  end
-end

data/spec/issues/issue202_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Session do
-  context "with unreachable host" do
-    it "raises Bunny::TCPConnectionFailed" do
-      begin
-        conn = Bunny.new(:hostname => "127.0.0.254", :port => 1433)
-        conn.start
-
-        fail "expected 192.192.192.192 to be unreachable"
-      rescue Bunny::TCPConnectionFailed => e
-      end
-    end
-  end
-end

data/spec/issues/issue224_spec.rb

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  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 :each do
-      connection.close if connection.open?
-    end
-
-
-    context "with payload 272179 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" * 272179)
-        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
-  end
-end

data/spec/issues/issue465_spec.rb

@@ -1,32 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-describe Bunny::Session 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
-
-  context 'after the connection has been manually closed' do
-    before :each do
-      connection.close
-    end
-
-    after :each do
-      connection.close if connection.open?
-    end
-
-    describe '#create_channel' do
-      it 'should raise an exception' do
-        expect {
-          connection.create_channel
-        }.to raise_error(Bunny::ConnectionAlreadyClosed)
-      end
-    end
-  end
-end

data/spec/issues/issue549_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Bunny::Session do
-  context 'when retry attempts have been exhausted' do
-    let(:io) { StringIO.new } # keep test output clear
-
-    def create_session
-      described_class.new(
-        host: 'fake.host',
-        recovery_attempts: 0,
-        connection_timeout: 0,
-        network_recovery_interval: 0,
-        logfile: io,
-      )
-    end
-
-    it 'closes the session' do
-      session = create_session
-      session.handle_network_failure(StandardError.new)
-      expect(session.closed?).to be true
-    end
-
-    it 'stops the reader loop' do
-      session = create_session
-      reader_loop = session.reader_loop
-      session.handle_network_failure(StandardError.new)
-      expect(reader_loop.stopping?).to be true
-    end
-  end
-end

data/spec/issues/issue78_spec.rb

@@ -1,72 +0,0 @@
-require "spec_helper"
-
-unless ENV["CI"]
-  describe Bunny::Queue, "#subscribe" do
-    before :all do
-      @connection1 = Bunny.new(:user => "bunny_gem", password:  "bunny_password", :vhost => "bunny_testbed")
-      @connection1.start
-      @connection2 = Bunny.new(:user => "bunny_gem", password:  "bunny_password", :vhost => "bunny_testbed")
-      @connection2.start
-    end
-
-    after :all do
-      [@connection1, @connection2].select { |c| !!c }.each do |c|
-        c.close if c.open?
-      end
-    end
-
-
-    context "with an empty queue" do
-      it "consumes messages" do
-        delivered_data = []
-
-        ch1 = @connection1.create_channel
-        ch2 = @connection1.create_channel
-
-        q   = ch1.queue("", exclusive: true)
-        q.subscribe(manual_ack: false) do |delivery_info, properties, payload|
-          delivered_data << payload
-        end
-        sleep 0.5
-
-        x = ch2.default_exchange
-        x.publish("abc", routing_key:  q.name)
-        sleep 0.7
-
-        expect(delivered_data).to eq ["abc"]
-
-        ch1.close
-        ch2.close
-      end
-    end
-
-    context "with a non-empty queue" do
-      let(:queue_name) { "queue#{rand}" }
-
-      it "consumes messages" do
-        delivered_data = []
-
-        ch1 = @connection1.create_channel
-        ch2 = @connection1.create_channel
-
-        q   = ch1.queue(queue_name, exclusive: true)
-        x = ch2.default_exchange
-        3.times do |i|
-          x.publish("data#{i}", routing_key:  queue_name)
-        end
-        sleep 0.7
-        expect(q.message_count).to eq 3
-
-        q.subscribe(manual_ack: false) do |delivery_info, properties, payload|
-          delivered_data << payload
-        end
-        sleep 0.7
-
-        expect(delivered_data).to eq ["data0", "data1", "data2"]
-
-        ch1.close
-        ch2.close
-      end
-    end
-  end
-end