bunny 0.8.0 → 0.9.0.pre1

data/spec/higher_level_api/integration/basic_nack_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#nack" 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
+
+  subject do
+    connection.create_channel
+  end
+
+  context "with requeue = false" do
+    it "rejects a message" do
+      q = subject.queue("bunny.basic.nack.with-requeue-false", :exclusive => true)
+      x = subject.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.5)
+      q.message_count.should == 1
+      delivery_info, _, content = q.pop(:ack => true)
+
+      subject.nack(delivery_info.delivery_tag, false, false)
+      sleep(0.5)
+      q.message_count.should == 0
+
+      subject.close
+    end
+  end
+
+  context "with multiple = true" do
+    it "rejects multiple messages"
+  end
+end

data/spec/higher_level_api/integration/basic_publish_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe "Publishing a message to the default exchange" 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
+
+
+  context "with all default delivery and message properties" do
+    it "routes messages to a queue with the same name as the routing key" do
+      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(1)
+      q.message_count.should == 4
+
+      ch.close
+    end
+  end
+
+
+  context "with all default delivery and message properties" do
+    it "routes the messages and preserves all the metadata" do
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("xyzzy", :routing_key => q.name, :persistent => true)
+
+      sleep(1)
+      q.message_count.should == 1
+
+      envelope, headers, payload = q.pop
+
+      payload.should == "xyzzy"
+
+      headers[:content_type].should == "application/octet-stream"
+      headers[:delivery_mode].should == 2
+      headers[:priority].should == 0
+
+      ch.close
+    end
+  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 => 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
+end

data/spec/higher_level_api/integration/basic_qos_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#prefetch" 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
+  end
+
+
+  subject do
+    connection.create_channel
+  end
+
+  context "with a positive integer" do
+    it "sets that prefetch level via basic.qos" do
+      subject.prefetch(10).should be_instance_of(AMQ::Protocol::Basic::QosOk)
+    end
+  end
+
+  context "with a negative integer" do
+    it "raises an ArgumentError" do
+      expect {
+        subject.prefetch(-2)
+      }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/higher_level_api/integration/basic_recover_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#recover" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  subject do
+    connection.create_channel
+  end
+
+  it "is supported" do
+    subject.recover(true).should be_instance_of(AMQ::Protocol::Basic::RecoverOk)
+    subject.recover(true).should be_instance_of(AMQ::Protocol::Basic::RecoverOk)
+  end
+end

data/spec/higher_level_api/integration/basic_reject_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#reject" 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
+
+  subject do
+    connection.create_channel
+  end
+
+  context "with requeue = true" do
+    it "requeues a message" do
+      q = subject.queue("bunny.basic.reject.manual-acks", :exclusive => true)
+      x = subject.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.5)
+      q.message_count.should == 1
+      delivery_info, _, _ = q.pop(:ack => true)
+
+      subject.reject(delivery_info.delivery_tag, true)
+      sleep(0.5)
+      q.message_count.should == 1
+
+      subject.close
+    end
+  end
+
+  context "with requeue = false" do
+    it "rejects a message" do
+      q = subject.queue("bunny.basic.reject.with-requeue-false", :exclusive => true)
+      x = subject.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.5)
+      q.message_count.should == 1
+      delivery_info, _, _ = q.pop(:ack => true)
+
+      subject.reject(delivery_info.delivery_tag, false)
+      sleep(0.5)
+      q.message_count.should == 0
+
+      subject.close
+    end
+  end
+end

data/spec/higher_level_api/integration/basic_return_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Bunny::Exchange, "#publish" 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
+
+
+  context "with :mandatory => true and a bad [no routes] routing key" do
+    it "causes a message to be returned" do
+      ch = connection.create_channel
+      x  = ch.default_exchange
+
+      returned = []
+      x.on_return do |basic_deliver, properties, content|
+        returned << content
+      end
+      
+      x.publish("xyzzy", :routing_key => rand.to_s, :mandatory => true)
+      sleep 0.5
+
+      returned.should include("xyzzy")
+
+      ch.close
+    end
+  end
+end

data/spec/higher_level_api/integration/channel_close_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Bunny::Channel, "when closed" 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
+  end
+
+
+  subject do
+    connection.create_channel
+  end
+
+  it "releases the id" do
+    n = subject.number
+
+    subject.should be_open
+    subject.close
+    subject.should be_closed
+
+    # a new channel with the same id can be created
+    connection.create_channel(n)
+  end
+end

data/spec/higher_level_api/integration/channel_flow_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#flow" 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
+  end
+
+
+  subject do
+    connection.create_channel
+  end
+
+  it "is supported" do
+    subject.flow(true).should be_instance_of(AMQ::Protocol::Channel::FlowOk)
+    subject.flow(false).should be_instance_of(AMQ::Protocol::Channel::FlowOk)
+    subject.flow(true).should be_instance_of(AMQ::Protocol::Channel::FlowOk)
+  end
+end

