itrigga-net_helper 0.2.0 → 0.3.0

data/spec/net_helper_spec.rb

@@ -1,139 +1,186 @@
 require File.join(File.dirname(__FILE__), 'spec_helper' )
 
 describe "Itrigga::NetHelper" do
-  before(:each) do
-    @mock_response = mock("response")
-    @mock_response.stub!(:body).and_return("body")
+  before do
+    @default_http_params = {
+      :timeout            => 5,
+      :retries_on_timeout => 5,
+      :max_redirects      => 3
+    }
+    
   end
   
-  describe "typhoeus_present?" do
-    context "when Typhoeus is loaded" do
-      before(:each) do
-        Itrigga::NetHelper.send(:const_set, "Typhoeus", Proc.new {})
-      end
-      
-      it "should return true" do
-        Itrigga::NetHelper.typhoeus_present?.should == true
-      end
+  describe "available_http_engines" do
+    it "should return the constants defined in the Itrigga::NetHelper module (ie the classes)" do
+      Itrigga::NetHelper.should_receive(:constants)
+      Itrigga::NetHelper.available_http_engines
     end
     
-    context "when Typhoeus is not loaded" do
-      before(:each) do
-        Itrigga::NetHelper.send(:remove_const, "Typhoeus")
+    it "should return the correct classes" do
+      Itrigga::NetHelper.available_http_engines.sort.should == ["RestClient","Typhoeus"].sort
+    end
+  end
+  
+  
+  describe "default_http_engine" do
+    it "should be rest client" do
+      Itrigga::NetHelper.default_http_engine.should == "RestClient"
+    end
+  end
+  
+  
+  describe "do_get" do
+    before do
+      Itrigga::NetHelper.stub!(:get).and_return("result")  
+    end
+    
+    context "using defaults" do
+      it "should call get changing the params into a hash" do
+        Itrigga::NetHelper.should_receive(:get).with(hash_including({:url => "blart"}.merge(@default_http_params)))
+        Itrigga::NetHelper.do_get "blart"
       end
-      
-      it "should return false" do
-        Itrigga::NetHelper.typhoeus_present?.should == false
+    end
+    
+    context "overriding defaults" do
+      it "should call get changing the params into a hash" do
+        Itrigga::NetHelper.should_receive(:get).with(hash_including(:url => "blart",:timeout => 1, :retries_on_timeout => 2, :max_redirects => 42))
+        Itrigga::NetHelper.do_get "blart", 1, 2, 42
       end
     end
     
+    it "should return the result from get" do
+      Itrigga::NetHelper.do_get("blart").should == "result"
+    end
   end
-
-  describe "do_get" do
-    before(:each) do
-      Itrigga::NetHelper.stub!(:typhoeus_present?).and_return(false)
+  
+  
+  describe "get" do
+    before do
+      Itrigga::NetHelper.stub!(:get_engine).and_return(@engine = mock("HTTPEngine"))
+      @engine.stub!(:get).and_return("result")
+      Itrigga::NetHelper.stub!(:with_timeout).and_yield
+      @default_http_params = @default_http_params.merge({:headers => {}})
+      @default_http_params_with_url = {:url => "blart"}.merge(@default_http_params)
     end
     
-      
-    it "should get the HTTP response" do
-      Itrigga::NetHelper.stub!(:handle_response).and_return("")
-      Net::HTTP.should_receive( :get_response ).with( URI.parse("http://some.com") ).and_return(@mock_response)
-      Itrigga::NetHelper.do_get( "http://some.com" )
+    it "should raise error if no :url option given" do
+      lambda { Itrigga::NetHelper.get }.should raise_error(ArgumentError,":url is required")
+    end
+    
+    it "should call get_engine with merged params" do
+      Itrigga::NetHelper.should_receive(:get_engine).with(hash_including(@default_http_params_with_url))
+      Itrigga::NetHelper.get :url => "blart"
+    end
+    
+    it "should call with_timeout" do
+      Itrigga::NetHelper.should_receive(:with_timeout).with(@default_http_params_with_url).and_yield
+      Itrigga::NetHelper.get :url => "blart"
+    end
+    
+    it "should call get in the http engine in the block" do
+      @engine.should_receive(:get).with(@default_http_params_with_url).and_return("result")
+      Itrigga::NetHelper.get :url => "blart"
     end
     
