excon 0.64.0 → 0.65.0

data/spec/excon/error_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-describe Excon::Error do
-  # Regression against e300458f2d9330cb265baeb8973120d08c665d9
-  describe '#status_errors' do
-    describe '.keys ' do
-      expected = [
-        100,
-        101,
-        (200..206).to_a,
-        (300..307).to_a,
-        (400..417).to_a,
-        422,
-        429,
-        (500..504).to_a
-      ].flatten
-
-      it('returns the pertinent HTTP error numbers') do
-        expected.flatten == Excon::Error.status_errors.keys
-      end
-    end
-  end
-
-  describe '#new' do
-    it('returns an Excon::Error') do
-      expect(Excon::Error.new('bar').class == Excon::Error).to be true
-    end
-    it('raises errors for bad URIs') do
-      expect { Excon.new('foo') }.to raise_error(ArgumentError)
-    end
-
-    it('raises errors for bad paths') do
-      expect { Excon.new('http://localhost', path: "foo\r\nbar: baz") }.to raise_error(URI::InvalidURIError)
-    end
-  end
-
-  context 'when remaining backwards compatible' do
-    describe '#new' do
-      it 'should raise standard error and catch standard error' do
-        expect { raise Excon::Error::Client, 'foo' }.to raise_error(Excon::Error)
-      end
-
-      it 'should raise legacy errors and catch legacy errors' do
-        expect do
-          raise Excon::Errors::Error, 'bar'
-        end.to raise_error(Excon::Errors::Error)
-      end
-
-      it 'should raise standard error and catch legacy errors' do
-        expect do
-          raise Excon::Error::NotFound, 'bar'
-        end.to raise_error(Excon::Errors::Error)
-      end
-    end
-
-    describe '#status_error' do
-      it 'should raise with status_error() and catch with standard error' do
-        expect do
-          raise Excon::Error.status_error({ expects: 200 }, status: 400)
-        end.to raise_error(Excon::Error)
-      end
-
-      it 'should raise with  status_error() and catch with legacy error' do
-        expect do
-          raise Excon::Error.status_error({ expects: 200 }, status: 400)
-        end.to raise_error(Excon::Errors::BadRequest)
-      end
-
-      it 'should raise with legacy status_error() and catch with standard' do
-        expect do
-          raise Excon::Errors.status_error({ expects: 200 }, status: 400)
-        end.to raise_error(Excon::Error)
-      end
-    end
-  end
-
-  context 'when exceptions are rescued' do
-    include_context("test server", :exec, 'error.rb', :before => :start, :after => :stop )
-
-    context 'when :debug_request and :debug_response are switched off' do
-      it('exception message does not include response or response info') do
-        begin
-          Excon.get('http://127.0.0.1:9292/error/not_found', expects: 200)
-        rescue Excon::Errors::HTTPStatusError => err
-          truth =
-            err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-            !err.message.include?('excon.error.request') &&
-            !err.message.include?('excon.error.response')
-          expect(truth).to be true
-        end
-      end
-    end
-
-    context 'when :debug_request and :debug_response are switched on' do
-      it 'exception message includes request and response info' do
-        begin
-          Excon.get('http://127.0.0.1:9292/error/not_found', expects: 200,
-                                                             debug_request: true, debug_response: true)
-        rescue Excon::Errors::HTTPStatusError => err
-          truth =
-            err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-            err.message.include?('excon.error.request') &&
-            err.message.include?('excon.error.response')
-          expect(truth).to be true
-        end
-      end
-    end
-
-    context 'when only :debug_request is turned on' do
-      it('exception message includes only request info') do
-        begin
-          Excon.get('http://127.0.0.1:9292/error/not_found', expects: 200,
-                                                             debug_request: true)
-        rescue Excon::Errors::HTTPStatusError => err
-          truth =
-            err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-            err.message.include?('excon.error.request') &&
-            !err.message.include?('excon.error.response')
-          expect(truth).to be true
-        end
-      end
-    end
-
-    context 'when only :debug_response is turned on ' do
-      it('exception message includes only response info') do
-        begin
-          Excon.get('http://127.0.0.1:9292/error/not_found', expects: 200,
-                                                             debug_response: true)
-        rescue Excon::Errors::HTTPStatusError => err
-          truth =
-            err.message.include?('Expected(200) <=> Actual(404 Not Found)') &&
-            !err.message.include?('excon.error.request') &&
-            err.message.include?('excon.error.response')
-          expect(truth).to be true
-        end
-      end
-    end
-  end
-end

