typhoeus 0.2.4 → 0.3.2

data/lib/typhoeus/utils.rb

@@ -1,3 +1,5 @@
+require 'tempfile'
+
 module Typhoeus
   module Utils
     # Taken from Rack::Utils, 1.2.1 to remove Rack dependency.
@@ -18,11 +20,10 @@ module Typhoeus
         when Hash
           traverse_params_hash(hash[key], result, new_key)
         when Array
-          array_key = "#{new_key}[]"
           hash[key].each do |v|
-            result[:params] << [array_key, v.to_s]
+            result[:params] << [new_key, v.to_s]
           end
-        when File
+        when File, Tempfile
           filename = File.basename(hash[key].path)
           types = MIME::Types.type_for(filename)
           result[:files] << [
@@ -41,7 +42,7 @@ module Typhoeus
 
     def traversal_to_param_string(traversal, escape = true)
       traversal[:params].collect { |param|
-        "#{Typhoeus::Utils.escape(param[0])}=#{Typhoeus::Utils.escape(param[1])}"
+        escape ? "#{Typhoeus::Utils.escape(param[0])}=#{Typhoeus::Utils.escape(param[1])}" : "#{param[0]}=#{param[1]}"
       }.join('&')
     end
     module_function :traversal_to_param_string

data/lib/typhoeus/version.rb

@@ -0,0 +1,3 @@
+module Typhoeus
+  VERSION = '0.3.2'
+end

data/spec/servers/app.rb

@@ -15,6 +15,10 @@ post '/file' do
   }.to_json
 end
 
+get '/multiple-headers' do
+  [200, { 'Set-Cookie' => %w[ foo bar ], 'Content-Type' => 'text/plain' }, ['']]
+end
+
 get '/fail/:number' do
   if @@fail_count >= params[:number].to_i
     "ok"

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require "rubygems"
 require 'json'
-require "spec"
+require "rspec"
 
 # gem install redgreen for colored test output
 begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end
@@ -10,5 +10,5 @@ $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
 
 require path + '/typhoeus'
 
-Spec::Runner.configure do |config|
-end
+RSpec.configure do |config|
+end

data/spec/typhoeus/easy_spec.rb

@@ -73,13 +73,13 @@ describe Typhoeus::Easy do
     end
 
     it "should allow you to set the user agent" do
-      easy = Typhoeus::Easy.new
-      easy.url    = "http://localhost:3002"
-      easy.method = :get
-      easy.user_agent = "myapp"
-      easy.perform
-      easy.response_code.should == 200
-      JSON.parse(easy.response_body)["HTTP_USER_AGENT"].should == "myapp"
+      e = Typhoeus::Easy.new
+      e.url    = "http://localhost:3002"
+      e.method = :get
+      e.user_agent = "myapp"
+      e.perform
+      e.response_code.should == 200
+      JSON.parse(e.response_body)["HTTP_USER_AGENT"].should == "myapp"
     end
 
     it "should provide a timeout in milliseconds" do
@@ -110,6 +110,15 @@ describe Typhoeus::Easy do
       e.perform
       e.response_code.should == 302
     end
+
+    it "should provide the primary IP address that was used to perform the HTTP request" do
+      e = Typhoeus::Easy.new
+      e.url    = "http://localhost:3002"
+      e.method = :get
+      e.perform
+      e.response_code.should == 200
+      e.primary_ip.should == "127.0.0.1"
+    end
   end
   
   describe "authentication" do
@@ -190,8 +199,7 @@ describe Typhoeus::Easy do
         :foo => 'bar',
         :username => ['dbalatero', 'dbalatero2']
       }
-      
-      easy.url.should =~ /\?.*username%5B%5D=dbalatero&username%5B%5D=dbalatero2/
+      easy.url.should =~ /\?.*foo=bar&username=dbalatero&username=dbalatero2/
     end
   end
 
@@ -215,6 +223,24 @@ describe Typhoeus::Easy do
       easy.response_code.should == 200
       easy.response_body.should include("this is a body!")
     end
+
+    it "should be able perform put with empty bodies on the same easy handle" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "PUT"
+
+      easy.reset
+
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "PUT"
+    end
+
   end
   
   describe "post" do
@@ -257,7 +283,7 @@ describe Typhoeus::Easy do
 
       request = JSON.parse(easy.response_body)
       request['CONTENT_TYPE'].should == 'application/x-www-form-urlencoded' 