-    it "should call handle_response with the response" do
-      Net::HTTP.stub!( :get_response ).with( URI.parse("http://some.com") ).and_return(@mock_response)
-      Itrigga::NetHelper.should_receive(:handle_response).and_return("")
-      Itrigga::NetHelper.do_get( "http://some.com" )
+    it "should return the result of the block" do
+      Itrigga::NetHelper.get(:url => "blart").should == "result"
     end
+  end
   
+  
+  describe "with_timeout" do
+    before do
+      @block = Proc.new{ 6 + 6 }
+    end
     
-    describe "when the GET takes longer than time_out seconds" do
-      before(:each) do
-        Itrigga::NetHelper.stub!(:get_with_timeout).and_raise( TimeoutError.new("expected timeout") ) 
+    context "when SystemTimer is available" do
+      before do
+        silence_warnings { Object.const_set(:SystemTimer, @system_timer = mock("SystemTimer")) }
+        @system_timer.stub!(:timeout_after).and_yield
+      end
+      after do
+        silence_warnings { Object.send(:remove_const, :SystemTimer) }
       end
       
-      describe "when it has retried < retries_on_timeout times" do
-        it "should retry" do
-          Itrigga::NetHelper.should_receive(:get_with_timeout).exactly(3).times
-          # NOTE: the important expectation is the above one!
-          lambda {
-            Itrigga::NetHelper.do_get( "http://some.com", 1, 2 )
-          }.should raise_error( IOError )
-        end
+      it "should call timeout_after" do
+        @system_timer.should_receive(:timeout_after).with(42).and_yield
+        Itrigga::NetHelper.with_timeout({:timeout => 42}, &@block)
       end
       
-      describe "when it has retried retries_on_timeout times" do
-        it "should raise an IOError" do
-          lambda {
-            Itrigga::NetHelper.do_get( "http://some.com", 0, 2 )
-          }.should raise_error( IOError )
-        end
+      it "should return the result from the block" do
+        Itrigga::NetHelper.with_timeout({:timeout => 42}, &@block).should == 12
       end
       
+      it "should not call timeout" do
+        Itrigga::NetHelper.should_not_receive(:timeout)
+        Itrigga::NetHelper.with_timeout({:timeout => 42}, &@block)
+      end  
     end
-  end
-  
-  describe "handle_response" do
     
-    describe "when the response is OK" do
-      before(:each) do
-        @mock_response.stub!(:is_a?).with(String).and_return false
-        @mock_response.stub!(:is_a?).with(Net::HTTPSuccess).and_return true
+    context "when SystemTimer is not available" do
+      it "should call timeout" do
+        Itrigga::NetHelper.should_receive(:timeout).with(42).and_yield
+        Itrigga::NetHelper.with_timeout({:timeout => 42}, &@block)
       end
       
-      it "should return the response body" do
-        Itrigga::NetHelper.handle_response("http://some.com", @mock_response).should == "body"
+      it "should return the result from the block" do
+        Itrigga::NetHelper.with_timeout({:timeout => 42}, &@block).should == 12
       end
     end
     
-    describe "when the response is a redirect" do
-      before(:each) do
-        @mock_response.stub!(:is_a?).with(String).and_return false
-        @mock_response.stub!(:is_a?).with(Net::HTTPSuccess).and_return false
-        @mock_response.stub!(:is_a?).with(Net::HTTPRedirection).and_return true
-        @mock_response.stub!(:[]).with('location').and_return("http://some.redirect")
+    context "when an error is thrown" do
+      it "should retry 3 times then raise an IOError" do
+        Itrigga::NetHelper.should_receive(:timeout).exactly(4).times.and_raise(TimeoutError)
+        lambda { Itrigga::NetHelper.with_timeout({:timeout => 42, :retries_on_timeout => 3}, &@block) }.should raise_error(IOError)
       end
       