data/spec/excon/test/server_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Excon::Test::Server do
-
-  context 'when the web server is webrick' do
-    it_should_behave_like "a excon test server", :webrick, 'basic.ru'
-  end
-
-
-  context 'when the web server is unicorn' do 
-    context 'bound to a tcp socket' do
-      it_should_behave_like "a excon test server", :unicorn, 'streaming.ru'
-    end
-
-    context "bound to a unix socket" do
-      socket_uri = 'unix:///tmp/unicorn.socket'
-      it_should_behave_like "a excon test server", :unicorn, 'streaming.ru', socket_uri
-    end
-  end
-
-  context 'when the web server is puma' do
-    it_should_behave_like "a excon test server", :puma, 'streaming.ru'
-  end
-
-  context 'when the web server is a executable' do
-    it_should_behave_like "a excon test server", :exec, 'good_ipv4.rb'
-  end
-end

data/spec/excon_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Excon do
-  it 'has a version number' do
-    expect(Excon::VERSION).not_to be nil
-  end
-end

data/spec/helpers/file_path_helpers.rb

@@ -1,22 +0,0 @@
-# Todo: s/tests/specs when migration is complete
-def get_abs_path(*parts)
-  File.join(File.expand_path('../../..', __FILE__), 'tests', *parts)
-end
-
-def data_path(*parts)
-  get_abs_path('data', *parts)
-end
-
-def rackup_path(*parts)
-  get_abs_path('rackups', *parts)
-end
-
-def webrick_path(*parts) rackup_path(*parts); end
-
-def unicorn_path(*parts) rackup_path(*parts); end
-
-def puma_path(*parts) rackup_path(*parts); end
-
-def exec_path(*parts)
-  get_abs_path('servers', *parts)
-end

data/spec/helpers/warning_helpers.rb

@@ -1,9 +0,0 @@
-def silence_warnings
-  orig_verbose = $VERBOSE
-  $VERBOSE = nil
-  Excon.set_raise_on_warnings!(false)
-  yield
-ensure
-  $VERBOSE = orig_verbose
-  Excon.set_raise_on_warnings!(true)
-end

data/spec/requests/basic_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Excon::Connection do
-  include_context('test server', :webrick, 'basic.ru', before: :start, after: :stop)
-  context 'when an explicit uri is passed' do
-    let(:conn) do
-      Excon::Connection.new(host: '127.0.0.1',
-                                           hostname: '127.0.0.1',
-                                           nonblock: false,
-                                           port: 9292,
-                                           scheme: 'http',
-                                           ssl_verify_peer: false)
-    end
-
-    describe '.new' do
-      it 'returns an instance' do
-        expect(conn).to be_instance_of Excon::Connection
-      end
-    end
-
-    context "when :method is :get and :path is /content-length/100" do
-      describe "#request" do
-        let(:response) do
-          response = 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
-          end
-        end
-      end
-    end
-    include_examples 'a basic client'
-  end
-end

data/spec/requests/eof_requests_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Excon do
-  context "when dispatching requests" do
-    context('to a server that does not supply response headers') do
-      include_context("test server", :exec, 'bad.rb', :before => :start, :after => :stop )
-      before(:all) do
-        @conn = Excon.new('http://127.0.0.1:9292')
-      end
-
-      context('when no block is given') do
-        it 'should rescue from an EOFError and return response' do
-          body = @conn.request(:method => :get, :path => '/eof/no_content_length_and_no_chunking').body
-        expect(body).to eq 'hello'
-        end
-      end
-
-      context('when a block is given') do
-        it 'should rescue from EOFError and return response' do
-          body = ""
-          response_block = lambda {|chunk, remaining, total| body << chunk }
-          @conn.request(:method => :get, :path => '/eof/no_content_length_and_no_chunking', :response_block => response_block)
-          expect(body).to eq 'hello'
-        end
-      end
-    end
-
-    context('to a server that prematurely aborts the request with no response') do
-      include_context("test server", :exec, 'eof.rb', :before => :start, :after => :stop )
-
-      it 'should raise an EOFError' do
-        expect { Excon.get('http://127.0.0.1:9292/eof') }.to raise_error(Excon::Errors::SocketError)
-      end
-    end
-  end
-end

