bunny 0.9.0.rc1 → 0.9.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3593389008586553f21244193e35c325767ee25
-  data.tar.gz: e16cdce6c2dea0e4a01d5847494286e2b64a17ca
+  metadata.gz: 23f16e1a514fe184d1460364e3a04247ddedf75d
+  data.tar.gz: a9e0dbba16677d8671a2e20ead8a0b5aa120b9ac
 SHA512:
-  metadata.gz: 292dc01ab77ceb89f4c6dcd8e3a81f91e90167de8df9461a5da6a1466cb9f705c7f18e22ad3286774c5f18e66a21175c73588cfc609321a87f386e91613e08b7
-  data.tar.gz: efd54687b032919ed942a985d4a7f9c703110bd35faab173eb97de8c8a02e24de8edd1da0a9b00bb96e1a572afe905142ab637b24f94ab8e1834ea11a7803597
+  metadata.gz: ede8a080ddae75c6011790a72fa0cb1d21e13e227cba2e4ab3fc35fc5e8b99649601595061ae4f178b3c965487f91ba75944a22fdf86bc51d144e2cf61ca8839
+  data.tar.gz: 7988d768033079976e984ec930684d195df9ee7dd54e83520149134eed080cec31cbecf83ed4f906e1bcdfbc14b7b90d22445cd0a697826d8b031fe3200d560c

data/.ruby-version

@@ -1 +1 @@
-2.0@amqp
+2.0@rabbitmq

data/ChangeLog.md

