excon 0.30.0 → 0.31.0

data/tests/pipeline_tests.rb

@@ -0,0 +1,40 @@
+Shindo.tests('Pipelined Requests') do
+  with_server('good') do
+
+    tests('with default :persistent => true') do
+      returns(%w{ 1 2 3 4 }, 'connection is persistent') do
+        connection = Excon.new('http://127.0.0.1:9292', :persistent => true)
+
+        ret = []
+        ret << connection.requests([
+          {:method => :get, :path => '/echo/request_count'},
+          {:method => :get, :path => '/echo/request_count'}
+        ]).map(&:body)
+        ret << connection.requests([
+          {:method => :get, :path => '/echo/request_count'},
+          {:method => :get, :path => '/echo/request_count'}
+        ]).map(&:body)
+        ret.flatten
+      end
+    end
+
+    tests('with default :persistent => false') do
+      returns(%w{ 1 2 1 2 }, 'connection is persistent per call to #requests') do
+        connection = Excon.new('http://127.0.0.1:9292', :persistent => false)
+
+        ret = []
+        ret << connection.requests([
+          {:method => :get, :path => '/echo/request_count'},
+          {:method => :get, :path => '/echo/request_count'}
+        ]).map(&:body)
+        ret << connection.requests([
+          {:method => :get, :path => '/echo/request_count'},
+          {:method => :get, :path => '/echo/request_count'}
+        ]).map(&:body)
+        ret.flatten
+      end
+
+    end
+
+  end
+end

data/tests/proxy_tests.rb

@@ -4,17 +4,17 @@ Shindo.tests('Excon proxy support') do
   tests('proxy configuration') do
 
     tests('no proxy') do
-      connection = Excon.new('http://foo.com')
-
       tests('connection.data[:proxy]').returns(nil) do
+        connection = Excon.new('http://foo.com')
         connection.data[:proxy]
       end
     end
 
     tests('with fully-specified proxy: https://myproxy.net:8080') do
-      connection = Excon.new('http://foo.com', :proxy => 'https://myproxy.net:8080')
+      connection = nil
 
       tests('connection.data[:proxy][:host]').returns('myproxy.net') do
+        connection = Excon.new('http://foo.com', :proxy => 'https://myproxy.net:8080')
         connection.data[:proxy][:host]
       end
 
@@ -31,9 +31,10 @@ Shindo.tests('Excon proxy support') do
       env_init(env)
 
       tests('an http connection') do
-        connection = Excon.new('http://foo.com')
+        connection = nil
 
         tests('connection.data[:proxy][:host]').returns('myproxy') do
+          connection = Excon.new('http://foo.com')
           connection.data[:proxy][:host]
         end
 
@@ -47,9 +48,10 @@ Shindo.tests('Excon proxy support') do
       end
 
       tests('an https connection') do
-        connection = Excon.new('https://secret.com')
+        connection = nil
 
         tests('connection.data[:proxy][:host]').returns('mysecureproxy') do
+          connection = Excon.new('https://secret.com')
           connection.data[:proxy][:host]
         end
 
@@ -63,9 +65,10 @@ Shindo.tests('Excon proxy support') do
       end
 
       tests('http proxy from the environment overrides config') do
-        connection = Excon.new('http://foo.com', :proxy => 'http://hard.coded.proxy:6666')
+        connection = nil
 
         tests('connection.data[:proxy][:host]').returns('myproxy') do
+          connection = Excon.new('http://foo.com', :proxy => 'http://hard.coded.proxy:6666')
           connection.data[:proxy][:host]
         end
 
@@ -75,25 +78,22 @@ Shindo.tests('Excon proxy support') do
       end
 
       tests('an http connection in no_proxy') do
-        connection = Excon.new('http://somesubdomain.noproxy')
-
-        tests('connection.data[:proxy]').returns(nil) do 
+        tests('connection.data[:proxy]').returns(nil) do
+          connection = Excon.new('http://somesubdomain.noproxy')
           connection.data[:proxy]
         end
       end
 
       tests('an http connection not completely matching no_proxy') do
-        connection = Excon.new('http://noproxy2')
-
         tests('connection.data[:proxy][:host]').returns('myproxy') do
+          connection = Excon.new('http://noproxy2')
           connection.data[:proxy][:host]
         end
       end
 
       tests('an http connection with subdomain in no_proxy') do
-        connection = Excon.new('http://a.subdomain.noproxy2')
-
         tests('connection.data[:proxy]').returns(nil) do
+          connection = Excon.new('http://a.subdomain.noproxy2')
           connection.data[:proxy]
         end
       end
@@ -119,9 +119,10 @@ Shindo.tests('Excon proxy support') do
       env_init({'http_proxy' => 'http://myproxy:8080' })
 
       tests('an https connection') do
-        connection = Excon.new('https://secret.com')
+        connection = nil
 
         tests('connection.data[:proxy][:host]').returns('myproxy') do
+          connection = Excon.new('https://secret.com')
           connection.data[:proxy][:host]
         end
 
