hot_tub 0.1.1 → 0.2.0

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 gem 'rake'
 
 group :development do
+	gem 'excon'
   platform :ruby do
     gem 'eventmachine'
     gem 'em-http-request', '~> 1.0', :require => 'em-http'

data/README.md

@@ -1,5 +1,5 @@
 # HotTub [![Build Status](https://travis-ci.org/JoshMcKin/hot_tub.png?branch=master)](https://travis-ci.org/JoshMcKin/hot_tub)
-A simple thread-safe connection pooling gem. Supports [HTTPClient](https://github.com/nahi/httpclient) (default) and
+A simple thread-safe connection pooling gem. Out-of-the-box support for [Excon](https://github.com/geemus/excon) and
 [EM-Http-Requests](https://github.com/igrigorik/em-http-request) via [EM-Synchrony](https://github.com/igrigorik/em-synchrony). 
 There are a couple Ruby connection pool libraries out there but HotTub differs from most in that its connections are lazy 
 (created only when necessary), accomidates libraries that do not clean their dirty connections automatically, and manages unexpected usage increases by opening new connections rather than just blocking or throwing exceptions (never_block), although never_block can be disabled. 
@@ -12,14 +12,15 @@ HotTub is available through [Rubygems](https://rubygems.org/gems/hot_tub) and ca
 
 ## Usage 
 
-### Default (HTTPClient)
+### Excon
 
+    require 'excon'
     class MyClass
       @@url = "http://test12345.com"
-      @@pool = HotTub::Pool.new({:size => 10})
+      @@pool = HotTub::Pool.new({:size => 10}) { Excon.new("http://somewebservice.com") }
       def self.fetch_results(url,query={})
         @@pool.run |connection|
-          connection.get(@@url,query).body
+          connection.get(:query => query).body
         end
       end
     end
@@ -47,6 +48,7 @@ HotTub is available through [Rubygems](https://rubygems.org/gems/hot_tub) and ca
  You can use any libary you want. Close and clean can be defined at initialization with
  lambdas, if they are not defined they are ignored.
 
+    require 'excon'
     class MyClass
       @@url = "http://test12345.com"
       @@pool = HotTub::Pool.new({:size => 10, :close => lambda {|clnt| clnt.close}}) { MyHttpLib.new }
@@ -59,18 +61,33 @@ HotTub is available through [Rubygems](https://rubygems.org/gems/hot_tub) and ca
 
     MyClass.fetch_results({:foo => "goo"}) # => "Some reponse"
 
-## Sessions
-
-HTTPClient has a built in thread-safe sessions feature that allows a single client to access multiple domains. 
-Not all clients have a sessions feature, Em-Http-Request clients are initialized to a single domain and while you
+## Sessions with Pool
+Not all clients have a sessions feature, Excon and Em-Http-Request clients are initialized to a single domain and while you
 can change paths the client domain cannot change. HotTub::Session allows you create a session object that initializes
-seperate pools for you various domains based on URI.
+seperate pools for your various domains based on URI. Options are passed to the pool when each pool is initialized.
 
-    # Assuming EM is running
-    require 'hot_tub/clients/em_http_request_client'
-    class EMClass
+    require 'excon'
+    class MyClass
+      # Our client block must accept the url argument
+      @@sessons = HotTub::Sessions.new(:size => 10) {|url| { Excon.new(url) } 
+      def async_post_results(query = {})
+        @@sessons.run("http://somewebservice.com") do |connection|    
+          puts connection.run(:query => results).response_header.status
+        end
+        @@sessons.run("https://someotherwebservice.com") do |connection|    
+          puts connection.get(:query => results).response_header.status
+        end
+      end
+    end
+
+## Sessions without Pool
+If you have a client that is thread safe but does not support sessions you can implement sessions similarly. Excon
+is thread safe but you are using a single client, so you may loose preformance with multithreading.
+    
+    require 'excon'
+    class MyClass
       # Our client block must accept the url argument
-      @@sessons = HotTub::Sessions.new {|url| HotTub::EmHttpRequestClient.new(url,{:connect_timeout => 5}) }
+      @@sessons = HotTub::Sessions.new(:with_pool => false) {|url| Excon.new(url) }
       def async_post_results(query = {})
         @@sessons.run("http://somewebservice.com") do |connection|    
           puts connection.get(:query => results).response_header.status
@@ -83,9 +100,10 @@ seperate pools for you various domains based on URI.
 
 ## Related
 
-* [HTTPClient](https://github.com/nahi/httpclient)
 * [EM-Http-Request](https://github.com/igrigorik/em-http-request)
 * [EM-Synchrony](https://github.com/igrigorik/em-synchrony)
+* [Excon](https://github.com/geemus/excon)
+* [HTTPClient](https://github.com/nahi/httpclient) A thread safe http client that supports sessions all by itself.
 
 ## Other Pooling Gem
 

data/hot_tub.gemspec

@@ -13,7 +13,6 @@ Gem::Specification.new do |s|
   s.description = %q{A simple thread-safe http connection pooling gem. Http client options include HTTPClient and EM-Http-Request}
 
   s.rubyforge_project = "hot_tub"
-  s.add_runtime_dependency "httpclient"
   s.add_development_dependency "rspec"
   
   s.files         = `git ls-files`.split("\n")

data/lib/hot_tub/pool.rb

@@ -1,13 +1,9 @@
-require 'httpclient'
 module HotTub
   class Pool
     attr_reader :current_size
     KNOWN_CLIENTS = {
-      "HTTPClient" => {
-        :close => lambda { |clnt|
-          sessions = clnt.instance_variable_get(:@session_manager)
-          sessions.reset_all if sessions
-        }
+      "Excon::Connection" => {
+        :close => lambda { |clnt| clnt.reset }
       },
       'EventMachine::HttpConnection' => {
         :close => lambda { |clnt|
@@ -27,15 +23,13 @@ module HotTub
       }
     }
 
-    # Generic lazy connection pool of HTTP clients
-    # The default client is HTTPClient.
-    # Clients must respond to :clean, :close, and :run
+    # Thread-safe lazy connection pool
     #
-    # == Example (HTTPClient)
-    #     pool = HotTub::Pool.new(:size => 25)
-    #     pool.run {|clnt| clnt.get('http://test.com').body }
+    # == Example Excon
+    #     pool = HotTub::Pool.new(:size => 25)  { Excon.new('http://test.com') }
+    #     pool.run {|clnt| clnt.get.body }
     #
-    # == Example with different client
+    # == Example EM-Http-Request
     #     pool = HotTub::Pool.new { EM::HttpRequest.new("http://somewebservice.com") }
     #     pool.run {|clnt| clnt.get(:keepalive => true).body }
     #
@@ -46,17 +40,18 @@ module HotTub
     # add new connections set :never_block to false; blocking_timeout defaults to 10 seconds.
     #
     # == Example without #never_block (will BlockingTimeout exception)
-    #     pool = HotTub::Pool.new(:size => 1, :never_block => false, :blocking_timeout => 0.5)
+    #     pool = HotTub::Pool.new(:size => 1, :never_block => false, :blocking_timeout => 0.5) { Excon.new('http://test.com') }
     #
     #     begin
-    #       pool.run {|clnt| clnt.get('http://test.com').body }
+    #       pool.run {|clnt| clnt.get.body }
     #     rescue HotTub::BlockingTimeout => e
     #       puts "Our pool ran out: {e}"
     #     end
     #
     def initialize(options={},&client_block)
+      raise ArgumentError, 'a block that initializes a new client is required' unless block_given?
       at_exit { close_all } # close connections at exit
-      @client_block = (block_given? ? client_block : lambda { HTTPClient.new })
+      @client_block = client_block
       @options = {
         :size => 5,
         :never_block => true,     # Return new client if we run out

data/lib/hot_tub/session.rb

@@ -2,15 +2,14 @@ require 'uri'
 module HotTub
   class Session
 
-    # A HotTub::Session is a synchronized hash used to separate HotTub::Pools by their domain.
-    # EmHttpRequest clients are initialized to a specific domain, so we sometimes need a way to
-    # manage multiple pools like when a process need to connect to various AWS resources. Sessions
-    # are unnecessary for HTTPClient because the client has its own threads safe sessions object.
+    # A HotTub::Session is a synchronized hash used to separate pools/clients by their domain.
+    # Excon and EmHttpRequest clients are initialized to a specific domain, so we sometimes need a way to
+    # manage multiple pools like when a process need to connect to various AWS resources.
     # Example:
     #
-    #   sessions = HotTub::Session.new(:client_options => {:connect_timeout => 10})
+    #   sessions = HotTub::Session.new(:client_options => {:connect_timeout => 10}) { |url| Excon.new(url) }
     #
-    #   sessions.run("https://wwww.yahoo.com") do |conn|
+    #   sessions.run("http://wwww.yahoo.com") do |conn|
     #     p conn.head.response_header.status
     #   end
     #
@@ -23,7 +22,7 @@ module HotTub
     # EmHttpRequest, accepting a URI and options see: hot_tub/clients/em_http_request_client.rb
     # Example Custom Client:
     #
-    #   sessions = HotTub::Session.new(:client_class => MyClient, :client_options => {:connect_timeout => 10})
+    #   sessions = HotTub::Session.new({:never_block => false})  { |url| Excon.new(url) }
     #
     #   sessions.run("https://wwww.yahoo.com") do |conn|
     #     p conn.head.response_header.status # => create pool for "https://wwww.yahoo.com"
@@ -34,21 +33,35 @@ module HotTub
     #   end
     def initialize(options={},&client_block)
       raise ArgumentError, "HotTub::Sessions requre a block on initialization that accepts a single argument" unless block_given?
+      @options = {:with_pool => true}.merge(options)
       @client_block = client_block
-      @options = {
-        :size => 5,
-        :never_block => true,
-        :blocking_timeout => 10,
-        :client_class => nil, # EmHttpRequestClient
-        :client_options => {}
-      }.merge(options || {})
       @sessions = Hash.new
       @mutex = (HotTub.em? ? EM::Synchrony::Thread::Mutex.new : Mutex.new)
     end
 
-    # Synchronize access to our key hash
+    # Synchronizes initialization of our sessions
     # expects a url string or URI
     def sessions(url)
+      key = to_key(url)
+      return @sessions[key] if @sessions[key]
+      @mutex.synchronize do
+        if @options[:with_pool]
+          @sessions[key] ||= HotTub::Pool.new(@options) { @client_block.call(url) } 
+        else
+          @sessions[key] ||= @client_block.call(url)
+        end
+      end
+    end
+
+    def run(url,&block)
+      session = sessions(url)
+      return session.run(&block) if @options[:with_pool]
+      block.call(sessions(url))
+    end
+
+    private
+
+    def to_key(url)
       if url.is_a?(String)
         uri = URI(url)
       elsif url.is_a?(URI)
@@ -56,17 +69,7 @@ module HotTub
       else
         raise ArgumentError, "you must pass a string or a URI object"
       end
-      key = "#{uri.scheme}-#{uri.host}"
-      return @sessions[key] if @sessions[key]
-      @mutex.synchronize do
-        @sessions[key] ||= HotTub::Pool.new(@options) { @client_block.call(url) }
-      end
-    end
-
-    # Hand off to pool.run
-    def run(url,&block)
-      pool = sessions(url)
-      pool.run(&block) if pool
+      "#{uri.scheme}-#{uri.host}"
     end
   end
 end

data/lib/hot_tub/version.rb

@@ -1,3 +1,3 @@
 module HotTub
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/spec/pool_spec.rb

@@ -7,7 +7,7 @@ describe HotTub::Pool do
 
   context 'default settings' do
     before(:each) do
-      @pool = HotTub::Pool.new()
+      @pool = HotTub::Pool.new { MocClient.new }
     end
 
     it "should have :size of 5" do
@@ -18,8 +18,8 @@ describe HotTub::Pool do
       @pool.instance_variable_get(:@options)[:blocking_timeout].should eql(10)
     end
 
-    it "should have default :client" do
-      @pool.instance_variable_get(:@client_block).call.should be_a(HTTPClient)
+    it "should have set the client" do
+      @pool.instance_variable_get(:@client_block).call.should be_a(MocClient)
     end
 
     it "should be true" do
@@ -40,10 +40,6 @@ describe HotTub::Pool do
       @pool.instance_variable_get(:@options)[:blocking_timeout].should eql(1.0)
     end
 
-    it "should have defult :client" do
-      @pool.instance_variable_get(:@client_block).call.should be_a(MocClient)
-    end
-
     it "should be true" do
       @pool.instance_variable_get(:@options)[:never_block].should be_false
     end
@@ -51,7 +47,7 @@ describe HotTub::Pool do
 
   describe '#run' do
     before(:each) do
-      @pool = HotTub::Pool.new
+      @pool = HotTub::Pool.new { MocClient.new}
     end
 
     it "should remove connection from pool when doing work" do
@@ -70,17 +66,9 @@ describe HotTub::Pool do
     end
 
     it "should work" do
-      status = 0
-      @pool.run{|clnt| status = clnt.head('https://www.google.com').status}
-      status.should eql(200)
-    end
-
-    context "block given" do
-      it "should call the supplied block" do
-        status = nil
-        @pool.run { |con| status = con.get('https://google.com').status}
-        status.should_not be_nil
-      end
+      result = nil
+      @pool.run{|clnt| result = clnt.get}
+      result.should_not be_nil
     end
 
     context 'block not given' do
@@ -92,7 +80,7 @@ describe HotTub::Pool do
 
   describe '#close_all' do
     before(:each) do
-      @pool = HotTub::Pool.new(:size => 5)
+      @pool = HotTub::Pool.new(:size => 5) { MocClient.new }
       5.times do
         @pool.send(:add)
       end
@@ -111,7 +99,7 @@ describe HotTub::Pool do
   context 'private methods' do
     before(:each) do
       @url = "http://www.testurl123.com/"
-      @pool = HotTub::Pool.new()
+      @pool = HotTub::Pool.new { MocClient.new}
     end
 
     describe '#client' do
@@ -121,8 +109,8 @@ describe HotTub::Pool do
         lambda { puts @pool.send(:client) }.should raise_error(HotTub::BlockingTimeout)
       end
 
-      it "should return an instance of the driver" do
-        @pool.send(:client).should be_instance_of(HTTPClient)
+      it "should return an instance of the client" do
+        @pool.send(:client).should be_instance_of(MocClient)
       end
     end
 
@@ -151,13 +139,13 @@ describe HotTub::Pool do
   context 'thread safety' do
     it "should work" do
       url = "https://www.google.com/"
-      pool = HotTub::Pool.new({:size => 20})
+      pool = HotTub::Pool.new({:size => 10}) { MocClient.new }
       failed = false
       lambda {
         threads = []
         20.times.each do
           threads << Thread.new do
-            pool.run{|connection| failed = true unless connection.head(url).status == 200}
+            pool.run{|connection| connection.get }
           end
         end
         sleep(0.01)
@@ -165,15 +153,13 @@ describe HotTub::Pool do
           t.join
         end
       }.should_not raise_error
-      pool.instance_variable_get(:@pool).length.should eql(20) # make sure work got done
-      failed.should be_false # Make sure our requests woked
+      pool.instance_variable_get(:@pool).length.should eql(10) # make sure work got done
     end
   end
 
   context "other http client" do
     before(:each) do
-      @url = "https://www.google.com"
-      @pool = HotTub::Pool.new(:clean => lambda {|clnt| clnt.clean}) {MocClient.new(@url)}
+      @pool = HotTub::Pool.new(:clean => lambda {|clnt| clnt.clean}) {MocClient.new}
     end
 
     it "should clean connections" do
@@ -183,6 +169,39 @@ describe HotTub::Pool do
     end
   end
 
+  context 'Excon' do
+    before(:each) do
+      @pool = HotTub::Pool.new(:size => 10) { Excon.new('https://www.google.com')}
+    end
+    it "should work" do
+      result = nil
+      @pool.run{|clnt| result = clnt.head.status}
+      result.should eql(200)
+    end
+    context 'threads' do
+      it "should work" do
+        url = "https://www.google.com/"
+        failed = false
+        threads = []
+        lambda {
+          20.times.each do
+            threads << Thread.new do
+              @pool.run{|connection| Thread.current[:status] = connection.head.status }
+            end
+          end
+          sleep(0.01)
+          threads.each do |t|
+            t.join
+          end
+        }.should_not raise_error
+        @pool.instance_variable_get(:@pool).length.should eql(10) # make sure work got done
+        results = threads.collect{ |t| t[:status]}
+        results.length.should eql(20) # make sure all threads are present
+        results.uniq.should eql([200]) # make sure all returned status 200
+      end
+    end
+  end
+
   unless HotTub.jruby?
     context 'EM:HTTPRequest' do
       before(:each) do

data/spec/session_spec.rb

@@ -1,123 +1,140 @@
 require 'spec_helper'
 require 'hot_tub/session'
 require 'uri'
+require 'time'
 describe HotTub::Session do
 
-  it "should raise error if block is not supplied" do
-    lambda {HotTub::Session.new}.should raise_error(ArgumentError)
+  context 'initialized without a block' do
+    it "should raise error if block is not supplied" do
+      lambda {HotTub::Session.new}.should raise_error(ArgumentError)
+    end
   end
-
-  context 'default settings' do
+  context 'initialized with a block' do
     before(:each) do
-      @url = "http://www.testurl123.com/"
-      @tub = HotTub::Session.new { |url| MocClient.new(url) }
-      @options = @tub.instance_variable_get(:@options)
-    end
-
-    it "should have :size of 5" do
-      @options[:size].should eql(5)
+      @url = "https://www.somewebsite.com"
+      @uri = URI(@url)
+      @sessions = HotTub::Session.new { |url| MocClient.new(url) }
     end
 
-    it "should have :blocking_timeout of 10 seconds" do
-      @options[:blocking_timeout].should eql(10)
+    context 'default options' do
+      describe ':with_pool' do
+        it "with_pool should be true" do
+          @sessions.instance_variable_get(:@options)[:with_pool].should be_true
+        end
+      end
     end
 
-    it "should default never_block to true" do
-      @options[:never_block].should be_true
-    end
-  end
+    describe '#to_url' do
+      context "passed URL string" do
+        it "should return key with URI scheme-domain" do
+          @sessions.send(:to_key,@url).should eql("#{@uri.scheme}-#{@uri.host}")
+        end
+      end
 
-  context 'passed options' do
-    before(:each) do
-      @url = "http://www.testurl123.com/"
-      @tub = HotTub::Session.new({:size => 21, :never_block => false}) { |url| MocClient.new(url) }
-      @options = @tub.instance_variable_get(:@options)
-    end
+      context "passed URI" do
+        it "should return key with URI scheme-domain" do
+          @sessions.send(:to_key,@uri).should eql("#{@uri.scheme}-#{@uri.host}")
+        end
+      end
 
-    it "should have @pool_size of 21" do
-      @options[:size].should eql(21)
+      context "invalid argument" do
+        it "should raise an ArgumentError" do
+          lambda { @sessions.send(:to_key, nil) }.should raise_error(ArgumentError)
+        end
+        it  "should raise URI::InvalidURIError with bad url" do
+          lambda { @sessions.send(:to_key,"bad url") }.should raise_error(URI::InvalidURIError)
+        end
+      end
     end
 
-    it "should have never_block be false" do
-      @options[:never_block].should be_false
-    end
-  end
+    describe '#sessions' do
 
-  describe '#sessions' do
-    before(:each) do
-      @url = "https://www.google.com"
-      @uri = URI(@url)
-      @tub = HotTub::Session.new({:size => 21, :never_block => false}) { |url| MocClient.new(url) }
-    end
-    
-    it "should add a new pool for the url" do
-      @tub.sessions(@url)
-      sessions = @tub.instance_variable_get(:@sessions)
-      sessions.length.should eql(1)
-      sessions.first[1].should be_a(HotTub::Pool)
-    end
+      context ':with_pool is true (default)' do
+        it "should add a new pool for the url" do
+          @sessions.sessions(@url)
+          sessions = @sessions.instance_variable_get(:@sessions)
+          sessions.length.should eql(1)
+          sessions.first[1].should be_a(HotTub::Pool)
+        end
 
-    context "passed URL string" do
-      it "should set key with URI scheme-domain" do
-        @tub.sessions(@url)
-        sessions = @tub.instance_variable_get(:@sessions)
-        sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(HotTub::Pool)
+        it "should pass options to pool" do
+          with_pool_options = HotTub::Session.new(:size => 13, :never_block => false) { |url| MocClient.new(url) }
+          with_pool_options.sessions(@url)
+          sessions = with_pool_options.instance_variable_get(:@sessions)
+          pool_options = sessions.first[1].instance_variable_get(:@options)
+          pool_options[:size].should eql(13)
+          pool_options[:never_block].should be_false
+        end
       end
-    end
 
-    context "passed URI" do
-      it "should set key with URI scheme-domain" do
-        @tub.sessions(@uri)
-        sessions = @tub.instance_variable_get(:@sessions)
-        sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(HotTub::Pool)
+      context ':with_pool is false' do
+        it "should add a new client for the url" do
+          no_pool = HotTub::Session.new(:with_pool => false) { |url| MocClient.new(url) }
+          no_pool.sessions(@url)
+          sessions = no_pool.instance_variable_get(:@sessions)
+          sessions.length.should eql(1)
+          sessions.first[1].should be_a(MocClient)
+        end
       end
-    end
-
-    context "invalid argument" do
-      it "should raise an ArgumentError" do
-        lambda { @tub.sessions(nil) }.should raise_error(ArgumentError)
 
+      context "passed URL string" do
+        it "should set key with URI scheme-domain" do
+          @sessions.sessions(@url)
+          sessions = @sessions.instance_variable_get(:@sessions)
+          sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(HotTub::Pool)
+        end
       end
-      it  "should raise URI::InvalidURIError with bad url" do
-        lambda { @tub.sessions("bad url") }.should raise_error(URI::InvalidURIError)
+      context "passed URI" do
+        it "should set key with URI scheme-domain" do
+          @sessions.sessions(@uri)
+          sessions = @sessions.instance_variable_get(:@sessions)
+          sessions["#{@uri.scheme}-#{@uri.host}"].should be_a(HotTub::Pool)
+        end
       end
     end
-  end
-  describe '#run' do
-    it "should work" do
-      @url = "https://www.google.com"
-      @tub = HotTub::Session.new({:size => 21, :never_block => false}) { |url| HTTPClient.new }
-      status = 0
-      @tub.run(@url) do |conn|
-        status =  conn.head(@url).status
+
+    describe '#run' do
+      it "should work" do
+        @url = "https://www.somewebsite.com"
+        @sessions = HotTub::Session.new { |url| MocClient.new(url) }
+        result = nil
+        @sessions.run(@url) do |conn|
+          result = conn.get
+        end
+        result.should_not be_nil
       end
-      status.should eql(200)
     end
-  end
 
-  context 'thread safety' do
-    it "should work" do
-      url = "https://www.google.com/"
-      url2 = "https://www.yahoo.com/"
-      session = HotTub::Session.new({:size => 20}) { |a_url| HTTPClient.new}
-      failed = false
-      lambda {
+    context 'thread safety' do
+      it "should work" do
+        url = "https://www.somewebsite.com/"
+        url2 = "http://www.someotherwebsit.com/"
+        session = HotTub::Session.new { |url| MocClient.new(url)}
+        failed = false
+        start_time = Time.now
+        stop_time = nil
+        mutex = Mutex.new
         threads = []
-        20.times.each do
-          threads << Thread.new do
-            session.run(url){|connection| failed = true unless connection.head(url).status == 200}
-            session.run(url2){|connection| failed = true unless connection.head(url).status == 200}
+        lambda {
+          10.times.each do
+            threads << Thread.new do
+              # MocClient is not thread safe so lets initialize a new instance for each
+              session.run(url)  { |clnt| Thread.current[:result] = MocClient.new(url).get }
+              session.run(url2) { |clnt| Thread.current[:result] = MocClient.new(url2).get }
+            end
           end
-        end
-        sleep(0.01)
-        threads.each do |t|
-          t.join
-        end
-      }.should_not raise_error
-      session.instance_variable_get(:@sessions).keys.length.should eql(2) # make sure work got done
-      session.instance_variable_get(:@sessions).values.first.instance_variable_get(:@pool).length.should eql(20) # make sure work got done
-      session.instance_variable_get(:@sessions).values.last.instance_variable_get(:@pool).length.should eql(20) # make sure work got done
-      failed.should be_false # Make sure our requests woked
+          threads.each do |t|
+            t.join
+          end
+          stop_time = Time.now
+        }.should_not raise_error # make sure we're thread safe
+        # Some extra checks just to make sure...
+        results = threads.collect{ |t| t[:result]}
+        results.length.should eql(10) # make sure all threads are present
+        results.uniq.should eql([results.first]) # make sure we got the same results
+        ((stop_time.to_i - start_time.to_i) < (results.length * MocClient.sleep_time)).should be_true # make sure IO is running parallel
+        session.instance_variable_get(:@sessions).keys.length.should eql(2) # make sure sessions were created
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ require 'hot_tub'
 require 'rspec'
 require 'bundler/setup'
 require 'logger'
-
+require 'excon'
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 #Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
@@ -18,23 +18,30 @@ class MocClient
     @clean = false
   end
 
+  # Perform an IO
   def get
-      sleep(0.05)
+    return `sleep #{self.class.sleep_time}; echo "that was slow IO"`
   end
 
   def close
-  	@close = true
+    @close = true
   end
 
   def closed?
-  	@close == true
+    @close == true
   end
 
   def clean
-  	@clean = true
+    @clean = true
   end
 
   def cleaned?
-  	@clean == true
+    @clean == true
+  end
+
+  class << self
+    def sleep_time
+      0.5
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hot_tub
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-02 00:00:00.000000000 Z
+date: 2013-04-03 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: httpclient
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +65,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 518626986870371684
+      hash: 1359205392366777656
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -90,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 518626986870371684
+      hash: 1359205392366777656
 requirements: []
 rubyforge_project: hot_tub
 rubygems_version: 1.8.25