@@ -1,7 +1,93 @@
-## Changes between Bunny 0.9.0.pre13 and 0.9.0.pre14
+## Changes between Bunny 0.9.0.rc1 and 0.9.0.rc2
+
+### Channel Now Properly Restarts Consumer Pool
+
+In a case when all consumers are cancelled, `Bunny::Channel`
+will shut down its consumer delivery thread pool.
+
+It will also now mark the pool as not running so that it can be
+started again successfully if new consumers are registered later.
+
+GH issue: #133.
+
+
+### Bunny::Queue#pop_waiting is Removed
+
+A little bit of background: on MRI, the method raised `ThreadErrors`
+reliably. On JRuby, we used a different [internal] queue implementation
+from JDK so it wasn't an issue.
+
+`Timeout.timeout` uses `Thread#kill` and `Thread#join`, both of which
+eventually attempt to acquire a mutex used by Queue#pop, which Bunny
+currently uses for continuations. The mutex is already has an owner
+and so a ThreadError is raised.
+
+This is not a problem on JRuby because there we don't use Ruby's
+Timeout and Queue and instead rely on a JDK concurrency primitive
+which provides "poll with a timeout".
+
+[The issue with `Thread#kill` and `Thread#raise`](http://blog.headius.com/2008/02/ruby-threadraise-threadkill-timeoutrb.html)
+has been first investigated and blogged about by Ruby implementers
+in 2008.
+
+Finding a workaround will probably take a bit of time and may involve
+reimplementing standard library and core classes.
+
+We don't want this issue to block Bunny 0.9 release. Neither we want
+to ship a broken feature.  So as a result, we will drop
+Bunny::Queue#pop_waiting since it cannot be reliably implemented in a
+reasonable amount of time on MRI.
+
+Per issue #131.
+
+
+### More Flexible SSLContext Configuration
+
+Bunny will now upgrade connection to SSL in `Bunny::Session#start`,
+so it is possible to fine tune SSLContext and socket settings
+before that:
+
+``` ruby
+require "bunny"
+
+conn = Bunny.new(:tls                   => true,
+                 :tls_cert              => "examples/tls/client_cert.pem",
+                 :tls_key               => "examples/tls/client_key.pem",
+                 :tls_ca_certificates   => ["./examples/tls/cacert.pem"])
+
+puts conn.transport.socket.inspect
+puts conn.transport.tls_context.inspect
+```
+
+This also means that `Bunny.new` will now open the socket. Previously
+it was only done when `Bunny::Session#start` was invoked.
+
+
+## Changes between Bunny 0.9.0.pre13 and 0.9.0.rc1
+
+### TLS Support
+
+Bunny 0.9 finally supports TLS. There are 3 new options `Bunny.new` takes:
+
+ * `:tls` which, when set to `true`, will set SSL context up and switch to TLS port (5671)
+ * `:tls_cert` which is a string path to the client certificate (public key) in PEM format
+ * `:tls_key` which is a string path to the client key (private key) in PEM format
+ * `:tls_ca_certificates` which is an array of string paths to CA certificates in PEM format
+
+An example:
+
+``` ruby
+conn = Bunny.new(:tls                   => true,
+                 :tls_cert              => "examples/tls/client_cert.pem",
+                 :tls_key               => "examples/tls/client_key.pem",
+                 :tls_ca_certificates   => ["./examples/tls/cacert.pem"])
+```
+
 
 ### Bunny::Queue#pop_waiting
 
+**This function was removed in v0.9.0.rc2**
+
 `Bunny::Queue#pop_waiting` is a new function that mimics `Bunny::Queue#pop`
 but will wait until a message is available. It uses a `:timeout` option and will
 raise an exception if the timeout is hit:
@@ -20,6 +106,13 @@ q.pop_waiting(:timeout => 0.5)
 This method only makes sense for collecting Request/Reply ("RPC") replies.
 
 
+### Bunny::InvalidCommand is now Bunny::CommandInvalid
+
+`Bunny::InvalidCommand` is now `Bunny::CommandInvalid` (follows
+the exception class naming convention based on response status
+name).
+
+
 
 ## Changes between Bunny 0.9.0.pre12 and 0.9.0.pre13
 
@@ -533,7 +626,7 @@ It makes more sense for beginners that way.
 
 `Bunny::Queue#subscribe` support the new `:block` option
 (a boolean).
-    
+
 It controls whether the current thread will be blocked
 by `Bunny::Queue#subscribe`.
 

data/README.md

@@ -1,13 +1,56 @@
 # Bunny, a Ruby RabbitMQ Client
 
-Bunny is a synchronous RabbitMQ client that focuses on ease of use. With the next
-0.9 release (currently in master), it is feature complete, supports all RabbitMQ 3.0
-features and is free of many limitations of earlier versions.
+Bunny is a synchronous RabbitMQ client that focuses on ease of use. It
+is feature complete, supports all RabbitMQ 3.0 features and does not
+have any heavyweight dependencies.
+
+
+## I Know What RabbitMQ and Bunny are, How Do I Get Started?
+
+[Right here](http://rubybunny.info/articles/getting_started.html)!
+
+
+## What is Bunny Good For?
+
+One can use amqp gem to make Ruby applications interoperate with other
+applications (both Ruby and not). Complexity and size may vary from
+simple work queues to complex multi-stage data processing workflows that involve
+many applications built with all kinds of technologies.
+
+Specific examples:
+
+ * Events collectors, metrics & analytics applications can aggregate events produced by various applications
+   (Web and not) in the company network.
+
+ * A Web application may route messages to a Java app that works
+   with SMS delivery gateways.
+
+ * MMO games can use flexible routing RabbitMQ provides to propagate event notifications to players and locations.
+
+ * Price updates from public markets or other sources can be distributed between interested parties, from trading systems to points of sale in a specific geographic region.
+
+ * Content aggregators may update full-text search and geospatial search indexes
+   by delegating actual indexing work to other applications over RabbitMQ.
+
+ * Companies may provide streaming/push APIs to their customers, partners
+   or just general public.
+
+ * Continuous integration systems can distribute builds between multiple machines with various hardware and software
+   configurations using advanced routing features of RabbitMQ.
+
+ * An application that watches updates from a real-time stream (be it markets data
+   or Twitter stream) can propagate updates to interested parties, including
+   Web applications that display that information in the real time.
+
 
 
 ## Supported Ruby Versions
 
-Bunny 0.9 and more recent versions support Ruby 1.9.3, 1.9.2, 2.0, JRuby 1.7, Rubinius 2.0 and 1.8.7.
+Bunny 0.9 and more recent versions support
+
+ * CRuby 1.9.3, 1.9.2, 2.0.0, and 1.8.7
+ * JRuby 1.7+
+ * Rubinius 2.0+
 
 
 ## Supported RabbitMQ Versions
@@ -16,13 +59,20 @@ Bunny `0.8.x` and later versions only support RabbitMQ 2.x and 3.x.
 Bunny `0.7.x` and earlier versions support RabbitMQ 1.x and 2.x.
 
 
-## Changes in Bunny 0.9
+## Project Maturity
 
-Bunny is a very old library with **a lot** of missing functionality. It also implements an older version of the spec
-and may or may not work with future RabbitMQ versions. As such, Bunny needed serious internal changes.
-We (the maintainers) make our best to keep the new version as backwards compatible as possible but within reason.
+Bunny is a pretty old (started circa late 2008) library that, before version 0.9, **a lot** of missing functionality. Version 0.9
+can be considered to be "second birthday" for Bunny as it was rewritten from scratch. Key objectives
+for 0.9 are
 
-See [this announcement](https://groups.google.com/forum/?fromgroups#!topic/ruby-amqp/crNVGEuHm68) to learn more.
+ * Be feature complete, support all RabbitMQ 3.x features
+ * Eliminate limitations Bunny used to have with earlier versions
+ * Be [well documented](http://rubybunny.info)
+ * Make use of concurrency and, if the runtime provides it, parallelism
+ * Reuse code with amqp gem and possibly other clients where it makes sense
+
+We (the maintainers) make our best to keep the new version as
+backwards compatible as possible but within reason.
 
 
 ## Installation & Bundler Dependency
@@ -33,12 +83,12 @@ To install Bunny 0.9.x with RubyGems:
 gem install bunny --pre
 ```
 
-the most recent 0.9.x version is `0.9.0.pre13`.
+the most recent 0.9.x version is `0.9.0.rc1`.
 
 To use Bunny 0.9.x in a project managed with Bundler:
 
 ``` ruby
-gem "bunny", ">= 0.9.0.pre13" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
+gem "bunny", ">= 0.9.0.rc1" # optionally: , :git => "git://github.com/ruby-amqp/bunny.git", :branch => "master"
 ```
 
 
@@ -62,11 +112,8 @@ ch = conn.create_channel
 # declare a queue
 q  = ch.queue("test1")
 
-# default direct exchange is automatically bound to all queues
-e  = ch.default_exchange
-
-# publish a message to the exchange which then gets routed to the queue
-e.publish("Hello, everybody!", :routing_key => 'test1')
+# publish a message to the default exchange which then gets routed to this queue
+q.publish("Hello, everybody!")
 
 # fetch a message from the queue
 delivery_info, metadata, payload = q.pop
@@ -86,7 +133,17 @@ For a 15 minute tutorial using more practical examples, see [Getting Started wit
 
 ### Guides
 
-Other documentation guides are available at [rubybunny.info](http://rubybunny.info).
+Other documentation guides are available at [rubybunny.info](http://rubybunny.info):
+
+ * [Queues and Consumers](http://rubybunny.info/articles/queues.html)
+ * [Exchanges and Publishers](http://rubybunny.info/articles/exchanges.html)
+ * [AMQP 0.9.1 Model Explained](http://www.rabbitmq.com/tutorials/amqp-concepts.html)
+ * [Connecting to RabbitMQ](http://rubybunny.info/articles/connecting.html)
+ * [Error Handling and Recovery](http://rubybunny.info/articles/error_handling.html)
+ * [TLS/SSL Support](http://rubybunny.info/articles/tls.html)
+ * [Bindings](http://rubybunny.info/articles/bindings.html)
+ * [Using RabbitMQ Extensions with Bunny](http://rubybunny.info/articles/extensions.html)
+ * [Durability and Related Matters](http://rubybunny.info/articles/durability.html)
 
 ### API Reference
 
@@ -110,6 +167,11 @@ For more immediate help, please join `#rabbitmq` on `irc.freenode.net`.
 
 To subscribe for announcements of releases, important changes and so on, please follow [@rubyamqp](https://twitter.com/#!/rubyamqp) on Twitter.
 
+More detailed announcements can be found in the blogs
+
+* [RabbitMQ Ruby clients blog](http://blog.rubyrabbitmq.info)
+* [Bunny Blog](http://bunnyamqp.wordpress.com)
+
 
 ### Reporting Issues
 
@@ -144,13 +206,6 @@ After that create a branch and make your changes on it. Once you are done with y
 on GitHub.
 
 
+## License
 
-## Other Resources
-
-* [AMQP 0.9.1 model explained](http://www.rabbitmq.com/tutorials/amqp-concepts.html): introductory explanation of the AMQP v0.9.1 specification with particular reference to RabbitMQ.
-
-
-## Links
-
-* [Source code](http://github.com/ruby-amqp/bunny)
-* [Blog](http://bunnyamqp.wordpress.com)
+Released under the MIT license.

data/bunny.gemspec

@@ -7,9 +7,9 @@ require File.expand_path("../lib/bunny/version", __FILE__)
 Gem::Specification.new do |s|
   s.name = "bunny"
   s.version = Bunny::VERSION.dup
-  s.homepage = "http://github.com/ruby-amqp/bunny"
+  s.homepage = "http://rubybunny.info"
   s.summary = "Popular easy to use Ruby client for RabbitMQ"
-  s.description = "Popular easy to use Ruby client for RabbitMQ"
+  s.description = "Easy to use, feature complete Ruby client for RabbitMQ 2.0."
   s.license = "MIT"
 
   # Sorted alphabetically.

data/lib/bunny/channel.rb

@@ -1690,17 +1690,21 @@ module Bunny
     # publishing). MK.
     # @private
     def maybe_start_consumer_work_pool!
-      @work_pool.start unless @work_pool.started?
+      if @work_pool && !@work_pool.running?
+        @work_pool.start
+      end
     end
 
     # @private
     def maybe_pause_consumer_work_pool!
-      @work_pool.pause if @work_pool && @work_pool.started?
+      @work_pool.pause if @work_pool && @work_pool.running?
     end
 
     # @private
     def maybe_kill_consumer_work_pool!
-      @work_pool.kill if @work_pool && @work_pool.started?
+      if @work_pool && @work_pool.running?
+        @work_pool.kill
+      end
     end
 
     # @private

data/lib/bunny/consumer_work_pool.rb

@@ -31,14 +31,16 @@ module Bunny
         @threads << t
       end
 
-      @started = true
+      @running = true
     end
 
-    def started?
-      @started
+    def running?
+      @running
     end
 
     def shutdown
+      @running = false
+
       @size.times do
         submit do |*args|
           throw :terminate
@@ -51,14 +53,20 @@ module Bunny
     end
 
     def pause
+      @running = false
+
       @threads.each { |t| t.stop }
     end
 
     def resume
+      @running = true
+
       @threads.each { |t| t.run }
     end
 
     def kill
+      @running = false
+
       @threads.each { |t| t.kill }
     end
 

data/lib/bunny/queue.rb

@@ -256,54 +256,6 @@ module Bunny
       end
     end
 
-    # @param [Hash] opts Options
-    #
-    # @option opts [Boolean] :ack (false) Will the message be acknowledged manually?
-    # @option opts [Float] :timeout (1.0) Max amount of time, in seconds, to wait before raising an exception
-    #
-    # @return [Array] Triple of delivery info, message properties and message content.
-    #                 If the queue is empty, all three will be nils.
-    #
-    # @raises [Bunny::ClientException] When no message is available in the amount of time provided via the :timeout option
-    #
-    # @see http://rubybunny.info/articles/queues.html Queues and Consumers guide
-    # @see Bunny::Queue#subscribe
-    # @api public
-    #
-    # @example
-    #   conn = Bunny.new
-    #   conn.start
-    #
-    #   ch   = conn.create_channel
-    #   q = ch.queue("test1")
-    #   x = ch.default_exchange
-    #   x.publish("Hello, everybody!", :routing_key => 'test1')
-    #
-    #   delivery_info, properties, payload = q.pop_waiting(:timeout => 0.5)
-    #
-    #   puts "This is the message: " + payload + "\n\n"
-    #   conn.close
-    def pop_waiting(opts = {:ack => false, :timeout => 1.0}, &block)
-      delivery_info, properties, content = nil, nil, nil
-
-      Bunny::Timer.timeout(opts[:timeout], ClientTimeout) do
-        loop do
-          delivery_info, properties, content = @channel.basic_get(@name, opts)
-
-          if !content.nil?
-            break
-          end
-        end
-      end
-
-      if block
-        block.call(delivery_info, properties, content)
-      else
-        [delivery_info, properties, content]
-      end
-    end
-    alias get_waiting pop_waiting
-
 
     # Publishes a message to the queue via default exchange. Takes the same arguments
     # as {Bunny::Exchange#publish}

data/lib/bunny/session.rb

@@ -178,11 +178,7 @@ module Bunny
     def configure_socket(&block)
       raise ArgumentError, "No block provided!" if block.nil?
 
-      if @transport
-        @transport.configure_socket(&block)
-      else
-        @socket_configurator = block
-      end
+      @transport.configure_socket(&block)
     end
 
     # Starts the connection process.
@@ -199,10 +195,9 @@ module Bunny
       begin
         # close existing transport if we have one,
         # to not leak sockets
-        self.maybe_close_transport
-        self.initialize_transport
+        @transport.maybe_initialize_socket
 
-        @transport.initialize_socket
+        @transport.post_initialize_socket
         @transport.connect
 
         if @socket_configurator

data/lib/bunny/transport.rb

@@ -49,6 +49,9 @@ module Bunny
       @disconnect_timeout = @read_write_timeout || @connect_timeout
 
       @writes_mutex       = Mutex.new
+
+      maybe_initialize_socket
+      prepare_tls_context if @tls_enabled
     end
 
 
@@ -71,15 +74,26 @@ module Bunny
       if uses_ssl?
         @socket.connect
         @socket.post_connection_check(host) if uses_tls? && @verify_peer
+
+        @status = :connected
+
+        @socket
       else
         # no-op
       end
     end
 
+    def connected?
+      :not_connected == @status && open?
+    end
+
     def configure_socket(&block)
-      block.call(@socket)
+      block.call(@socket) if @socket
     end
 
+    def configure_tls_context(&block)
+      block.call(@tls_context) if @tls_context
+    end
 
     # Writes data to the socket. If read/write timeout was specified, Bunny::ClientTimeout will be raised
     # if the operation times out.
@@ -102,6 +116,7 @@ module Bunny
         end
       rescue SystemCallError, Bunny::ClientTimeout, Bunny::ConnectionError, IOError => e
         close
+        @status = :not_connected
 
         if @session.automatically_recover?
           @session.handle_network_failure(e)
@@ -153,11 +168,11 @@ module Bunny
 
 
     def close(reason = nil)
-      @socket.close if @socket && !@socket.closed?
+      @socket.close if open?
     end
 
     def open?
-      !@socket.closed?
+      @socket && !@socket.closed?
     end
 
     def closed?
@@ -224,17 +239,11 @@ module Bunny
 
     def initialize_socket
       begin
-        s = Bunny::Timer.timeout(@connect_timeout, ConnectionTimeout) do
+        @socket = Bunny::Timer.timeout(@connect_timeout, ConnectionTimeout) do
           Bunny::Socket.open(@host, @port,
                              :keepalive      => @opts[:keepalive],
                              :socket_timeout => @connect_timeout)
         end
-
-        @socket =  if uses_tls?
-                     wrap_in_tls_socket(s)
-                   else
-                     s
-                   end
       rescue StandardError, ConnectionTimeout => e
         @status = :not_connected
         raise Bunny::TCPConnectionFailed.new(e, self.hostname, self.port)
@@ -243,6 +252,18 @@ module Bunny
       @socket
     end
 
+    def maybe_initialize_socket
+      initialize_socket if !@socket || closed?
+    end
+
+    def post_initialize_socket
+      @socket = if uses_tls?
+                  wrap_in_tls_socket(@socket)
+                else
+                  @socket
+                end
+    end
+
     protected
 
     def tls_enabled?(opts)
@@ -257,10 +278,15 @@ module Bunny
       opts[:tls_key] || opts[:ssl_key] || opts[:tls_key_path] || opts[:ssl_key_path]
     end
 
-    def wrap_in_tls_socket(socket)
+    def prepare_tls_context
       read_tls_keys!
 
       @tls_context = initialize_tls_context(OpenSSL::SSL::SSLContext.new)
+    end
+
+    def wrap_in_tls_socket(socket)
+      raise ArgumentError, "cannot wrap nil into TLS socket, @tls_context is nil. This is a Bunny bug." unless socket
+      raise "cannot wrap a socket into TLS socket, @tls_context is nil. This is a Bunny bug." unless @tls_context
 
       s = Bunny::SSLSocket.new(socket, @tls_context)
       s.sync_close = true

data/lib/bunny/version.rb

@@ -2,5 +2,5 @@
 
 module Bunny
   # @return [String] Version of the library
-  VERSION = "0.9.0.rc1"
+  VERSION = "0.9.0.rc2"
 end

data/spec/higher_level_api/integration/basic_consume_spec.rb

@@ -114,5 +114,54 @@ describe Bunny::Queue, "#subscribe" do
         ch.close
       end
     end
+  end # 20.times
+
+
+  context "after consumer pool has already been shut down" do
+    let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+    it "registers the consumer" do
+      delivered_keys = []
+      delivered_data = []
+
+      t = Thread.new do
+        ch = connection.create_channel
+        q  = ch.queue(queue_name)
+
+
+
+        c1  = q.subscribe(:exclusive => false, :manual_ack => false, :block => false) do |delivery_info, properties, payload|
+        end
+        c1.cancel
+        puts "Cancelled #{c1.consumer_tag}"
+
+        c2  = q.subscribe(:exclusive => false, :manual_ack => false, :block => false) do |delivery_info, properties, payload|
+          delivered_keys << delivery_info.routing_key
+          delivered_data << payload
+        end
+        c2.cancel
+        puts "Cancelled #{c2.consumer_tag}"
+
+        q.subscribe(:exclusive => false, :manual_ack => false, :block => true) 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).message_count.should == 0
+
+      ch.close
+    end
   end
-end
+
+end # describe

data/spec/higher_level_api/integration/basic_get_spec.rb

@@ -2,7 +2,8 @@ require "spec_helper"
 
 describe Bunny::Queue, "#pop" do
   let(:connection) do
-    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed",
+                  :automatically_recover => false)
     c.start
     c
   end
@@ -30,25 +31,6 @@ describe Bunny::Queue, "#pop" do
   end
 
 
-  context "with all defaults and a timeout that is never hit" do
-    it "fetches a messages which is automatically acknowledged" do
-      ch = connection.create_channel
-
-      q  = ch.queue("", :exclusive => true)
-      x  = ch.default_exchange
-
-      x.publish("xyzzy", :routing_key => q.name)
-
-      sleep(0.5)
-      delivery_info, properties, content = q.pop_waiting(:timeout => 1.0)
-      content.should == "xyzzy"
-      q.message_count.should == 0
-
-      ch.close
-    end
-  end
-
-
   context "with an empty queue" do
     it "returns an empty response" do
       ch = connection.create_channel
@@ -63,20 +45,4 @@ describe Bunny::Queue, "#pop" do
       ch.close
     end
   end
-
-
-  context "with an empty queue and a timeout" do
-    it "raises an exception" do
-      ch = connection.create_channel
-
-      q  = ch.queue("", :exclusive => true)
-      q.purge
-
-      lambda {
-        _, _, content = q.pop_waiting(:timeout => 0.5)
-      }.should raise_error(Timeout::Error)
-
-      ch.close
-    end
-  end
 end

data/spec/higher_level_api/integration/connection_spec.rb

@@ -153,27 +153,37 @@ describe Bunny::Session do
     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
+  unless ENV["CI"]
+    context "initialized with :ssl => true" do
+      let(:subject) do
+        described_class.new(:user     => "bunny_gem",
+                            :password => "bunny_password",
+                            :vhost    => "bunny_testbed",
+                            :ssl                   => true,
+                            :ssl_cert              => "spec/tls/client_cert.pem",
+                            :ssl_key               => "spec/tls/client_key.pem",
+                            :ssl_ca_certificates   => ["./spec/tls/cacert.pem"])
+      end
 
-  context "initialized with :tls => true" do
-    after :each do
-      subject.close if subject.open?
+      it "uses TLS port" do
+        subject.port.should == tls_port
+      end
     end
 
-    let(:subject) { described_class.new(:tls => true) }
+    context "initialized with :tls => true" do
+      let(:subject) do
+        described_class.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"])
+      end
 
-    it "uses TLS port" do
-      subject.port.should == tls_port
+      it "uses TLS port" do
+        subject.port.should == tls_port
+      end
     end
   end
 
@@ -346,19 +356,17 @@ describe Bunny::Session do
 
 
   context "initialized with a disconnected host" do
-    subject do
-      described_class.new(:port => 38000)
-    end
-
     it "fails to connect" do
       lambda do
-        subject.start
+        c = described_class.new(:port => 38000)
+        c.start
       end.should raise_error(Bunny::TCPConnectionFailed)
     end
 
     it "is not connected" do
       begin
-        subject.start
+        c = described_class.new(:port => 38000)
+        c.start
       rescue Bunny::TCPConnectionFailed => e
         true
       end
@@ -368,7 +376,8 @@ describe Bunny::Session do
 
     it "is not open" do
       begin
-        subject.start
+        c = described_class.new(:port => 38000)
+        c.start
       rescue Bunny::TCPConnectionFailed => e
         true
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bunny
 version: !ruby/object:Gem::Version
-  version: 0.9.0.rc1
+  version: 0.9.0.rc2
 platform: ruby
 authors:
 - Chris Duncan
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-14 00:00:00.000000000 Z
+date: 2013-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amq-protocol
@@ -28,7 +28,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 1.6.0
-description: Popular easy to use Ruby client for RabbitMQ
+description: Easy to use, feature complete Ruby client for RabbitMQ 2.0.
 email:
 - celldee@gmail.com
 - eric@5stops.com
@@ -178,7 +178,7 @@ files:
 - spec/unit/concurrent/condition_spec.rb
 - spec/unit/concurrent/linked_continuation_queue_spec.rb
 - spec/unit/transport_spec.rb
-homepage: http://github.com/ruby-amqp/bunny
+homepage: http://rubybunny.info
 licenses:
 - MIT
 metadata: {}