data/spec/requests/unix_socket_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe Excon::Connection do
-  include_context('stubs')
-  context "when speaking to a UNIX socket" do
-    context "Host header handling" do
-      before do
-        Excon.stub do |req|
-          {
-            body: req[:headers].to_json,
-            status: 200,
-          }
-        end
-      end
-      it "sends an empty Host= by default" do
-        conn = Excon::Connection.new(
-          scheme: "unix",
-          socket: "/tmp/x.sock",
-        )
-
-        headers = JSON.parse(conn.get(path: "/path").body)
-
-        expect(headers["Host"]).to eq("")
-      end
-
-      it "doesn't overwrite an explicit Host header" do
-        conn = Excon::Connection.new(
-          scheme: "unix",
-          socket: "/tmp/x.sock",
-        )
-
-        headers = JSON.parse(conn.get(path: "/path", headers: { "Host" => "localhost" }).body)
-
-        expect(headers["Host"]).to eq("localhost")
-      end
-    end
-  end
-end

data/spec/requests/validation_spec.rb

@@ -1,80 +0,0 @@
-describe Excon::Connection do
-  include_context('stubs')
-  describe 'validating parameters' do
-    class FooMiddleware < Excon::Middleware::Base
-      def self.valid_parameter_keys
-        [:foo]
-      end
-    end
-
-    let(:foo_stack) do
-      Excon.defaults[:middlewares] + [FooMiddleware]
-    end
-
-    def expect_parameter_warning(validation, key)
-      expect { yield }.to raise_error(Excon::Error::Warning, "Invalid Excon #{validation} keys: #{key.inspect}")
-    end
-
-    context 'with default middleware' do
-      it 'Connection.new warns on invalid parameter keys' do
-        expect_parameter_warning('connection', :foo) do
-          Excon.new('http://foo', :foo => :bar)
-        end
-      end
-
-      it 'Connection#request warns on invalid parameter keys' do
-        conn = Excon.new('http://foo')
-        expect_parameter_warning('request', :foo) do
-          conn.request(:foo => :bar)
-        end
-      end
-    end
-
-    context 'with custom middleware at instantiation' do
-      it 'Connection.new accepts parameters that are valid for the provided middleware' do
-        Excon.new('http://foo', :foo => :bar, :middlewares => foo_stack)
-      end
-
-      it 'Connection.new warns on parameters that are not valid for the provided middleware' do
-        expect_parameter_warning('connection', :bar) do
-          Excon.new('http://foo', :bar => :baz, :middlewares => foo_stack)
-        end
-      end
-
-      it 'Connection#request accepts parameters that are valid for the provided middleware' do
-        Excon.stub({}, {})
-        conn = Excon.new('http://foo', :middlewares => foo_stack)
-        conn.request(:foo => :bar)
-      end
-
-      it 'Connection#request warns on parameters that are not valid for the provided middleware' do
-        conn = Excon.new('http://foo', :middlewares => foo_stack)
-        expect_parameter_warning('request', :bar) do
-          conn.request(:bar => :baz)
-        end
-      end
-    end
-
-    context 'with custom middleware at request time' do
-      it 'Connection#request accepts parameters that are valid for the provided middleware' do
-        Excon.stub({}, {})
-        conn = Excon.new('http://foo')
-        conn.request(:foo => :bar, :middlewares => foo_stack)
-      end
-
-      it 'Connection#request warns on parameters that are not valid for the request middleware' do
-        conn = Excon.new('http://foo')
-        expect_parameter_warning('request', :bar) do
-          conn.request(:bar => :baz, :middlewares => foo_stack)
-        end
-      end
-
-      it 'Connection#request warns on parameters from instantiation that are not valid for the request middleware' do
-        conn = Excon.new('http://foo', :foo => :bar, :middlewares => foo_stack)
-        expect_parameter_warning('connection', :foo) do
-          conn.request(:middlewares => Excon.defaults[:middlewares])
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-require 'excon'
-require 'excon/test/server'
-require 'json'
-
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
- config.mock_with :rspec do |mocks|
-   mocks.verify_partial_doubles = true
-  end
-
-  if config.files_to_run.one?
-    config.default_formatter = 'doc'
-  end
-
-  Excon.set_raise_on_warnings!(true)
-end
-
-# Load helpers
-Dir["./spec/helpers/**/*.rb"].sort.each { |f| require f}
-
-# Load shared examples and contexts
-Dir["./spec/support/**/*.rb"].sort.each { |f| require f}

