excon 0.62.0 → 0.92.3

data/tests/servers/good.rb

@@ -1,350 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'eventmachine'
-require 'stringio'
-require 'uri'
-require 'zlib'
-
-module GoodServer
-  # This method will be called with each request received.
-  #
-  #     request = {
-  #       :method   => method,
-  #       :uri      => URI.parse(uri),
-  #       :headers  => {},
-  #       :body     => ''
-  #     }
-  #
-  # Each connection to this server is persistent unless the client sends
-  # "Connection: close" in the request. If a response requires the connection
-  # to be closed, use `start_response(:persistent => false)`.
-  def send_response(request)
-    type, path = request[:uri].path.split('/', 3)[1, 2]
-    case type
-    when 'echo'
-      case path
-      when 'request'
-        data = Marshal.dump(request)
-        start_response
-        send_data "Content-Length: #{ data.size }\r\n"
-        send_data "\r\n"
-        send_data data
-
-      when 'request_count'
-        (@request_count ||= '0').next!
-        start_response
-        send_data "Content-Length: #{ @request_count.size }\r\n"
-        send_data "Connection: Keep-Alive\r\n"
-        send_data "\r\n"
-        send_data @request_count
-
-      when /(content|transfer)-encoded\/?(.*)/
-        if (encoding_type = $1) == 'content'
-          accept_header = 'Accept-Encoding'
-          encoding_header = 'Content-Encoding'
-        else
-          accept_header = 'TE'
-          encoding_header = 'Transfer-Encoding'
-        end
-        chunked = $2 == 'chunked'
-
-        encodings = parse_encodings(request[:headers][accept_header])
-        while encoding = encodings.pop
-          break if ['gzip', 'deflate'].include?(encoding)
-        end
-
-        case encoding
-        when 'gzip'
-          body = request[:body]
-          if(body.nil? || body.empty?)
-            body = ''
-          else
-            io = (Zlib::GzipWriter.new(StringIO.new) << request[:body]).finish
-            io.rewind
-            body = io.read
-          end
-        when 'deflate'
-          # drops the zlib header
-          deflator = Zlib::Deflate.new(nil, -Zlib::MAX_WBITS)
-          body = deflator.deflate(request[:body], Zlib::FINISH)
-          deflator.close
-        else
-          body = request[:body]
-        end
-
-        # simulate server pre/post content encoding
-        encodings = [
-          request[:headers]["#{ encoding_header }-Pre"],
-          encoding,
-          request[:headers]["#{ encoding_header }-Post"],
-        ]
-        if chunked && encoding_type == 'transfer'
-          encodings << 'chunked'
-        end
-        encodings = encodings.compact.join(', ')
-
-        start_response
-        # let the test know what the server sent
-        send_data "#{ encoding_header }-Sent: #{ encodings }\r\n"
-        send_data "#{ encoding_header }: #{ encodings }\r\n" unless encodings.empty?
-        if chunked
-          if encoding_type == 'content'
-            send_data "Transfer-Encoding: chunked\r\n"
-          end
-          send_data "\r\n"
-          send_data chunks_for(body)
-          send_data "\r\n"
-        else
-          send_data "Content-Length: #{ body.size }\r\n"
-          send_data "\r\n"
-          send_data body
-        end
-      end
-
-    when 'chunked'
-      case path
-      when 'simple'
-        start_response
-        send_data "Transfer-Encoding: chunked\r\n"
-        send_data "\r\n"
-        # chunk-extension is currently ignored.
-        # this works because "6; chunk-extension".to_i => "6"
-        send_data "6; chunk-extension\r\n"
-        send_data "hello \r\n"
-        send_data "5; chunk-extension\r\n"
-        send_data "world\r\n"
-        send_data "0; chunk-extension\r\n" # last-chunk
-        send_data "\r\n"
-
-      # merged trailers also support continuations
-      when 'trailers'
-        start_response
-        send_data "Transfer-Encoding: chunked\r\n"
-        send_data "Test-Header: one, two\r\n"
-        send_data "\r\n"
-        send_data chunks_for('hello world')
-        send_data "Test-Header: three, four,\r\n"
-        send_data "\tfive, six\r\n"
-        send_data "\r\n"
-      end
-
-    when 'content-length'
-      case path
-      when 'simple'
-        start_response
-        send_data "Content-Length: 11\r\n"
-        send_data "\r\n"
-        send_data "hello world"
-      end
-
-    when 'unknown'
-      case path
-      when 'cookies'
-        start_response(:persistent => false)
-        send_data "Set-Cookie: one, two\r\n"
-        send_data "Set-Cookie: three, four\r\n"
-        send_data "\r\n"
-        send_data "hello world"
-
-      when 'simple'
-        start_response(:persistent => false)
-        send_data "\r\n"
-        send_data "hello world"
-
-      when 'header_continuation'
-        start_response(:persistent => false)
-        send_data "Test-Header: one, two\r\n"
-        send_data "Test-Header: three, four,\r\n"
-        send_data "  five, six\r\n"
-        send_data "\r\n"
-        send_data "hello world"
-      end
-
-    when 'bad'
-      # Excon will close these connections due to the errors.
-      case path
-      when 'malformed_header'
-        start_response
-        send_data "Bad-Header\r\n"  # no ':'
-        send_data "\r\n"
-        send_data "hello world"
-
-      when 'malformed_header_continuation'
-        send_data "HTTP/1.1 200 OK\r\n"
-        send_data " Bad-Header: one, two\r\n"  # no previous header
-        send_data "\r\n"
-        send_data "hello world"
-      end
-
-    when 'not-found'
-      start_response(:status => "404 Not Found")
-      send_data "Content-Length: 11\r\n"
-      send_data "\r\n"
-      send_data "hello world"
-    end
-  end
-
-  # Sends response status-line, plus headers common to all responses.
-  def start_response(opts = {})
-    opts = {
-      :status     => '200 OK',
-      :persistent => @persistent  # true unless client sent Connection: close
-    }.merge!(opts)
-
-    @persistent = opts[:persistent]
-    send_data "HTTP/1.1 #{ opts[:status] }\r\n"
-    send_data "Connection: close\r\n" unless @persistent
-  end
-
-  def post_init
-    @buffer = StringIO.new
-    @buffer.set_encoding('BINARY') if @buffer.respond_to?(:set_encoding)
-  end
-
-  # Receives a String of +data+ sent from the client.
-  # +data+ may only be a portion of what the client sent.
-  # The data is buffered, then processed and removed from the buffer
-  # as data becomes available until the @request is complete.
-  def receive_data(data)
-    @buffer.seek(0, IO::SEEK_END)
-    @buffer.write(data)
-
-    parse_headers unless @request
-    parse_body if @request
-
-    if @request_complete
-      send_response(@request)
-      if @persistent
-        @request = nil
-        @request_complete = false
-        # process remaining buffer for next request
-        receive_data('') unless @buffer.eof?
-      else
-        close_connection(true)
-      end
-    end
-  end
-
-  # Removes the processed portion of the buffer
-  # by replacing the buffer with it's contents from the current pos.
-  def sync_buffer
-    @buffer.string = @buffer.read
-  end
-
-  def parse_headers
-    @buffer.rewind
-    # wait until buffer contains the end of the headers
-    if /\sHTTP\/\d+\.\d+\r\n.*?\r\n\r\n/m =~ @buffer.read
-      @buffer.rewind
-      # For persistent connections, the buffer could start with the
-      # \r\n chunked-message terminator from the previous request.
-      # This will discard anything up to the request-line.
-      until m = /^(\w+)\s(.*)\sHTTP\/\d+\.\d+$/.match(@buffer.readline.chop!); end
-      method, uri = m[1, 2]
-
-      headers = {}
-      last_key = nil
-      until (line = @buffer.readline.chop!).empty?
-        if !line.lstrip!.nil?
-          headers[last_key] << ' ' << line.rstrip
-        else
-          key, value = line.split(':', 2)
-          headers[key] = ([headers[key]] << value.strip).compact.join(', ')
-          last_key = key
-        end
-      end
-
-      sync_buffer
-
-      @chunked = headers['Transfer-Encoding'] =~ /chunked/i
-      @content_length = headers['Content-Length'].to_i
-      @persistent = headers['Connection'] !~ /close/i
-      @request = {
-        :method   => method,
-        :uri      => URI.parse(uri),
-        :headers  => headers,
-        :body     => ''
-      }
-    end
-  end
-
-  def parse_body
-    if @chunked
-      @buffer.rewind
-      until @request_complete || @buffer.eof?
-        unless @chunk_size
-          # in case buffer only contains a portion of the chunk-size line
-          if (line = @buffer.readline) =~ /\r\n\z/
-            @chunk_size = line.to_i(16)
-            if @chunk_size > 0
-              sync_buffer
-            else # last-chunk
-              @buffer.read(2)  # the final \r\n may or may not be in the buffer
-              sync_buffer
-              @chunk_size = nil
-              @request_complete = true
-            end
-          end
-        end
-        if @chunk_size
-          if @buffer.size >= @chunk_size + 2
-            @request[:body] << @buffer.read(@chunk_size + 2).chop!
-            @chunk_size = nil
-            sync_buffer
-          else
-            break # wait for more data
-          end
-        end
-      end
-    elsif @content_length > 0
-      @buffer.rewind
-      unless @buffer.eof?  # buffer only contained the headers
-        @request[:body] << @buffer.read(@content_length - @request[:body].size)
-        sync_buffer
-        if @request[:body].size == @content_length
-          @request_complete = true
-        end
-      end
-    else
-      # no body
-      @request_complete = true
-    end
-  end
-
-  def chunks_for(str)
-    chunks = ''
-    str.force_encoding('BINARY') if str.respond_to?(:force_encoding)
-    chunk_size = str.size / 2
-    until (chunk = str.slice!(0, chunk_size)).empty?
-      chunks << chunk.size.to_s(16) << "\r\n"
-      chunks << chunk << "\r\n"
-    end
-    chunks << "0\r\n" # last-chunk
-  end
-
-  # only supports a single quality parameter for tokens
-  def parse_encodings(encodings)
-    return [] if encodings.nil?
-    split_header_value(encodings).map do |value|
-      token, q_val = /^(.*?)(?:;q=(.*))?$/.match(value.strip)[1, 2]
-      if q_val && q_val.to_f == 0
-        nil
-      else
-        [token, (q_val || 1).to_f]
-      end
-    end.compact.sort_by {|_, q_val| q_val }.map {|token, _| token }
-  end
-
-  # Splits a header value +str+ according to HTTP specification.
-  def split_header_value(str)
-    return [] if str.nil?
-    str.strip.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",]+)+)
-                        (?:,\s*|\Z)'xn).flatten
-  end
-end
-
-EM.run do
-  EM.start_server("127.0.0.1", 9292, GoodServer)
-  EM.start_server("::1", 9293, GoodServer) unless RUBY_PLATFORM == 'java'
-  $stderr.puts "ready"
-end

