bunny 1.0.7 → 2.24.0

data/spec/higher_level_api/integration/read_only_consumer_spec.rb

@@ -1,60 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "#subscribe" do
-  let(:publisher_connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  let(:consumer_connection) do
-    c = Bunny.new(:user => "bunny_reader", :password => "reader_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  after :each do
-    publisher_connection.close if publisher_connection.open?
-    consumer_connection.close  if consumer_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 = []
-
-      ch = publisher_connection.create_channel
-      # declare the queue because the read-only user won't be able to issue
-      # queue.declare
-      q  = ch.queue(queue_name, :auto_delete => true, :durable => false)
-
-      t = Thread.new do
-        # give the main thread a bit of time to declare the queue
-        sleep 0.5
-        ch = consumer_connection.create_channel
-        # this connection is read only, use passive declare to only get
-        # a reference to the queue
-        q  = ch.queue(queue_name, :auto_delete => true, :durable => false, :passive => true)
-        q.subscribe(:exclusive => 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
-
-      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 # describe

data/spec/higher_level_api/integration/sender_selected_distribution_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-describe "Sender-selected distribution" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  end
-
-  after :each do
-    connection.close if connection.open?
-  end
-
-  it "lets publishers specify additional routing keys using CC and BCC headers" do
-    ch   = connection.create_channel
-    x    = ch.direct("bunny.tests.ssd.exchange")
-    q1   = ch.queue("", :exclusive => true).bind(x, :routing_key => "one")
-    q2   = ch.queue("", :exclusive => true).bind(x, :routing_key => "two")
-    q3   = ch.queue("", :exclusive => true).bind(x, :routing_key => "three")
-    q4   = ch.queue("", :exclusive => true).bind(x, :routing_key => "four")
-
-    n    = 10
-    n.times do |i|
-      x.publish("Message #{i}", :routing_key => "one", :headers => {"CC" => ["two", "three"]})
-    end
-
-    sleep 0.5
-
-    q1.message_count.should == n
-    q2.message_count.should == n
-    q3.message_count.should == n
-    q4.message_count.should be_zero
-
-    x.delete
-  end
-end

data/spec/higher_level_api/integration/tls_connection_spec.rb

@@ -1,127 +0,0 @@
-# -*- coding: utf-8 -*-
-require "spec_helper"
-
-unless ENV["CI"]
-  shared_examples_for "successful TLS connection" do
-    it "succeeds" do
-      connection.should be_tls
-      ch = connection.create_channel
-
-      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)
-
-      sleep 0.5
-      q.message_count.should == 4
-
-      i = 0
-      q.subscribe do |delivery_info, _, payload|
-        i += 1
-      end
-      sleep 1.0
-      i.should == 4
-      q.message_count.should == 0
-
-      ch.close
-    end
-  end
-
-
-  describe "TLS connection to RabbitMQ with client certificates" do
-    let(:connection) do
-      c = Bunny.new(:user     => "bunny_gem",
-        :password => "bunny_password",
-        :vhost    => "bunny_testbed",
-        :tls                   => true,
-        :tls_cert              => "spec/tls/client_cert.pem",
-        :tls_key               => "spec/tls/client_key.pem",
-        :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-
-  describe "TLS connection to RabbitMQ without client certificates" do
-    let(:connection) do
-      c = Bunny.new(:user     => "bunny_gem",
-        :password => "bunny_password",
-        :vhost    => "bunny_testbed",
-        :tls                   => true,
-        :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-
-  describe "TLS connection to RabbitMQ with a connection string" do
-    let(:connection) do
-      c = Bunny.new("amqps://bunny_gem:bunny_password@127.0.0.1/bunny_testbed",
-        :tls_cert              => "spec/tls/client_cert.pem",
-        :tls_key               => "spec/tls/client_key.pem",
-        :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-
-  describe "TLS connection to RabbitMQ with a connection string and w/o client certificate and key" do
-    let(:connection) do
-      c = Bunny.new("amqps://bunny_gem:bunny_password@127.0.0.1/bunny_testbed",
-        :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-
-
-  describe "TLS connection to RabbitMQ with client certificates provided inline" do
-    let(:connection) do
-      c = Bunny.new(:user     => "bunny_gem",
-        :password => "bunny_password",
-        :vhost    => "bunny_testbed",
-        :tls                   => true,
-        :tls_cert              => File.read("./spec/tls/client_cert.pem"),
-        :tls_key               => File.read("./spec/tls/client_key.pem"),
-        :tls_ca_certificates   => ["./spec/tls/cacert.pem"])
-      c.start
-      c
-    end
-
-    after :each do
-      connection.close
-    end
-
-    include_examples "successful TLS connection"
-  end
-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(:user => "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(:user => "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(:user => "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
-    ch.should 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
-    let(:connection) do
-      c = Bunny.new(:user     => "bunny_gem",
-                    :password => "bunny_password",
-                    :vhost    => "bunny_testbed",
-                    :socket_timeout => 0)
-      c.start
-      c
-    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,44 +0,0 @@
-require "spec_helper"
-
-describe "Registering 2nd exclusive consumer on queue" do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-    c.start
-    c
-  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
-
-    lambda do
-      q2.subscribe(:exclusive => true) do |_, _, _|
-      end
-    end.should raise_error(Bunny::AccessRefused)
-
-    ch1.should be_open
-    ch2.should be_closed
-
-    q1.publish("abc")
-    sleep 0.1
-
-    # verify that the first consumer is fine
-    xs.should == ["abc"]
-
-    q1.delete
-  end
-end

data/spec/issues/issue78_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-unless ENV["CI"]
-  describe Bunny::Queue, "#subscribe" do
-    let(:connection1) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-      c.start
-      c
-    end
-    let(:connection2) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
-      c.start
-      c
-    end
-
-    after :all do
-      connection1.close if connection1.open?
-      connection2.close if connection2.open?
-    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(:ack => false, :block => 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
-
-        delivered_data.should == ["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
-        q.message_count.should == 3
-
-        q.subscribe(:ack => false, :block => false) do |delivery_info, properties, payload|
-          delivered_data << payload
-        end
-        sleep 0.7
-
-        delivered_data.should == ["data0", "data1", "data2"]
-
-        ch1.close
-        ch2.close
-      end
-    end
-  end
-end

data/spec/issues/issue83_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel, "#open" 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 "properly resets channel exception state" do
-    ch = connection.create_channel
-
-    begin
-      ch.queue("bunny.tests.does.not.exist", :passive => true)
-    rescue Bunny::NotFound
-      # expected
-    end
-
-    # reopen the channel
-    ch.open
-
-    # should not raise
-    q = ch.queue("bunny.tests.my.queue")
-    q.delete
-  end
-end