excon 0.64.0 → 0.65.0

data/spec/support/shared_contexts/test_stub_context.rb

@@ -1,11 +0,0 @@
-shared_context "stubs" do 
-  before do
-    @original_mock = Excon.defaults[:mock]
-    Excon.defaults[:mock] = true
-  end
-
-  after do
-    Excon.defaults[:mock] = @original_mock
-    Excon.stubs.clear
-  end
-end

data/spec/support/shared_examples/shared_example_for_clients.rb

@@ -1,220 +0,0 @@
-require 'time'
-
-shared_examples_for 'a basic client' do |url = 'http://127.0.0.1:9292', opts = {}|
-  # TODO: Ditch iterator and manually write a context for each set of options
-  ([true, false] * 2).combination(2).to_a.uniq.each do |nonblock, persistent|
-    context "when nonblock is #{nonblock} and persistent is #{persistent}" do
-      opts = opts.merge(ssl_verify_peer: false, nonblock: nonblock, persistent: persistent)
-
-      let(:conn) { Excon.new(url, opts) }
-
-      context 'when :method is get and :path is /content-length/100' do
-        describe '#request' do
-          let(:response) do
-            conn.request(method: :get, path: '/content-length/100')
-          end
-
-          it 'returns an Excon::Response' do
-            expect(response).to be_instance_of Excon::Response
-          end
-          describe Excon::Response do
-            describe '#status' do
-              it 'returns 200' do
-                expect(response.status).to eq 200
-              end
-
-              it '#status returns 200' do
-                expect(response[:status]).to eq 200
-              end
-            end
-            describe '#headers' do
-              it '["Content-Length"] returns 100' do
-                expect(response.headers['Content-Length']).to eq '100'
-              end
-              it '["Content-Type"] returns  "text/html;charset=utf-8"' do
-                expect(response.headers['Content-Type']).to eq 'text/html;charset=utf-8'
-              end
-
-              it "['Date'] returns a valid date" do
-                if RUBY_PLATFORM == 'java' && conn.data[:scheme] == Excon::UNIX
-                  skip('until puma responds with a date header')
-                else
-                  time = Time.parse(response.headers['Date'])
-                  expect(time.is_a?(Time)).to be true
-                end
-              end
-
-              it "['Server'] matches /^WEBrick/" do
-                pending('until unix_socket response has server header') if conn.data[:scheme] == Excon::UNIX
-                expect(!!(response.headers['Server'] =~ /^WEBrick/)).to be true
-              end
-
-              it "['Custom'] returns Foo: bar" do
-                expect(response.headers['Custom']).to eq 'Foo: bar'
-              end
-            end
-            describe '#remote_ip' do
-              it 'returns 127.0.0.1' do
-                pending('until pigs can fly') if conn.data[:scheme] == Excon::UNIX
-                expect(response.remote_ip).to eq '127.0.0.1'
-              end
-            end
-          end
-
-          context('when tcp_nodelay is true') do
-            describe '#request' do
-              response = nil
-              options = opts.merge(ssl_verify_peer: false, nonblock: nonblock, tcp_nodelay: true)
-              connection = Excon.new(url, options)
-
-              it 'returns an Excon::Response' do
-                expect do
-                  response = connection.request(method: :get, path: '/content-length/100')
-                end.to_not raise_error
-              end
-
-              describe Excon::Response do
-                describe '#body' do
-                  describe '.status' do
-                    it '#returns 200' do
-                      expect(response.status).to eq 200
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        context 'when utilizing deprecated block usage' do
-          describe '#request' do
-            data = []
-            it 'yields with a chunk, remaining length, and total length' do
-              expect do
-                silence_warnings do
-                  conn.request(method: :get, path: '/content-length/100') do |chunk, remaining_length, total_length|
-                    data = [chunk, remaining_length, total_length]
-                  end
-                end
-              end.to_not raise_error
-            end
-            it 'completes with expected data' do
-              expect(data).to eq ['x' * 100, 0, 100]
-            end
-          end
-        end
-
-        context 'when utilizing response_block usage' do
-          describe '#request' do
-            data = []
-            it 'yields a chunk, remaining length, and total_length' do
-              response_block = lambda do |chunk, remaining_length, total_length|
-                data = [chunk, remaining_length, total_length]
-              end
-              expect do
-                conn.request(method: :get, path: '/content-length/100', response_block: response_block)
-              end.to_not raise_error
-            end
-            it 'completes with expected data' do
-              expect(data).to eq ['x' * 100, 0, 100]
-            end
-          end
-        end
-        context 'when method is :post' do
-          context 'when :path is /body-sink' do
-            context 'when a body parameter is supplied' do
-              response = nil
-              it 'returns an Excon::Response' do
-                response = conn.request(method: :post, path: '/body-sink', headers: { 'Content-Type' => 'text/plain' }, body: 'x' * 5_000_000)
-                expect(response).to be_instance_of Excon::Response
-              end
-              describe Excon::Response do
-                describe '#body' do
-                  it 'equals "5000000"' do
-                    expect(response.body).to eq '5000000'
-                  end
-                end
-              end
-            end
-            context 'when the body parameter is an empty string' do
-              response = nil
-
-              it 'returns an Excon::Response' do
-                response = conn.request(method: :post, path: '/body-sink', headers: { 'Content-Type' => 'text/plain' }, body: '')
-                expect(response).to be_instance_of Excon::Response
-              end
-              describe Excon::Response do
-                describe '#body' do
-                  it 'equals "0"' do
-                    expect(response.body).to eq '0'
-                  end
-                end
-              end
-            end
-          end
-
-          context 'when :path is /echo' do
-            context('when a file handle is the body paramter') do
-              describe Excon::Response do
-                it '#body equals "x" * 100 + "\n"' do
-                  file_path = data_path('xs')
-                  response = conn.request(method: :post, path: '/echo', body: File.open(file_path))
-                  expect(response.body).to eq 'x' * 100 + "\n"
-                end
-              end
-            end
-
-            context 'when a string is the body paramter' do
-              it 'does not change the enconding of the body' do
-                skip unless RUBY_VERSION >= '2.0'
-
-                string_body = '¥£€'
-                expect do
-                  conn.request(method: :post, path: '/echo', body: string_body)
-                end.to_not change { string_body.encoding }
-              end
-
-              context 'without request_block' do
-                describe Excon::Response do
-                  it "#body equals 'x' * 100)" do
-                    response = conn.request(method: :post, path: '/echo', body: 'x' * 100)
-                    expect(response.body).to eq 'x' * 100
-                  end
-                end
-              end
-
-              context 'when a request_block paramter is supplied' do
-                describe Excon::Response do
-                  it "#body equals'x' * 100" do
-                    data = ['x'] * 100
-                    request_block = lambda do
-                      data.shift.to_s
-                    end
-                    response = conn.request(method: :post, path: '/echo', request_block: request_block)
-                    expect(response.body).to eq 'x' * 100
-                  end
-                end
-              end
-
-              context('when a multi-byte string is the body paramter') 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
-                describe Excon::Response do
-                  it '#body properly concatenates request+headers and body' do
-                    response = conn.request(method: :post, path: '/echo',
-                                            headers: headers, body: body)
-                    expect(response.body).to eq body
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/shared_examples/shared_example_for_streaming_clients.rb