-      request['rack.request.form_vars'].should == 'a=b&c=d&e%5Bf%5D%5Bg%5D=h'
+      request['rack.request.form_vars'].should == 'a=b&c=d&e[f][g]=h'
     end
 
     it "should handle a file upload, as multipart" do
@@ -311,6 +337,16 @@ describe Typhoeus::Easy do
       easy.response_code.should == 200
       JSON.parse(easy.response_body)["HTTP_ACCEPT_ENCODING"].should == "deflate, gzip"
     end
+
+    it "should send valid encoding headers and decode the response after reset" do
+      easy = Typhoeus::Easy.new
+      easy.reset
+      easy.url = "http://localhost:3002/gzipped"
+      easy.method = :get
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["HTTP_ACCEPT_ENCODING"].should == "deflate, gzip"
+    end
     
   end
 end

data/spec/typhoeus/form_spec.rb

@@ -36,9 +36,9 @@ describe Typhoeus::Form do
         :name => "John Smith",
         :age => "29"
       })
-      form.should_receive(:formadd_param).with("colors[]", "brown")
-      form.should_receive(:formadd_param).with("colors[]", "green")
-      form.should_receive(:formadd_param).with("colors[]", "white")
+      form.should_receive(:formadd_param).with("colors", "brown")
+      form.should_receive(:formadd_param).with("colors", "green")
+      form.should_receive(:formadd_param).with("colors", "white")
       form.should_receive(:formadd_param).with("name", "John Smith")
       form.should_receive(:formadd_param).with("age", "29")
       form.process!
@@ -62,6 +62,16 @@ describe Typhoeus::Form do
         form.should_receive(:formadd_file).with("text_file", "placeholder.txt", "text/plain", anything)
         form.process!
       end
+
+      it "should handle tempfiles (file subclasses)" do
+        tempfile = Tempfile.new('placeholder_temp')
+        form = Typhoeus::Form.new(
+          :file => tempfile
+        )
+        form.should_receive(:formadd_file).with("file", File.basename(tempfile.path), "application/octet-stream", anything)
+        form.process!
+      end
+
       it "should default to 'application/octet-stream' if no content type can be determined" do
         pending
         form = Typhoeus::Form.new(
@@ -79,7 +89,7 @@ describe Typhoeus::Form do
         :name => "John Smith",
         :age => "29"
       })
-      form.to_s.should == "age=29&name=John+Smith"
+      form.to_s.should == "age=29&name=John Smith"
     end
 
     it "should handle params that are a hash" do
@@ -92,16 +102,16 @@ describe Typhoeus::Form do
         :name => "John Smith",
         :age => "29"
       })
-      form.to_s.should == "age=29&attributes%5Beyes%5D=brown&attributes%5Bhair%5D=green&attributes%5Bteeth%5D=white&name=John+Smith"
+      form.to_s.should == "age=29&attributes[eyes]=brown&attributes[hair]=green&attributes[teeth]=white&name=John Smith"
     end
 
-    it "should params that have mutliple values" do
+    it "should params that have multiple values" do
       form = Typhoeus::Form.new({
         :colors => ["brown", "green", "white"],
         :name => "John Smith",
         :age => "29"
       })
-      form.to_s.should == "age=29&colors%5B%5D=brown&colors%5B%5D=green&colors%5B%5D=white&name=John+Smith"
+      form.to_s.should == "age=29&colors=brown&colors=green&colors=white&name=John Smith"
     end
   end
 end

data/spec/typhoeus/hydra_mock_spec.rb

@@ -98,12 +98,12 @@ describe Typhoeus::HydraMock do
         Typhoeus::Request.new("http://localhost:3000", options.merge(:method => :get))
       end
 
-      def mock(options = {})
+      def hydra(options = {})
         Typhoeus::HydraMock.new("http://localhost:3000", :get, options)
       end
 
       context 'when no :headers option is given' do
-        subject { mock }
+        subject { hydra }
 
         it "matches regardless of whether or not the request has headers" do
           subject.matches?(request(:headers => nil)).should be_true
@@ -114,7 +114,7 @@ describe Typhoeus::HydraMock do
 
       [nil, {}].each do |value|
         context "for :headers => #{value.inspect}" do