data/spec/higher_level_api/integration/channel_open_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Bunny::Channel, "when opened" 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
+  end
+
+  context "without explicitly provided id" do
+    subject do
+      connection.create_channel
+    end
+
+    it "gets an allocated id and is successfully opened" do
+      connection.should be_connected
+      subject.should be_open
+
+      subject.id.should be > 0
+    end
+  end
+
+
+  context "with explicitly provided id" do
+    subject do
+      connection.create_channel(767)
+    end
+
+    it "uses that id and is successfully opened" do
+      connection.should be_connected
+      subject.should be_open
+
+      subject.id.should == 767
+    end
+  end
+
+
+
+  context "with explicitly provided id that is already taken" do
+    subject do
+      connection.create_channel(767)
+    end
+
+    it "reuses the channel that is already opened" do
+      connection.should be_connected
+      subject.should be_open
+
+      subject.id.should == 767
+
+      connection.create_channel(767).should == subject
+    end
+  end
+end

data/spec/higher_level_api/integration/channel_open_stress_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe "Rapidly opening and closing lots of channels" 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
+  end
+
+  it "works correctly" do
+    xs = Array.new(2000) { connection.create_channel }
+
+    xs.size.should == 2000
+    xs.each do |ch|
+      ch.close
+    end
+  end
+end

data/spec/higher_level_api/integration/confirm_select_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#confirm_select" 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 "is supported" do
+    connection.with_channel do |ch|
+      ch.confirm_select
+    end
+  end
+end

data/spec/higher_level_api/integration/connection_spec.rb