data/tests/test_helper.rb

@@ -1,306 +0,0 @@
-require 'rubygems' if RUBY_VERSION < '1.9'
-require 'bundler/setup'
-require 'excon'
-require 'delorean'
-require 'open4'
-
-Excon.defaults.merge!(
-  :connect_timeout  => 5,
-  :read_timeout     => 5,
-  :write_timeout    => 5
-)
-
-def basic_tests(url = 'http://127.0.0.1:9292', options = {})
-  ([true, false] * 2).combination(2).to_a.uniq.each do |nonblock, persistent|
-    connection = nil
-    test do
-      options = options.merge({:ssl_verify_peer => false, :nonblock => nonblock, :persistent => persistent })
-      connection = Excon.new(url, options)
-      true
-    end
-
-    tests("nonblock => #{nonblock}, persistent => #{persistent}") do
-
-      tests('GET /content-length/100') do
-        response = nil
-
-        tests('response.status').returns(200) do
-          response = connection.request(:method => :get, :path => '/content-length/100')
-
-          response.status
-        end
-
-        tests('response[:status]').returns(200) do
-          response[:status]
-        end
-
-        tests("response.headers['Content-Length']").returns('100') do
-          response.headers['Content-Length']
-        end
-
-        tests("response.headers['Content-Type']").returns('text/html;charset=utf-8') do
-          response.headers['Content-Type']
-        end
-
-        test("Time.parse(response.headers['Date']).is_a?(Time)") do
-          pending if connection.data[:scheme] == Excon::UNIX
-          Time.parse(response.headers['Date']).is_a?(Time)
-        end
-
-        test("!!(response.headers['Server'] =~ /^WEBrick/)") do
-          pending if connection.data[:scheme] == Excon::UNIX
-          !!(response.headers['Server'] =~ /^WEBrick/)
-        end
-
-        tests("response.headers['Custom']").returns("Foo: bar") do
-          response.headers['Custom']
-        end
-
-        tests("response.remote_ip").returns("127.0.0.1") do
-          pending if connection.data[:scheme] == Excon::UNIX
-          response.remote_ip
-        end
-
-        tests("response.body").returns('x' * 100) do
-          response.body
-        end
-
-        tests("deprecated block usage").returns(['x' * 100, 0, 100]) do
-          data = []
-          silence_warnings do
-            connection.request(:method => :get, :path => '/content-length/100') do |chunk, remaining_length, total_length|
-              data = [chunk, remaining_length, total_length]
-            end
-          end
-          data
-        end
-
-        tests("response_block usage").returns(['x' * 100, 0, 100]) do
-          data = []
-          response_block = lambda do |chunk, remaining_length, total_length|
-            data = [chunk, remaining_length, total_length]
-          end
-          connection.request(:method => :get, :path => '/content-length/100', :response_block => response_block)
-          data
-        end
-
-      end
-
-      tests('POST /body-sink') do
-
-        tests('response.body').returns("5000000") do
-          response = connection.request(:method => :post, :path => '/body-sink', :headers => { 'Content-Type' => 'text/plain' }, :body => 'x' * 5_000_000)
-          response.body
-        end
-
-        tests('empty body').returns('0') do
-          response = connection.request(:method => :post, :path => '/body-sink', :headers => { 'Content-Type' => 'text/plain' }, :body => '')
-          response.body
-        end
-
-      end
-
-      tests('POST /echo') do
-
-        tests('with file').returns('x' * 100 + "\n") do
-          file_path = File.join(File.dirname(__FILE__), "data", "xs")
-          response = connection.request(:method => :post, :path => '/echo', :body => File.open(file_path))
-          response.body
-        end
-
-        tests('without request_block').returns('x' * 100) do
-          response = connection.request(:method => :post, :path => '/echo', :body => 'x' * 100)
-          response.body
-        end
-
-        tests('with request_block').returns('x' * 100) do
-          data = ['x'] * 100
-          request_block = lambda do
-            data.shift.to_s
-          end
-          response = connection.request(:method => :post, :path => '/echo', :request_block => request_block)
-          response.body
-        end
-
-        tests('with multi-byte strings') do
-          body = "\xC3\xBC" * 100
-          headers = { 'Custom' => body.dup }
-          if RUBY_VERSION >= '1.9'
-            body.force_encoding('BINARY')
-            headers['Custom'].force_encoding('UTF-8')
-          end
-
-          returns(body, 'properly concatenates request+headers and body') do
-            response = connection.request(:method => :post, :path => '/echo', :headers => headers, :body => body)
-            response.body
-          end
-        end
-
-      end
-
-      tests('PUT /echo') do
-
-        tests('with file').returns('x' * 100 + "\n") do
-          file_path = File.join(File.dirname(__FILE__), "data", "xs")
-          response = connection.request(:method => :put, :path => '/echo', :body => File.open(file_path))
-          response.body
-        end
-
-        tests('without request_block').returns('x' * 100) do
-          response = connection.request(:method => :put, :path => '/echo', :body => 'x' * 100)
-          response.body
-        end
-
-        tests('request_block usage').returns('x' * 100) do
-          data = ['x'] * 100
-          request_block = lambda do
-            data.shift.to_s
-          end
-          response = connection.request(:method => :put, :path => '/echo', :request_block => request_block)
-          response.body
-        end
-
-        tests('with multi-byte strings') do
-          body = "\xC3\xBC" * 100
-          headers = { 'Custom' => body.dup }
-          if RUBY_VERSION >= '1.9'
-            body.force_encoding('BINARY')
-            headers['Custom'].force_encoding('UTF-8')
-          end
-
-          returns(body, 'properly concatenates request+headers and body') do
-            response = connection.request(:method => :put, :path => '/echo', :headers => headers, :body => body)
-            response.body
-          end
-        end
-
-      end
-
-      tests('should succeed with tcp_nodelay').returns(200) do
-        options = options.merge(:ssl_verify_peer => false, :nonblock => nonblock, :tcp_nodelay => true)
-        connection = Excon.new(url, options)
-        response = connection.request(:method => :get, :path => '/content-length/100')
-        response.status
-      end
-
-    end
-  end
-end
-
-
-PROXY_ENV_VARIABLES = %w{http_proxy https_proxy no_proxy} # All lower-case
-
-def env_init(env={})
-  current = {}
-  PROXY_ENV_VARIABLES.each do |key|
-    current[key] = ENV.delete(key)
-    current[key.upcase] = ENV.delete(key.upcase)
-  end
-  env_stack << current
-
-  env.each do |key, value|
-    ENV[key] = value
-  end
-end
-
-def env_restore
-  ENV.update(env_stack.pop)
-end
-
-def env_stack
-  @env_stack ||= []
-end
-
-def silence_warnings
-  orig_verbose = $VERBOSE
-  $VERBOSE = nil
-  yield
-ensure
-  $VERBOSE = orig_verbose
-end
-
-def capture_response_block
-  captures = []
-  yield lambda {|chunk, remaining_bytes, total_bytes|
-    captures << [chunk, remaining_bytes, total_bytes]
-  }
-  captures
-end
-
-def rackup_path(*parts)
-  File.expand_path(File.join(File.dirname(__FILE__), 'rackups', *parts))
-end
-
-def with_rackup(name, host="127.0.0.1")
-  unless RUBY_PLATFORM == 'java'
-    GC.disable if RUBY_VERSION < '1.9'
-    pid, w, r, e = Open4.popen4("rackup", "-s", "webrick", "--host", host, rackup_path(name))
-  else
-    pid, w, r, e = IO.popen4("rackup", "-s", "webrick", "--host", host, rackup_path(name))
-  end
-  until e.gets =~ /HTTPServer#start:/; end
-  yield
-ensure
-  Process.kill(9, pid)
-  unless RUBY_PLATFORM == 'java'
-    GC.enable if RUBY_VERSION < '1.9'
-    Process.wait(pid)
-  end
-
-  # dump server errors
-  lines = e.read.split($/)
-  while line = lines.shift
-    case line
-    when /(ERROR|Error)/
-      unless line =~ /(null cert chain|did not return a certificate|SSL_read:: internal error)/
-        in_err = true
-        puts
-      end
-    when /^(127|localhost)/
-      in_err = false
-    end
-    puts line if in_err
-  end
-end
-
-def with_unicorn(name, listen='127.0.0.1:9292')
-  unless RUBY_PLATFORM == 'java'
-    GC.disable if RUBY_VERSION < '1.9'
-    unix_socket = listen.sub('unix://', '') if listen.start_with? 'unix://'
-    pid, w, r, e = Open4.popen4("unicorn", "--no-default-middleware","-l", listen, rackup_path(name))
-    until e.gets =~ /worker=0 ready/; end
-  else
-    # need to find suitable server for jruby
-  end
-  yield
-ensure
-  unless RUBY_PLATFORM == 'java'
-    Process.kill(9, pid)
-    GC.enable if RUBY_VERSION < '1.9'
-    Process.wait(pid)
-  end
-  if not unix_socket.nil? and File.exist?(unix_socket)
-    File.delete(unix_socket)
-  end
-end
-
-def server_path(*parts)
-  File.expand_path(File.join(File.dirname(__FILE__), 'servers', *parts))
-end
-
-def with_server(name)
-  unless RUBY_PLATFORM == 'java'
-    GC.disable if RUBY_VERSION < '1.9'
-    pid, w, r, e = Open4.popen4(server_path("#{name}.rb"))
-  else
-    pid, w, r, e = IO.popen4(server_path("#{name}.rb"))
-  end
-  until e.gets =~ /ready/; end
-  yield
-ensure
-  Process.kill(9, pid)
-  unless RUBY_PLATFORM == 'java'
-    GC.enable if RUBY_VERSION < '1.9'
-    Process.wait(pid)
-  end
-end