@@ -142,10 +143,12 @@ Shindo.tests('Excon proxy support') do
   with_rackup('proxy.ru') do
 
     tests('http proxying: http://foo.com:8080') do
-      connection = Excon.new('http://foo.com:8080', :proxy => 'http://127.0.0.1:9292')
-      response = connection.request(:method => :get, :path => '/bar', :query => {:alpha => 'kappa'})
+      response = nil
 
       tests('response.status').returns(200) do
+        connection = Excon.new('http://foo.com:8080', :proxy => 'http://127.0.0.1:9292')
+        response = connection.request(:method => :get, :path => '/bar', :query => {:alpha => 'kappa'})
+
         response.status
       end
 
@@ -168,10 +171,12 @@ Shindo.tests('Excon proxy support') do
     end
 
     tests('http proxying: http://user:pass@foo.com:8080') do
-      connection = Excon.new('http://foo.com:8080', :proxy => 'http://user:pass@127.0.0.1:9292')
-      response = connection.request(:method => :get, :path => '/bar', :query => {:alpha => 'kappa'})
+      response = nil
 
       tests('response.status').returns(200) do
+        connection = Excon.new('http://foo.com:8080', :proxy => 'http://user:pass@127.0.0.1:9292')
+        response = connection.request(:method => :get, :path => '/bar', :query => {:alpha => 'kappa'})
+
         response.status
       end
 

data/tests/query_string_tests.rb

@@ -1,35 +1,34 @@
 Shindo.tests('Excon query string variants') do
   with_rackup('query_string.ru') do
-    connection = Excon.new('http://127.0.0.1:9292')
+    connection = nil
 
     tests(":query => {:foo => 'bar'}") do
+      tests("query string sent").returns('foo=bar') do
+        connection = Excon.new('http://127.0.0.1:9292')
 
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar'})
-      query_string = response.body[7..-1] # query string sent
+        response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar'})
+        query_string = response.body[7..-1] # query string sent
 
-      tests("query string sent").returns('foo=bar') do
         query_string
       end
-
     end
 
     tests(":query => {:foo => nil}") do
-
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => nil})
-      query_string = response.body[7..-1] # query string sent
-
       tests("query string sent").returns('foo') do
+        response = connection.request(:method => :get, :path => '/query', :query => {:foo => nil})
+        query_string = response.body[7..-1] # query string sent
+
         query_string
       end
-
     end
 
     tests(":query => {:foo => 'bar', :me => nil}") do
-
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar', :me => nil})
-      query_string = response.body[7..-1] # query string sent
+      query_string = nil
 
       test("query string sent includes 'foo=bar'") do
+        response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar', :me => nil})
+        query_string = response.body[7..-1] # query string sent
+
         query_string.split('&').include?('foo=bar')
       end
 
@@ -40,11 +39,12 @@ Shindo.tests('Excon query string variants') do
     end
 
     tests(":query => {:foo => 'bar', :me => 'too'}") do
-
-      response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar', :me => 'too'})
-      query_string = response.body[7..-1] # query string sent
+      query_string = nil
 
       test("query string sent includes 'foo=bar'") do
+        response = connection.request(:method => :get, :path => '/query', :query => {:foo => 'bar', :me => 'too'})
+        query_string = response.body[7..-1] # query string sent
+
         query_string.split('&').include?('foo=bar')
       end
 

data/tests/rackups/basic.rb

@@ -1,6 +1,10 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class Basic < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   get('/content-length/:value') do |value|
     headers("Custom" => "Foo: bar")
     'x' * value.to_i

data/tests/rackups/proxy.ru