@@ -0,0 +1,340 @@
+require "spec_helper"
+
+describe Bunny::Session do
+  let(:port)     { AMQ::Protocol::DEFAULT_PORT }
+  let(:username) { "guest" }
+
+  let(:tls_port) { AMQ::Protocol::TLS_PORT }
+
+  context "initialized via connection URI" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    context "when schema is not one of [amqp, amqps]" do
+      it "raises ArgumentError" do
+        expect {
+          described_class.new("http://dev.rabbitmq.com")
+        }.to raise_error(ArgumentError, /amqp or amqps schema/)
+      end
+    end
+
+
+    it "handles amqp:// URIs w/o path part" do
+      session = described_class.new("amqp://dev.rabbitmq.com")
+      session.start
+
+      session.vhost.should == "/"
+      session.host.should == "dev.rabbitmq.com"
+      session.port.should == 5672
+      session.ssl?.should be_false
+
+      session.close
+    end
+
+
+    context "when URI ends in a slash" do
+      it "parses vhost as an empty string" do
+        session = described_class.new("amqp://dev.rabbitmq.com/")
+
+        session.hostname.should == "dev.rabbitmq.com"
+        session.port.should == 5672
+        session.vhost.should == ""
+      end
+    end
+
+    context "when URI is amqp://dev.rabbitmq.com/a/path/with/slashes" do
+      it "raises an ArgumentError" do
+        lambda { described_class.new("amqp://dev.rabbitmq.com/a/path/with/slashes") }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+
+
+
+  context "initialized with all defaults" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    subject do
+      Bunny.new
+    end
+
+    it "successfully negotiates the connection" do
+      subject.start
+      subject.should be_connected
+
+      subject.server_properties.should_not be_nil
+      subject.server_capabilities.should_not be_nil
+
+      props = subject.server_properties
+
+      props["product"].should_not be_nil
+      props["platform"].should_not be_nil
+      props["version"].should_not be_nil
+    end
+  end
+
+  context "initialized with TCP connection timeout = 5" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    subject do
+      described_class.new(:connection_timeout => 5)
+    end
+
+    it "successfully connects" do
+      subject.start
+      subject.should be_connected
+
+      subject.server_properties.should_not be_nil
+      subject.server_capabilities.should_not be_nil
+
+      props = subject.server_properties
+
+      props["product"].should_not be_nil
+      props["platform"].should_not be_nil
+      props["version"].should_not be_nil
+    end
+  end
+
+  context "initialized with :host => 127.0.0.1" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    let(:host)  { "127.0.0.1" }
+    subject do
+      described_class.new(:host => host)
+    end
+
+    it "uses hostname = 127.0.0.1" do
+      subject.host.should == host
+      subject.hostname.should == host
+    end
+
+    it "uses port 5672" do
+      subject.port.should == port
+    end
+
+    it "uses username = guest" do
+      subject.username.should == username
+    end
+  end
+
+  context "initialized with :hostname => localhost" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    let(:host)    { "localhost" }
+    let(:subject) { described_class.new(:hostname => host) }
+
+    it "uses hostname = localhost" do
+      subject.host.should == host
+      subject.hostname.should == host
+    end
+
+    it "uses port 5672" do
+      subject.port.should == port
+    end
+
+    it "uses username = guest" do
+      subject.username.should == username
+      subject.user.should == username
+    end
+  end
+
+  context "initialized with :ssl => true" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    let(:subject) { described_class.new(:ssl => true) }
+
+    it "uses TLS port" do
+      subject.port.should == tls_port
+    end
+  end
+
+  context "initialized with :tls => true" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    let(:subject) { described_class.new(:tls => true) }
+
+    it "uses TLS port" do
+      subject.port.should == tls_port
+    end
+  end
+
+
+  context "initialized with :host => 127.0.0.1 and non-default credentials" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    let(:host)     { "127.0.0.1" }
+    # see ./bin/ci/before_build.sh
+    let(:username) { "bunny_gem" }
+    let(:password) { "bunny_password" }
+    let(:vhost)    { "bunny_testbed" }
+
+    subject do
+      described_class.new(:hostname => host, :username => username, :password => password, :virtual_host => vhost)
+    end
+
+    it "successfully connects" do
+      subject.start
+      subject.should be_connected
+
+      subject.server_properties.should_not be_nil
+      subject.server_capabilities.should_not be_nil
+
+      props = subject.server_properties
+
+      props["product"].should_not be_nil
+      props["platform"].should_not be_nil
+      props["version"].should_not be_nil
+    end
+
+    it "uses hostname = 127.0.0.1" do
+      subject.host.should == host
+      subject.hostname.should == host
+    end
+
+    it "uses port 5672" do
+      subject.port.should == port
+    end
+
+    it "uses provided vhost" do
+      subject.vhost.should == vhost
+      subject.virtual_host.should == vhost
+    end
+
+    it "uses provided username" do
+      subject.username.should == username
+    end
+
+    it "uses provided password" do
+      subject.password.should == password
+    end
+  end
+
+
+  context "initialized with :host => 127.0.0.1 and non-default credentials (take 2)" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    let(:host)     { "127.0.0.1" }
+    # see ./bin/ci/before_build.sh
+    let(:username) { "bunny_gem" }
+    let(:password) { "bunny_password" }
+    let(:vhost)    { "bunny_testbed" }
+
+    subject do
+      described_class.new(:hostname => host, :user => username, :pass => password, :vhost => vhost)
+    end
+
+    it "successfully connects" do
+      subject.start
+      subject.should be_connected
+
+      subject.server_properties.should_not be_nil
+      subject.server_capabilities.should_not be_nil
+
+      props = subject.server_properties
+
+      props["product"].should_not be_nil
+      props["platform"].should_not be_nil
+      props["version"].should_not be_nil
+    end
+
+    it "uses hostname = 127.0.0.1" do
+      subject.host.should == host
+      subject.hostname.should == host
+    end
+
+    it "uses port 5672" do
+      subject.port.should == port
+    end
+
+    it "uses provided username" do
+      subject.username.should == username
+    end
+
+    it "uses provided password" do
+      subject.password.should == password
+    end
+  end
+
+
+
+  context "initialized with :host => 127.0.0.1 and non-default credentials (take 2)" do
+    after :each do
+      subject.close if subject.open?
+    end
+
+    let(:host)     { "127.0.0.1" }
+    # see ./bin/ci/before_build.sh
+    let(:username) { "bunny_gem" }
+    let(:password) { "bunny_password" }
+    let(:vhost)    { "bunny_testbed" }
+    let(:interval) { 1 }
+
+    subject do
+      described_class.new(:hostname => host, :user => username, :pass => password, :vhost => vhost, :heartbeat_interval => interval)
+    end
+
+    it "successfully connects" do
+      subject.start
+      subject.should be_connected
+
+      subject.server_properties.should_not be_nil
+      subject.server_capabilities.should_not be_nil
+
+      props = subject.server_properties
+
+      props["product"].should_not be_nil
+      props["platform"].should_not be_nil
+      props["version"].should_not be_nil
+    end
+
+    it "uses provided heartbeat interval" do
+      subject.heartbeat.should == interval
+    end
+  end
+
+
+
+  context "initialized with :host => 127.0.0.1 and INVALID credentials" do
+    let(:host)     { "127.0.0.1" }
+    # see ./bin/ci/before_build.sh
+    let(:username) { "bunny_gem#{Time.now.to_i}" }
+    let(:password) { "sdjkfhsdf8ysd8fy8" }
+    let(:vhost)    { "___sd89aysd98789" }
+
+    subject do
+      described_class.new(:hostname => host, :user => username, :pass => password, :vhost => vhost)
+    end
+
+    it "fails to connect" do
+      lambda do
+        subject.start        
+      end.should raise_error(Bunny::PossibleAuthenticationFailureError)
+    end
+
+    it "uses provided username" do
+      subject.username.should == username
+    end
+
+    it "uses provided password" do
+      subject.password.should == password
+    end
+  end
+end