-      describe "when redirects > 0" do
-        it "should recurse" do
-          Itrigga::NetHelper.should_receive(:do_get)
-          Itrigga::NetHelper.handle_response("http://some.com", @mock_response)          
-        end
-        
-        it "should pass the location field from the response as the url, and the same timeout" do
-          Itrigga::NetHelper.should_receive(:do_get).with( "http://some.redirect", 23, anything )
-          Itrigga::NetHelper.handle_response( "http://some.com", @mock_response, 23)     
-        end
-        
-        it "should pass redirects - 1 as the redirects param" do
-          Itrigga::NetHelper.should_receive(:do_get).with( anything, anything, 15 )
-          Itrigga::NetHelper.handle_response( "http://some.com", @mock_response, 23, 16)     
-        end
-        
-        describe "when the response location is relative" do
-          before(:each) do
-            @mock_response.stub!(:[]).with('location').and_return("/some/relative/path?param=567")
-          end
-          
-          it "should pass on the absolute url" do
-            Itrigga::NetHelper.should_receive(:do_get).with( "http://some.com/some/relative/path?param=567", anything, anything )
-            Itrigga::NetHelper.handle_response( "http://some.com/some_other/path.xml?id=123", @mock_response, 23, 16)
-          end
-        end
+      it "should not handle other errors" do
+        Itrigga::NetHelper.stub!(:timeout).and_raise "Funkiness Alert!"
+        lambda { Itrigga::NetHelper.with_timeout({:timeout => 42, :retries_on_timeout => 3}, &@block) }.should raise_error
+      end
+    end
+  end
+  
+  
+  describe "get_engine" do
+    context "when the ITNH_HTTP_ENGINE is defined" do
+      before do
+        silence_warnings { 
+          Object.const_set(:ITNH_HTTP_ENGINE, "Typhoeus") 
+          Object.const_set(:Typhoeus, "Typhoeus") 
+        }
+      end
+      after do
+        silence_warnings { 
+          Object.send(:remove_const, :ITNH_HTTP_ENGINE) 
+          Object.send(:remove_const, :Typhoeus) 
+        }
       end
       
-      describe "when redirects = 0" do
-        it "should raise an IOError" do
-          lambda {
-            Itrigga::NetHelper.handle_response( "http://some.com", @mock_response, 23, 0)     
-          }.should raise_error( IOError )
-        end
+      it "should return the Typhoeus class" do
+        Itrigga::NetHelper.get_engine.should == Itrigga::NetHelper::Typhoeus
+      end
+      
+      it "should respect overrides" do
+         Itrigga::NetHelper.get_engine(:http_engine => "RestClient").should == Itrigga::NetHelper::RestClient
+      end   
+    end
+    
+    context "with no Typhoeus defined" do
+      it "should not use Typhoeus even when told to" do
+        Object.send(:remove_const, :Typhoeus) rescue nil #only remove it if its present
+        Itrigga::NetHelper.get_engine(:http_engine => "Typhoeus").should == Itrigga::NetHelper::RestClient # because Typhoeus is not defined (ie not available)
+          
       end
     end
     
+    it "should use the default engine if given an invalid option" do
+      Itrigga::NetHelper.get_engine(:http_engine => "blart and flange").should == Itrigga::NetHelper::RestClient
+    end
+    
   end
   
+  
   describe "query_string" do
     it "should return a string" do
       Itrigga::NetHelper.query_string( 'blart' => 'flange' ).should be_a(String)
@@ -172,6 +219,9 @@ describe "Itrigga::NetHelper" do
     end
   end
   
+  
+  
+  
   describe "discover_favicon_url" do
     before(:each) do
       @url = "http://blart.com"
@@ -189,9 +239,6 @@ describe "Itrigga::NetHelper" do
       Itrigga::NetHelper.discover_favicon_url(@url)
     end
       
-      
-
-    
     context "each discovered href" do
       context "when the get is a success" do
         before(:each) do
@@ -209,6 +256,9 @@ describe "Itrigga::NetHelper" do
     end
       
   end
+  
+  
+  
   describe "discover_icon_hrefs" do
     before(:each) do
       @html = <<-HTML
@@ -252,145 +302,7 @@ describe "Itrigga::NetHelper" do
 
   end
   