@@ -1,6 +1,10 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class App < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   get('*') do
     headers(
       "Sent-Request-Uri" => request.env['REQUEST_URI'].to_s,

data/tests/rackups/query_string.ru

@@ -1,6 +1,10 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class App < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   get('/query') do
     "query: " << request.query_string
   end

data/tests/rackups/request_headers.ru

@@ -1,6 +1,10 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class App < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   post '/' do
     h = ""
     env.each { |k,v| h << "#{$1.downcase}: #{v}\n" if k =~ /http_(.*)/i }

data/tests/rackups/request_methods.ru

@@ -1,14 +1,18 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class App < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   get '/' do
     'GET'
   end
-  
+
   post '/' do
     'POST'
   end
-  
+
   delete '/' do
     'DELETE'
   end

data/tests/rackups/response_header.ru

@@ -1,6 +1,10 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class App < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   get('/foo') do
     headers(
       "MixedCase-Header" => 'MixedCase',

data/tests/rackups/thread_safety.ru

@@ -1,6 +1,10 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class App < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   get('/id/:id/wait/:wait') do |id, wait|
     sleep(wait.to_i)
     id.to_s

data/tests/rackups/timeout.ru

@@ -1,8 +1,13 @@
 require 'sinatra'
+require File.join(File.dirname(__FILE__), 'webrick_patch')
 
 class App < Sinatra::Base
+  set :environment, :production
+  enable :dump_errors
+
   get('/timeout') do
     sleep(2)
+    ''
   end
 end
 

data/tests/rackups/webrick_patch.rb

@@ -0,0 +1,34 @@
+# The ruby 2.0 stdlib includes the following changes
+# to avoid "can't add a new key into hash during iteration" errors.
+#   https://github.com/ruby/ruby/commit/3c491a92f6fbfecc065f7687c51c7d6d52a38883
+#   https://github.com/ruby/ruby/commit/7b18633804c606e8bcccfbb44e7d7b795e777ea6
+# However, these changes were not backported to the 1.9.x stdlib.
+# These errors are causing intermittent errors in the tests (frequently in jruby),
+# so we're applying those changes here. This is loaded by all rackups using WEBrick.
+if RUBY_VERSION =~ /^1\.9/
+  require 'webrick/utils'
+  module WEBrick
+    module Utils
+      class TimeoutHandler
+        def initialize
+          @timeout_info = Hash.new
+          Thread.start{
+            while true
+              now = Time.now
+              @timeout_info.keys.each{|thread|
+                ary = @timeout_info[thread]
+                next unless ary
+                ary.dup.each{|info|
+                  time, exception = *info
+                  interrupt(thread, info.object_id, exception) if time < now
+                }
+              }
+              sleep 0.5
+            end
+          }
+        end
+      end
+    end
+  end
+end
+

data/tests/request_method_tests.rb

@@ -19,10 +19,10 @@ Shindo.tests('Excon request methods') do
     end
 
     tests 'with a connection object' do
-
-      connection = Excon.new('http://localhost:9292')
+      connection = nil
 
       tests('connection.get').returns('GET') do
+        connection = Excon.new('http://localhost:9292')
         connection.get.body
       end
 

data/tests/request_tests.rb

@@ -0,0 +1,113 @@
+Shindo.tests('Request Tests') do
+  with_server('good') do
+
+    tests('sets transfer-coding and connection options') do
+
+      tests('without a :response_block') do
+        request = nil
+
+        returns('trailers, deflate, gzip', 'sets encoding options') do
+          request = Marshal.load(
+            Excon.get('http://127.0.0.1:9292/echo/request').body
+          )
+
+          request[:headers]['TE']
+        end
+
+        returns(true, 'TE added to Connection header') do
+          request[:headers]['Connection'].include?('TE')
+        end
+      end
+
+      tests('with a :response_block') do
+        request = nil
+
+        returns('trailers', 'does not set encoding options') do
+          captures = capture_response_block do |block|
+            Excon.get('http://127.0.0.1:9292/echo/request',
+                      :response_block => block)
+          end
+          data = captures.map {|capture| capture[0] }.join
+          request = Marshal.load(data)
+
+          request[:headers]['TE']
+        end
+
+        returns(true, 'TE added to Connection header') do
+          request[:headers]['Connection'].include?('TE')
+        end
+      end
+
+    end
+
+    tests('persistent connections') do
+
+      tests('with default :persistent => true') do
+        connection = nil
+
+        returns(['1', '2'], 'uses a persistent connection') do
+          connection = Excon.new('http://127.0.0.1:9292', :persistent => true)
+          2.times.map do
+            connection.request(:method => :get, :path => '/echo/request_count').body
+          end
+        end
+
+        returns(['3', '1', '2'], ':persistent => false resets connection') do
+          ret = []
+          ret << connection.request(:method => :get,
+                                    :path   => '/echo/request_count',
+                                    :persistent => false).body
+          ret << connection.request(:method => :get,
+                                    :path   => '/echo/request_count').body
+          ret << connection.request(:method => :get,
+                                    :path   => '/echo/request_count').body
+        end
+      end
+
+      tests('with default :persistent => false') do
+        connection = nil
+
+        returns(['1', '1'], 'does not use a persistent connection') do
+          connection = Excon.new('http://127.0.0.1:9292', :persistent => false)
+          2.times.map do
+            connection.request(:method => :get, :path => '/echo/request_count').body
+          end
+        end
+
+        returns(['1', '2', '3', '1'], ':persistent => true enables persistence') do
+          ret = []
+          ret << connection.request(:method => :get,
+                                    :path   => '/echo/request_count',
+                                    :persistent => true).body
+          ret << connection.request(:method => :get,
+                                    :path   => '/echo/request_count',
+                                    :persistent => true).body
+          ret << connection.request(:method => :get,
+                                    :path   => '/echo/request_count').body
+          ret << connection.request(:method => :get,
+                                    :path   => '/echo/request_count').body
+        end
+      end
+
+      tests('sends `Connection: close`') do
+        returns(true, 'when :persistent => false') do
+          request = Marshal.load(
+            Excon.get('http://127.0.0.1:9292/echo/request',
+                      :persistent => false).body
+          )
+          request[:headers]['Connection'].include?('close')
+        end
+
+        returns(false, 'not when :persistent => true') do
+          request = Marshal.load(
+            Excon.get('http://127.0.0.1:9292/echo/request',
+                      :persistent => true).body
+          )
+          request[:headers]['Connection'].include?('close')
+        end
+      end
+
+    end
+
+  end
+end