@@ -1,20 +0,0 @@
-shared_examples_for 'a streaming client' do |endpoint, timeout|
-  ret = []
-  timing = 'response times ok'
-  start = Time.now
-  block = lambda do |c,r,t|
-    # add the response
-    ret.push(c)
-    # check if the timing is ok
-    # each response arrives after timeout and before timeout + 1
-    cur_time = Time.now - start
-    if cur_time < ret.length * timeout or cur_time > (ret.length+1) * timeout
-      timing = 'response time not ok!'
-    end
-  end
-  it "gets a response in less than or equal to #{(timeout*3).round(2)} seconds" do
-    Excon.get(endpoint, :response_block => block)
-    # validate the final timing
-    expect((Time.now - start <= timeout*3) == true && timing == 'response times not ok!').to be false
-  end
-end

data/spec/support/shared_examples/shared_example_for_test_servers.rb

@@ -1,16 +0,0 @@
-shared_examples_for "a excon test server" do |plugin, file|
-
-    include_context("test server", plugin, file)
-
-    it "returns an instance" do
-      expect(@server).to be_instance_of Excon::Test::Server
-    end
-
-    it 'starts the server' do
-      expect(@server.start).to be true
-    end
-
-    it 'stops the server' do
-      expect(@server.stop).to be true
-    end
-end

