hot_tub 0.0.4 → 0.1.0

data/lib/hot_tub/version.rb

@@ -1,3 +1,3 @@
 module HotTub
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/pool_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+unless HotTub.jruby?
+  require "em-synchrony"
+  require "em-synchrony/em-http"
+end
+describe HotTub::Pool do
+
+  context 'default settings' do
+    before(:each) do
+      @pool = HotTub::Pool.new()
+    end
+
+    it "should have :size of 5" do
+      @pool.instance_variable_get(:@size).should eql(5)
+    end
+
+    it "should have :blocking_timeout of 0.5" do
+      @pool.instance_variable_get(:@blocking_timeout).should eql(10)
+    end
+
+    it "should have default :client" do
+      @pool.instance_variable_get(:@client_block).call.should be_a(HTTPClient)
+    end
+
+    it "should be true" do
+      @pool.instance_variable_get(:@never_block).should be_true
+    end
+  end
+
+  context 'custom settings' do
+    before(:each) do
+      @pool = HotTub::Pool.new(:size => 10, :blocking_timeout => 1.0, :never_block => false) { MocClient.new }
+    end
+
+    it "should have :size of 5" do
+      @pool.instance_variable_get(:@size).should eql(10)
+    end
+
+    it "should have :blocking_timeout of 0.5" do
+      @pool.instance_variable_get(:@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(:@never_block).should be_false
+    end
+  end
+
+  describe '#run' do
+    before(:each) do
+      @pool = HotTub::Pool.new
+    end
+
+    it "should remove connection from pool when doing work" do
+      @pool.run do |connection|
+        @connection = connection
+        @fetched = @pool.instance_variable_get(:@pool).select{|c| c.object_id == @connection.object_id}.length.should eql(0) # not in pool because its doing work
+      end
+    end
+
+    it "should return the connection after use" do
+      @pool.run do |connection|
+        @connection = connection
+      end
+      # returned to pool after work was done
+      @pool.instance_variable_get(:@pool).select{|c| c.object_id == @connection.object_id}.length.should eql(1)
+    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
+    end
+
+    context 'block not given' do
+      it "should raise ArgumentError" do
+        lambda { @pool.run }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#close_all' do
+    before(:each) do
+      @pool = HotTub::Pool.new(:size => 5)
+      5.times do
+        @pool.send(:add)
+      end
+    end
+    it "should reset pool" do
+      @pool.current_size.should eql(5)
+      @pool.instance_variable_get(:@clients).length.should eql(5)
+      @pool.instance_variable_get(:@pool).length.should eql(5)
+      @pool.close_all
+      @pool.instance_variable_get(:@clients).length.should eql(0)
+      @pool.instance_variable_get(:@pool).length.should eql(0)
+      @pool.current_size.should eql(0)
+    end
+  end
+
+  context 'private methods' do
+    before(:each) do
+      @url = "http://www.testurl123.com/"
+      @pool = HotTub::Pool.new()
+    end
+
+    describe '#client' do
+      it "should raise HotTub::BlockingTimeout if an available is not found in time"do
+        @pool.instance_variable_set(:@never_block,false)
+        @pool.instance_variable_set(:@blocking_timeout,0.1)
+        @pool.stub(:pop).and_return(nil)
+        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)
+      end
+    end
+
+    describe 'add?' do
+      it "should be true if @pool_data[:length] is less than desired pool size and
+    the pool is empty?"do
+        @pool.instance_variable_set(:@pool,[])
+        @pool.send(:add?).should be_true
+      end
+
+      it "should be false pool has reached pool_size" do
+        @pool.instance_variable_set(:@pool_data,{:current_size => 5})
+        @pool.instance_variable_set(:@pool,["connection","connection","connection","connection","connection"])
+        @pool.send(:add?).should be_false
+      end
+    end
+
+    describe '#add' do
+      it "should add connections for supplied url"do
+        @pool.send(:add)
+        @pool.instance_variable_get(:@pool).should_not be_nil
+      end
+    end
+  end
+
+  context 'thread safety' do
+    it "should work" do
+      url = "https://www.google.com/"
+      pool = HotTub::Pool.new({:size => 20})
+      failed = false
+      lambda {
+        threads = []
+        20.times.each do
+          threads << Thread.new do
+            pool.run{|connection| failed = true unless connection.head(url).status == 200}
+          end
+        end
+        sleep(0.01)
+        threads.each do |t|
+          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
+    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)}
+    end
+
+    it "should clean connections" do
+      @pool.run  do |clnt|
+        clnt.cleaned?.should be_true
+      end
+    end
+  end
+
+  unless HotTub.jruby?
+    context 'EM:HTTPRequest' do
+      before(:each) do
+        @url = "https://www.google.com"
+      end
+
+      it "should work" do
+        EM.synchrony do
+          status = []
+          c = HotTub::Pool.new {EM::HttpRequest.new(@url)}
+          c.run { |conn| status << conn.head(:keepalive => true).response_header.status}
+          c.run { |conn| status << conn.ahead(:keepalive => true).response_header.status}
+          c.run { |conn| status << conn.head(:keepalive => true).response_header.status}
+          status.should eql([200,0,200])
+          EM.stop
+        end
+      end
+
+      context 'fibers' do
+        it "should work" do
+          EM.synchrony do
+            url = "https://www.google.com/"
+            pool = HotTub::Pool.new({:size => 5}) {EM::HttpRequest.new(@url)}
+            failed = false
+            fibers = []
+            lambda {
+              10.times.each do
+                fibers << Fiber.new do
+                  pool.run{|connection| failed = true unless connection.head(:keepalive => true).response_header.status == 200}
+                end
+              end
+              fibers.each do |f|
+                f.resume
+              end
+              loop do
+                done = true
+                fibers.each do |f|
+                  done = false if f.alive?
+                end
+                if done
+                  break
+                else
+                  EM::Synchrony.sleep(0.01)
+                end
+              end
+            }.should_not raise_error
+            pool.instance_variable_get(:@pool).length.should eql(5) #make sure work got done
+            failed.should be_false # Make sure our requests worked
+            EM.stop
+          end
+        end
+      end
+    end
+  end
+end