-  describe "raw_get" do
-    before(:each) do
-      Itrigga::NetHelper.stub!(:get_with_auth).and_return( 'body' )
-      Itrigga::NetHelper.stub!(:establish_session_if_needed)
-      Itrigga::NetHelper.stub!(:typhoeus_present?).and_return(false)
-      @mock_session = mock("http session")
-      @mock_session.stub!(:request_get).and_return( @mock_response = mock('request_get response') )
-      @mock_response.stub!(:body).and_return('response body')
-      @mock_parsed_url = mock("parsed url")
-      @mock_parsed_url.stub!(:host).and_return("host")
-      @mock_parsed_url.stub!(:path).and_return("path")
-      @mock_parsed_url.stub!(:port).and_return("port")
-      
-      @mock_response = mock('response')
-      @mock_response.stub!(:is_a?).with(Net::HTTPRedirection).and_return(false)
-      @mock_response.stub!(:body).and_return('cheese')
-    end
-    
-    it "should call establish_session_if_needed with the given opts" do
-      Itrigga::NetHelper.should_receive(:establish_session_if_needed).with(hash_including(:blart=>'flange'))
-      Itrigga::NetHelper.raw_get(:blart=>'flange', :http_session=>@mock_session, :parsed_url=>@mock_parsed_url)
-    end
-    
-    context "when given a :username" do
-      it "should call get_with_auth with the given options" do
-        Itrigga::NetHelper.should_receive(:get_with_auth).with(hash_including(:username=>'dave')).and_return(@mock_response)
-        Itrigga::NetHelper.raw_get(:username=>'dave')
-      end
-      
-      it "should return the result of get_with_auth" do
-        Itrigga::NetHelper.stub!(:get_with_auth).with(hash_including(:username=>'dave')).and_return(@mock_response)
-        Itrigga::NetHelper.raw_get(:username=>'dave').should == 'cheese'
-      end
-      
-      context "when response is a redirection" do
-        before(:each) do
-          @mock_response.stub!(:is_a?).with(Net::HTTPRedirection).and_return(true, false)
-          @mock_response.stub!(:[]).with('location').and_return("http://cheesefish.com")
-          URI.stub!(:parse).with("http://cheesefish.com").and_return(@mock_parsed_url = mock('parsed url'))
-        end
-        
-        it "should follow the redirect" do
-          URI.should_receive(:parse).with("http://cheesefish.com").and_return(@mock_parsed_url = mock('parsed url'))
-          Itrigga::NetHelper.should_receive(:get_with_auth).twice.and_return(@mock_response)
-          Itrigga::NetHelper.raw_get(:username=>'dave')
-        end
-      end
-    end
-    
-    context "when not given a :username" do
-      it "should call request_get on the http session with the :parsed_url's path and :headers" do
-        @mock_session.should_receive(:request_get).with( 'path', {:donkey=>'dipstick'}).and_return(@mock_response)
-        Itrigga::NetHelper.raw_get( :parsed_url=>@mock_parsed_url, :http_session=>@mock_session, :headers=>{:donkey=>'dipstick'} )
-      end
-      
-      it "should return the result of calling body on the request_get's response" do
-        Itrigga::NetHelper.raw_get(:parsed_url=>@mock_parsed_url, :http_session=>@mock_session).should == 'response body'
-      end
-    end
-    
-  end
-  
-  describe "get_with_auth" do
-    before(:each) do
-      Itrigga::NetHelper.stub!(:establish_session_if_needed)
-      Itrigga::NetHelper.stub!(:typhoeus_present).and_return(false)
-      @mock_get = mock('get')
-      @mock_get.stub!(:basic_auth)
-      Net::HTTP::Get.stub!(:new).and_return(@mock_get)
-      @mock_parsed_url = mock("parsed url")
-      @mock_parsed_url.stub!(:host).and_return("host")
-      @mock_parsed_url.stub!(:path).and_return("path")
-      @mock_parsed_url.stub!(:port).and_return("port")
-      @mock_session = mock("http session")
-      @mock_session.stub!(:request).and_return("request response")
-    end
-    
-    it "should call establish_session_if_needed with the given opts" do
-      Itrigga::NetHelper.should_receive(:establish_session_if_needed).with(hash_including(:blart=>'flange'))
-      Itrigga::NetHelper.get_with_auth(:blart=>'flange', :parsed_url=>@mock_parsed_url, :http_session=>@mock_session)
-    end
-    
-    it "should create a new Net::HTTP::Get with the path of the :parsed_url" do
-      Net::HTTP::Get.should_receive(:new).with('path').and_return(@mock_get)
-      Itrigga::NetHelper.get_with_auth(:blart=>'flange', :parsed_url=>@mock_parsed_url, :http_session=>@mock_session)
-    end
-    
-    it "should call basic_auth on the get, passing :username and :password from the given params" do
-      @mock_get.should_receive(:basic_auth).with( 'username', 'password' )
-      Itrigga::NetHelper.get_with_auth(:username=>'username', :password=>'password', :parsed_url=>@mock_parsed_url, :http_session=>@mock_session)
-    end
-    
-    it "should call request on the http_session with the get, and any given :headers" do
-      @mock_session.should_receive(:request).with(@mock_get, {:header1=>'value1'})
-      Itrigga::NetHelper.get_with_auth(:http_session=>@mock_session, :headers=>{:header1=>'value1'}, :parsed_url=>@mock_parsed_url, :http_session=>@mock_session )
-    end
-    
-    it "should return the result of the request" do
-      @mock_session.should_receive(:request).with(@mock_get, {:header1=>'value1'}).and_return("cheese")
-      Itrigga::NetHelper.get_with_auth(:http_session=>@mock_session, :headers=>{:header1=>'value1'}, :parsed_url=>@mock_parsed_url, :http_session=>@mock_session ).should == "cheese"
-    end
-  end
   
