bunny 1.0.7 → 2.24.0

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(:user => "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, :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
-
-    metadata.content_type.should == "application/octet-stream"
-    metadata.priority.should     == 8
-
-    time = metadata.headers["time"]
-    time.year.should == @now.year
-    time.month.should == @now.month
-    time.day.should == @now.day
-    time.hour.should == @now.hour
-    time.min.should == @now.min
-    time.sec.should == @now.sec
-
-    metadata.headers["coordinates"]["latitude"].should == 59.35
-    metadata.headers["participants"].should == 11
-    metadata.headers["venue"].should == "Stockholm"
-    metadata.headers["true_field"].should == true
-    metadata.headers["false_field"].should == false
-    metadata.headers["nil_field"].should be_nil
-    metadata.headers["ary_field"].should == ["one", 2.0, 3, [{ "abc" => 123}]]
-
-    metadata.timestamp.should == Time.at(@now.to_i)
-    metadata.type.should == "kinda.checkin"
-    metadata.reply_to.should == "a.sender"
-    metadata.correlation_id.should == "r-1"
-    metadata.message_id.should == "m-1"
-    metadata.app_id.should == "bunny.example"
-
-    envelope.consumer_tag.should_not be_nil
-    envelope.consumer_tag.should_not be_empty
-    envelope.should_not be_redelivered
-    envelope.delivery_tag.should == 1
-    envelope.routing_key.should  == queue_name
-    envelope.exchange.should == ""
-
-    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(:user => "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)
-      x.should be_predeclared
-    end
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/publisher_confirms_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Channel do
-  let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :continuation_timeout => 10000)
-    c.start
-    c
-  end
-
-  after :each do
-    connection.close if connection.open?
-  end
-
-  let(:n) { 200 }
-
-  context "when publishing with confirms enabled" do
-    it "increments delivery index" do
-      ch = connection.create_channel
-      ch.should_not be_using_publisher_confirmations
-
-      ch.confirm_select
-      ch.should be_using_publisher_confirmations
-
-      q  = ch.queue("", :exclusive => true)
-      x  = ch.default_exchange
-
-      n.times do
-        x.publish("xyzzy", :routing_key => q.name)
-      end
-
-      ch.next_publish_seq_no.should == n + 1
-      ch.wait_for_confirms.should be_true
-      sleep 0.25
-
-      q.message_count.should == n
-      q.purge
-
-      ch.close
-    end
-  end
-
-
-  context "with a single-threaded connection" do
-    let(:connection) do
-      c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed", :continuation_timeout => 10000, :threaded => false)
-      c.start
-      c
-    end
-
-
-    context "when publishing with confirms enabled" do
-      it "increments delivery index" do
-        ch = connection.create_channel
-        ch.should_not be_using_publisher_confirmations
-
-        ch.confirm_select
-        ch.should be_using_publisher_confirmations
-
-        q  = ch.queue("", :exclusive => true)
-        x  = ch.default_exchange
-
-        n.times do
-          x.publish("xyzzy", :routing_key => q.name)
-        end
-
-        ch.next_publish_seq_no.should == n + 1
-        ch.wait_for_confirms.should be_true
-        sleep 0.25
-
-        q.message_count.should == n
-        q.purge
-
-        ch.close
-      end
-    end
-  end
-end

data/spec/higher_level_api/integration/publishing_edge_cases_spec.rb

@@ -1,65 +0,0 @@
-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 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)
-        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 => false, :mandatory => true)
-
-        sleep(0.5)
-        q.message_count.should == 1
-
-        envelope, headers, payload = q.pop
-
-        payload.should == ""
-
-        headers[:content_type].should == "application/octet-stream"
-        headers[:delivery_mode].should == 1
-        headers[:priority].should == 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(:user => "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)
-    q.should_not be_server_named
-
-    q.bind("amq.fanout").should == 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)
-    q.should_not be_server_named
-
-    q.bind("amq.fanout")
-    q.unbind("amq.fanout").should == 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}")
-    q.bind(x).should == 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)
-    q.should_not be_server_named
-
-    x  = ch.fanout("bunny.tests.fanout", :auto_delete => true, :durable => false)
-
-    q.bind(x)
-    q.unbind(x).should == 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)
-    q.should be_server_named
-
-    q.bind("amq.fanout").should == q
-
-    ch.close
-  end
-
-  it "can be unbound from a pre-declared exchange" do
-    ch = connection.create_channel
-    q  = ch.queue("", :exclusive => true)
-    q.should be_server_named
-
-    q.bind("amq.fanout")
-    q.unbind("amq.fanout").should == 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}")
-    q.bind(x).should == 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)
-    q.unbind(name).should == q
-
-    x.delete
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/queue_declare_spec.rb