-          subject { mock(:headers => value) }
+          subject { hydra(:headers => value) }
 
           it "matches when the request has no headers" do
             subject.matches?(request(:headers => nil)).should be_true
@@ -129,7 +129,7 @@ describe Typhoeus::HydraMock do
 
       context 'for :headers => [a hash]' do
         it 'does not match if the request has no headers' do
-          m = mock(:headers => { 'A' => 'B', 'C' => 'D' })
+          m = hydra(:headers => { 'A' => 'B', 'C' => 'D' })
 
           m.matches?(request).should be_false
           m.matches?(request(:headers => nil)).should be_false
@@ -137,7 +137,7 @@ describe Typhoeus::HydraMock do
         end
 
         it 'does not match if the request lacks any of the given headers' do
-          mock(
+          hydra(
             :headers => { 'A' => 'B', 'C' => 'D' }
           ).matches?(request(
             :headers => { 'A' => 'B' }
@@ -145,7 +145,7 @@ describe Typhoeus::HydraMock do
         end
 
         it 'does not match if any of the specified values are different from the request value' do
-          mock(
+          hydra(
             :headers => { 'A' => 'B', 'C' => 'D' }
           ).matches?(request(
             :headers => { 'A' => 'B', 'C' => 'E' }
@@ -153,39 +153,39 @@ describe Typhoeus::HydraMock do
         end
 
         it 'matches if the given hash is exactly equal to the request headers' do
-          mock(
+          hydra(
             :headers => { 'A' => 'B', 'C' => 'D' }
           ).matches?(request(
             :headers => { 'A' => 'B', 'C' => 'D' }
           )).should be_true
         end
 
-        it 'matches even if the request has additional headers not specified in the mock' do
-          mock(
+        it 'matches even if the request has additional headers not specified in the hydra' do
+          hydra(
             :headers => { 'A' => 'B', 'C' => 'D' }
           ).matches?(request(
             :headers => { 'A' => 'B', 'C' => 'D', 'E' => 'F' }
           )).should be_true
         end
 
-        it 'matches even if the casing of the header keys is different between the mock and request' do
-          mock(
+        it 'matches even if the casing of the header keys is different between the hydra and request' do
+          hydra(
             :headers => { 'A' => 'B', 'c' => 'D' }
           ).matches?(request(
             :headers => { 'a' => 'B', 'C' => 'D' }
           )).should be_true
         end
 
-        it 'matches if the mocked values are regexes and match the request values' do
-          mock(
+        it 'matches if the hydraed values are regexes and match the request values' do
+          hydra(
             :headers => { 'A' => /foo/, }
           ).matches?(request(
             :headers => { 'A' => 'foo bar' }
           )).should be_true
         end
 
-        it 'does not match if the mocked values are regexes and do not match the request values' do
-          mock(
+        it 'does not match if the hydraed values are regexes and do not match the request values' do
+          hydra(
             :headers => { 'A' => /foo/, }
           ).matches?(request(
             :headers => { 'A' => 'bar' }
@@ -194,15 +194,15 @@ describe Typhoeus::HydraMock do
 
         context 'when a header is specified as an array' do
           it 'matches when the request header has the same array' do
-            mock(
+            hydra(
               :headers => { 'Accept' => ['text/html', 'text/plain'] }
             ).matches?(request(
               :headers => { 'Accept' => ['text/html', 'text/plain'] }
             )).should be_true
           end
 
-          it 'matches when the request header is a single value and the mock array has the same value' do
-            mock(
+          it 'matches when the request header is a single value and the hydra array has the same value' do
+            hydra(
               :headers => { 'Accept' => ['text/html'] }
             ).matches?(request(
               :headers => { 'Accept' => 'text/html' }
@@ -210,7 +210,7 @@ describe Typhoeus::HydraMock do
           end
 
           it 'matches even when the request header array is ordered differently' do
-            mock(
+            hydra(
               :headers => { 'Accept' => ['text/html', 'text/plain'] }
             ).matches?(request(
               :headers => { 'Accept' => ['text/plain', 'text/html'] }
@@ -218,7 +218,7 @@ describe Typhoeus::HydraMock do
           end
 
           it 'does not match when the request header array lacks a value' do
-            mock(
+            hydra(
               :headers => { 'Accept' => ['text/html', 'text/plain'] }
             ).matches?(request(
               :headers => { 'Accept' => ['text/plain'] }
@@ -226,7 +226,7 @@ describe Typhoeus::HydraMock do
           end
 
           it 'does not match when the request header array has an extra value' do
-            mock(
+            hydra(
               :headers => { 'Accept' => ['text/html', 'text/plain'] }
             ).matches?(request(
               :headers => { 'Accept' => ['text/html', 'text/plain', 'application/xml'] }
@@ -234,7 +234,7 @@ describe Typhoeus::HydraMock do
           end
 
           it 'does not match when the request header is not an array' do
-            mock(
+            hydra(
               :headers => { 'Accept' => ['text/html', 'text/plain'] }
             ).matches?(request(
               :headers => { 'Accept' => 'text/html' }

data/spec/typhoeus/hydra_spec.rb

@@ -46,6 +46,29 @@ describe Typhoeus::Hydra do
     second.response.body.should include("second")
   end
 
+  it "runs queued requests in order of queuing" do
+    hydra  = Typhoeus::Hydra.new :max_concurrency => 1
+    first  = Typhoeus::Request.new("http://localhost:3000/first")
+    second = Typhoeus::Request.new("http://localhost:3001/second")
+    third = Typhoeus::Request.new("http://localhost:3001/third")
+    second.on_complete do |response|
+      first.response.should_not == nil
+      third.response.should == nil
+    end
+    third.on_complete do |response|
+      first.response.should_not == nil
+      second.response.should_not == nil
+    end
+
+    hydra.queue first
+    hydra.queue second
+    hydra.queue third
+    hydra.run
+    first.response.body.should include("first")
+    second.response.body.should include("second")
+    third.response.body.should include("third")
+  end
+
   it "should store the curl return codes on the reponses" do
     hydra  = Typhoeus::Hydra.new
     first  = Typhoeus::Request.new("http://localhost:3001/?delay=1", :timeout => 100)
@@ -165,6 +188,31 @@ describe Typhoeus::Hydra do
     @cache.get(second.cache_key).should be_nil
   end
 
+  it "continues queued requests after a queued cache hit" do
+    # Set max_concurrency to 1 so that the second and third requests will end
+    # up in the request queue.
+    hydra  = Typhoeus::Hydra.new :max_concurrency => 1
+    hydra.cache_getter do |request|
+      @cache.get(request.cache_key) rescue nil
+    end
+    hydra.cache_setter do |request|
+      @cache.set(request.cache_key, request.response, request.cache_timeout)
+    end
+
+    first  = Typhoeus::Request.new("http://localhost:3000/first", :params => {:delay => 1})
+    second = Typhoeus::Request.new("http://localhost:3000/second", :params => {:delay => 1})
+    third = Typhoeus::Request.new("http://localhost:3000/third", :params => {:delay => 1})
+    @cache.set(second.cache_key, "second", 60)
+    hydra.queue first
+    hydra.queue second
+    hydra.queue third
+    hydra.run
+
+    first.response.body.should include("first")
+    second.response.should == "second"
+    third.response.body.should include("third")
+  end
+
   it "has a global on_complete" do
     foo = nil
     hydra  = Typhoeus::Hydra.new
@@ -300,6 +348,34 @@ describe Typhoeus::Hydra::Stubbing do
 
     after(:each) do
       @stub_target.clear_stubs
+      @stub_target.stub_finders.clear
+    end
+
+    it 'allows users to register a custom stub finder' do
+      @stub_target.register_stub_finder do |request|
+        Typhoeus::Response.new :code => 200, :body => "stub for #{request.url.split('/').last}"
+      end
+
+      request = Typhoeus::Request.new("http://localhost:3000/foo")
+      returned_response = nil
+      request.on_complete { |response| returned_response = response }
+      @hydra.queue(request); @hydra.run
+
+      returned_response.code.should == 200
+      returned_response.body.should == "stub for foo"
+    end
+
+    it 'ignores the custom stub finder if it the block returns nil' do
+      @stub_target.register_stub_finder { |r| }
+
+      @stub_target.stub(:get, "http://localhost:3000/foo",
+                        :headers => { 'user-agent' => 'test'}).
+                        and_return(@response)
+
+      @hydra.queue(@request)
+      @hydra.run
+      @on_complete_handler_called.should be_true
+      @response.request.should == @request
     end
 
     it "should provide a stubs accessor" do