data/spec/support/shared_contexts/test_server_context.rb

@@ -1,83 +0,0 @@
-# TODO: Clean up this doc and dry up the conditionals
-#
-# Required params:
-#   plugin (e.g., webrick, unicorn, etc)
-#   file (e.g. a rackup )
-#
-# Optional params:
-# optional paramters may given as a hash
-# opts may contain a bind argument
-# opts may also contain before and after options
-#
-# In its simplest form:
-# { :before => :start, :after => :stop }
-#
-# With lambdas, which recieve @server as an argument
-# { before: lambda {|s| s.start }, after: lambda { |s| s.stop} }
-#
-# In both the cases above, before defaults to before(:all)
-# This can be circumvented with a Hash
-# { before: { :context => :start }, after: { :context => :stop } }
-# or
-# { before: { context: lambda { |s| s.start } }, after: { context: lambda { |s| s.stop } } }
-
-shared_context "test server" do |plugin, file, opts = {}|
-  plugin = plugin.to_sym unless plugin.is_a? Symbol
-  if plugin == :unicorn && RUBY_PLATFORM == "java"
-    before { skip("until unicorn supports jruby") }
-  end
-  abs_file = Object.send("#{plugin}_path", file)
-  args = { plugin => abs_file}
-  args[:bind] = opts[:bind] if opts.key? :bind
-
-
-  before_hook = opts.key?(:before) && (opts[:before].is_a?(Symbol) || opts[:before].is_a?(Proc) || opts[:before].is_a?(Hash))
-
-  if before_hook && opts[:before].is_a?(Hash)
-    event = opts[:before].keys.first
-    before(event) {
-      @server = Excon::Test::Server.new(args)
-      if opts[:before][event].is_a? Symbol
-        @server.send(opts[:before][event])
-      else
-        opts[:before][event].call(@server)
-      end
-    }
-  elsif
-    before(:all) {
-      @server = Excon::Test::Server.new(args)
-      before_hook = opts.key?(:before) && (opts[:before].is_a?(Symbol) || opts[:before].is_a?(Proc) || opts[:before].is_a?(Hash))
-
-      if before_hook
-        if opts[:before].is_a? Symbol
-          @server.send(opts[:before])
-        else
-          opts[:before].call(@server)
-        end
-      end
-    }
-  end
-
-  after_hook = opts.key?(:after) && (opts[:after].is_a?(Symbol) || opts[:after].is_a?(Proc) || opts[:after].is_a?(Hash))
-
-  if after_hook && opts[:after].is_a?(Hash)
-      event = opts[:after].keys.first
-      after(event) {
-        if opts[:after][event].is_a? Symbol
-          @server.send(opts[:after][event])
-        else
-          opts[:after][event].call(@server)
-        end
-      }
-  elsif after_hook
-    after(:all) {
-      if opts[:after].is_a? Symbol
-        @server.send(opts[:after])
-      elsif opts[:after].is_a? Hash
-
-      else
-        opts[:after].call(@server)
-      end
-    }
-  end
-end