@@ -1,190 +0,0 @@
-require "spec_helper"
-
-describe Bunny::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
-
-  context "when queue name is specified" do
-    let(:name) { "a queue declared at #{Time.now.to_i}" }
-
-    it "declares a new queue with that name" do
-      ch   = connection.create_channel
-
-      q    = ch.queue(name)
-      q.name.should == name
-
-      q.delete
-      ch.close
-    end
-
-    it "caches that queue" do
-      ch   = connection.create_channel
-
-      q = ch.queue(name)
-      ch.queue(name).object_id.should == q.object_id
-
-      q.delete
-      ch.close
-    end
-  end
-
-
-  context "when queue name is passed on as an empty string" do
-    it "uses server-assigned queue name" do
-      ch   = connection.create_channel
-
-      q = ch.queue("")
-      q.name.should_not be_empty
-      q.name.should =~ /^amq.gen.+/
-      q.should be_server_named
-      q.delete
-
-      ch.close
-    end
-  end
-
-
-  context "when queue is declared as durable" do
-    it "declares it as durable" do
-      ch   = connection.create_channel
-
-      q = ch.queue("bunny.tests.queues.durable", :durable => true)
-      q.should be_durable
-      q.should_not be_auto_delete
-      q.should_not be_exclusive
-      q.arguments.should be_nil
-      q.delete
-
-      ch.close
-    end
-  end
-
-
-  context "when queue is declared as exclusive" do
-    it "declares it as exclusive" do
-      ch   = connection.create_channel
-
-      q = ch.queue("bunny.tests.queues.exclusive", :exclusive => true)
-      q.should be_exclusive
-      q.should_not be_durable
-      q.delete
-
-      ch.close
-    end
-  end
-
-
-  context "when queue is declared as auto-delete" do
-    it "declares it as auto-delete" do
-      ch   = connection.create_channel
-
-      q = ch.queue("bunny.tests.queues.auto-delete", :auto_delete => true)
-      q.should be_auto_delete
-      q.should_not be_exclusive
-      q.should_not be_durable
-      q.delete
-
-      ch.close
-    end
-  end
-
-
-
-  context "when queue is declared with a different set of attributes" do
-    it "raises an exception" do
-      ch   = connection.create_channel
-
-      q = ch.queue("bunny.tests.queues.auto-delete", :auto_delete => true, :durable => false)
-      expect {
-        # force re-declaration
-        ch.queue_declare("bunny.tests.queues.auto-delete", :auto_delete => false, :durable => true)
-      }.to raise_error(Bunny::PreconditionFailed)
-
-      ch.should be_closed
-    end
-  end
-
-
-  context "when queue is declared with message TTL" do
-    let(:args) do
-      # in ms
-      {"x-message-ttl" => 1000}
-    end
-
-    it "causes all messages in it to have a TTL" do
-      ch   = connection.create_channel
-
-      q = ch.queue("bunny.tests.queues.with-arguments.ttl", :arguments => args, :exclusive => true)
-      q.arguments.should == args
-
-      q.publish("xyzzy")
-      sleep 0.1
-
-      q.message_count.should == 1
-      sleep 1.5
-      q.message_count.should == 0
-
-      ch.close
-    end
-  end
-
-
-  describe "#queue_exists?" do
-    context "when a queue exists" do
-      it "returns true" do
-        ch = connection.create_channel
-        q  = ch.queue("", :exlusive => true)
-
-        connection.queue_exists?(q.name).should be_true
-      end
-    end
-
-    context "when a queue DOES NOT exist" do
-      it "returns false" do
-        connection.queue_exists?("suf89u9a4jo3ndnakls##{Time.now.to_i}").should be_false
-      end
-    end
-  end
-
-
-
-  unless ENV["CI"]
-    # requires RabbitMQ 3.1+
-    context "when queue is declared with bounded length" do
-      let(:n) { 10 }
-      let(:args) do
-        # in ms
-        {"x-max-length" => n}
-      end
-
-      # see http://www.rabbitmq.com/maxlength.html for more info
-      it "causes the queue to be bounded" do
-        ch   = connection.create_channel
-
-        q = ch.queue("bunny.tests.queues.with-arguments.max-length", :arguments => args, :exclusive => true)
-        q.arguments.should == args
-
-        (n * 10).times do
-          q.publish("xyzzy")
-        end
-
-        q.message_count.should == n
-        (n * 5).times do
-          q.publish("xyzzy")
-        end
-
-        q.message_count.should == n
-        q.delete
-
-        ch.close
-      end
-    end
-  end
-end

data/spec/higher_level_api/integration/queue_delete_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "#delete" 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
-  end
-
-
-
-  context "with a name of an existing queue" do
-    it "deletes that queue" do
-      ch = connection.create_channel
-      q  = ch.queue("")
-
-      q.delete
-      # no exception as of RabbitMQ 3.2. MK.
-      q.delete
-
-      ch.queues.size.should == 0
-    end
-  end
-
-
-  context "with a name of an existing queue" do
-    it "DOES NOT raise an exception" do
-      ch = connection.create_channel
-
-      # no exception as of RabbitMQ 3.2. MK.
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-      ch.queue_delete("sdkhflsdjflskdjflsd#{rand}")
-    end
-  end
-end

data/spec/higher_level_api/integration/queue_purge_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Bunny::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
-  end
-
-
-  it "can be purged" do
-    ch = connection.create_channel
-
-    q  = ch.queue("", :exclusive => true)
-    x  = ch.default_exchange
-
-    x.publish("xyzzy", :routing_key => q.name)
-    sleep(0.5)
-
-    q.message_count.should == 1
-    q.purge
-    q.message_count.should == 0
-
-    ch.close
-  end
-end

data/spec/higher_level_api/integration/queue_unbind_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-describe Bunny::Queue, "bound to an exchange" 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
-  end
-
-
-  it "can be unbound from an exchange it was bound to" do
-    ch = connection.create_channel
-    x  = ch.fanout("amq.fanout")
-    q  = ch.queue("", :exclusive => true).bind(x)
-
-    x.publish("")
-    sleep 0.3
-    q.message_count.should == 1
-
-    q.unbind(x)
-
-    x.publish("")
-    q.message_count.should == 1
-  end
-end
-
-
-
-describe Bunny::Queue, "NOT bound to an exchange" 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
-  end
-
-
-  it "cannot be unbound (raises a channel error)" do
-    ch = connection.create_channel
-    x  = ch.fanout("amq.fanout")
-    q  = ch.queue("", :exclusive => true)
-
-    # No exception as of RabbitMQ 3.2. MK.
-    q.unbind(x)
-    q.unbind(x)
-  end
-end