data/tests/thread_safety_tests.rb

@@ -1,39 +0,0 @@
-Shindo.tests('Excon thread safety') do
-  
-  tests('thread_safe_sockets configuration') do
-    tests('thread_safe_sockets default').returns(true) do
-      connection = Excon.new('http://foo.com')
-      connection.data[:thread_safe_sockets]
-    end
-
-    tests('with thread_safe_sockets set false').returns(false) do
-      connection = Excon.new('http://foo.com', :thread_safe_sockets => false)
-      connection.data[:thread_safe_sockets]
-    end
-  end
-
-  with_rackup('thread_safety.ru') do
-    connection = Excon.new('http://127.0.0.1:9292')
-
-    long_thread = Thread.new {
-      response = connection.request(:method => 'GET', :path => '/id/1/wait/2')
-      Thread.current[:success] = response.body == '1'
-    }
-
-    short_thread = Thread.new {
-      response = connection.request(:method => 'GET', :path => '/id/2/wait/1')
-      Thread.current[:success] = response.body == '2'
-    }
-
-    test('long_thread') do
-      long_thread.join
-      short_thread.join
-
-      long_thread[:success]
-    end
-
-    test('short_thread') do
-      short_thread[:success]
-    end
-  end
-end

data/tests/timeout_tests.rb

@@ -1,12 +0,0 @@
-Shindo.tests('read should timeout') do
-  with_rackup('timeout.ru') do
-
-    [false, true].each do |nonblock|
-      tests("nonblock => #{nonblock} hits read_timeout").raises(Excon::Errors::Timeout) do
-        connection = Excon.new('http://127.0.0.1:9292', :nonblock => nonblock)
-        connection.request(:method => :get, :path => '/timeout', :read_timeout => 1)
-      end
-    end
-
-  end
-end