-  describe "establish_session_if_needed" do
-    before(:each) do
-      @mock_parsed_url = mock("parsed url")
-      @mock_parsed_url.stub!(:host).and_return("host")
-      @mock_parsed_url.stub!(:port).and_return("port")
-      @mock_parsed_url.stub!(:scheme).and_return("scheme")
-      @mock_session = mock('http session')
-      @mock_session.stub!(:use_ssl=)
-      Net::HTTP.stub!(:new).and_return(@mock_session)
-    end
-    
-    context "When not given a :parsed_url" do
-      it "should set :parsed_url to URI.parse(:url)" do
-        URI.should_receive(:parse).with("URL").and_return(@mock_parsed_url)
-        Itrigga::NetHelper.establish_session_if_needed(:url=>"URL")
-      end
-    end 
-    
-    context "When not given a :http_session" do
-      it "should set :http_session to a new Net::HTTP with the parsed_url's host and port" do
-       Net::HTTP.should_receive(:new).with("host", "port").and_return(@mock_session)
-       Itrigga::NetHelper.establish_session_if_needed(:parsed_url=>@mock_parsed_url)
-      end
-    end
-    
-    context "when the :parsed_url's scheme is https" do
-      before(:each) do
-        @mock_parsed_url.stub!(:scheme).and_return("https")
-      end
-      
-      it "should set use_ssl=true on the http session" do
-        @mock_session.should_receive(:use_ssl=).with(true)
-        Itrigga::NetHelper.establish_session_if_needed(:parsed_url=>@mock_parsed_url)
-      end
-    end
-  end
   
   describe "shorten_url" do
     before do
@@ -423,6 +335,9 @@ describe "Itrigga::NetHelper" do
     end
   end
   
+  
+  
+  
   describe "format_url_shortener_api_url" do
     before do
       @raw_url = "http://very_long_url_goes_here.com"  
@@ -478,8 +393,24 @@ describe "Itrigga::NetHelper" do
       opts = {:target => "display_name", :file => "a_file_name", :target_path => "/path/goes/here/to/file.xml", :host=>@host}
       Itrigga::NetHelper.should_receive(:'`').with("scp -P123 -i key_file_path a_file_name user@hostname:/path/goes/here/to/file.xml")
       Itrigga::NetHelper.transfer_file_scp(opts)
+    end  
+  end
+  
+  
+  
+  describe "ip_of" do
+    before do
+      IPSocket.stub!(:getaddress).and_return("ip_address")
+    end
+    
+    it "should call getaddress" do
+      IPSocket.should_receive(:getaddress).with("server").and_return("ip_address")
+      Itrigga::NetHelper.ip_of("server")
     end
     
+    it "should return the address" do
+      Itrigga::NetHelper.ip_of("server").should == "ip_address"
+    end
   end
   
 end