data/tests/authorization_header_tests.rb

@@ -1,27 +0,0 @@
-Shindo.tests('Excon basics (Authorization data redacted)') do
-  cases = [
-    ['user & pass', 'http://user1:pass1@foo.com/', 'Basic dXNlcjE6cGFzczE='],
-    ['email & pass', 'http://foo%40bar.com:pass1@foo.com/', 'Basic Zm9vQGJhci5jb206cGFzczE='],
-    ['user no pass', 'http://three_user@foo.com/', 'Basic dGhyZWVfdXNlcjo='],
-    ['pass no user', 'http://:derppass@foo.com/', 'Basic OmRlcnBwYXNz']
-  ]
-  cases.each do |desc,url,auth_header|
-    conn = nil
-
-    test("authorization header concealed for #{desc}") do
-      conn = Excon.new(url)
-      !conn.inspect.include?(auth_header)
-    end
-
-    if conn.data[:password]
-      test("password param concealed for #{desc}") do
-        !conn.inspect.include?(conn.data[:password])
-      end
-    end
-
-    test("password param remains correct for #{desc}") do
-      conn.data[:password] == URI.parse(url).password
-    end
-
-  end
-end

data/tests/bad_tests.rb

@@ -1,69 +0,0 @@
-Shindo.tests('Excon bad server interaction') do
-
-  with_server('bad') do
-
-    tests('header splitting') do
-
-      tests('prevents key splitting').raises(Excon::Errors::InvalidHeaderKey) do
-        connection = Excon.new('http://127.0.0.1:9292')
-        connection.request(
-          headers: { "Foo\r\nBar" => "baz" },
-          method:  :get,
-          path: '/echo'
-        )
-      end
-
-      tests('prevents value splitting').raises(Excon::Errors::InvalidHeaderValue) do
-        connection = Excon.new('http://127.0.0.1:9292')
-        connection.request(
-          headers: { Foo: "bar\r\nBaz: qux" },
-          method:  :get,
-          path: '/echo'
-        )
-      end
-
-    end
-
-    tests('bad server: causes EOFError') do
-
-      tests('with no content length and no chunking') do
-        tests('without a block') do
-          tests('response.body').returns('hello') do
-            connection = Excon.new('http://127.0.0.1:9292')
-
-            connection.request(:method => :get, :path => '/eof/no_content_length_and_no_chunking').body
-          end
-        end
-
-        tests('with a block') do
-          tests('body from chunks').returns('hello') do
-            connection = Excon.new('http://127.0.0.1:9292')
-
-            body = ""
-            response_block = lambda {|chunk, remaining, total| body << chunk }
-
-            connection.request(:method => :get, :path => '/eof/no_content_length_and_no_chunking', :response_block => response_block)
-
-            body
-          end
-        end
-
-      end
-
-    end
-
-  end
-
-  with_server('eof') do
-
-    tests('eof server: causes EOFError') do
-
-      tests('request').raises(Excon::Errors::SocketError) do
-        Excon.get('http://127.0.0.1:9292/eof')
-      end
-
-    end
-
-  end
-
-end

data/tests/basic_tests.rb