data/spec/session_spec.rb

@@ -1,108 +1,97 @@
 require 'spec_helper'
-  class MocClient < HotTub::Client
-    def initialize(url,options={})   
-    end
-  
-    def get
-      sleep(0.05)
-    end
-  end
-
+require 'hot_tub/session'
+require 'uri'
 describe HotTub::Session do
 
-  before(:each) do
-    @url = "http://www.testurl123.com/"
-    @tub = HotTub::Session.new(MocClient.new(@url)) 
+  it "should raise error if block is not supplied" do
+    lambda {HotTub::Session.new}.should raise_error(ArgumentError)
   end
 
-  context 'default configuration' do
-   
-    it "should have @pool_size of 5" do
-      @tub.instance_variable_get(:@options)[:size].should eql(5)
+  context 'default settings' 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 @pool_timeout of 0" do
-      @tub.instance_variable_get(:@options)[:blocking_timeout].should eql(0.5)
+
+    it "should have :size of 5" do
+      @options[:size].should eql(5)
     end
-  end
-        
-  describe '#add_client?' do
-    it "should be true if @pool_data[:length] is less than desired pool size and 
-    the pool is empty?"do
-      @tub.instance_variable_set(:@pool_data,{:current_size => 1})
-      @tub.send(:add_client?).should be_true 
+
+    it "should have :blocking_timeout of 10 seconds" do
+      @options[:blocking_timeout].should eql(10)
     end
-          
-    it "should be false pool has reached pool_size" do
-      @tub.instance_variable_set(:@pool_data,{:current_size => 5})
-      @tub.instance_variable_set(:@pool,
-        ["connection","connection","connection","connection","connection"])
-      @tub.send(:add_client?).should be_false
+
+    it "should default never_block to true" do
+      @options[:never_block].should be_true
     end
   end
-        
-  describe '#add_client' do
-    it "should add connections for supplied url"do
-      @tub.send(:add_client)
-      @tub.instance_variable_get(:@pool).should_not be_nil
+
+  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
-  end   
-        
-  describe '#fetch' do
-    it "should raise Timeout::Error if an available is not found in time"do
-      @tub.stub(:pool).and_return([])
-      lambda { @tub.send(:fetch)}.should raise_error(Timeout::Error)
+
+    it "should have @pool_size of 21" do
+      @options[:size].should eql(21)
     end
-    
-    it "should not raise Timeout::Error if an available is not found in time"do
-      @tub.instance_variable_get(:@options)[:never_block] = true
-      @tub.stub(:pool).and_return([])
-      lambda { @tub.send(:fetch)}.should_not raise_error(Timeout::Error)
+
+    it "should have never_block be false" do
+      @options[:never_block].should be_false
+    end
+  end
+
+  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 return an instance of the driver" do
-      @tub.send(:fetch).should be_instance_of(MocClient)
+    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
-  end
-  
-  describe '#run' do
-    it "should fetch a connection and run the supplied block" do
-      @fetched = nil
-      
-      @tub.run do |connection|
-        @fetched = connection.class.name
+
+    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)
       end
-      @fetched.should eql("MocClient")
     end
-    
-    it "should return the connection after use" do
-      @tub.run do |connection|
-        @connection = connection
-        @fetched = @tub.instance_variable_get(:@pool).include?(connection)
+
+    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)
+      end
+    end
+
+    context "invalid argument" do
+      it "should raise an ArgumentError" do
+        lambda { @tub.sessions(nil) }.should raise_error(ArgumentError)
+
+      end
+      it  "should raise URI::InvalidURIError with bad url" do
+        lambda { @tub.sessions("bad url") }.should raise_error(URI::InvalidURIError)
       end
-      @fetched.should be_false # not in pool because its doing work
-      
-      # returned to pool after work was done
-      @tub.instance_variable_get(:@pool).include?(@connection).should be_true
     end
   end
-  
-  context 'thread safety' do
+  describe '#run' do
     it "should work" do
-      threads = []
-      20.times.each do
-        threads << Thread.new do
-          @tub.run{|connection| connection.get}
-        end
-      end
-      
-      sleep(0.5)
-      
-      threads.each do |t|
-        t.join
+      @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
       end
-      
-      @tub.instance_variable_get(:@pool).length.should eql(5)
+      status.should eql(200)
     end
   end
 end

data/spec/spec_helper.rb

@@ -7,6 +7,34 @@ require 'logger'
 # in ./support/ and its subdirectories.
 #Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 HotTub.logger.level = Logger::ERROR
+
 RSpec.configure do |config|
 
-end
+end
+
+class MocClient
+  def initialize(url=nil,options={})
+    @close = false
+    @clean = false
+  end
+
+  def get
+      sleep(0.05)
+  end
+
+  def close
+  	@close = true
+  end
+
+  def closed?
+  	@close == true
+  end
+
+  def clean
+  	@clean = true
+  end
+
+  def cleaned?
+  	@clean == true
+  end
+end