@@ -1,351 +0,0 @@
-require 'json'
-
-Shindo.tests('Excon basics') do
-  env_init
-
-  with_rackup('basic.ru') do
-    basic_tests
-
-    tests('explicit uri passed to connection') do
-      tests('GET /content-length/100').returns(200) do
-        connection = Excon::Connection.new({
-          :host             => '127.0.0.1',
-          :hostname         => '127.0.0.1',
-          :nonblock         => false,
-          :port             => 9292,
-          :scheme           => 'http',
-          :ssl_verify_peer  => false
-        })
-        response = connection.request(:method => :get, :path => '/content-length/100')
-        response[:status]
-      end
-    end
-  end
-end
-
-Shindo.tests('Excon streaming basics') do
-  pending if RUBY_PLATFORM == 'java' # need to find suitable server for jruby
-  with_unicorn('streaming.ru') do
-    # expected values: the response, in pieces, and a timeout after each piece
-    res = %w{Hello streamy world}
-    timeout = 0.1
-
-    # expect the full response as a string
-    # and expect it to take a (timeout * pieces) seconds
-    tests('simple blocking request on streaming endpoint').returns([res.join(''),'response time ok']) do
-      start = Time.now
-      ret = Excon.get('http://127.0.0.1:9292/streamed/simple').body
-
-      if Time.now - start <= timeout*3
-        [ret, 'streaming response came too quickly']
-      else
-        [ret, 'response time ok']
-      end
-    end
-
-    # expect the full response as a string and expect it to
-    # take a (timeout * pieces) seconds (with fixed Content-Length header)
-    tests('simple blocking request on streaming endpoint with fixed length').returns([res.join(''),'response time ok']) do
-      start = Time.now
-      ret = Excon.get('http://127.0.0.1:9292/streamed/fixed_length').body
-
-      if Time.now - start <= timeout*3
-        [ret, 'streaming response came too quickly']
-      else
-        [ret, 'response time ok']
-      end
-    end
-
-    # expect each response piece to arrive to the body right away
-    # and wait for timeout until next one arrives
-    def timed_streaming_test(endpoint, timeout)
-      ret = []
-      timing = 'response times ok'
-      start = Time.now
-      Excon.get(endpoint, :response_block => lambda do |c,r,t|
-        # add the response
-        ret.push(c)
-        # check if the timing is ok
-        # each response arrives after timeout and before timeout + 1
-        cur_time = Time.now - start
-        if cur_time < ret.length * timeout or cur_time > (ret.length+1) * timeout
-          timing = 'response time not ok!'
-        end
-      end)
-      # validate the final timing
-      if Time.now - start <= timeout*3
-        timing = 'final timing was not ok!'
-      end
-      [ret, timing]
-    end
-
-    tests('simple request with response_block on streaming endpoint').returns([res,'response times ok']) do
-      timed_streaming_test('http://127.0.0.1:9292/streamed/simple', timeout)
-    end
-
-    tests('simple request with response_block on streaming endpoint with fixed length').returns([res,'response times ok']) do
-      timed_streaming_test('http://127.0.0.1:9292/streamed/fixed_length', timeout)
-    end
-
-  end
-end
-
-Shindo.tests('Excon basics (Basic Auth Pass)') do
-  with_rackup('basic_auth.ru') do
-    basic_tests('http://test_user:test_password@127.0.0.1:9292')
-    user, pass, uri = ['test_user', 'test_password', 'http://127.0.0.1:9292'].map(&:freeze)
-
-    tests('with frozen args').returns(200) do
-      connection = Excon.new(uri, :method => :get, :password => pass, :path => '/content-length/100', :user => user)
-      response = connection.request
-      response.status
-    end
-
-    tests('with user/pass on request').returns(200) do
-      connection = Excon.new(uri, :method => :get, :path => '/content-length/100')
-      response = connection.request(:user => user, :password => pass)
-      response.status
-    end
-
-    tests('with user/pass on connection and request').returns(200) do
-      connection = Excon.new(uri, :method => :get, :password => 'incorrect_password', :path => '/content-length/100', :user => 'incorrect_user')
-      response = connection.request(user: user, password: pass)
-      response.status
-    end
-  end
-end
-
-Shindo.tests('Excon basics (Basic Auth Fail)') do
-  with_rackup('basic_auth.ru') do
-    cases = [
-      ['correct user, no password', 'http://test_user@127.0.0.1:9292'],
-      ['correct user, wrong password', 'http://test_user:fake_password@127.0.0.1:9292'],
-      ['wrong user, correct password', 'http://fake_user:test_password@127.0.0.1:9292']
-    ]
-    cases.each do |desc,url|
-      tests("response.status for #{desc}").returns(401) do
-        connection = Excon.new(url)
-        response = connection.request(:method => :get, :path => '/content-length/100')
-        response.status
-      end
-    end
-  end
-end
-
-Shindo.tests('Excon basics (ssl)') do
-  with_rackup('ssl.ru') do
-    basic_tests('https://127.0.0.1:9443')
-  end
-end
-
-Shindo.tests('Excon ssl verify peer (ssl)') do
-  with_rackup('ssl.ru') do
-    connection = nil
-    test do
-      ssl_ca_file = File.join(File.dirname(__FILE__), 'data', '127.0.0.1.cert.crt')
-      connection = Excon.new('https://127.0.0.1:9443', :ssl_verify_peer => true, :ssl_ca_file => ssl_ca_file )
-      true
-    end
-
-    tests('response.status').returns(200) do
-      response = connection.request(:method => :get, :path => '/content-length/100')
-
-      response.status
-    end
-  end
-
-  with_rackup('ssl_mismatched_cn.ru') do
-    connection = nil
-    test do
-      ssl_ca_file = File.join(File.dirname(__FILE__), 'data', 'excon.cert.crt')
-      connection = Excon.new('https://127.0.0.1:9443', :ssl_verify_peer => true, :ssl_ca_file => ssl_ca_file, :ssl_verify_peer_host => 'excon' )
-      true
-    end
-
-    tests('response.status').returns(200) do
-      response = connection.request(:method => :get, :path => '/content-length/100')
-
-      response.status
-    end
-  end
-end
-
-Shindo.tests('Excon ssl verify peer (ssl cert store)') do
-  with_rackup('ssl.ru') do
-    connection = nil
-    test do
-      ssl_ca_cert = File.read(File.join(File.dirname(__FILE__), 'data', '127.0.0.1.cert.crt'))
-      ssl_cert_store = OpenSSL::X509::Store.new
-      ssl_cert_store.add_cert OpenSSL::X509::Certificate.new ssl_ca_cert
-      connection = Excon.new('https://127.0.0.1:9443', :ssl_verify_peer => true, :ssl_cert_store => ssl_cert_store )
-      true
-    end
-
-    tests('response.status').returns(200) do
-      response = connection.request(:method => :get, :path => '/content-length/100')
-
-      response.status
-    end
-  end
-end
-
-Shindo.tests('Excon basics (ssl file)',['focus']) do
-  with_rackup('ssl_verify_peer.ru') do
-
-    tests('GET /content-length/100').raises(Excon::Errors::SocketError) do
-      connection = Excon::Connection.new({
-        :host             => '127.0.0.1',
-        :hostname         => '127.0.0.1',
-        :nonblock         => false,
-        :port             => 8443,
-        :scheme           => 'https',
-        :ssl_verify_peer  => false
-      })
-      connection.request(:method => :get, :path => '/content-length/100')
-    end
-
-    cert_key_path = File.join(File.dirname(__FILE__), 'data', 'excon.cert.key')
-    cert_crt_path = File.join(File.dirname(__FILE__), 'data', 'excon.cert.crt')
-    basic_tests('https://127.0.0.1:8443', client_key: cert_key_path, client_cert: cert_crt_path)
-
-    cert_key_data = File.read cert_key_path
-    cert_crt_data = File.read cert_crt_path
-    basic_tests('https://127.0.0.1:8443', client_key_data: cert_key_data, client_cert_data: cert_crt_data)
-  end
-end
-
-Shindo.tests('Excon basics (ssl file paths)',['focus']) do
-  with_rackup('ssl_verify_peer.ru') do
-
-    tests('GET /content-length/100').raises(Excon::Errors::SocketError) do
-      connection = Excon::Connection.new({
-        :host             => '127.0.0.1',
-        :hostname         => '127.0.0.1',
-        :nonblock         => false,
-        :port             => 8443,
-        :scheme           => 'https',
-        :ssl_verify_peer  => false
-      })
-      connection.request(:method => :get, :path => '/content-length/100')
-    end
-
-    basic_tests('https://127.0.0.1:8443',
-                :private_key_path => File.join(File.dirname(__FILE__), 'data', 'excon.cert.key'),
-                :certificate_path => File.join(File.dirname(__FILE__), 'data', 'excon.cert.crt')
-               )
-
-  end
-end
-
-Shindo.tests('Excon basics (ssl string)', ['focus']) do
-  with_rackup('ssl_verify_peer.ru') do
-    basic_tests('https://127.0.0.1:8443',
-                :private_key => File.read(File.join(File.dirname(__FILE__), 'data', 'excon.cert.key')),
-                :certificate => File.read(File.join(File.dirname(__FILE__), 'data', 'excon.cert.crt'))
-               )
-  end
-end
-
-Shindo.tests('Excon basics (Unix socket)') do
-  pending if RUBY_PLATFORM == 'java' # need to find suitable server for jruby
-
-  file_name = '/tmp/unicorn.sock'
-  with_unicorn('basic.ru', 'unix://'+file_name) do
-    basic_tests("unix:/", :socket => file_name)
-
-    tests('explicit uri passed to connection') do
-      tests('GET /content-length/100').returns(200) do
-        connection = Excon::Connection.new({
-          :socket           => file_name,
-          :nonblock         => false,
-          :scheme           => 'unix',
-          :ssl_verify_peer  => false
-        })
-        response = connection.request(:method => :get, :path => '/content-length/100')
-        response[:status]
-      end
-    end
-
-    tests('http Host header is empty') do
-      tests('GET /headers').returns("") do
-        connection = Excon::Connection.new({
-          :socket           => file_name,
-          :nonblock         => false,
-          :scheme           => 'unix',
-          :ssl_verify_peer  => false
-        })
-        response = connection.request(:method => :get, :path => '/headers')
-        JSON.parse(response.body)['HTTP_HOST']
-      end
-    end
-  end
-end
-
-Shindo.tests('Excon basics (reusable local port)') do
-  class CustomSocket < Socket
-    def initialize
-      super(AF_INET, SOCK_STREAM, 0)
-      setsockopt(SOL_SOCKET, SO_REUSEADDR, true)
-      if defined?(SO_REUSEPORT)
-        setsockopt(SOL_SOCKET, SO_REUSEPORT, true)
-      end
-    end
-
-    def bind(address, port)
-      super(Socket.pack_sockaddr_in(port, address))
-    end
-
-    def connect(address, port)
-      super(Socket.pack_sockaddr_in(port, address))
-    end
-
-    def http_get(path)
-      print "GET /content-length/10 HTTP/1.0\r\n\r\n"
-      read.split("\r\n\r\n", 2)[1]
-    end
-
-    def self.ip_address_list
-      if Socket.respond_to?(:ip_address_list)
-        Socket.ip_address_list.select(&:ipv4?).map(&:ip_address)
-      else
-        `ifconfig`.scan(/inet.*?(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/).flatten
-      end
-    end
-
-    def self.find_alternate_ip(ip)
-      ip_address_list.detect {|a| a != ip } || '127.0.0.1'
-    end
-  end
-
-  with_rackup('basic.ru', '0.0.0.0') do
-    connection = Excon.new("http://127.0.0.1:9292/echo",
-                           :reuseaddr => true, # enable address and port reuse
-                           :persistent => true # keep the socket open
-                           )
-    response = connection.get
-
-    tests('has a local port').returns(true) do
-      response.local_port.to_s =~ /\d{4,5}/ ? true : false
-    end
-
-    tests('local port can be re-bound').returns('x' * 10) do
-      # create a socket with address/port reuse enabled
-      s = CustomSocket.new
-
-      # bind to the same local port and address used in the get above (won't work without reuse options on both sockets)
-      s.bind(response.local_address, response.local_port)
-
-      # connect to the server on a different address than was used for the initial connection to avoid duplicate 5-tuples of: {protcol, src_port, src_addr, dst_port, dst_addr}
-      s.connect(CustomSocket.find_alternate_ip(response.local_address), 9292)
-
-      # send the request
-      body = s.http_get("/content-length/10")
-
-      # close both the sockets
-      s.close
-      connection.reset
-
-      body
-    end
-  end
-end